//! Lexical region resolver tests.

use std::mem;

use std::testing;

use std::lang::types;

use std::lang::resolver;

use std::lang::ast;

/// Optional aggregate payloads start at their required alignment after the tag.

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

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

        let layout = resolver::Layout { size: 32, alignment };

        assert resolver::getOptionalValOffset(layout) == alignment;

    }

}

/// Each declaration has a distinct identity within its resolver.

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

    let mut arena = super::testArena();

    let storage: 'test = &mut arena in {

        let mut res = super::testResolver(storage);

        let result = try super::resolveProgramStr(&mut res, "fn f() {} fn g() {}");

        try super::expectNoErrors(&result);

        let case ast::NodeValue::Block(block) = result.root.value else throw testing::TestError::Failed;

        let first = resolver::symbolFor(&res, block.statements[0]) else throw testing::TestError::Failed;

        let second = resolver::symbolFor(&res, block.statements[1]) else throw testing::TestError::Failed;

        assert first.id <> second.id;

        assert first.id < res.symbolCount;

        assert second.id < res.symbolCount;

        let firstBinding = resolver::nodeData(&res, block.statements[0]).binding else throw testing::TestError::Failed;

        let secondBinding = resolver::nodeData(&res, block.statements[1]).binding else throw testing::TestError::Failed;

        assert firstBinding.id == first.id;

        assert secondBinding.id == second.id;

    }

}

/// Trait lookup accepts empty tables from safe code.

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

    assert resolver::findTraitMethod(&[], "missing") == nil;

}

/// Trait lookup returns the matching method metadata in declaration order.

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

    let mut arena = super::testArena();

    let storage: 'test = &mut arena in {

        let mut res = super::testResolver(storage);

        let result = try super::resolveProgramStr(&mut res, "trait R { fn (&R) first(); fn (&mut R) second(); }");

        try super::expectNoErrors(&result);

        let case ast::NodeValue::Block(block) = result.root.value else throw testing::TestError::Failed;

        let sym = resolver::symbolFor(&res, block.statements[0]) else throw testing::TestError::Failed;

        let case resolver::SymbolData::Trait(info) = sym.data else throw testing::TestError::Failed;

        let first = resolver::findTraitMethod(&info.methods[..], "first") else throw testing::TestError::Failed;

        let last = resolver::findTraitMethod(&info.methods[..], "second") else throw testing::TestError::Failed;

        assert first.index == 0;

        assert not first.mutable;

        assert last.index == 1;

        assert last.mutable;

        assert resolver::findTraitMethod(&info.methods[..], "missing") == nil;

    }

}

/// Standalone method identities select independent registry entries.

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

    let mut arena = super::testArena();

    let storage: 'test = &mut arena in {

        let mut res = super::testResolver(storage);

        let result = try super::resolveProgramStr(&mut res, "record R {} fn (r: &R) first() {} fn (r: &mut R) second() {}");

        try super::expectNoErrors(&result);

        let case ast::NodeValue::Block(block) = result.root.value else throw testing::TestError::Failed;

        let firstSymbol = resolver::symbolFor(&res, block.statements[1]) else throw testing::TestError::Failed;

        let lastSymbol = resolver::symbolFor(&res, block.statements[2]) else throw testing::TestError::Failed;

        let first = resolver::findMethodBySymbol(&res, firstSymbol.id) else throw testing::TestError::Failed;

        let last = resolver::findMethodBySymbol(&res, lastSymbol.id) else throw testing::TestError::Failed;

        assert mem::eq(first.name, "first");

        assert not first.mutable;

        assert mem::eq(last.name, "second");

        assert last.mutable;

        assert first.fullFnType.paramTypes.len == 1;

        assert first.fnType.paramTypes.len == 0;

        assert last.fullFnType.paramTypes.len == 1;

        assert last.fnType.paramTypes.len == 0;

        assert resolver::findMethodBySymbol(&res, res.symbolCount) == nil;

    }

}

/// Iteration over raw slices requires permission to read their storage.

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

    for program in [

        "fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }",

        "fn f(p: *unsafe mut [u32]) { for item, index in p { assert item == index; } }",

        "record R { items: *unsafe [u32] } fn f(r: &R) { for item in r.items { assert item == 0; } }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

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

        }

    }

}

