radiance · Radiance self-hosting compiler

compiler/ kernel/ lib/ examples/ std/ arch/ char/ collections/ lang/ alloc/ ast/ gen/ il/ module/ parser/ resolver/ tests/ printer.rad 24.7 KiB tests.rad 383.5 KiB scanner/ alloc.rad 7.1 KiB ast.rad 26.7 KiB gen.rad 513 B il.rad 19.5 KiB lower.rad 308.1 KiB module.rad 14.9 KiB package.rad 1.3 KiB parser.rad 89.5 KiB resolver.rad 439.6 KiB scanner.rad 18.0 KiB sexpr.rad 6.4 KiB strings.rad 2.2 KiB types.rad 1.6 KiB sys/ arch.rad 68 B char.rad 855 B collections.rad 39 B fmt.rad 8.3 KiB intrinsics.rad 467 B io.rad 1.7 KiB lang.rad 276 B mem.rad 2.3 KiB sys.rad 179 B testing.rad 2.4 KiB tests.rad 15.7 KiB vec.rad 3.2 KiB std.rad 281 B scripts/ seed/ sublime/ test/ vim/ .gitignore 336 B .gitsigners 112 B CONTRIBUTING 2.1 KiB LICENSE 1.1 KiB Makefile 9.2 KiB README 2.5 KiB STYLE 2.5 KiB std.lib 1.5 KiB std.lib.test 662 B
lib/std/lang/resolver/tests.rad 383.5 KiB raw
//! Resolver tests.

/// Region identity, borrowing, and nominal application tests.
@test mod regions;

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

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

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

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

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

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

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

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

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

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

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

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

/// String literals used in tests.
constant LITERALS: [*[u8]; 15] = [
    "Ok", "Error", "R", "S",
    "f", "Status", "Pending",
    "Some", "None", "First",
    "Second", "Opt", "x",
    "value", "idx"
];

/// Resolver result with AST, used by test helpers.
export record TestResult: Copy {
    /// Diagnostics from semantic analysis.
    diagnostics: super::Diagnostics,
    /// Root of the parsed test program.
    root: *ast::Node,
}

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

/// Create an arena owner for one resolver test scope.
export unsafe fn testArena() -> alloc::Arena {
    return alloc::new(&mut ARENA_STORAGE[..]);
}

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

    return res;
}

/// Resolve a block of statements by wrapping them in a synthetic function.
unsafe fn resolveStatements 'arena (
    self: &mut super::Resolver 'arena, block: ast::Block, arena: &mut ast::NodeArena
) -> TestResult throws (super::ResolveError) {
    let module = ast::synthFnModule(arena, super::ANALYZE_BLOCK_FN_NAME, block.statements);
    let diagnostics = try super::resolveModuleRoot(self, module.modBody) catch {
        return TestResult { diagnostics: super::diagnostics(self), root: module.modBody };
    };
    return TestResult { diagnostics, root: module.fnBody };
}

/// Parse and analyze an expression string for testing.
unsafe fn resolveExprStr 'arena (self: &mut super::Resolver 'arena, 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.
export unsafe fn resolveProgramStr 'arena (self: &mut super::Resolver 'arena, stmt: *[u8]) -> TestResult throws (testing::TestError) {
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let stmt: *ast::Node = try parser::parse(scanner::SourceLoc::String, stmt, &mut arena, &mut STRING_POOL) catch {
        panic "resolveProgramStr: parsing failed";
    };
    let diagnostics = try super::resolveModuleRoot(self, stmt) catch {
        throw testing::TestError::Failed;
    };
    return TestResult { diagnostics, root: stmt };
}

/// Resolve session diagnostics against the standard allocator declaration contract.
export unsafe fn resolveSessionProgramStr 'arena (self: &mut super::Resolver 'arena, program: *[u8]) -> TestResult
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let root = try registerModule(&mut MODULE_GRAPH, nil, "std", "export mod lang; mod app;", &mut arena);
    let lang = try registerModule(&mut MODULE_GRAPH, root, "lang", "export mod alloc;", &mut arena);
    let allocator = try registerModule(&mut MODULE_GRAPH, lang, "alloc",
        "export record Arena { data: *mut [u8], offset: u32 } export fn reset(arena: &mut Arena) { set arena.offset = 0; } export union AllocError: Copy { OutOfMemory } export trait Alloc { unsafe fn (&mut Alloc) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError); unsafe fn (&mut Alloc) reserveSlice(itemSize: u32, itemAlignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError); } instance Alloc for Arena { unsafe fn (arena: &mut Arena) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) { panic; } unsafe fn (arena: &mut Arena) reserveSlice(size: u32, alignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError) { panic; } }",
        &mut arena);
    let app = try registerModule(&mut MODULE_GRAPH, root, "app", program, &mut arena);
    return try resolveModuleTree(self, root);
}

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

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

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

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

/// Ensure an expression statement produces the expected type and return the expression node.
fn expectExprStmtType 'arena (self: &super::Resolver 'arena, 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.
export 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.
export fn expectError(result: &TestResult) -> super::Error throws (testing::TestError) {
    let err = super::errorAt(&result.diagnostics.errors[..], 0)
        else throw testing::TestError::Failed;
    return err;
}

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

