//! Lexical region resolver tests.

use std::mem;

use std::testing;

use std::lang::types;

use std::lang::resolver;

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

    }

}

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

    }

}

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

    }

}

/// By-value cycles have no layout, including cycles through exact applications.

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

    for program in [

        "record N: 'r { next: N 'r }",

        "record N: 'r { next: ?N 'r }",

        "union U: 'r { More(U 'r), Empty }",

        "record N: 'r { m: M 'r } record M: 'r { n: N 'r }",

    ] {

        let mut testArena27 = super::testArena();

        let testStorage27: 'test27 = &mut testArena27 in {

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

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

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

            let case resolver::ErrorKind::RecursiveType = error.kind else throw testing::TestError::Failed;

        }

    }

}

/// Recursive substitutions can permute arguments without expanding the type graph.

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

    let mut testArena28 = super::testArena();

    let testStorage28: 'test28 = &mut testArena28 in {

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

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

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

        );

        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, i in info.paramTypes {

            let case resolver::Type::Nominal(resolver::NominalType::Record(body)) = *parameter

                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, *info.paramTypes[1 - i]));

        }

    }

}

/// Calls transfer named exclusive references on normal and error paths.

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

    for program in [

        "fn take 'r (p: &'r mut u32) {} fn run 'r (p: &'r mut u32) { take(p); take(p); }",

        "fn take 'r (p: &'r mut u32) {} unsafe fn run 'r (p: &'r mut u32) { take(p); set *p = 1; }",

        "fn take 'r (p: &'r mut [u32]) {} fn run 'r (p: &'r mut [u32]) { take(p); p[0]; }",

        "fn take 'r (p: &'r mut u32) {} fn run 'r (p: &'r mut u32) { let f = take 'r; f(p); set *p = 1; }",

        "union E { Bad } fn take 'r (p: &'r mut u32) throws (E) { throw E::Bad; } fn run 'r (p: &'r mut u32) { try take(p) catch {}; set *p = 1; }",

        "fn take 'r (p: &'r mut u32) {} fn run 'r (p: &'r mut u32, c: bool) { if c { take(p); } set *p = 1; }",

    ] {

        let mut testArena29 = super::testArena();

        let testStorage29: 'test29 = &mut testArena29 in {

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

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

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

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

        }

    }

}

/// Full-region projections protect their source after a local binding leaves scope.

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

    for program in [

        "fn f 'r (p: &'r mut u32) { let shared = &*p; let copy = shared; set *p = 1; }",

        "unsafe fn f 'r (p: &'r mut u32) { let shared = &*p; let copy = shared; set *p = 1; }",

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

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

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

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

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

        "fn f 'r (p: &'r mut u32) { { let q = &mut *p; let moved = q; } *p; }",

        "record P { a: u32, b: u32 } fn f 'r (p: &'r mut P) { { let q = &mut p.a; } p.a; }",

        "record P { a: u32, b: u32 } fn f 'r (p: &'r mut P) { { let q = &p.a; } set p.a = 2; }",

    ] {

        let mut testArena30 = super::testArena();

        let testStorage30: 'test30 = &mut testArena30 in {

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

            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;

        }

    }

}

/// A regional loan on any live branch remains active at the branch join.

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

    for program in [

        "fn f 'r (p: &'r mut u32, c: bool) { if c { let q = &mut *p; } set *p = 2; }",

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

        "fn f 'r (p: &'r mut u32, c: bool) { match c { case true => { let q = &mut *p; } else => {} } *p; }",

        "fn f 'r (p: &'r mut u32, c: ?u32) { if let n = c { let q = &*p; } set *p = 2; }",

    ] {

        let mut testArena31 = super::testArena();

        let testStorage31: 'test31 = &mut testArena31 in {

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

            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;

        }

    }

}

/// Loop back edges carry regional loans into later iterations.

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

    for program in [

        "fn f 'r (p: &'r mut u32) { for i in 0..2 { let q = &mut *p; } }",

        "fn f 'r (p: &'r mut u32) { for i in 0..2 { set *p = 1; let q = &*p; } }",

        "fn f 'r (p: &'r mut u32) { for i in 0..2 { set *p = 1; let q = &*p; continue; } }",

        "fn f 'r (p: &'r mut u32, c: bool) { while c { let q = &mut *p; } }",

        "fn f 'r (p: &'r mut u32, c: ?u32) { while let n = c { let q = &mut *p; } }",

        "fn f 'r (p: &'r mut u32) { loop { let q = &mut *p; } }",

        "fn f 'r (p: &'r mut u32, c: bool) { loop { if c { set *p = 1; break; } let q = &*p; } }",

    ] {

        let mut testArena32 = super::testArena();

        let testStorage32: 'test32 = &mut testArena32 in {

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

            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;

        }

    }

}