/// Checked iteration is safe, and raw iteration accepts explicit permission.

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

    for program in [

        "unsafe fn f(p: *unsafe [u32]) { for item in p { assert item == 0; } }",

        "fn f(p: *unsafe [u32]) { unsafe { for item in p { assert item == 0; } } }",

        "fn f(p: &[u32]) { for item in p { assert item == 0; } }",

        "fn f(p: &mut [u32]) { for item, index in p { assert item == index; } }",

        "fn f(p: [u32; 2]) { for item in p { assert item == 0; } }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Short-circuit paths must agree on exact-use regional ownership.

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

    for program in [

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } fn f 'r (t: Ticket 'r) { let result = false and take(t); }",

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } fn f 'r (t: Ticket 'r) { let result = true or take(t); }",

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } fn f 'r (t: Ticket 'r, flag: bool) { let result = flag and take(t); }",

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } unsafe fn f 'r (t: Ticket 'r, flag: bool) { let result = flag or take(t); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::LinearBranchMismatch(_) = error.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// The left operand executes on every short-circuit path.

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

    for program in [

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } fn f 'r (t: Ticket 'r) { let result = take(t) and false; }",

        "union Ticket: 'r + Once { Value(&'r u32) } fn take 'r (t: Ticket 'r) -> bool { match t { case Ticket::Value(p) => return *p == 1, } } fn f 'r (t: Ticket 'r) { let result = take(t) or true; }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Earlier reference arguments protect their storage during later arguments.

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

    for program in [

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f 'r (p: &'r mut u32) { outer(&mut *p, inner(p)); }",

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f 'r (p: &'r mut u32) { outer(&*p, inner(p)); }",

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} unsafe fn f 'r (p: &'r mut u32) { outer(&mut *p, inner(p)); }",

        "record R { n: u32 } fn (r: &mut R) call(n: u32) {} fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn f 'r (r: &'r mut R) { (&mut *r).call(inner(&mut r.n)); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::BorrowConflict(_) = error.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// Conditional cell creation protects each source from ordinary shared access.

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

    for program in [

        "fn inspect(c: &cell u32, p: &u32) { set *c = 2; } fn f(p: &mut u32, q: &mut u32, flag: bool) { inspect(&cell *p if flag else &cell *q, p); }",

        "fn inspect(c: &cell u32, p: &u32) { set *c = 2; } unsafe fn f(p: &mut u32, q: &mut u32, flag: bool) { inspect(&cell *p if flag else &cell *q, q); }",

        "fn read(p: &u32) -> u32 { return *p; } fn inspect(c: &cell u32, n: u32) {} fn f(p: &mut u32, q: &mut u32, flag: bool) { inspect(&cell *p if flag else &cell *q, read(q)); }",

        "fn inspect(c: &cell u32, p: &u32) {} fn f(p: &mut u32, q: &mut u32, flag: bool) { inspect((&cell *p if flag else &cell *q) as &cell u32, p); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::BorrowConflict(_) = error.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// Conditional cell loans allow separate storage and shared cell aliases.

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

    for program in [

        "fn inspect(c: &cell u32, p: &u32) {} fn f(p: &mut u32, q: &mut u32, r: &u32, flag: bool) { inspect(&cell *p if flag else &cell *q, r); set *p = 1; set *q = 2; }",

        "record R { a: u32, b: u32, c: u32 } fn inspect(c: &cell u32, p: &u32) {} fn f(r: &mut R, flag: bool) { inspect(&cell r.a if flag else &cell r.b, &r.c); set r.a = 1; }",

        "fn inspect(a: &cell u32, b: &cell u32) {} fn f(a: &cell u32, b: &cell u32, flag: bool) { inspect(a if flag else b, a); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Conditional explicit arguments protect every possible borrowed place.

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

    for program in [

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(&*p if flag else &*q, inner(p)); }",

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(&*p if flag else &*q, inner(q)); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(&mut *p if flag else &mut *q, &mut *p); }",

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} unsafe fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(&*p if flag else &*q, inner(q)); }",

        "fn outer(p: &mut u32, q: &mut u32) {} unsafe fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(&mut *p if flag else &mut *q, &mut *q); }",

        "fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &u32, n: u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer((&*p if flag else &*q) as &u32, inner(p)); }",

        "record R { n: u32 } fn (r: &R) call(n: u32) {} fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn f 'r (p: &'r mut R, q: &'r mut R, flag: bool) { (&*p if flag else &*q).call(inner(&mut q.n)); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::BorrowConflict(_) = error.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// Conditional argument alternatives cannot overlap another exclusive argument.

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

    for program in [

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(p if flag else q, p); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(p if flag else q, q); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(p, p if flag else q); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(q, p if flag else q); }",

        "fn outer(p: &mut u32, q: &mut u32) {} unsafe fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(p if flag else q, p); }",

        "fn outer(p: &u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(p if flag else q, q); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(p if flag else q, q if flag else p); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, r: &'r mut u32, a: bool, b: bool) { outer((p if a else q) if b else r, q); }",

        "fn outer(p: &u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer((p if flag else q) as &'r u32, p); }",

        "record R { n: u32 } fn (r: &mut R) call(p: &R) {} fn f 'r (p: &'r mut R, q: &'r mut R, flag: bool) { (p if flag else q).call(p); }",

        "trait R { fn (&mut R) call(p: &opaque R); } fn f 'r (p: &'r mut opaque R, q: &'r mut opaque R, flag: bool) { (p if flag else q).call(q); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::BorrowConflict(_) = error.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// Conditional argument alternatives permit shared access and disjoint places.

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

    for program in [

        "fn outer(p: &u32, q: &u32) {} fn f 'r (p: &'r u32, q: &'r u32, flag: bool) { outer(p if flag else q, p); }",

        "fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, r: &'r mut u32, flag: bool) { outer(p if flag else q, r); }",

        "record R: 'r { a: &'r mut u32, b: &'r mut u32, c: &'r mut u32 } fn outer(p: &mut u32, q: &mut u32) {} fn f 'r (r: &mut R 'r, flag: bool) { outer(r.a if flag else r.b, r.c); }",

        "record R { n: u32 } fn (r: &mut R) call(p: &R) {} fn f 'r (p: &'r mut R, q: &'r mut R, r: &'r R, flag: bool) { (p if flag else q).call(r); }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Call loans allow shared reads, separate fields, and access after the call.

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

    for program in [

        "fn read(p: &u32) -> u32 { return *p; } fn outer(p: &u32, n: u32) {} fn f 'r (p: &'r mut u32, q: &'r mut u32, flag: bool) { outer(&*p if flag else &*q, read(p)); set *p = 3; set *q = 4; }",

        "record R { a: u32, b: u32, c: u32 } fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f 'r (r: &'r mut R, flag: bool) { outer(&mut r.a if flag else &mut r.b, inner(&mut r.c)); set r.a = 3; }",

        "fn outer(p: &mut u32, n: u32) {} fn f 'r (p: &'r mut u32, flag: bool) { outer(&mut *p if flag else &mut *p, 0); set *p = 3; }",

        "fn read(p: &u32) -> u32 { return *p; } fn outer(p: &u32, n: u32) {} fn f 'r (p: &'r mut u32) { outer(&*p, read(p)); set *p = 3; }",

        "record R { a: u32, b: u32 } fn inner(p: &mut u32) -> u32 { set *p = 2; return 0; } fn outer(p: &mut u32, n: u32) {} fn f 'r (r: &'r mut R) { outer(&mut r.a, inner(&mut r.b)); set r.a = 3; }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Equal region spellings in separate functions have distinct identities.

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

    let mut testArena1 = super::testArena();

    let testStorage1: 'test1 = &mut testArena1 in {

        let mut res = super::testResolver(testStorage1);

        let result = try super::resolveProgramStr(&mut res,

            "fn first 'r (p: &'r u8) -> u8 { return *p; }\nfn second 'r (p: &'r u8) -> u8 { return *p; }"

        );

        try super::expectNoErrors(&result);

        let first = try super::getBlockStmt(result.root, 0);

        let second = try super::getBlockStmt(result.root, 1);

        let firstType = resolver::typeFor(&res, first) else throw testing::TestError::Failed;

        let secondType = resolver::typeFor(&res, second) else throw testing::TestError::Failed;

        let case resolver::Type::Fn(a) = firstType else throw testing::TestError::Failed;

        let case resolver::Type::Fn(b) = secondType else throw testing::TestError::Failed;

        let case resolver::Type::Pointer { class: types::PointerClass::Region(ar), .. } = *a.paramTypes[0]

            else throw testing::TestError::Failed;

        let case resolver::Type::Pointer { class: types::PointerClass::Region(br), .. } = *b.paramTypes[0]

            else throw testing::TestError::Failed;

        try testing::expect(mem::eq(ar.name, br.name));

        try testing::expect(ar.id <> br.id);

        try testing::expect(not resolver::typesEqual(*a.paramTypes[0], *b.paramTypes[0]));

        try testing::expect(resolver::getTypeLayout(*a.paramTypes[0]).size == 8);

    }

}