/// Extract the first error and ensure it has the expected kind.
export 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 'arena (self: &super::Resolver 'arena, expr: *ast::Node, expected: super::Type)
    throws (testing::TestError)
{
    let actual = super::typeFor(self, expr)
        else throw testing::TestError::Failed;

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

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

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

/// Require an inferred integer type mismatch.
unsafe fn expectIntMismatch(program: *[u8], expected: super::Type)
    throws (testing::TestError)
{
    let mut testArena2 = testArena();
    let testStorage2: 'test2 = &mut testArena2 in {
        let mut a = testResolver(testStorage2);
        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.
export fn getBlockStmt(block: *ast::Node, index: u32) -> *ast::Node
    throws (testing::TestError)
{
    let case ast::NodeValue::Block(body) = block.value
        else throw testing::TestError::Failed;

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

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

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

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

    return blk;
}

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

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

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

/// Require an array type and return its element type.
fn expectArrayType(ty: super::Type, length: u32) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Array(info) = ty
        else throw testing::TestError::Failed;
    try testing::expect(info.length == length);

    return *info.item;
}

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

    return *item;
}

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

    return *target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testResolveSliceFromArray() throws (testing::TestError) {
    {
        let mut testArena43 = testArena();
        let testStorage43: 'test43 = &mut testArena43 in {
            let mut a = testResolver(testStorage43);
            let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena44 = testArena();
        let testStorage44: 'test44 = &mut testArena44 in {
            let mut a = testResolver(testStorage44);
            let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[0..3];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena45 = testArena();
        let testStorage45: 'test45 = &mut testArena45 in {
            let mut a = testResolver(testStorage45);
            let program = "static xs: [i32; 3] = [1, 2, 3]; let slice: *[i32] = &xs[..3];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena46 = testArena();
        let testStorage46: 'test46 = &mut testArena46 in {
            let mut a = testResolver(testStorage46);
            let program = "static xs: [u8; 2] = [1, 2]; let slice = &xs[1..1];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveSliceLiteralMutableRequiresMut() throws (testing::TestError) {
    let mut testArena47 = testArena();
    let testStorage47: 'test47 = &mut testArena47 in {
        let mut a = testResolver(testStorage47);
        let program = "let slice: *mut [i32] = &[1, 2, 3];";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

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

@test unsafe fn testResolvePointerMutableAssignmentRequiresMut() throws (testing::TestError) {
    let mut testArena49 = testArena();
    let testStorage49: 'test49 = &mut testArena49 in {
        let mut a = testResolver(testStorage49);
        let program = "let x: i32 = 0; let ptr: *mut i32 = &x;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolvePointerMutableToImmutableAssignment() throws (testing::TestError) {
    let mut testArena50 = testArena();
    let testStorage50: 'test50 = &mut testArena50 in {
        let mut a = testResolver(testStorage50);
        let program = "static x: i32 = 0; let mptr: *mut i32 = &mut x; let ptr: *i32 = mptr;";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

@test unsafe fn testResolveAddressOfRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut testArena51 = testArena();
        let testStorage51: 'test51 = &mut testArena51 in {
            let mut a = testResolver(testStorage51);
            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 testArena52 = testArena();
        let testStorage52: 'test52 = &mut testArena52 in {
            let mut a = testResolver(testStorage52);
            let program = "let mut x: i32 = 0; &mut x;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveAddressOfSliceRequiresMutableBinding() throws (testing::TestError) {
    {
        let mut testArena53 = testArena();
        let testStorage53: 'test53 = &mut testArena53 in {
            let mut a = testResolver(testStorage53);
            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 testArena54 = testArena();
        let testStorage54: 'test54 = &mut testArena54 in {
            let mut a = testResolver(testStorage54);
            let program = "let mut xs: [i32; 3] = [1, 2, 3]; &mut xs[..];";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveSliceCannotAssignToArray() throws (testing::TestError) {
    let mut testArena55 = testArena();
    let testStorage55: 'test55 = &mut testArena55 in {
        let mut a = testResolver(testStorage55);
        let program = "let xs: *[u8] = &[1, 2]; let ys: [u8; 2] = xs;";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveSliceSyntaxRequiresAddressOf() throws (testing::TestError) {
    let mut testArena56 = testArena();
    let testStorage56: 'test56 = &mut testArena56 in {
        let mut a = testResolver(testStorage56);
        let program = "let xs: [u8; 2] = [1, 2]; xs[..];";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::SliceRequiresAddress);
    }
}

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

@test unsafe fn testResolveSliceRangeOutOfBounds() throws (testing::TestError) {
    {
        let mut testArena58 = testArena();
        let testStorage58: 'test58 = &mut testArena58 in {
            let mut a = testResolver(testStorage58);
            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 testArena59 = testArena();
        let testStorage59: 'test59 = &mut testArena59 in {
            let mut a = testResolver(testStorage59);
            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 testArena60 = testArena();
        let testStorage60: 'test60 = &mut testArena60 in {
            let mut a = testResolver(testStorage60);
            let program = "let xs: [u8; 4] = [1, 2, 3, 4]; let slice = &xs[3..2];";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::SliceRangeOutOfBounds);
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testResolveWhileLetBindingScope() throws (testing::TestError) {
    {
        let mut testArena72 = testArena();
        let testStorage72: 'test72 = &mut testArena72 in {
            let mut a = testResolver(testStorage72);
            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 testArena73 = testArena();
        let testStorage73: 'test73 = &mut testArena73 in {
            let mut a = testResolver(testStorage73);
            let program = "let opt: ?i32 = nil; while let x = opt; true { break } else { x }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testResolveMatchUnionNonExhaustive() throws (testing::TestError) {
    {
        let mut testArena85 = testArena();
        let testStorage85: 'test85 = &mut testArena85 in {
            let mut a = testResolver(testStorage85);
            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 testArena86 = testArena();
        let testStorage86: 'test86 = &mut testArena86 in {
            let mut a = testResolver(testStorage86);
            let program = "union Opt { Some, None } fn run(value: Opt) { match value { else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

/// Test matching on optionals: exhaustiveness and type unwrapping.
@test unsafe fn testResolveMatchOptional() throws (testing::TestError) {
    {
        // Exhaustive: binding + nil case.
        let mut testArena95 = testArena();
        let testStorage95: 'test95 = &mut testArena95 in {
            let mut a = testResolver(testStorage95);
            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 testArena96 = testArena();
        let testStorage96: 'test96 = &mut testArena96 in {
            let mut a = testResolver(testStorage96);
            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 testArena97 = testArena();
        let testStorage97: 'test97 = &mut testArena97 in {
            let mut a = testResolver(testStorage97);
            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 testArena98 = testArena();
        let testStorage98: 'test98 = &mut testArena98 in {
            let mut a = testResolver(testStorage98);
            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 testArena99 = testArena();
        let testStorage99: 'test99 = &mut testArena99 in {
            let mut a = testResolver(testStorage99);
            let program = "fn f(opt: ?i32) -> i32 { match opt { v => return v + 1, case nil => return 0 } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that match on non-union types requires exhaustiveness.
@test unsafe fn testResolveMatchGenericExhaustive() throws (testing::TestError) {
    {
        // Match on i32 without catch-all should error.
        let mut testArena100 = testArena();
        let testStorage100: 'test100 = &mut testArena100 in {
            let mut a = testResolver(testStorage100);
            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 testArena101 = testArena();
        let testStorage101: 'test101 = &mut testArena101 in {
            let mut a = testResolver(testStorage101);
            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 testArena102 = testArena();
        let testStorage102: 'test102 = &mut testArena102 in {
            let mut a = testResolver(testStorage102);
            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 testArena103 = testArena();
        let testStorage103: 'test103 = &mut testArena103 in {
            let mut a = testResolver(testStorage103);
            let program = "fn f(x: i32) { match x { case _ => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that match on bool requires both true and false cases.
@test unsafe fn testResolveMatchBoolExhaustive() throws (testing::TestError) {
    {
        // Match on bool with both cases is fine.
        let mut testArena104 = testArena();
        let testStorage104: 'test104 = &mut testArena104 in {
            let mut a = testResolver(testStorage104);
            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 testArena105 = testArena();
        let testStorage105: 'test105 = &mut testArena105 in {
            let mut a = testResolver(testStorage105);
            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 testArena106 = testArena();
        let testStorage106: 'test106 = &mut testArena106 in {
            let mut a = testResolver(testStorage106);
            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 testArena107 = testArena();
        let testStorage107: 'test107 = &mut testArena107 in {
            let mut a = testResolver(testStorage107);
            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 testArena108 = testArena();
        let testStorage108: 'test108 = &mut testArena108 in {
            let mut a = testResolver(testStorage108);
            let program = "fn f(x: bool) { match x { b => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveBreakRequiresLoop() throws (testing::TestError) {
    {
        let mut testArena109 = testArena();
        let testStorage109: 'test109 = &mut testArena109 in {
            let mut a = testResolver(testStorage109);
            let result = try resolveProgramStr(&mut a, "break;");
            try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
        }
    } {
        let mut testArena110 = testArena();
        let testStorage110: 'test110 = &mut testArena110 in {
            let mut a = testResolver(testStorage110);
            let result = try resolveProgramStr(&mut a, "loop { break }");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveContinueRequiresLoop() throws (testing::TestError) {
    {
        let mut testArena111 = testArena();
        let testStorage111: 'test111 = &mut testArena111 in {
            let mut a = testResolver(testStorage111);
            let result = try resolveProgramStr(&mut a, "continue;");
            try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);
        }
    } {
        let mut testArena112 = testArena();
        let testStorage112: 'test112 = &mut testArena112 in {
            let mut a = testResolver(testStorage112);
            let result = try resolveProgramStr(&mut a, "while true { continue }");
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Test that match statements with returns in all branches don't require a
/// return at the end of the function.
@test unsafe fn testResolveFnMatchAllPathsReturn() throws (testing::TestError) {
    {
        // Union match with all variants returning.
        let mut testArena131 = testArena();
        let testStorage131: 'test131 = &mut testArena131 in {
            let mut a = testResolver(testStorage131);
            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 testArena132 = testArena();
        let testStorage132: 'test132 = &mut testArena132 in {
            let mut a = testResolver(testStorage132);
            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 testArena133 = testArena();
        let testStorage133: 'test133 = &mut testArena133 in {
            let mut a = testResolver(testStorage133);
            let program = "union E { A, B } fn f(e: E) -> i32 { match e { case E::A => return 1, case E::B => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::FnMissingReturn);
        }
    }
}

@test unsafe fn testResolveAssign() throws (testing::TestError) {
    {
        let mut testArena134 = testArena();
        let testStorage134: 'test134 = &mut testArena134 in {
            let mut a = testResolver(testStorage134);
            let result = try resolveProgramStr(&mut a, "let mut x: i32 = 0; set x = 1;");
            try expectNoErrors(&result);
        }
    } {
        let mut testArena135 = testArena();
        let testStorage135: 'test135 = &mut testArena135 in {
            let mut a = testResolver(testStorage135);
            let result = try resolveProgramStr(&mut a, "let x: i32 = 0; set x = 1;");
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut testArena136 = testArena();
        let testStorage136: 'test136 = &mut testArena136 in {
            let mut a = testResolver(testStorage136);
            let result = try resolveProgramStr(&mut a, "let mut x: bool = false; set x = 1;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut testArena137 = testArena();
        let testStorage137: 'test137 = &mut testArena137 in {
            let mut a = testResolver(testStorage137);
            let result = try resolveProgramStr(&mut a, "set x = 1;");
            try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("x"));
        }
    } {
        let mut testArena138 = testArena();
        let testStorage138: 'test138 = &mut testArena138 in {
            let mut a = testResolver(testStorage138);
            let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = 1;");
            try expectNoErrors(&result);
        }
    } {
        let mut testArena139 = testArena();
        let testStorage139: 'test139 = &mut testArena139 in {
            let mut a = testResolver(testStorage139);
            let result = try resolveProgramStr(&mut a, "let mut x: ?i32 = 0; set x = nil;");
            try expectNoErrors(&result);
        }
    }
}

@test unsafe fn testResolveAssignSubscript() throws (testing::TestError) {
    {
        let mut testArena140 = testArena();
        let testStorage140: 'test140 = &mut testArena140 in {
            let mut a = testResolver(testStorage140);
            let program = "let mut xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    {
        let mut testArena141 = testArena();
        let testStorage141: 'test141 = &mut testArena141 in {
            let mut a = testResolver(testStorage141);
            let program = "static xs: [u8; 2] = [0, 1]; let slice: *mut [u8] = &mut xs[..]; set slice[0] = 1;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
    {
        let mut testArena142 = testArena();
        let testStorage142: 'test142 = &mut testArena142 in {
            let mut a = testResolver(testStorage142);
            let program = "static xs: [u8; 2] = [0, 1]; let mut slice: *[u8] = &xs[..]; set slice[0] = 1;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
    {
        let mut testArena143 = testArena();
        let testStorage143: 'test143 = &mut testArena143 in {
            let mut a = testResolver(testStorage143);
            let program = "let xs: [u8; 2] = [0, 1]; set xs[0] = 9;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
    {
        let mut testArena144 = testArena();
        let testStorage144: 'test144 = &mut testArena144 in {
            let mut a = testResolver(testStorage144);
            let program = "static xs: [u8; 2] = [0, 1]; let slice: *[u8] = &xs[..]; set slice[0] = 1;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    }
}

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

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

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

@test unsafe fn testNilCoercions() throws (testing::TestError) {
    {
        let mut testArena145 = testArena();
        let testStorage145: 'test145 = &mut testArena145 in {
            let mut a = testResolver(testStorage145);
            let result = try resolveBlockStr(&mut a, "let opt: ?i32 = nil;");
            try expectNoErrors(&result);
        }
    } {
        let mut testArena146 = testArena();
        let testStorage146: 'test146 = &mut testArena146 in {
            let mut a = testResolver(testStorage146);
            let program = "fn g(opt: ?i32) {} fn f() { g(nil); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena147 = testArena();
        let testStorage147: 'test147 = &mut testArena147 in {
            let mut a = testResolver(testStorage147);
            let program = "fn make(flag: bool) -> ?i32 { if flag { return 1; } return nil; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Test that anonymous record with wrong field type causes type mismatch.
@test unsafe fn testResolveAnonRecordWrongFieldType() throws (testing::TestError) {
    let mut testArena155 = testArena();
    let testStorage155: 'test155 = &mut testArena155 in {
        let mut a = testResolver(testStorage155);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: true, y: 2 });";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that anonymous record with missing field causes a missing field error.
@test unsafe fn testResolveAnonRecordMissingField() throws (testing::TestError) {
    let mut testArena156 = testArena();
    let testStorage156: 'test156 = &mut testArena156 in {
        let mut a = testResolver(testStorage156);
        let program = "record Pt { x: i32, y: i32 } fn foo(p: Pt) {} foo({ x: 1 });";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::RecordFieldMissing("y"));
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testUndefinedCoercions() throws (testing::TestError) {
    {
        let mut testArena176 = testArena();
        let testStorage176: 'test176 = &mut testArena176 in {
            let mut a = testResolver(testStorage176);
            let result = try resolveBlockStr(&mut a, "unsafe { let count: i32 = undefined; }");
            try expectNoErrors(&result);
        }
    } {
        let mut testArena177 = testArena();
        let testStorage177: 'test177 = &mut testArena177 in {
            let mut a = testResolver(testStorage177);
            let program = "unsafe { let mut value: i32 = 0; set value = undefined; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena178 = testArena();
        let testStorage178: 'test178 = &mut testArena178 in {
            let mut a = testResolver(testStorage178);
            let program = "fn f(x: i32) {} unsafe fn g() { f(undefined); }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena179 = testArena();
        let testStorage179: 'test179 = &mut testArena179 in {
            let mut a = testResolver(testStorage179);
            let program = "unsafe fn fetch() -> i32 { return undefined; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testResolveLetCaseElse() throws (testing::TestError) {
    {
        let mut testArena192 = testArena();
        let testStorage192: 'test192 = &mut testArena192 in {
            let mut a = testResolver(testStorage192);
            let program = "let case _ = 1 else panic;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena193 = testArena();
        let testStorage193: 'test193 = &mut testArena193 in {
            let mut a = testResolver(testStorage193);
            let program = "let case _ = true else false;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

/// Test that `try?` converts errors to optionals without requiring caller to throw.
@test unsafe fn testResolveTryOptionalConvertsToOptional() throws (testing::TestError) {
    // `try?` should wrap the return type in optional and not require caller to throw.
    {
        let mut testArena203 = testArena();
        let testStorage203: 'test203 = &mut testArena203 in {
            let mut a = testResolver(testStorage203);
            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 testArena204 = testArena();
        let testStorage204: 'test204 = &mut testArena204 in {
            let mut a = testResolver(testStorage204);
            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 testArena205 = testArena();
        let testStorage205: 'test205 = &mut testArena205 in {
            let mut a = testResolver(testStorage205);
            let program = "fn fallible() -> i32 throws (i32) { panic; } fn caller() -> i32 { if let x = try? fallible() { return x; } return 0; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

@test unsafe fn testResolveBinaryOpArithmetic() throws (testing::TestError) {
    {
        let mut testArena209 = testArena();
        let testStorage209: 'test209 = &mut testArena209 in {
            let mut a = testResolver(testStorage209);
            let result = try resolveExprStr(&mut a, "4 + 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena210 = testArena();
        let testStorage210: 'test210 = &mut testArena210 in {
            let mut a = testResolver(testStorage210);
            let result = try resolveExprStr(&mut a, "10 - 3");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena211 = testArena();
        let testStorage211: 'test211 = &mut testArena211 in {
            let mut a = testResolver(testStorage211);
            let result = try resolveExprStr(&mut a, "5 * 6");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena212 = testArena();
        let testStorage212: 'test212 = &mut testArena212 in {
            let mut a = testResolver(testStorage212);
            let result = try resolveExprStr(&mut a, "20 / 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena213 = testArena();
        let testStorage213: 'test213 = &mut testArena213 in {
            let mut a = testResolver(testStorage213);
            let result = try resolveExprStr(&mut a, "17 % 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena214 = testArena();
        let testStorage214: 'test214 = &mut testArena214 in {
            let mut a = testResolver(testStorage214);
            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 testArena215 = testArena();
        let testStorage215: 'test215 = &mut testArena215 in {
            let mut a = testResolver(testStorage215);
            let result = try resolveExprStr(&mut a, "1 + (2 * 3) - 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena216 = testArena();
        let testStorage216: 'test216 = &mut testArena216 in {
            let mut a = testResolver(testStorage216);
            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 testArena217 = testArena();
        let testStorage217: 'test217 = &mut testArena217 in {
            let mut a = testResolver(testStorage217);
            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 testArena218 = testArena();
        let testStorage218: 'test218 = &mut testArena218 in {
            let mut a = testResolver(testStorage218);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; n - 1;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    }
}

@test unsafe fn testResolveBinaryOpComparison() throws (testing::TestError) {
    {
        let mut testArena219 = testArena();
        let testStorage219: 'test219 = &mut testArena219 in {
            let mut a = testResolver(testStorage219);
            let result = try resolveExprStr(&mut a, "5 == 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena220 = testArena();
        let testStorage220: 'test220 = &mut testArena220 in {
            let mut a = testResolver(testStorage220);
            let result = try resolveExprStr(&mut a, "5 <> 10");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena221 = testArena();
        let testStorage221: 'test221 = &mut testArena221 in {
            let mut a = testResolver(testStorage221);
            let result = try resolveExprStr(&mut a, "5 < 10");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena222 = testArena();
        let testStorage222: 'test222 = &mut testArena222 in {
            let mut a = testResolver(testStorage222);
            let result = try resolveExprStr(&mut a, "10 > 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena223 = testArena();
        let testStorage223: 'test223 = &mut testArena223 in {
            let mut a = testResolver(testStorage223);
            let result = try resolveExprStr(&mut a, "5 <= 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena224 = testArena();
        let testStorage224: 'test224 = &mut testArena224 in {
            let mut a = testResolver(testStorage224);
            let result = try resolveExprStr(&mut a, "10 >= 5");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena225 = testArena();
        let testStorage225: 'test225 = &mut testArena225 in {
            let mut a = testResolver(testStorage225);
            let result = try resolveExprStr(&mut a, "true == false");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena226 = testArena();
        let testStorage226: 'test226 = &mut testArena226 in {
            let mut a = testResolver(testStorage226);
            let result = try resolveExprStr(&mut a, "5 + 3 > 10 - 4");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena227 = testArena();
        let testStorage227: 'test227 = &mut testArena227 in {
            let mut a = testResolver(testStorage227);
            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 testArena228 = testArena();
        let testStorage228: 'test228 = &mut testArena228 in {
            let mut a = testResolver(testStorage228);
            let result = try resolveBlockStr(&mut a, "let n: i32 = 5; 1 == n;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::Bool);
        }
    }
}

@test unsafe fn testResolveBinaryOpLogical() throws (testing::TestError) {
    {
        let mut testArena229 = testArena();
        let testStorage229: 'test229 = &mut testArena229 in {
            let mut a = testResolver(testStorage229);
            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 testArena230 = testArena();
        let testStorage230: 'test230 = &mut testArena230 in {
            let mut a = testResolver(testStorage230);
            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 testArena231 = testArena();
        let testStorage231: 'test231 = &mut testArena231 in {
            let mut a = testResolver(testStorage231);
            let result = try resolveExprStr(&mut a, "true and false");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    }
}

@test unsafe fn testResolveBinaryOpArithmeticTypeMismatch() throws (testing::TestError) {
    {
        let mut testArena232 = testArena();
        let testStorage232: 'test232 = &mut testArena232 in {
            let mut a = testResolver(testStorage232);
            let result = try resolveProgramStr(&mut a, "4 + true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena233 = testArena();
        let testStorage233: 'test233 = &mut testArena233 in {
            let mut a = testResolver(testStorage233);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 4; let y: bool = false; x + y;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena234 = testArena();
        let testStorage234: 'test234 = &mut testArena234 in {
            let mut a = testResolver(testStorage234);
            let result = try resolveProgramStr(&mut a, "10 - false");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena235 = testArena();
        let testStorage235: 'test235 = &mut testArena235 in {
            let mut a = testResolver(testStorage235);
            let result = try resolveProgramStr(&mut a, "5 * true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena236 = testArena();
        let testStorage236: 'test236 = &mut testArena236 in {
            let mut a = testResolver(testStorage236);
            let result = try resolveProgramStr(&mut a, "20 / false");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena237 = testArena();
        let testStorage237: 'test237 = &mut testArena237 in {
            let mut a = testResolver(testStorage237);
            let result = try resolveProgramStr(&mut a, "17 % true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena238 = testArena();
        let testStorage238: 'test238 = &mut testArena238 in {
            let mut a = testResolver(testStorage238);
            let result = try resolveProgramStr(&mut a, "1 + (true * 3)");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    }
}

@test unsafe fn testResolveBinaryOpLogicalTypeMismatch() throws (testing::TestError) {
    {
        let mut testArena239 = testArena();
        let testStorage239: 'test239 = &mut testArena239 in {
            let mut a = testResolver(testStorage239);
            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 testArena240 = testArena();
        let testStorage240: 'test240 = &mut testArena240 in {
            let mut a = testResolver(testStorage240);
            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 testArena241 = testArena();
        let testStorage241: 'test241 = &mut testArena241 in {
            let mut a = testResolver(testStorage241);
            let result = try resolveProgramStr(&mut a, "1 and 2");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    }
}

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

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

@test unsafe fn testResolveUnaryOpNot() throws (testing::TestError) {
    {
        let mut testArena243 = testArena();
        let testStorage243: 'test243 = &mut testArena243 in {
            let mut a = testResolver(testStorage243);
            let result = try resolveExprStr(&mut a, "not true");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena244 = testArena();
        let testStorage244: 'test244 = &mut testArena244 in {
            let mut a = testResolver(testStorage244);
            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 testArena245 = testArena();
        let testStorage245: 'test245 = &mut testArena245 in {
            let mut a = testResolver(testStorage245);
            let result = try resolveExprStr(&mut a, "not (true and false)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena246 = testArena();
        let testStorage246: 'test246 = &mut testArena246 in {
            let mut a = testResolver(testStorage246);
            let result = try resolveProgramStr(&mut a, "not 42");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::Int);
        }
    } {
        let mut testArena247 = testArena();
        let testStorage247: 'test247 = &mut testArena247 in {
            let mut a = testResolver(testStorage247);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 5; not x;");
            let err = try expectError(&result);
            try expectTypeMismatch(err, super::Type::Bool, super::Type::I32);
        }
    }
}

@test unsafe fn testResolveUnaryOpNeg() throws (testing::TestError) {
    {
        let mut testArena248 = testArena();
        let testStorage248: 'test248 = &mut testArena248 in {
            let mut a = testResolver(testStorage248);
            let result = try resolveExprStr(&mut a, "-42");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena249 = testArena();
        let testStorage249: 'test249 = &mut testArena249 in {
            let mut a = testResolver(testStorage249);
            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 testArena250 = testArena();
        let testStorage250: 'test250 = &mut testArena250 in {
            let mut a = testResolver(testStorage250);
            let result = try resolveExprStr(&mut a, "-(5 + 3)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena251 = testArena();
        let testStorage251: 'test251 = &mut testArena251 in {
            let mut a = testResolver(testStorage251);
            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 testArena252 = testArena();
        let testStorage252: 'test252 = &mut testArena252 in {
            let mut a = testResolver(testStorage252);
            let result = try resolveProgramStr(&mut a, "-true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena253 = testArena();
        let testStorage253: 'test253 = &mut testArena253 in {
            let mut a = testResolver(testStorage253);
            let result = try resolveBlockStr(&mut a, "let x: bool = false; -x;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    }
}

@test unsafe fn testResolveUnaryOpBitNot() throws (testing::TestError) {
    {
        let mut testArena254 = testArena();
        let testStorage254: 'test254 = &mut testArena254 in {
            let mut a = testResolver(testStorage254);
            let result = try resolveExprStr(&mut a, "~42");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena255 = testArena();
        let testStorage255: 'test255 = &mut testArena255 in {
            let mut a = testResolver(testStorage255);
            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 testArena256 = testArena();
        let testStorage256: 'test256 = &mut testArena256 in {
            let mut a = testResolver(testStorage256);
            let result = try resolveExprStr(&mut a, "~(0xFF)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena257 = testArena();
        let testStorage257: 'test257 = &mut testArena257 in {
            let mut a = testResolver(testStorage257);
            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 testArena258 = testArena();
        let testStorage258: 'test258 = &mut testArena258 in {
            let mut a = testResolver(testStorage258);
            let result = try resolveProgramStr(&mut a, "~true");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    } {
        let mut testArena259 = testArena();
        let testStorage259: 'test259 = &mut testArena259 in {
            let mut a = testResolver(testStorage259);
            let result = try resolveBlockStr(&mut a, "let x: bool = false; ~x;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
        }
    }
}

@test unsafe fn testResolveUnaryOpNested() throws (testing::TestError) {
    {
        let mut testArena260 = testArena();
        let testStorage260: 'test260 = &mut testArena260 in {
            let mut a = testResolver(testStorage260);
            let result = try resolveExprStr(&mut a, "not not true");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Bool);
        }
    } {
        let mut testArena261 = testArena();
        let testStorage261: 'test261 = &mut testArena261 in {
            let mut a = testResolver(testStorage261);
            let result = try resolveExprStr(&mut a, "--42");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena262 = testArena();
        let testStorage262: 'test262 = &mut testArena262 in {
            let mut a = testResolver(testStorage262);
            let result = try resolveExprStr(&mut a, "~~0xFF");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    } {
        let mut testArena263 = testArena();
        let testStorage263: 'test263 = &mut testArena263 in {
            let mut a = testResolver(testStorage263);
            let result = try resolveExprStr(&mut a, "-(~42)");
            try expectNoErrors(&result);
            try expectType(&a, result.root, super::Type::Int);
        }
    }
}

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

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

@test unsafe fn testResolveDeref() throws (testing::TestError) {
    {
        let mut testArena264 = testArena();
        let testStorage264: 'test264 = &mut testArena264 in {
            let mut a = testResolver(testStorage264);
            let result = try resolveBlockStr(&mut a, "static x: i32 = 42; let ptr: *i32 = &x; *ptr;");
            try expectNoErrors(&result);
            let stmt = try parser::tests::getBlockLastStmt(result.root);
            try expectExprStmtType(&a, stmt, super::Type::I32);
        }
    } {
        let mut testArena265 = testArena();
        let testStorage265: 'test265 = &mut testArena265 in {
            let mut a = testResolver(testStorage265);
            let result = try resolveExprStr(&mut a, "*42");
            try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
        }
    } {
        let mut testArena266 = testArena();
        let testStorage266: 'test266 = &mut testArena266 in {
            let mut a = testResolver(testStorage266);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 5; *x;");
            try expectErrorKind(&result, super::ErrorKind::ExpectedPointer);
        }
    }
}

@test unsafe fn testResolveAssignDeref() throws (testing::TestError) {
    {
        let mut testArena267 = testArena();
        let testStorage267: 'test267 = &mut testArena267 in {
            let mut a = testResolver(testStorage267);
            let program = "static x: i32 = 0; let ptr: *mut i32 = &mut x; set *ptr = 42;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    } {
        let mut testArena268 = testArena();
        let testStorage268: 'test268 = &mut testArena268 in {
            let mut a = testResolver(testStorage268);
            let program = "static x: i32 = 0; let ptr: *i32 = &x; set *ptr = 42;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut testArena269 = testArena();
        let testStorage269: 'test269 = &mut testArena269 in {
            let mut a = testResolver(testStorage269);
            let program = "static x: i32 = 0; let mut ptr: *i32 = &x; set *ptr = 42;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);
        }
    } {
        let mut testArena270 = testArena();
        let testStorage270: 'test270 = &mut testArena270 in {
            let mut a = testResolver(testStorage270);
            let program = "static x: u8 = 0; let mut ptr: *mut u8 = &mut x; set *ptr = 255;";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

@test unsafe fn testResolveBasicTypeInference() throws (testing::TestError) {
    {
        // Boolean literals are unambiguous.
        let mut testArena271 = testArena();
        let testStorage271: 'test271 = &mut testArena271 in {
            let mut a = testResolver(testStorage271);
            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 testArena272 = testArena();
        let testStorage272: 'test272 = &mut testArena272 in {
            let mut a = testResolver(testStorage272);
            let result = try resolveProgramStr(&mut a, "let x = 34;");
            try expectErrorKind(&result, super::ErrorKind::CannotInferType);
        }
    }
}

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

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

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

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

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

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

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

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

        // TODO: Test payload type.
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testResolveAlignAnnotation() throws (testing::TestError) {
    {
        let mut testArena284 = testArena();
        let testStorage284: 'test284 = &mut testArena284 in {
            let mut a = testResolver(testStorage284);
            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 testArena285 = testArena();
        let testStorage285: 'test285 = &mut testArena285 in {
            let mut a = testResolver(testStorage285);
            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 testArena286 = testArena();
        let testStorage286: 'test286 = &mut testArena286 in {
            let mut a = testResolver(testStorage286);
            let result = try resolveProgramStr(&mut a, "let x: u32 align(7) = 0;");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAlignmentValue(val) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(val == 7);
        }
    }
}

@test unsafe fn testResolveVoidAssignmentError() throws (testing::TestError) {
    {
        let mut testArena287 = testArena();
        let testStorage287: 'test287 = &mut testArena287 in {
            let mut a = testResolver(testStorage287);
            let program = "fn voidFn() {} let _ = voidFn();";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
        }
    } {
        let mut testArena288 = testArena();
        let testStorage288: 'test288 = &mut testArena288 in {
            let mut a = testResolver(testStorage288);
            let program = "fn voidFn() {} let x = voidFn();";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::CannotAssignVoid);
        }
    }
}

//
// Module Declaration Tests
//

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Mixed-width range bounds require an explicit cast.
@test unsafe fn testRangeEndTypeSubType() throws (testing::TestError) {
    {
        let mut testArena331 = testArena();
        let testStorage331: 'test331 = &mut testArena331 in {
            let mut a = testResolver(testStorage331);
            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 testArena332 = testArena();
        let testStorage332: 'test332 = &mut testArena332 in {
            let mut a = testResolver(testStorage332);
            let program = "fn f(start: i8, end: u32) { for i in (start as u32)..end {} }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

// Opaque pointer tests.

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

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

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

/// You cannot have a value of type `opaque` (function parameter).
@test unsafe fn testOpaqueValue() throws (testing::TestError) {
    {
        let mut testArena343 = testArena();
        let testStorage343: 'test343 = &mut testArena343 in {
            let mut a = testResolver(testStorage343);
            let result = try resolveProgramStr(&mut a, "fn f(x: opaque) {}");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        }
    } {
        let mut testArena344 = testArena();
        let testStorage344: 'test344 = &mut testArena344 in {
            let mut a = testResolver(testStorage344);
            let result = try resolveProgramStr(&mut a, "unsafe fn f() { let x: opaque = undefined; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        }
    } {
        let mut testArena345 = testArena();
        let testStorage345: 'test345 = &mut testArena345 in {
            let mut a = testResolver(testStorage345);
            let result = try resolveProgramStr(&mut a, "record R { x: opaque }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
        }
    }
}

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

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

/// You cannot do pointer arithmetic with an opaque pointer.
@test unsafe fn testOpaquePointerNoArithmetic() throws (testing::TestError) {
    {
        let mut testArena348 = testArena();
        let testStorage348: 'test348 = &mut testArena348 in {
            let mut a = testResolver(testStorage348);
            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 testArena349 = testArena();
        let testStorage349: 'test349 = &mut testArena349 in {
            let mut a = testResolver(testStorage349);
            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 testArena350 = testArena();
        let testStorage350: 'test350 = &mut testArena350 in {
            let mut a = testResolver(testStorage350);
            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 testArena351 = testArena();
        let testStorage351: 'test351 = &mut testArena351 in {
            let mut a = testResolver(testStorage351);
            let result = try resolveProgramStr(&mut a, "fn f(a: *i32) { let o: *opaque = a; let x = 1 - o; }");
            let err = try expectError(&result);
            try expectErrorKind(&result, super::ErrorKind::OpaquePointerArithmetic);
        }
    }
}

// Wildcard import/reexport tests.

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

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

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

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

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

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

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

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

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

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

        // Verify the array constant has the correct type with length 3.
        let arrStmt = try getBlockStmt(result.root, 1);
        let sym = super::symbolFor(&a, arrStmt)
            else throw testing::TestError::Failed;
        let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
            else throw testing::TestError::Failed;
        try testing::expect(arrType.length == 3);
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Test that function pointers with different parameter types are not assignable.
@test unsafe fn testFnPointerParamMismatch() throws (testing::TestError) {
    let mut testArena365 = testArena();
    let testStorage365: 'test365 = &mut testArena365 in {
        let mut a = testResolver(testStorage365);
        let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i8) -> i32 { return n as i32; } apply(other, 5);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that function pointers with different return types are not assignable.
@test unsafe fn testFnPointerReturnMismatch() throws (testing::TestError) {
    let mut testArena366 = testArena();
    let testStorage366: 'test366 = &mut testArena366 in {
        let mut a = testResolver(testStorage366);
        let program = "fn apply(f: fn(i32) -> i32, x: i32) -> i32 { return f(x); } fn other(n: i32) -> i8 { return n as i8; } apply(other, 5);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that named records use nominal typing, not structural.
///
/// Two different named record types with identical fields should NOT be
/// assignable to each other, because they are distinct nominal types.
@test unsafe fn testNamedRecordNominalTyping() throws (testing::TestError) {
    let mut testArena367 = testArena();
    let testStorage367: 'test367 = &mut testArena367 in {
        let mut a = testResolver(testStorage367);
        let program = "record Point { x: i32, y: i32 } record Vec2 { x: i32, y: i32 } fn take(p: Point) -> i32 { return p.x; } let v = Vec2 { x: 1, y: 2 }; take(v);";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test that union variants with labeled record payloads can be constructed.
@test unsafe fn testUnionVariantAnonRecordPayload() throws (testing::TestError) {
    let mut testArena368 = testArena();
    let testStorage368: 'test368 = &mut testArena368 in {
        let mut a = testResolver(testStorage368);
        let program = "union Event { Click { x: i32, y: i32 }, Key { code: u32 } } let e = Event::Click { x: 10, y: 20 };";
        let result = try resolveProgramStr(&mut a, program);
        try expectNoErrors(&result);
    }
}

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

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

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

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

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

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

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

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

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

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

/// Test record pattern with `..` ignoring fields.
@test unsafe fn testResolveMatchRecordPatternIgnoreRest() throws (testing::TestError) {
    {
        let mut testArena379 = testArena();
        let testStorage379: 'test379 = &mut testArena379 in {
            let mut a = testResolver(testStorage379);
            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 testArena380 = testArena();
        let testStorage380: 'test380 = &mut testArena380 in {
            let mut a = testResolver(testStorage380);
            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 testArena381 = testArena();
        let testStorage381: 'test381 = &mut testArena381 in {
            let mut a = testResolver(testStorage381);
            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 testArena382 = testArena();
        let testStorage382: 'test382 = &mut testArena382 in {
            let mut a = testResolver(testStorage382);
            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 testArena383 = testArena();
        let testStorage383: 'test383 = &mut testArena383 in {
            let mut a = testResolver(testStorage383);
            let program = "union G { Point { x: i32, y: i32, z: i32 } } fn f(g: G) -> bool { match g { case G::Point { .. } => return true } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

/// Test @sliceOf with wrong argument count produces an error.
@test unsafe fn testResolveSliceOfWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut testArena396 = testArena();
        let testStorage396: 'test396 = &mut testArena396 in {
            let mut a = testResolver(testStorage396);
            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 testArena397 = testArena();
        let testStorage397: 'test397 = &mut testArena397 in {
            let mut a = testResolver(testStorage397);
            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 testArena398 = testArena();
        let testStorage398: 'test398 = &mut testArena398 in {
            let mut a = testResolver(testStorage398);
            let program = "fn f(ptr: *u8, len: u32, cap: u32, extra: u32) -> *[u8] { return @sliceOf(ptr, len, cap, extra); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::BuiltinArgCountMismatch(mismatch) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(mismatch.expected == 2);
            try testing::expect(mismatch.actual == 4);
        }
    }
}

/// Test @sliceOf with wrong argument types produces errors.
@test unsafe fn testResolveSliceOfWrongArgTypes() throws (testing::TestError) {
    // Non-pointer first argument.
    {
        let mut testArena399 = testArena();
        let testStorage399: 'test399 = &mut testArena399 in {
            let mut a = testResolver(testStorage399);
            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 testArena400 = testArena();
        let testStorage400: 'test400 = &mut testArena400 in {
            let mut a = testResolver(testStorage400);
            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 testArena401 = testArena();
        let testStorage401: 'test401 = &mut testArena401 in {
            let mut a = testResolver(testStorage401);
            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 testArena402 = testArena();
        let testStorage402: 'test402 = &mut testArena402 in {
            let mut a = testResolver(testStorage402);
            let program = "fn f(ptr: *u8, len: *u32) -> *[u8] { return @sliceOf(ptr, len); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::TypeMismatch(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

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

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

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

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

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

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

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

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

/// Test `.delete()` with wrong argument count produces an error.
@test unsafe fn testResolveSliceDeleteWrongArgCount() throws (testing::TestError) {
    // No arguments.
    {
        let mut testArena413 = testArena();
        let testStorage413: 'test413 = &mut testArena413 in {
            let mut a = testResolver(testStorage413);
            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 testArena414 = testArena();
        let testStorage414: 'test414 = &mut testArena414 in {
            let mut a = testResolver(testStorage414);
            let program = "fn f(s: *mut [i32]) { s.delete(0, 1); }";
            let result = try resolveProgramStr(&mut a, program);
            let err = try expectError(&result);
            let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
                else throw testing::TestError::Failed;
            try testing::expect(m.expected == 1);
            try testing::expect(m.actual == 2);
        }
    }
}

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

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

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

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

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

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

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

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

/// Non-constant integer widening must use an explicit cast.
@test unsafe fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
    {
        let mut testArena419 = testArena();
        let testStorage419: 'test419 = &mut testArena419 in {
            let mut a = testResolver(testStorage419);
            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 testArena420 = testArena();
        let testStorage420: 'test420 = &mut testArena420 in {
            let mut a = testResolver(testStorage420);
            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 testArena421 = testArena();
        let testStorage421: 'test421 = &mut testArena421 in {
            let mut a = testResolver(testStorage421);
            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 testArena422 = testArena();
        let testStorage422: 'test422 = &mut testArena422 in {
            let mut a = testResolver(testStorage422);
            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 testArena423 = testArena();
        let testStorage423: 'test423 = &mut testArena423 in {
            let mut a = testResolver(testStorage423);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = x as u32;");
            try expectNoErrors(&result);
        }
    } {
        let mut testArena424 = testArena();
        let testStorage424: 'test424 = &mut testArena424 in {
            let mut a = testResolver(testStorage424);
            let result = try resolveBlockStr(&mut a, "let x: i8 = 1; let y: i32 = x as i32;");
            try expectNoErrors(&result);
        }
    }
}

/// Mixed-width integer binary ops require an explicit cast.
@test unsafe fn testResolveIntegerWideningBinOpRequiresCast() throws (testing::TestError) {
    {
        let mut testArena425 = testArena();
        let testStorage425: 'test425 = &mut testArena425 in {
            let mut a = testResolver(testStorage425);
            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 testArena426 = testArena();
        let testStorage426: 'test426 = &mut testArena426 in {
            let mut a = testResolver(testStorage426);
            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 testArena427 = testArena();
        let testStorage427: 'test427 = &mut testArena427 in {
            let mut a = testResolver(testStorage427);
            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 testArena428 = testArena();
        let testStorage428: 'test428 = &mut testArena428 in {
            let mut a = testResolver(testStorage428);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u8 = x << 2;");
            try expectNoErrors(&result);
        }
    } {
        let mut testArena429 = testArena();
        let testStorage429: 'test429 = &mut testArena429 in {
            let mut a = testResolver(testStorage429);
            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 testArena430 = testArena();
        let testStorage430: 'test430 = &mut testArena430 in {
            let mut a = testResolver(testStorage430);
            let result = try resolveBlockStr(&mut a, "let x: u8 = 1; let y: u32 = 2; let z: u32 = (x as u32) + y;");
            try expectNoErrors(&result);
        }
    }
}

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

/// Comprehensive tests for `as` cast expressions.
@test unsafe fn testResolveAsCasts() throws (testing::TestError) {
    { // Pointer to numeric.
        let mut testArena432 = testArena();
        let testStorage432: 'test432 = &mut testArena432 in {
            let mut a = testResolver(testStorage432);
            let result = try resolveBlockStr(&mut a, "static x: i32 = 0; let p = &x; p as u32;");
            try expectNoErrors(&result);
        }
    } { // Function pointer to numeric.
        let mut testArena433 = testArena();
        let testStorage433: 'test433 = &mut testArena433 in {
            let mut a = testResolver(testStorage433);
            let result = try resolveProgramStr(&mut a, "fn run(f: fn()) { f as u32; }");
            try expectNoErrors(&result);
        }
    } { // *u8 to *i32 (u8 to i32 is valid).
        let mut testArena434 = testArena();
        let testStorage434: 'test434 = &mut testArena434 in {
            let mut a = testResolver(testStorage434);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: *u8 = undefined; p as *i32; }");
            try expectNoErrors(&result);
        }
    } { // **u8 to **i32 (*u8 to *i32 is valid).
        let mut testArena435 = testArena();
        let testStorage435: 'test435 = &mut testArena435 in {
            let mut a = testResolver(testStorage435);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let p: **u8 = undefined; p as **i32; }");
            try expectNoErrors(&result);
        }
    }

    { // *[i32] to *[opaque].
        let mut testArena436 = testArena();
        let testStorage436: 'test436 = &mut testArena436 in {
            let mut a = testResolver(testStorage436);
            let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *[opaque]; }");
            try expectNoErrors(&result);
        }
    } { // *[opaque] to *[i32].
        let mut testArena437 = testArena();
        let testStorage437: 'test437 = &mut testArena437 in {
            let mut a = testResolver(testStorage437);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[opaque] = undefined; s as *[i32]; }");
            try expectNoErrors(&result);
        }
    }

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

    { // *[u8] to *[i32].
        let mut testArena440 = testArena();
        let testStorage440: 'test440 = &mut testArena440 in {
            let mut a = testResolver(testStorage440);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[u8] = undefined; s as *[i32]; }");
            try expectNoErrors(&result);
        }
    } { // *[*u8] to *[*i32]
        let mut testArena441 = testArena();
        let testStorage441: 'test441 = &mut testArena441 in {
            let mut a = testResolver(testStorage441);
            let result = try resolveProgramStr(&mut a, "unsafe fn run() { let s: *[*u8] = undefined; s as *[*i32]; }");
            try expectNoErrors(&result);
        }
    }

    { // Identity cast: *mut [i32] to *mut [i32].
        let mut testArena442 = testArena();
        let testStorage442: 'test442 = &mut testArena442 in {
            let mut a = testResolver(testStorage442);
            let result = try resolveProgramStr(&mut a, "fn run(s: *mut [i32]) { s as *mut [i32]; }");
            try expectNoErrors(&result);
        }
    } { // Identity cast: *i32 to *i32.
        let mut testArena443 = testArena();
        let testStorage443: 'test443 = &mut testArena443 in {
            let mut a = testResolver(testStorage443);
            let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *i32; }");
            try expectNoErrors(&result);
        }
    } { // Identity cast: i32 to i32.
        let mut testArena444 = testArena();
        let testStorage444: 'test444 = &mut testArena444 in {
            let mut a = testResolver(testStorage444);
            let result = try resolveBlockStr(&mut a, "let x: i32 = 0; x as i32;");
            try expectNoErrors(&result);
        }
    }
}