/// Loans in caller-supplied regions survive loop and nested-region exits.

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

    for program in [

        "fn f 'r (p: &'r mut u32) { loop { let q = &mut *p; break; } set *p = 2; }",

        "fn f 'r (p: &'r mut u32, c: bool) { while c { let q = &*p; break; } else {} set *p = 2; }",

        "fn f 'r (p: &'r mut u32) { for i in 0..2 { let q = &*p; break; } else {} set *p = 2; }",

        "fn f 'r (p: &'r mut u32) { let x: u32 = 0; let v: 'child = &x where 'r: 'child in { let q = &*p; } set *p = 2; }",

    ] {

        let mut testArena33 = super::testArena();

        let testStorage33: 'test33 = &mut testArena33 in {

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

            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;

        }

    }

}

/// Region erasure cannot merge distinct error alternatives in one signature.

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

    for program in [

        "record E: 'r + Copy {} fn f 'a 'b () throws (E 'a, E 'b) {}",

        "record E: 'r + Copy {} unsafe fn f 'a 'b () throws (E 'a, E 'b) {}",

        "record E: 'r + Copy {} record Callback: 'a + 'b { f: fn() throws (E 'a, E 'b) }",

        "fn f 'a 'b () throws (&'a u32, &'b u32) {}",

    ] {

        let mut testArena34 = super::testArena();

        let testStorage34: 'test34 = &mut testArena34 in {

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

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

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

        }

    }

}

/// Moving an exclusive reference into an aggregate transfers its ownership.

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

    for program in [

        "record W: 'r { p: &'r mut u32 } fn f 'r (p: &'r mut u32) { let w = W 'r { p }; set *p = 1; }",

        "record W: 'r { p: &'r mut u32 } unsafe fn f 'r (p: &'r mut u32) { let w = W 'r { p }; set *p = 1; }",

        "record W: 'r { p: &'r mut u32 } fn f 'r (w: W 'r) { let case W { p } = w else panic; let again = w; }",

        "union W: 'r { P { p: &'r mut u32 } } fn f 'r (p: &'r mut u32) { let w = W 'r::P { p }; set *p = 1; }",

        "fn f 'r (p: &'r mut u32) { let a: [&'r mut u32; 1] = [p]; set *p = 1; }",

        "fn f 'r (p: &'r mut u32) { let a: ?&'r mut u32 = p; set *p = 1; }",

    ] {

        let mut testArena35 = super::testArena();

        let testStorage35: 'test35 = &mut testArena35 in {

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

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

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

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

        }

    }

}

/// Aggregate transfers do not end a projection loan on its source.

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

    for program in [

        "record W: 'r { p: &'r mut u32 } fn f 'r (p: &'r mut u32) { { let w = W 'r { p: &mut *p }; } set *p = 1; }",

        "record R: 'r + Copy { p: &'r u32 } fn f 'r (p: &'r mut u32) { { let r = R 'r { p: &*p }; } set *p = 1; }",

        "record R: 'r + Copy { p: &'r u32 } fn take 'r (r: R 'r) {} fn f 'r (p: &'r mut u32) { take(R 'r { p: &*p }); set *p = 1; }",

        "fn id 'r (p: &'r mut u32) -> &'r mut u32 { return p; } fn f 'r (p: &'r mut u32) { let q = id(p); { let other = &mut *q; } set *q = 1; }",

    ] {

        let mut testArena36 = super::testArena();

        let testStorage36: 'test36 = &mut testArena36 in {

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

            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;

        }

    }

}

/// Local storage cannot acquire a caller region through returns or aggregate hints.

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

    for program in [

        "fn f 'r () -> &'r u32 { let x: u32 = 1; return &x; }",

        "unsafe fn f 'r () -> &'r u32 { let x: u32 = 1; return &x; }",

        "record R: 'r + Copy { p: &'r u32 } fn f 'r () -> R 'r { let x: u32 = 1; return R 'r { p: &x }; }",

        "record R: 'r + Copy { p: &'r u32 } fn f 'r () -> R 'r { let x: u32 = 1; let p: 'short = &x in { return R 'short { p }; } }",

        "record R: 'r + Copy { p: &'r u32 } fn f 'r (p: &'r u32) -> &'r R 'r { let r = R 'r { p }; return &r; }",

        "record R: 'r + Copy { p: &'r u32 } fn f 'r (p: &'r u32) { let mut outer = R 'r { p }; let x: u32 = 1; let q: 'short = &x in { set outer = R 'short { p: q }; } }",

    ] {

        let mut testArena37 = super::testArena();

        let testStorage37: 'test37 = &mut testArena37 in {

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

            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;

        }

    }

}

/// Reference fields retain their ownership and storage restrictions.

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

    {

        let mut testArena38 = super::testArena();

        let testStorage38: 'test38 = &mut testArena38 in {

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

            let result = try super::resolveProgramStr(&mut res, "record W: 'r { p: &'r mut u32 } fn f 'r (w: W 'r) { let p = w.p; }");

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

        }

    }

    {

        let mut testArena39 = super::testArena();

        let testStorage39: 'test39 = &mut testArena39 in {

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

            let result = try super::resolveProgramStr(&mut res, "record R: 'r { p: &u32 }");

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

        }

    }

    {

        let mut testArena40 = super::testArena();

        let testStorage40: 'test40 = &mut testArena40 in {

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

            let result = try super::resolveProgramStr(&mut res, "fn f 'r (p: &'r u32) { static r: &'r u32 = undefined; }");

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

        }

    }

}