/// Parent links resolve forward declarations and preserve transitive ancestry.

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

    let mut testArena2 = super::testArena();

    let testStorage2: 'test2 = &mut testArena2 in {

        let mut res = super::testResolver(testStorage2);

        let result = try super::resolveProgramStr(&mut res,

            "fn read 'child 'middle 'root (p: &'child u8, q: &'root u8) where 'middle: 'child, 'root: 'middle {}"

        );

        try super::expectNoErrors(&result);

        let func = try super::getBlockStmt(result.root, 0);

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

        let case resolver::Type::Fn(info) = ty else throw testing::TestError::Failed;

        let case resolver::Type::Pointer { class: types::PointerClass::Region(child), .. } = *info.paramTypes[0]

            else throw testing::TestError::Failed;

        let case resolver::Type::Pointer { class: types::PointerClass::Region(root), .. } = *info.paramTypes[1]

            else throw testing::TestError::Failed;

        try testing::expect(types::regionContains(root, child));

        try testing::expect(types::regionContains(child, child));

        try testing::expect(not types::regionContains(child, root));

    }

}

/// Region declarations reject duplicate names, missing parents, and cycles.

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

    for program in [

        "fn f 'r 'r () {}",

        "fn f 'r () where 'missing: 'r {}",

        "fn f 'r () where 'r: 'r {}",

        "fn f 'a 'b 'c () where 'b: 'a, 'c: 'b, 'a: 'c {}",

    ] {

        let mut testArena3 = super::testArena();

        let testStorage3: 'test3 = &mut testArena3 in {

            let mut res = super::testResolver(testStorage3);

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

            let _ = try super::expectError(&result);

        }

    }

}