/// Tests for invalid `as` casts that should be rejected.
@test unsafe fn testResolveAsCastsInvalid() throws (testing::TestError) {
    { // Pointer to slice is invalid.
        let mut testArena445 = testArena();
        let testStorage445: 'test445 = &mut testArena445 in {
            let mut a = testResolver(testStorage445);
            let result = try resolveProgramStr(&mut a, "fn run(p: *i32) { p as *[i32]; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // Slice to pointer is invalid.
        let mut testArena446 = testArena();
        let testStorage446: 'test446 = &mut testArena446 in {
            let mut a = testResolver(testStorage446);
            let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as *i32; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // *T to *i32 is invalid.
        let mut testArena447 = testArena();
        let testStorage447: 'test447 = &mut testArena447 in {
            let mut a = testResolver(testStorage447);
            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 testArena448 = testArena();
        let testStorage448: 'test448 = &mut testArena448 in {
            let mut a = testResolver(testStorage448);
            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 testArena449 = testArena();
        let testStorage449: 'test449 = &mut testArena449 in {
            let mut a = testResolver(testStorage449);
            let result = try resolveProgramStr(&mut a, "fn run(s: *[i32]) { s as u32; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    } { // *record to *u8 is invalid.
        let mut testArena450 = testArena();
        let testStorage450: 'test450 = &mut testArena450 in {
            let mut a = testResolver(testStorage450);
            let result = try resolveProgramStr(&mut a, "record R { x: i32 } fn f(p: *R) { p as *u8; }");
            let err = try expectError(&result);
            let case super::ErrorKind::InvalidAsCast(_) = err.kind
                else throw testing::TestError::Failed;
        }
    }
}

/// Test that catch binding is available in catch block scope.
@test unsafe fn testResolveTryCatchBinding() throws (testing::TestError) {
    {
        let mut testArena451 = testArena();
        let testStorage451: 'test451 = &mut testArena451 in {
            let mut a = testResolver(testStorage451);
            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 testArena452 = testArena();
        let testStorage452: 'test452 = &mut testArena452 in {
            let mut a = testResolver(testStorage452);
            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 testArena453 = testArena();
        let testStorage453: 'test453 = &mut testArena453 in {
            let mut a = testResolver(testStorage453);
            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 testArena454 = testArena();
        let testStorage454: 'test454 = &mut testArena454 in {
            let mut a = testResolver(testStorage454);
            let program = "union Error { Fail(u32) } fn fallible() -> u32 throws (Error) { throw Error::Fail(42); } fn caller() -> u32 { return try fallible() catch err { match err { case Error::Fail(x) => return x, } }; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that duplicate union variant patterns are detected.
@test unsafe fn testResolveMatchDuplicateUnionPattern() throws (testing::TestError) {
    {
        let mut testArena455 = testArena();
        let testStorage455: 'test455 = &mut testArena455 in {
            let mut a = testResolver(testStorage455);
            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 testArena456 = testArena();
        let testStorage456: 'test456 = &mut testArena456 in {
            let mut a = testResolver(testStorage456);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, case U::B => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that duplicate bool patterns are detected.
@test unsafe fn testResolveMatchDuplicateBoolPattern() throws (testing::TestError) {
    {
        let mut testArena457 = testArena();
        let testStorage457: 'test457 = &mut testArena457 in {
            let mut a = testResolver(testStorage457);
            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 testArena458 = testArena();
        let testStorage458: 'test458 = &mut testArena458 in {
            let mut a = testResolver(testStorage458);
            let program = "fn f(x: bool) { match x { case false => {}, case false => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    }
}

/// Test that duplicate nil patterns in optional match are detected.
@test unsafe fn testResolveMatchDuplicateOptionalPattern() throws (testing::TestError) {
    {
        let mut testArena459 = testArena();
        let testStorage459: 'test459 = &mut testArena459 in {
            let mut a = testResolver(testStorage459);
            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 testArena460 = testArena();
        let testStorage460: 'test460 = &mut testArena460 in {
            let mut a = testResolver(testStorage460);
            let program = "fn f(opt: ?i32) { match opt { v => {}, w => {}, case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::DuplicateMatchPattern);
        }
    }
}

/// Test that guarded match arms are not considered duplicates.
@test unsafe fn testResolveMatchGuardedNotDuplicate() throws (testing::TestError) {
    {
        // Guarded union variant followed by same variant is fine.
        let mut testArena461 = testArena();
        let testStorage461: 'test461 = &mut testArena461 in {
            let mut a = testResolver(testStorage461);
            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 testArena462 = testArena();
        let testStorage462: 'test462 = &mut testArena462 in {
            let mut a = testResolver(testStorage462);
            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 testArena463 = testArena();
        let testStorage463: 'test463 = &mut testArena463 in {
            let mut a = testResolver(testStorage463);
            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 testArena464 = testArena();
        let testStorage464: 'test464 = &mut testArena464 in {
            let mut a = testResolver(testStorage464);
            let program = "fn f(opt: ?i32) { match opt { v if true => {}, w => {}, case nil => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that unreachable else is detected when all union variants are covered.
@test unsafe fn testResolveMatchUnreachableElseUnion() throws (testing::TestError) {
    {
        let mut testArena465 = testArena();
        let testStorage465: 'test465 = &mut testArena465 in {
            let mut a = testResolver(testStorage465);
            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 testArena466 = testArena();
        let testStorage466: 'test466 = &mut testArena466 in {
            let mut a = testResolver(testStorage466);
            let program = "union U { A, B } fn f(u: U) { match u { case U::A => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that unreachable else is detected when both bool cases are covered.
@test unsafe fn testResolveMatchUnreachableElseBool() throws (testing::TestError) {
    {
        let mut testArena467 = testArena();
        let testStorage467: 'test467 = &mut testArena467 in {
            let mut a = testResolver(testStorage467);
            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 testArena468 = testArena();
        let testStorage468: 'test468 = &mut testArena468 in {
            let mut a = testResolver(testStorage468);
            let program = "fn f(x: bool) { match x { case true => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

/// Test that unreachable else is detected when both optional cases are covered.
@test unsafe fn testResolveMatchUnreachableElseOptional() throws (testing::TestError) {
    {
        let mut testArena469 = testArena();
        let testStorage469: 'test469 = &mut testArena469 in {
            let mut a = testResolver(testStorage469);
            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 testArena470 = testArena();
        let testStorage470: 'test470 = &mut testArena470 in {
            let mut a = testResolver(testStorage470);
            let program = "fn f(opt: ?i32) { match opt { v => {}, else => {} } }";
            let result = try resolveProgramStr(&mut a, program);
            try expectNoErrors(&result);
        }
    }
}

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

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

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

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

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

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

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

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

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

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

@test unsafe fn testResolveInstanceReceiverTypeMustMatchTarget() throws (testing::TestError) {
    let mut testArena480 = testArena();
    let testStorage480: 'test480 = &mut testArena480 in {
        let mut a = testResolver(testStorage480);
        let program = "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

@test unsafe fn testResolveTraitMethodThrowsRequireTry() throws (testing::TestError) {
    let mut testArena481 = testArena();
    let testStorage481: 'test481 = &mut testArena481 in {
        let mut a = testResolver(testStorage481);
        let program = "union Error { Fail } record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32 throws (Error); } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 throws (Error) { throw Error::Fail; return n; } } fn caller(a: *mut opaque Adder) -> i32 { return a.add(1); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::MissingTry);
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Instance method body type must match the trait return type.
/// The trait declares `-> i32` but the body returns `bool`.
@test unsafe fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) {
    let mut testArena492 = testArena();
    let testStorage492: 'test492 = &mut testArena492 in {
        let mut a = testResolver(testStorage492);
        let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return true; } }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// References are rejected from every nested or storable type position.
@test unsafe fn testNestedRefPositionsRejected() throws (testing::TestError) {
    {
        let mut testArena526 = testArena();
        let testStorage526: 'test526 = &mut testArena526 in {
            let mut a = testResolver(testStorage526);
            let program = "record Marker: Once {} union Bad { Value(&u32) }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut testArena527 = testArena();
        let testStorage527: 'test527 = &mut testArena527 in {
            let mut a = testResolver(testStorage527);
            let program = "record Marker: Once {} fn bad(value: ?&u32) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut testArena528 = testArena();
        let testStorage528: 'test528 = &mut testArena528 in {
            let mut a = testResolver(testStorage528);
            let program = "record Marker: Once {} fn bad(value: [&u32; 1]) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut testArena529 = testArena();
        let testStorage529: 'test529 = &mut testArena529 in {
            let mut a = testResolver(testStorage529);
            let program = "record Marker: Once {} fn bad(value: *&u32) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut testArena530 = testArena();
        let testStorage530: 'test530 = &mut testArena530 in {
            let mut a = testResolver(testStorage530);
            let program = "record Marker: Once {} static BAD: &u32 = undefined;";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    } {
        let mut testArena531 = testArena();
        let testStorage531: 'test531 = &mut testArena531 in {
            let mut a = testResolver(testStorage531);
            let program = "record Marker: Once {} fn bad(callback: fn() -> &u32) {}";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
        }
    }
}

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

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

/// Every operation that interprets an unsafe address requires an unsafe declaration.
@test unsafe fn testUnsafePointerOperationsRejected() throws (testing::TestError) {
    {
        let mut testArena534 = testArena();
        let testStorage534: 'test534 = &mut testArena534 in {
            let mut a = testResolver(testStorage534);
            let program = "record Marker: Once {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut testArena535 = testArena();
        let testStorage535: 'test535 = &mut testArena535 in {
            let mut a = testResolver(testStorage535);
            let program = "record Marker: Once {} fn compare(pointer: *unsafe u32) -> bool { return pointer == pointer; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut testArena536 = testArena();
        let testStorage536: 'test536 = &mut testArena536 in {
            let mut a = testResolver(testStorage536);
            let program = "record Marker: Once {} fn offset(pointer: *unsafe u32) -> *unsafe u32 { return pointer + 1; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut testArena537 = testArena();
        let testStorage537: 'test537 = &mut testArena537 in {
            let mut a = testResolver(testStorage537);
            let program = "record Marker: Once {} fn index(values: *unsafe [u32]) -> u32 { return values[0]; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut testArena538 = testArena();
        let testStorage538: 'test538 = &mut testArena538 in {
            let mut a = testResolver(testStorage538);
            let program = "record Marker: Once {} record Cell { value: u32 } fn field(cell: *unsafe Cell) -> u32 { return cell.value; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut testArena539 = testArena();
        let testStorage539: 'test539 = &mut testArena539 in {
            let mut a = testResolver(testStorage539);
            let program = "record Marker: Once {} fn store(pointer: *unsafe mut u32) { set *pointer = 1; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    } {
        let mut testArena540 = testArena();
        let testStorage540: 'test540 = &mut testArena540 in {
            let mut a = testResolver(testStorage540);
            let program = "record Marker: Once {} fn cast() { let value: u32 = 0; let pointer = &value as *unsafe u32; }";
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
}

/// Pointer offsets require an unsafe function for either operand order.
@test unsafe fn testPointerArithmeticRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *u8 { return p + 1; }",
        "fn run(p: *u8) -> *u8 { return 1 + p; }",
        "fn run(p: *u8) -> *u8 { return p - 1; }",
        "fn run(input: *mut u8) { let mut p = input; set p += 1; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let p = &DATA[0]; return *(p + 1); }",
    ];
    for program in programs {
        let mut testArena541 = testArena();
        let testStorage541: 'test541 = &mut testArena541 in {
            let mut a = testResolver(testStorage541);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return p + 1; }");
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u8 { return 1 + p; }");
    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut u8 { return p - 1; }");
    try expectAnalyzeOk("fn run(value: u32) -> u32 { return value + 1; }");
}

/// Casts that reinterpret storage require an unsafe function.
@test unsafe fn testStorageCastsRequireUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *u64 { return p as *u64; }",
        "fn run(p: &u8) -> u64 { return *(p as &u64); }",
        "fn run(p: *mut u8) -> *mut u64 { return p as *mut u64; }",
        "fn run(p: *opaque) -> *u64 { return p as *u64; }",
        "fn run(p: **u8) -> **u64 { return p as **u64; }",
        "fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }",
        "fn run(s: *[opaque]) -> *[u64] { return s as *[u64]; }",
        "fn run(s: &mut [u64]) { let _ = s as &mut [u8]; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u64 { return *(&DATA[0] as *u64); }",
    ];
    for program in programs {
        let mut testArena542 = testArena();
        let testStorage542: 'test542 = &mut testArena542 in {
            let mut a = testResolver(testStorage542);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *u64 { return p as *u64; }");
    try expectAnalyzeOk("unsafe fn run(p: &u8) -> u64 { return *(p as &u64); }");
    try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *[u64] { return s as *[u64]; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *u8 { return p as *u8; }");
    try expectAnalyzeOk("fn run(p: *u8) -> *opaque { return p as *opaque; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *[opaque] { return s as *[opaque]; }");
    try expectAnalyzeOk("fn run(p: *mut u8) -> *u8 { return p as *u8; }");
}

/// Explicit slice bounds require an unsafe function.
@test unsafe fn testSliceConstructionRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(p: *u8) -> *[u8] { return @sliceOf(p, 100); }",
        "fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }",
        "fn run(p: &u8) -> u8 { return @sliceOf(p, 100)[99]; }",
        "fn run(p: &mut u8) { set @sliceOf(p, 100)[99] = 1; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = @sliceOf(&DATA[0], 100); return s[99]; }",
    ];
    for program in programs {
        let mut testArena543 = testArena();
        let testStorage543: 'test543 = &mut testArena543 in {
            let mut a = testResolver(testStorage543);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(p: *u8) -> *[u8] { return @sliceOf(p, 100); }");
    try expectAnalyzeOk("unsafe fn run(p: *mut u8) -> *mut [u8] { return @sliceOf(p, 0, 100); }");
    try expectAnalyzeOk("unsafe fn run(p: &u8) -> u8 { return @sliceOf(p, 1)[0]; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *[u8] { return &s[..]; }");
}

/// Slice header writes and mutable field borrows require an unsafe function.
@test unsafe fn testSliceHeaderMutationRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { set s.len = 100; }",
        "fn run(s: *mut [u8]) { set s.cap = 100; }",
        "fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }",
        "fn run(s: *mut [u8]) { set s.len += 1; }",
        "fn change(n: &mut u32) { set *n = 100; } fn run(s: *mut [u8]) { change(&mut s.len); }",
        "fn change(n: &mut u32) { set *n = 100; } fn run(s: *mut [u8]) { change(&mut s.cap); }",
        "fn change(p: &mut *u8, q: *u8) { set *p = q; } fn run(q: *u8) { let mut s: *[u8] = &[]; change(&mut s.ptr, q); }",
        "fn run(s: &mut *[u8]) { set s.len = 100; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let mut s = &DATA[..]; set s.len = 100; return s[99]; }",
    ];
    for program in programs {
        let mut testArena544 = testArena();
        let testStorage544: 'test544 = &mut testArena544 in {
            let mut a = testResolver(testStorage544);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(s: *mut [u8]) { set s.len = 0; set s.cap = 0; }");
    try expectAnalyzeOk("unsafe fn run(s: *mut [u8], p: *mut u8) { set s.ptr = p; }");
    try expectAnalyzeOk("fn change(n: &mut u32) { set *n = 0; } unsafe fn run(s: *mut [u8]) { change(&mut s.len); }");
    try expectAnalyzeOk("fn run(s: *mut [u8]) { set s[0] = 1; }");
    try expectAnalyzeOk("record R { len: u32 } fn run(r: &mut R) { set r.len = 1; }");
}

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

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

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

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

/// Slice pointer access requires an unsafe context for every slice class.
@test unsafe fn testSlicePointerRequiresUnsafe() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *[u8]) -> *u8 { return s.ptr; }",
        "fn run(s: *mut [u8]) -> *mut u8 { return s.ptr; }",
        "fn run(s: &[u8]) -> u8 { return *s.ptr; }",
        "fn run(s: &mut [u8]) { set *s.ptr = 1; }",
        "fn run(s: &*[u8]) -> *u8 { return s.ptr; }",
        "static DATA: [u8; 1] = [42]; fn run() -> u8 { let s = &DATA[1..]; return *s.ptr; }",
        "fn run(s: *[u8]) -> u64 { return s.ptr as u64; }",
    ];
    for program in programs {
        let mut testArena549 = testArena();
        let testStorage549: 'test549 = &mut testArena549 in {
            let mut a = testResolver(testStorage549);
            let result = try resolveProgramStr(&mut a, program);
            try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
        }
    }
    try expectAnalyzeOk("unsafe fn run(s: *[u8]) -> *u8 { return s.ptr; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> u64 { unsafe { return s.ptr as u64; } }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> *u8 { return &s[0]; }");
    try expectAnalyzeOk("fn run(s: *[u8]) -> u32 { return s.len + s.cap; }");
    try expectAnalyzeOk("record R { ptr: u32 } fn run(r: R) -> u32 { return r.ptr; }");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Test-only imports do not require their modules in a normal build.
@test unsafe fn testConditionalUse() throws (testing::TestError) {
    let mut testArena587 = testArena();
    let testStorage587: 'test587 = &mut testArena587 in {
        let mut a = testResolver(testStorage587);
        set a.config.buildTest = false;
        let source = "@test use missing::testing; fn value() -> u32 { return 1; }";
        let result = try resolveProgramStr(&mut a, source);
        try expectNoErrors(&result);
        set a.config.buildTest = true;
        let enabled = try resolveProgramStr(&mut a, source);
        try testing::expect(enabled.diagnostics.errors.len > 0);
    }
}

/// Resolver metadata retains its caller's arena when the context moves.
unsafe fn relocateResolver 'arena (context: super::Resolver 'arena) -> super::Resolver 'arena {
    return context;
}

