//! 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;

/// Interning preserves exact identity across populated collision chains.

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

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let item = super::allocType(&mut res, super::Type::U32);

        let mut entries: [?*super::Type; 2048] = [nil; 2048];

        for i in 0..entries.len {

            let ty = super::Type::Array(super::ArrayType { item, length: i });

            set entries[i] = super::allocType(&mut res, ty);

        }

        for i in 0..entries.len {

            let ty = super::Type::Array(super::ArrayType { item, length: i });

            let entry = entries[i] else throw testing::TestError::Failed;

            assert super::allocType(&mut res, ty) == entry;

            assert *entry == ty;

        }

        let values = [

            super::Type::U32, super::Type::U64,

            super::Type::Optional(item),

            super::Type::Range { start: nil, end: nil },

            super::Type::Range { start: item, end: nil },

            super::Type::Range { start: nil, end: item },

            super::Type::Range { start: item, end: item },

            super::Type::Cell { class: types::PointerClass::Ref, payload: item },

            super::Type::Pointer { class: types::PointerClass::Ref, target: item, mutable: false },

            super::Type::Pointer { class: types::PointerClass::Ref, target: item, mutable: true },

            super::Type::Pointer { class: types::PointerClass::Owned, target: item, mutable: false },

            super::Type::Pointer { class: types::PointerClass::Unsafe, target: item, mutable: false },

            super::Type::Slice { class: types::PointerClass::Ref, item, mutable: false },

            super::Type::Slice { class: types::PointerClass::Ref, item, mutable: true },

        ];

        for ty, i in values {

            let entry = super::allocType(&mut res, ty);

            assert super::allocType(&mut res, ty) == entry;

            for other, j in values {

                assert (entry == super::allocType(&mut res, other)) == (i == j);

            }

        }

    }

}

/// Reused ownership slots retain the current binding's exact-use diagnostics.

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

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res,

            "union Token: Once { Value(u32) } fn consume(t: Token) { match t { case Token::Value(_) => {} } } fn f() { { let first = Token::Value(1); consume(first); } let second = Token::Value(2); consume(second); consume(second); }"

        );

        try expectErrorKind(&result, super::ErrorKind::LinearUseAfterConsume("second"));

    }

    let mut branchArena = testArena();

    let branchStorage: 'branch = &mut branchArena in {

        let mut res = testResolver(branchStorage);

        let result = try resolveProgramStr(&mut res,

            "union Token: Once { Value(u32) } fn consume(t: Token) { match t { case Token::Value(_) => {} } } fn f(choice: bool) { { let first = Token::Value(1); consume(first); } let second = Token::Value(2); if choice { consume(second); } }"

        );

        try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("second"));

    }

}

/// Nested loops keep separate break state and restore the stack after errors.

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

    for program, index in [

        "fn f() { loop { break; } loop { loop { break; } continue; } }",

        "fn f() { loop { loop { missing; } } }",

        "fn f() { loop { break; } break; }",

        "fn f() { loop { break; } continue; }",

        "break;",

        "continue;",

        "loop { break }",

        "while true { continue }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, program);

            assert res.loopDepth == 0;

            if index == 0 {

                try expectNoErrors(&result);

                let body = try getFnBody(&res, result.root, "f");

                let first = super::typeFor(&res, body.statements[0]) else throw testing::TestError::Failed;

                let second = super::typeFor(&res, body.statements[1]) else throw testing::TestError::Failed;

                let case super::Type::Void = first else throw testing::TestError::Failed;

                let case super::Type::Never = second else throw testing::TestError::Failed;

            } else if index == 1 {

                try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("missing"));

            } else if index < 6 {

                try expectErrorKind(&result, super::ErrorKind::InvalidLoopControl);

            } else {

                try expectNoErrors(&result);

            }

        }

    }

}