/// Regions from another declaration cannot enter a function signature or body.

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

    for program in [

        "fn f(p: &'missing u8) {}",

        "fn f 'r (p: &'r u8) {} fn g(p: &'r u8) {}",

        "unsafe fn f(p: &'missing u8) {}",

        "fn f 'r (p: &'r u8) { let q: &'missing u8 = p; }",

    ] {

        let mut testArena4 = super::testArena();

        let testStorage4: 'test4 = &mut testArena4 in {

            let mut res = super::testResolver(testStorage4);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::UnknownRegion(_) = err.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// An ancestor relation does not make distinct reference regions assignable.

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

    for program in [

        "fn f 'a 'b (p: &'a u8) where 'a: 'b { let q: &'b u8 = p; }",

        "unsafe fn f 'a 'b (p: &'b u8) where 'a: 'b { let q: &'a u8 = p; }",

    ] {

        let mut testArena5 = super::testArena();

        let testStorage5: 'test5 = &mut testArena5 in {

            let mut res = super::testResolver(testStorage5);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::TypeMismatch(_) = err.kind

                else throw testing::TestError::Failed;

        }

    }

}

/// Nominal region environments diagnose their own invalid parent relations.

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

    for program in [

        "record R: 'r where 'missing: 'r { value: u8 }",

        "union U: 'r where 'missing: 'r { Empty }",

        "record R: 'r { value: &'other u8 }",

        "union U: 'r { Value(&'other u8) }",

    ] {

        let mut testArena6 = super::testArena();

        let testStorage6: 'test6 = &mut testArena6 in {

            let mut res = super::testResolver(testStorage6);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::UnknownRegion(_) = err.kind

                else throw testing::TestError::Failed;

        }

    }

    for program in [

        "record R: 'r + 'r { value: u8 }",

        "union U: 'r + 'r { Empty }",

    ] {

        let mut testArena7 = super::testArena();

        let testStorage7: 'test7 = &mut testArena7 in {

            let mut res = super::testResolver(testStorage7);

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

            let _ = try super::expectErrorKind(&result, resolver::ErrorKind::DuplicateBinding("'r"));

        }

    }

}

/// Region declarations restore their environment after a signature error.

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

    let mut testArena8 = super::testArena();

    let testStorage8: 'test8 = &mut testArena8 in {

        let mut res = super::testResolver(testStorage8);

        let result = try super::resolveProgramStr(&mut res,

            "fn f 'r (p: &'missing u8) {} fn g 'other (p: &'r u8) {}"

        );

        let err = try super::expectError(&result);

        let case resolver::ErrorKind::UnknownRegion(name) = err.kind

            else throw testing::TestError::Failed;

        try testing::expect(mem::eq(name, "'missing"));

        try testing::expect(res.regionScope == nil);

        try testing::expect(res.currentFn == nil);

        try testing::expect(res.currentFnNode == nil);

    }

}

/// Regional exclusive references retain affine ownership and arithmetic checks.

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

    for program in [

        "fn f 'r (p: &'r mut u8) { let q: &'r mut u8 = p; set *p = 3; }",

        "unsafe fn f 'r (p: &'r mut u8) { let q: &'r mut u8 = p; set *p = 3; }",

        "unsafe fn f 'r (p: &'r mut u8) { let q = p + 1; }",

        "unsafe fn f 'r (p: &'r mut u8) { let q = p as *mut u8; }",

    ] {

        let mut testArena9 = super::testArena();

        let testStorage9: 'test9 = &mut testArena9 in {

            let mut res = super::testResolver(testStorage9);

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

            let _ = try super::expectError(&result);

        }

    }

}