@test unsafe fn testResolverRelocation() throws (testing::TestError) {
    static DATA: [u8; 65536] = [0; 65536];
    static AST_DATA: [u8; 8192] = [0; 8192];
    static NODES: [super::NodeData; 128] = undefined;
    static ERRORS: [super::Error; 8] = undefined;
    static SCOPE: super::Scope = undefined;
    static POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };
    let mut arena = alloc::new(&mut DATA[..]);
    let mut astArena = ast::nodeArena(&mut AST_DATA[..]);
    let root = try! parser::parse(scanner::SourceLoc::String,
        "fn answer() -> u32 { return 42; }", &mut astArena, &mut POOL);
    let storage = super::ResolverStorage {
        nodeData: &mut NODES[..], pkgScope: &mut SCOPE, errors: &mut ERRORS[..],
    };
    let arenaRef: 'arena = &mut arena in {
        let context = super::resolver(arenaRef, storage, super::Config { buildTest: false });
        let initialized = alloc::used(context.arena);
        try testing::expect(initialized > 0);
        let mut moved = relocateResolver(context);
        let diagnostics = try! super::resolveModuleRoot(&mut moved, root);
        try testing::expect(super::success(&diagnostics));
        try testing::expect(alloc::used(moved.arena) > initialized);
        try testing::expect(moved.arena.offset == alloc::used(moved.arena));
        let output = try! alloc::alloc(&mut *moved.arena, @sizeOf(u32), @alignOf(u32)) as *mut u32;
        set *output = 42;
        try testing::expect(*output == 42);
    }
}