/// Loop bindings and lowering metadata retain the same item type and names.

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

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res,

            "fn f(s: &[u8], start: u64, end: u64) { let xs: [u16; 2] = [1, 2]; for value, idx in xs {} for byte in s {} for _, idx in start..end {} }"

        );

        try expectNoErrors(&result);

        let body = try getFnBody(&res, result.root, "f");

        for index in [1 as u32, 2, 3] {

            let node = body.statements[index];

            let case ast::NodeValue::For(loopNode) = node.value else throw testing::TestError::Failed;

            let info = super::forLoopInfoFor(&res, node) else throw testing::TestError::Failed;

            let bindingType = super::typeFor(&res, loopNode.binding) else throw testing::TestError::Failed;

            match info {

                case super::ForLoopInfo::Collection { elemType, length, bindingName, indexName } => {

                    assert bindingType == *elemType;

                    let name = bindingName else throw testing::TestError::Failed;

                    if index == 1 {

                        assert *elemType == super::Type::U16;

                        let count = length else throw testing::TestError::Failed;

                        assert count == 2;

                        assert mem::eq(name, "value");

                        let name = indexName else throw testing::TestError::Failed;

                        assert mem::eq(name, "idx");

                    } else {

                        assert index == 2;

                        assert *elemType == super::Type::U8;

                        assert length == nil;

                        assert mem::eq(name, "byte");

                        assert indexName == nil;

                    }

                }

                case super::ForLoopInfo::Range { valType, range, bindingName, indexName } => {

                    assert index == 3;

                    assert bindingType == *valType;

                    assert *valType == super::Type::U64;

                    assert bindingName == nil;

                    let name = indexName else throw testing::TestError::Failed;

                    assert mem::eq(name, "idx");

                    let case ast::NodeValue::Range(source) = loopNode.iterable.value else throw testing::TestError::Failed;

                    assert range == source;

                }

            }

            if let binding = loopNode.index {

                let ty = super::typeFor(&res, binding) else throw testing::TestError::Failed;

                assert ty == super::Type::U32;

            }

        }

    }

}

/// Invalid iterables and unsafe slice iteration retain their diagnostics.

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

    for program in [

        "fn f() { for x in true {} }",

        "fn f(end: u32) { for x in ..end {} }",

        "fn f(start: u32, end: u32) { let range = start..end; for x in range {} }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, program);

            try expectErrorKind(&result, super::ErrorKind::ExpectedIterable);

        }

    }

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res, "fn f(s: *unsafe [u32]) { for x in s {} }");

        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);

    }

    try expectAnalyzeOk("unsafe fn f(s: *unsafe [u32]) { for x in s {} }");

}

/// Slice operations retain initialized element, capacity, and access metadata.

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

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res,

            "fn f() { let mut xs: [u32; 4] = [1, 2, 3, 4]; set xs[1..3] = 7; let view = &mut xs[1..3]; set view[..] = 3; let shared = &view[..]; }"

        );

        try expectNoErrors(&result);

        let body = try getFnBody(&res, result.root, "f");

        for index in [1 as u32, 3] {

            let stmt = body.statements[index];

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

            let info = super::sliceRangeInfoFor(&res, stmt) else throw testing::TestError::Failed;

            assert *info.itemType == super::Type::U32;

            assert info.mutable;

            let capacity: ?u32 = 4 if index == 1 else nil;

            assert info.capacity == capacity;

        }

        for index in [2 as u32, 4] {

            let stmt = body.statements[index];

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

            let case ast::NodeValue::AddressOf(_) = binding.value.value else throw testing::TestError::Failed;

            let info = super::sliceRangeInfoFor(&res, binding.value) else throw testing::TestError::Failed;

            assert *info.itemType == super::Type::U32;

            assert info.mutable == (index == 2);

            let capacity: ?u32 = 4 if index == 2 else nil;

            assert info.capacity == capacity;

        }

    }

}