/// Callback signatures preserve the same region substitution as data arguments.

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

    let mut testArena10 = super::testArena();

    let testStorage10: 'test10 = &mut testArena10 in {

        let mut res = super::testResolver(testStorage10);

        let result = try super::resolveProgramStr(&mut res, "fn read 'r (p: &'r u32) -> u32 { return *p; } fn useOp 'r (p: &'r u32, op: fn(&'r u32) -> u32) -> u32 { return op(p); } fn relay 'a 'b (p: &'a u32) -> u32 { return useOp(p, read 'b); }");

        let err = try super::expectError(&result);

        let case resolver::ErrorKind::RegionInference(_) = err.kind else throw testing::TestError::Failed;

    }

}

/// A single region parameter requires one consistent named argument.

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

    for program in [

        "fn pair 'r (a: &'r u32, b: &'r u32) {} fn relay 'a 'b (a: &'a u32, b: &'b u32) { pair(a, b); }",

        "fn read 'r (p: &'r u32) {} fn relay(p: &u32) { read(p); }",

        "unsafe fn read 'r (p: &'r u32) {} unsafe fn relay(p: *unsafe u32) { read(p); }",

        "fn answer 'r () -> u32 { return 42; } fn relay() -> u32 { return answer(); }",

        "fn read 'r (p: ?&'r u32) {} fn relay() { read(nil); }",

        "unsafe fn read 'r (p: ?&'r u32) {} unsafe fn relay() { read(nil); }",

    ] {

        let mut testArena11 = super::testArena();

        let testStorage11: 'test11 = &mut testArena11 in {

            let mut res = super::testResolver(testStorage11);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::RegionInference(_) = err.kind else throw testing::TestError::Failed;

        }

    }

}

/// Inferred and explicit region arguments must satisfy declared parent relations.

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

    for program in [

        "fn pair 'p 'c (p: &'p u32, c: &'c u32) where 'p: 'c {} fn relay 'a 'b (a: &'a u32, b: &'b u32) { pair(a, b); }",

        "fn pair 'p 'c (p: &'p u32, c: &'c u32) where 'p: 'c {} unsafe fn relay 'a 'b (a: &'a u32, b: &'b u32) where 'a: 'b { pair 'b 'a (b, a); }",

    ] {

        let mut testArena12 = super::testArena();

        let testStorage12: 'test12 = &mut testArena12 in {

            let mut res = super::testResolver(testStorage12);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::RegionParent(_) = err.kind else throw testing::TestError::Failed;

        }

    }

}

/// Region applications require the declared arity and accessible names.

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

    for program in [

        "fn read 'r (p: &'r u32) {} fn relay 'a 'b (p: &'a u32) { read 'a 'b (p); }",

        "fn read(p: &u32) {} fn relay 'a (p: &'a u32) { read 'a (p); }",

    ] {

        let mut testArena13 = super::testArena();

        let testStorage13: 'test13 = &mut testArena13 in {

            let mut res = super::testResolver(testStorage13);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::RegionArgumentCount(_) = err.kind else throw testing::TestError::Failed;

        }

    }

    let mut testArena14 = super::testArena();

    let testStorage14: 'test14 = &mut testArena14 in {

        let mut res = super::testResolver(testStorage14);

        let result = try super::resolveProgramStr(&mut res, "fn read 'r (p: &'r u32) {} fn relay 'a (p: &'a u32) { read 'missing (p); }");

        let err = try super::expectError(&result);

        let case resolver::ErrorKind::UnknownRegion(_) = err.kind else throw testing::TestError::Failed;

    }

}

/// Region header loans stay active through moves and nested exclusive reborrows.

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

    for program in [

        "fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { set x = 2; } }",

        "unsafe fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { set x = 2; } }",

        "fn run() { let mut x: u32 = 1; let p: 'r = &mut x, q = &mut x in {} }",

        "fn run() { let mut x: u32 = 1; let p: 'r = &x, q = &mut x in {} }",

        "fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { { let q = p; set *q = 2; } set x = 3; } }",

        "fn run() { let mut x: u32 = 1; let p: 'a = &mut x in { let q: 'b = &mut *p in { set *p = 3; } } }",

        "fn run(i: u32, j: u32) { let mut x: [u32; 2] = [1, 2]; let p: 'r = &mut x[i], q = &mut x[j] in {} }",

    ] {

        let mut testArena15 = super::testArena();

        let testStorage15: 'test15 = &mut testArena15 in {

            let mut res = super::testResolver(testStorage15);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::BorrowConflict(_) = err.kind else throw testing::TestError::Failed;

        }

    }

}