/// Regional projection tracking limits simultaneous live projections.

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

    let mut reuseArena = super::testArena();

    let reuseStorage: 'reuse = &mut reuseArena in {

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

        let result = try super::resolveProgramStr(&mut res, "fn f 'r (p: &'r u32) { let outer: 'outer = &*p where 'r: 'outer in { let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } let q: 'x = &*outer in { &*q; } } }");

        try super::expectNoErrors(&result);

    }

    let mut testArena41 = super::testArena();

    let testStorage41: 'test41 = &mut testArena41 in {

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

        let result = try super::resolveProgramStr(&mut res, "fn f 'r (p: &'r u32) { [&*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p]; }");

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

    }

}

/// Shared regional parameters consume exclusive arguments that can be retained.

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

    for program in [

        "fn read 'r (p: &'r u32) -> &'r u32 { return p; } fn f 'r (p: &'r mut u32) -> u32 { let q = read(p); set *p = 2; return *q; }",

        "fn read 'r (p: &'r u32) -> &'r u32 { return p; } unsafe fn f 'r (p: &'r mut u32) { let q = read(p); set *p = 2; }",

        "fn read 'r (p: &'r [u32]) -> &'r [u32] { return p; } fn f 'r (p: &'r mut [u32]) { let q = read(p); set p[0] = 2; }",

        "fn read 'r (p: &'r u32) -> &'r u32 { return p; } fn f 'r (p: &'r mut u32) { let callback = read 'r; let q = callback(p); set *p = 2; }",

    ] {

        let mut testArena42 = super::testArena();

        let testStorage42: 'test42 = &mut testArena42 in {

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

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

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

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

        }

    }

}

/// Values stored in a regional destination must cover its full lifetime.

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

    for program in [

        "fn f 'a 'b (dst: &'a mut ?&'b u32, p: &'b u32) { set *dst = p; }",

        "unsafe fn f 'a 'b (dst: &'a mut ?&'b u32, p: &'b u32) { set *dst = p; }",

        "fn f 'a 'b (dst: &'a mut ?&'b u32, p: &'b u32) where 'a: 'b { set *dst = p; }",

        "record R: 'r + Copy { p: &'r u32 } fn f 'a 'b (dst: &'a mut R 'b, p: &'b u32) { set *dst = R 'b { p }; }",

        "fn f 'a 'b (dst: &'a mut [&'b u32], p: &'b u32) { set dst[0] = p; }",

        "fn f 'a 'b (dst: &'a mut [&'b u32], p: &'b u32) { set dst[..] = p; }",

        "fn f 'a 'b (dst: &'a mut fn(&'b u32), callback: fn(&'b u32)) { set *dst = callback; }",

    ] {

        let mut testArena43 = super::testArena();

        let testStorage43: 'test43 = &mut testArena43 in {

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

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

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

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

        }

    }

}

/// A session holds the arena loan after the interface is moved or discarded.

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

    for program in [

        "use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { alloc::reset(arena); } }",

        "use std::lang::alloc; unsafe fn f(arena: &mut alloc::Arena) { use *arena as s in { alloc::reset(arena); } }",

        "use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { let moved = s; alloc::reset(arena); } }",

        "use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { let _ = s; set arena.offset = 0; } }",

        "use std::lang::alloc; fn f(arena: &mut alloc::Arena) { use *arena as s in { use *arena as t in {} } }",

    ] {

        let mut testArena44 = super::testArena();

        let testStorage44: 'test44 = &mut testArena44 in {

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

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

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

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

        }

    }

}

/// Session interfaces have affine ownership and invariant region arguments.

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

    for program in [

        "fn f 'r (s: Session 'r) { let moved = s; let again = s; }",

        "unsafe fn f 'r (s: Session 'r) { let moved = s; let again = s; }",

        "fn take 'r (s: Session 'r) {} fn f 'r (s: Session 'r) { take(s); take(s); }",

    ] {

        let mut testArena45 = super::testArena();

        let testStorage45: 'test45 = &mut testArena45 in {

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

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

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

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

        }

    }

    {

        let mut testArena46 = super::testArena();

        let testStorage46: 'test46 = &mut testArena46 in {

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

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

                "fn f 'r 's (s: Session 's) -> Session 'r where 'r: 's { return s; }");

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

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

        }

    }

}

/// Regional `use` blocks require a mutable allocation trait implementer.

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

    for program in [

        "record Arena { data: *mut [u8], offset: u32 } fn f(arena: &mut Arena) { use *arena as s in {} }",

        "fn f(value: &mut u32) { use *value as s in {} }",

    ] {

        let mut testArena47 = super::testArena();

        let testStorage47: 'test47 = &mut testArena47 in {

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

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

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

        }

    }

    let mut customArena = super::testArena();

    let customStorage: 'custom = &mut customArena in {