/// Slice assignment and borrowing enforce static bounds and source access.

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

    for program in [

        "fn f() { let mut xs: [u32; 2] = [1, 2]; set xs[..3] = 0; }",

        "fn f() { let mut xs: [u32; 2] = [1, 2]; set xs[2..1] = 0; }",

        "fn f() { let mut xs: [u32; 2] = [1, 2]; let view = &mut xs[..3]; }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, program);

            let err = try expectError(&result);

            assert err.kind == super::ErrorKind::SliceRangeOutOfBounds, program;

        }

    }

    for program in [

        "fn f() { let mut value: u32 = 1; set value[..] = 0; }",

        "fn f() { let mut value: u32 = 1; let view = &value[..]; }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, program);

            let err = try expectError(&result);

            assert err.kind == super::ErrorKind::ExpectedIndexable, program;

        }

    }

    for program in [

        "fn f() { let xs: [u32; 2] = [1, 2]; let view = &xs[..]; set view[..] = 0; }",

        "fn f() { let xs: [u32; 2] = [1, 2]; let view = &xs[..]; let other = &mut view[..]; }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, program);

            let err = try expectError(&result);

            assert err.kind == super::ErrorKind::ImmutableBinding, program;

        }

    }

}

/// Fixed and result layouts cover primitive and pointer-like representations.

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

    for ty in [super::Type::Void, super::Type::Never] {

        checkFixedTypeLayout(ty, 0, 0);

    }

    for ty in [super::Type::Bool, super::Type::U8, super::Type::I8] {

        checkFixedTypeLayout(ty, 1, 1);

    }

    for ty in [super::Type::U16, super::Type::I16] { checkFixedTypeLayout(ty, 2, 2); }

    for ty in [super::Type::U32, super::Type::I32] { checkFixedTypeLayout(ty, 4, 4); }

    for ty in [super::Type::Int, super::Type::U64, super::Type::I64] { checkFixedTypeLayout(ty, 8, 8); }

    let mut arena = testArena();

    let itemStorage = try! alloc::alloc(&mut arena, @sizeOf(super::Type), @alignOf(super::Type)) as *mut super::Type;

    set *itemStorage = super::Type::U32;

    let item: *super::Type = itemStorage;

    let region = types::Region { id: 1, origin: types::RegionOrigin::Block, name: "r", parent: nil };

    let traitInfo = super::TraitType { name: "T", moduleId: 0, methods: &mut [], supertraits: &mut [] };

    let signature = try! alloc::alloc(&mut arena, @sizeOf(super::FnType), @alignOf(super::FnType)) as *mut super::FnType;

    set *signature = super::FnType {

        regions: nil, paramTypes: &[], returnType: item, throwList: &[], isUnsafe: false,

    };

    checkFixedTypeLayout(super::Type::Fn(signature), 8, 8);

    checkFixedTypeLayout(super::Type::Session(&region), 16, 8);

    for class in [types::PointerClass::Owned, types::PointerClass::Ref,

                  types::PointerClass::Unsafe, types::PointerClass::Region(&region)] {

        checkFixedTypeLayout(super::Type::Cell { class, payload: item }, 8, 8);

        for mutable in [false, true] {

            checkFixedTypeLayout(super::Type::Pointer { class, target: item, mutable }, 8, 8);

            checkFixedTypeLayout(super::Type::Slice { class, item, mutable }, 16, 8);

            checkFixedTypeLayout(super::Type::TraitObject { class, traitInfo: &traitInfo, mutable }, 16, 8);

        }

    }

    /// Result layouts retain the tag and the largest success or error payload.

    let errors = try! alloc::allocSlice(&mut arena, @sizeOf(*super::Type), @alignOf(*super::Type), 3)

        as *mut [*super::Type];

    for ty, i in [super::Type::Void, super::Type::U8, super::Type::U64] {

        let slot = try! alloc::alloc(&mut arena, @sizeOf(super::Type), @alignOf(super::Type)) as *mut super::Type;

        set *slot = ty;

        set errors[i] = slot;

    }

    let throwList: *[*super::Type] = errors;

    let payloads = [super::Type::Void, super::Type::U8,

        super::Type::Array(super::ArrayType { item: throwList[2], length: 3 })];

    let emptySizes: [u32; 3] = [8, 9, 32];

    let errorSizes: [u32; 3] = [16, 16, 32];

    for payload, i in payloads {

        let empty = super::getResultLayout(payload, &[]);

        assert empty.size == emptySizes[i] and empty.alignment == 8;

        let result = super::getResultLayout(payload, throwList);

        assert result.size == errorSizes[i] and result.alignment == 8;

    }

}