/// Borrow headers require existing places and accessible, distinct region names.

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

    for program in [

        "fn run() { let p: 'r = &1 in {} }",

        "fn value() -> u32 { return 1; } fn run() { let p: 'r = &value() in {} }",

        "fn run() { let x: u32 = 1; let p: 'r = &x in { let q: 'r = &x in {} } }",

        "fn run() { let x: u32 = 1; let p: 'r = &x in {} let q: &'r u32 = &x; }",

        "fn run 'a (p: &'a mut u32) { let q: 'b = &mut *p in {} }",

    ] {

        let mut testArena16 = super::testArena();

        let testStorage16: 'test16 = &mut testArena16 in {

            let mut res = super::testResolver(testStorage16);

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

            let _ = try super::expectError(&result);

        }

    }

}

/// A block-local value cannot supply storage for the whole enclosing region.

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

    for program in [

        "fn run() { let a: u32 = 1; let p: 'outer = &a in { let mut cursor = p; let b: u32 = 2; let q: 'inner = &b where 'outer: 'inner in { set cursor = q; } } }",

        "unsafe fn run() { let a: u32 = 1; let p: 'outer = &a in { let mut cursor = p; let b: u32 = 2; let q: 'inner = &b where 'outer: 'inner in { set cursor = q; } } }",

        "fn run() { let x: u32 = 1; let p: 'r = &x in { let y: u32 = 2; let q: &'r u32 = &y; } }",

        "unsafe fn run() { let x: u32 = 1; let p: 'r = &x in { let y: u32 = 2; let q: &'r u32 = &y; } }",

        "fn run() { let mut x: u32 = 1; let p: 'a = &mut x in { let q: 'b = &mut *p in { let outer: &'a mut u32 = q; } } }",

    ] {

        let mut testArena17 = super::testArena();

        let testStorage17: 'test17 = &mut testArena17 in {

            let mut res = super::testResolver(testStorage17);

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

            let err = try super::expectError(&result);

            let case resolver::ErrorKind::TypeMismatch(_) = err.kind else throw testing::TestError::Failed;

        }

    }

}

/// Generic calls keep the exclusive-argument overlap check after substitution.

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

    let mut testArena18 = super::testArena();

    let testStorage18: 'test18 = &mut testArena18 in {

        let mut res = super::testResolver(testStorage18);

        let result = try super::resolveProgramStr(&mut res, "fn pair 'r (a: &'r mut u32, b: &'r mut u32) {} fn run() { let mut x: u32 = 1; let p: 'r = &mut x in { pair(p, p); } }");

        let err = try super::expectError(&result);

        let case resolver::ErrorKind::BorrowConflict(_) = err.kind else throw testing::TestError::Failed;

    }

}

/// Ownership markers do not change the positions of nominal region arguments.

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

    for program in [

        "record Pair: Copy + 'a + 'b { left: &'a u32, right: &'b u32 } fn f 'x 'y (left: &'x u32, right: &'y u32) -> Pair 'x 'y { return Pair 'x 'y { left, right }; }",

        "record Pair: 'a + Copy + 'b { left: &'a u32, right: &'b u32 } fn f 'x 'y (left: &'x u32, right: &'y u32) -> Pair 'x 'y { return Pair 'x 'y { left, right }; }",

        "record Pair: 'a + 'b + Copy { left: &'a u32, right: &'b u32 } fn f 'x 'y (left: &'x u32, right: &'y u32) -> Pair 'x 'y { return Pair 'x 'y { left, right }; }",

    ] {

        let mut arena = super::testArena();

        let storage: 'test = &mut arena in {

            let mut res = super::testResolver(storage);

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Exact application keys include the base and the ordered region arguments.

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

    let mut arena = super::testArena();

    let storage: 'test = &mut arena in {

        let mut res = super::testResolver(storage);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r + 's + Copy { value: u32 } record M: 'r + 's + Copy { value: u32 } fn f 'a 'b (x: N 'a 'b, y: N 'a 'b, z: N 'b 'a, w: N 'a 'a, v: M 'a 'b) {}"

        );

        try super::expectNoErrors(&result);

        let func = try super::getBlockStmt(result.root, 2);

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

        let case resolver::Type::Fn(info) = ty else throw testing::TestError::Failed;

        for param, i in info.paramTypes {

            for other, j in info.paramTypes {

                assert (param == other) == (i == j or (i < 2 and j < 2));

            }

        }

        let mut count: u32 = 0;

        let mut cursor = res.applications;

        while let entry = cursor {

            assert entry.arguments.len == 2;

            assert resolver::nominalApplication(entry.view) == entry;

            set count += 1;

            set cursor = entry.next;

        }

        assert count == 4;

    }

}

