//! Resolver tests.

/// Region identity, borrowing, and nominal application tests.

@test mod regions;

/// Placeholder binding, pattern, and expression tests.

@test mod placeholderTests;

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, permission: nil, 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, permission: nil, 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.

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

/// One parsed module staged for permission-checked graph construction.

record TestModule: Copy {

    /// Parent identity, or nil for a package root.

    parentId: ?u16,

    /// Source module name.

    name: *[u8],

    /// Parsed module root.

    root: *ast::Node,

    /// Source text used to parse the root.

    source: *[u8],

}

/// Permission-independent module fixture populated by resolver tests.

export opaque record TestModuleGraph {

    /// Staged modules in identifier order.

    entries: [?TestModule; 8],

    /// Number of initialized staged modules.

    entriesLen: u32,

}

/// Module entries used when materializing resolver test graphs.

unsafe static MODULE_ENTRIES: [?*module::ModuleEntry; 8] = [nil; 8];

/// Staged module graph used by resolver tests.

export unsafe static MODULE_GRAPH: TestModuleGraph = TestModuleGraph {

    entries: [nil; 8],

    entriesLen: 0,

};

/// 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.

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

    }

    set MODULE_GRAPH.entriesLen = 0;

    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,

    };

}

/// Materialize staged modules under one externally owned permission.

unsafe fn materializeModuleGraph 'permission (

    fixture: &TestModuleGraph,

    permission: &'permission mut module::Permission

) -> module::ModuleGraph 'permission throws (testing::TestError) {

    set MODULE_ARENA = ast::nodeArena(&mut MODULE_ARENA_STORAGE[..]);

    let mut graph = module::moduleGraph(

        &mut MODULE_ENTRIES[..], &mut MODULE_ARENA, permission

    );

    for i in 0..fixture.entriesLen {

        let staged = fixture.entries[i] else throw testing::TestError::Failed;

        let id = if let parentId = staged.parentId {

            try module::registerChild(

                &mut graph, &mut STRING_POOL, parentId, staged.name, "<test>"

            ) catch {

                throw testing::TestError::Failed;

            }

        } else {

            try module::registerRootWithName(

                &mut graph, &mut STRING_POOL, 0, staged.name, "<test>"

            ) catch {

                throw testing::TestError::Failed;

            }

        };

        if id as u32 != i {

            throw testing::TestError::Failed;

        }

        try module::setAst(&mut graph, id, staged.root) catch {

            throw testing::TestError::Failed;

        };

        try module::setSource(&mut graph, id, staged.source) catch {

            throw testing::TestError::Failed;

        };

    }

    return graph;

}

/// Print module diagnostics using a freshly materialized permission-checked graph.

export unsafe fn printDiagnostics 'arena (

    diagnostics: &super::Diagnostics,

    res: &super::Resolver 'arena

) {

    let mut owner = module::Permission {};

    let permission: 'permission = &mut owner in {

        let graph = try! materializeModuleGraph(&MODULE_GRAPH, permission);

        super::printer::printDiagnostics(diagnostics, res, &graph);

    }

}

/// Resolve a staged module tree with the full resolution process.

export unsafe fn resolveModuleTree 'arena (

    res: &mut super::Resolver 'arena,

    rootId: u16

) -> TestResult throws (testing::TestError) {

    let mut owner = module::Permission {};

    let permission: 'permission = &mut owner in {

        let graph = try materializeModuleGraph(&MODULE_GRAPH, permission);

        let root = module::get(&graph, rootId)

            else throw testing::TestError::Failed;

        let rootAst = module::astFor(&graph, root)

            else throw testing::TestError::Failed;

        let packages = [super::Pkg {

            rootEntry: root,

            rootAst,

        }];

        let diagnostics = try super::resolve(

            res, &graph, &packages[..]

        ) catch {

            throw testing::TestError::Failed;

        };

        return TestResult { diagnostics, root: rootAst };

    }

}

/// Register a parsed module in the permission-independent test fixture.

/// If `parentId` is nil, registers a root module.

export unsafe fn registerModule(

    graph: &mut TestModuleGraph,

    parentId: ?u16,

    name: *[u8],

    code: *[u8],

    arena: &mut ast::NodeArena

) -> u16 throws (testing::TestError) {

    if graph.entriesLen >= graph.entries.len {

        throw testing::TestError::Failed;

    }

    let root = try parser::parse(

        scanner::SourceLoc::String, code, arena, &mut STRING_POOL

    ) catch {

        panic "registerModule: parsing failed";

    };

    let id = graph.entriesLen as u16;

    set graph.entries[graph.entriesLen] = TestModule {

        parentId,

        name,

        root,

        source: code,

    };

    set graph.entriesLen += 1;

    return id;

}

/// 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)