/// Check a fixed layout through direct, array, and optional type traversal.

unsafe fn checkFixedTypeLayout(ty: super::Type, size: u32, alignment: u32) {

    let layout = super::getTypeLayout(ty);

    assert layout.size == size and layout.alignment == alignment;

    let mut arena = alloc::new(&mut FIXED_LAYOUT_STORAGE[..]);

    let itemStorage = try! alloc::alloc(&mut arena, @sizeOf(super::Type), @alignOf(super::Type)) as *mut super::Type;

    set *itemStorage = ty;

    let item: *super::Type = itemStorage;

    for length in [0 as u32, 1, 3] {

        let array = super::getTypeLayout(super::Type::Array(super::ArrayType { item, length }));

        assert array.size == size * length and array.alignment == alignment;

    }

    let optional = super::getTypeLayout(super::Type::Optional(item));

    let expected = layout if super::isNullableType(ty) else super::getOptionalAggregateLayout(layout);

    assert optional.size == expected.size and optional.alignment == expected.alignment;

    let optionalStorage = try! alloc::alloc(&mut arena, @sizeOf(super::Type), @alignOf(super::Type)) as *mut super::Type;

    set *optionalStorage = super::Type::Optional(item);

    let optionalItem: *super::Type = optionalStorage;

    for length in [0 as u32, 1, 3] {

        let array = super::getTypeLayout(super::Type::Array(super::ArrayType { item: optionalItem, length }));

        assert array.size == optional.size * length and array.alignment == optional.alignment;

    }

    let nested = super::getTypeLayout(super::Type::Optional(optionalItem));

    let nestedExpected = super::getOptionalAggregateLayout(optional);

    assert nested.size == nestedExpected.size and nested.alignment == nestedExpected.alignment;

}

/// Storage for owned types used by array and optional layout fixtures.

static FIXED_LAYOUT_STORAGE: [u8; 256] = [0; 256];

/// Array layouts retain element alignment for empty and populated arrays.

@test fn testArrayLayoutFromElementLayout() throws (testing::TestError) {

    for alignment in [1 as u32, 2, 4, 8, 16] {

        let item = super::Layout { size: alignment, alignment };

        for count in [0 as u32, 1, 3] {

            let result = super::getArrayLayout(item, count);

            assert result.size == alignment * count;

            assert result.alignment == alignment;

        }

    }

}

/// Synthetic file path used for resolver tests.

constant MODULE_PATH: *[u8] = "/dev/test.rad";

/// Optional aggregate layouts align the tag and payload for safe callers.

@test fn testOptionalAggregateLayouts() throws (testing::TestError) {

    for alignment in [1 as u32, 2, 4, 8, 16] {

        for length in [0 as u32, 1, 3] {

            let payload = super::Layout { size: length * alignment, alignment };

            let layout = super::getOptionalAggregateLayout(payload);

            assert layout.size == (length + 1) * alignment;

            assert layout.alignment == alignment;

        }

    }

}

/// 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 poolRef: 'pool = &mut STRING_POOL, arenaRef = &mut arena in {

        let mut p = parser::mkParser(scanner::SourceLoc::String, stmt, arenaRef, poolRef);

        parser::advance(&mut p);

        let expr = try parser::parseExpr(&mut p) catch {

            panic "resolveExprStr: parsing failed";

        };

        let diagnostics = try super::resolveExpr(self, expr, p.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;