/// Exact arguments share one descriptor and all applications share the source layout.

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

    let mut testArena19 = super::testArena();

    let testStorage19: 'test19 = &mut testArena19 in {

        let mut res = super::testResolver(testStorage19);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r + Copy { value: u32 } fn f 'a 'b (x: N 'a, y: N 'a, z: N 'b) {}"

        );

        try super::expectNoErrors(&result);

        let func = try super::getBlockStmt(result.root, 1);

        let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;

        let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;

        let case resolver::Type::Nominal(x) = *info.paramTypes[0] else throw testing::TestError::Failed;

        let case resolver::Type::Nominal(y) = *info.paramTypes[1] else throw testing::TestError::Failed;

        let case resolver::Type::Nominal(z) = *info.paramTypes[2] else throw testing::TestError::Failed;

        try testing::expect(x == y);

        try testing::expect(x <> z);

        try testing::expect(not resolver::typesEqual(*info.paramTypes[0], *info.paramTypes[2]));

        let a = resolver::nominalApplication(x) else throw testing::TestError::Failed;

        let b = resolver::nominalApplication(z) else throw testing::TestError::Failed;

        try testing::expect(a.base == b.base);

        try testing::expect(a.arguments[0].id <> b.arguments[0].id);

        let case resolver::NominalType::Record(base) = *a.base else throw testing::TestError::Failed;

        let case resolver::NominalType::Record(first) = *x else throw testing::TestError::Failed;

        let case resolver::NominalType::Record(second) = *z else throw testing::TestError::Failed;

        try testing::expect(base.layout == first.layout);

        try testing::expect(first.layout == second.layout);

        try testing::expect(first.layout.size == 4);

    }

}

/// Applications introduced in successive function bodies are fully resolved.

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

    let mut arena = super::testArena();

    let storage: 'test = &mut arena in {

        let mut res = super::testResolver(storage);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r + Copy { value: &'r u32 } fn f 'a (x: &'a u32) { let n = N 'a { value: x }; } fn g 'b (x: &'b u32) { let n = N 'b { value: x }; }"

        );

        try super::expectNoErrors(&result);

        let mut count: u32 = 0;

        let mut cursor = res.applications;

        while let applied = cursor {

            let case resolver::NominalType::Record(body) = *applied.view else throw testing::TestError::Failed;

            assert body.application == applied;

            assert body.fields.len == 1;

            set count += 1;

            set cursor = applied.next;

        }

        assert count == 2;

    }

}

/// Recursive fields refer to their own exact applied descriptor.

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

    let mut testArena20 = super::testArena();

    let testStorage20: 'test20 = &mut testArena20 in {

        let mut res = super::testResolver(testStorage20);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r + Copy { next: ?*N 'r } fn f 'a 'b (x: N 'a, y: N 'b) {}"

        );

        try super::expectNoErrors(&result);

        let func = try super::getBlockStmt(result.root, 1);

        let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;

        let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;

        for parameter in info.paramTypes {

            let case resolver::Type::Nominal(descriptor) = *parameter else throw testing::TestError::Failed;

            let case resolver::NominalType::Record(body) = *descriptor else throw testing::TestError::Failed;

            let case resolver::Type::Optional(inner) = body.fields[0].fieldType else throw testing::TestError::Failed;

            let case resolver::Type::Pointer { target, .. } = *inner else throw testing::TestError::Failed;

            try testing::expect(resolver::typesEqual(*target, *parameter));

            try testing::expect(body.layout.size == 8);

        }

    }

}

/// An inline union payload retains its enclosing application's region arguments.

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

    let mut testArena21 = super::testArena();

    let testStorage21: 'test21 = &mut testArena21 in {

        let mut res = super::testResolver(testStorage21);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r + Copy { value: u32 } union U: 'r + Copy { Link { node: *N 'r }, Empty } fn f 'a (u: U 'a, n: N 'a) {}"

        );

        try super::expectNoErrors(&result);

        let func = try super::getBlockStmt(result.root, 2);

        let fnType = resolver::typeFor(&res, func) else throw testing::TestError::Failed;

        let case resolver::Type::Fn(info) = fnType else throw testing::TestError::Failed;

        let case resolver::Type::Nominal(resolver::NominalType::Union(body)) = *info.paramTypes[0]

            else throw testing::TestError::Failed;

        let case resolver::Type::Nominal(resolver::NominalType::Record(payload)) = body.variants[0].valueType

            else throw testing::TestError::Failed;

        let case resolver::Type::Pointer { target, .. } = payload.fields[0].fieldType

            else throw testing::TestError::Failed;

        try testing::expect(resolver::typesEqual(*target, *info.paramTypes[1]));

        let applied = body.application else throw testing::TestError::Failed;

        let case resolver::NominalType::Union(base) = *applied.base else throw testing::TestError::Failed;

        try testing::expect(body.layout == base.layout);

    }

}

/// Nominal applications require exactly the declared number of region arguments.

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

    for program in [

        "record N: 'r { value: u32 } fn f(n: N) {}",

        "record N { value: u32 } fn f 'r (n: N 'r) {}",

        "record N: 'r + 's { value: u32 } fn f 'a (n: N 'a) {}",

        "record N: 'r { value: u32 } fn f 'a 'b (n: N 'a 'b) {}",

        "record N: 'r { value: u32 } fn f() { let n = N { value: 1 }; }",

        "union U: 'r { Empty } fn f() { let u = U::Empty; }",

    ] {

        let mut testArena22 = super::testArena();

        let testStorage22: 'test22 = &mut testArena22 in {

            let mut res = super::testResolver(testStorage22);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::RegionArgumentCount(_) = error.kind else throw testing::TestError::Failed;

        }

    }

}

/// Type arguments are invariant in values, constructor hints, and patterns.

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

    for program in [

        "record N: 'r + Copy { value: u32 } fn f 'a 'b (n: N 'a) { let x: N 'b = n; }",

        "record N: 'r + Copy { value: u32 } unsafe fn f 'a 'b (n: N 'a) { let x: N 'b = n; }",

        "record N: 'r + Copy { value: u32 } fn f 'a 'b () { let n: N 'a = N 'b { value: 1 }; }",

        "record N: 'r + Copy { value: u32 } fn f 'a 'b (n: N 'a) { let case N 'b { value } = n else panic; }",

        "record N: 'r + Copy (u32); fn f 'a 'b (n: N 'a) { let case N 'b (value) = n else panic; }",

        "record N: 'r + Copy { value: u32 } record M: 'r + Copy { value: u32 } fn f 'a (n: N 'a) { let case M 'a { value } = n else panic; }",

    ] {

        let mut testArena23 = super::testArena();

        let testStorage23: 'test23 = &mut testArena23 in {

            let mut res = super::testResolver(testStorage23);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::TypeMismatch(_) = error.kind else throw testing::TestError::Failed;

        }

    }

}

/// Region inference must agree between an outer reference and its embedded nominal type.

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

    for program in [

        "record N: 'r + Copy { value: u32 } fn take 'r (n: &'r N 'r) {} fn f 'a 'b (n: &'a N 'b) { take(n); }",

        "record N: 'r + Copy { value: u32 } fn take 'r (n: N 'r, m: N 'r) {} fn f 'a 'b (n: N 'a, m: N 'b) { take(n, m); }",

    ] {

        let mut testArena24 = super::testArena();

        let testStorage24: 'test24 = &mut testArena24 in {

            let mut res = super::testResolver(testStorage24);

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

            let error = try super::expectError(&result);

            let case resolver::ErrorKind::RegionInference(_) = error.kind else throw testing::TestError::Failed;

        }

    }

}

/// Applications must satisfy the source declaration's explicit parent relations.

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

    let mut testArena25 = super::testArena();

    let testStorage25: 'test25 = &mut testArena25 in {

        let mut res = super::testResolver(testStorage25);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r + 's where 'r: 's { value: u32 } fn f 'a 'b (n: N 'a 'b) {}"

        );

        let error = try super::expectError(&result);

        let case resolver::ErrorKind::RegionParent(_) = error.kind else throw testing::TestError::Failed;

    }

}

/// An applied affine type retains the source declaration's move rule.

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

    let mut testArena26 = super::testArena();

    let testStorage26: 'test26 = &mut testArena26 in {

        let mut res = super::testResolver(testStorage26);

        let result = try super::resolveProgramStr(&mut res,

            "record N: 'r { value: u32 } fn f 'a (n: N 'a) { let first = n; let second = n; }"

        );

        let error = try super::expectError(&result);

        let case resolver::ErrorKind::AffineUseAfterMove(_) = error.kind else throw testing::TestError::Failed;