let matchBlock = currentBlock(self);

    let mut fallback: ?il::Val = nil;

    // The fallback uses the enclosing scope before pattern bindings exist.

    switchToBlock(self, elseBlock);

    if try typeOf(self, letElse.elseBranch) == resolver::Type::Never {

        try lowerNode(self, letElse.elseBranch);

    } else {

        set fallback = try lowerExpr(self, letElse.elseBranch);

    }

    let fallbackBlock = currentBlock(self);

    switchToBlock(self, matchBlock);

    try sealBlock(self, elseBlock);

    if let value = fallback {

        switchToBlock(self, fallbackBlock);

            defVar(self, variable, value);

    /// Cell payload checks that require complete nominal layouts.

    cellChecks: *mut [CellCheck],

/// Cell signature whose payload needs a complete nominal layout.

record CellCheck: Copy {

    /// Source signature used for diagnostics.

    node: *ast::Node,

    /// Payload whose layout and ownership must be checked.

    payload: Type,

    /// Region environment at the source signature.

    regions: ?*RegionScope,

    /// Module that owns the source signature.

    moduleId: u16,

}

            break;

    let previousRegions = self.regionScope;

    let previousModule = self.currentMod;

    let mut index: u32 = 0;

    while index < self.cellChecks.len {

        let check = self.cellChecks[index];

        set self.regionScope = check.regions;

        set self.currentMod = check.moduleId;

        try validateCellPayload(self, check.node, check.payload) catch error {

            set self.regionScope = previousRegions;

            set self.currentMod = previousModule;

            throw error;

        };

        set index += 1;

    }

    set self.cellChecks.len = 0;

    set self.regionScope = previousRegions;

    set self.currentMod = previousModule;

        cellChecks: &mut [],

        // Pointer, slice, and cell layouts do not depend on their element layout.

        case Type::Pointer { .. }, Type::Slice { .. }, Type::Cell { .. } => {

    if ident <> owner {

        setNodeSymbol(self, ident, sym);

    }

            let _ = try bindValueIdent(self, pat.pattern, node, payloadTy, pat.mutable, 0, 0);

            try ensureStorableType(self, node, inner);

            let allocator = alloc::arenaAllocator(self.arena);

            self.cellChecks.append(CellCheck {

                node, payload: inner, regions: self.regionScope, moduleId: self.currentMod,

            }, allocator);

    expireAllocationLoans(checker, &mut thenEnv, conditional.pattern.pattern, conditional.pattern.scrutinee);

            expireAllocationLoans(checker, &mut bodyEnv, whileStmt.pattern.pattern, whileStmt.pattern.scrutinee);

/// Fresh allocation storage has no loans from earlier loop iterations.

unsafe fn expireAllocationLoans 'arena 'checking (

    checker: &mut LinearChecker 'arena 'checking, env: &mut LinearEnv,

    node: *ast::Node, value: *ast::Node

) where 'arena: 'checking {

    let case ast::NodeValue::Try(allocation) = value.value else return;

    if allocation.catches.len <> 0 {

        return;

    }

    let case NodeExtra::SessionAllocation(_) = checker.resolver.nodeData.entries[allocation.expr.id].extra

        else return;

    let symbol = checker.resolver.nodeData.entries[node.id].binding else return;

    for i in 0..checker.regionalLen {

        if regionalLoan(checker, i).place.root == symbol.symbol {

            set env.regionalLoans &= ~((1 as u64) << (i as u64));

        }

    }

}

            expireAllocationLoans(checker, env, node, binding.value);

            try addLinearPatternBindings(checker, &mut guardedEnv, binding.pattern.pattern);

            expireAllocationLoans(checker, &mut guardedEnv, binding.pattern.pattern, binding.pattern.scrutinee);

                try finishLinearScope(checker, &mut guardFallbackEnv, base.len);

/// Conditional bindings enforce moves through bodies and guards.

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

    for program in [

        "record Token {} fn take(value: Token) {} fn f(value: ?Token) { if let item = value { take(item); take(item); } }",

        "record Token {} fn take(value: Token) {} fn f(value: ?Token) { let item = value else return; take(item); take(item); }",

        "record Token {} fn take(value: Token) {} fn next() -> ?Token { return Token {}; } fn f() { while let item = next() { take(item); take(item); } }",

        "record Token {} fn take(value: Token) -> bool { return true; } fn f(value: ?Token) { if let item = value; take(item) { take(item); } }",

        "record Token {} fn take(value: Token) {} unsafe fn f(value: ?Token) { if let item = value { take(item); take(item); } }",

        "record Token {} record Box { item: Token } fn take(item: Token) -> bool { return true; } fn f(box: Box) { let case Box { item } = box if take(item) else return; take(item); }",

        "record Token {} record Box { item: Token } fn take(item: Token) -> bool { return true; } unsafe fn f(box: Box) { let case Box { item } = box if take(item) else return; take(item); }",

        "record Token {} union Box { Full(Token), Empty } fn take(item: Token) -> bool { return true; } fn f(box: Box) { let case Box::Full(item) = box if take(item) else return; take(item); }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

            try super::expectErrorKind(&result, resolver::ErrorKind::AffineUseAfterMove("item"));

        }

    }

}

/// Guard ownership distinguishes consumed fields, borrowed fields, and failure paths.

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

    for program in [

        "record Token {} record Box { item: Token } fn take(item: Token) -> bool { return true; } fn f(box: Box) { let case Box { item } = box if take(item) else return; }",

        "record Token {} record Box { item: Token } fn read(item: &Token) -> bool { return true; } fn take(item: Token) {} fn f(box: Box) { let case Box { item } = box if read(&item) else return; take(item); }",

        "union Box { Full(u32), Empty } fn f(box: Box) -> u32 { let case Box::Full(item) = box if item > 0 else return 0; return item; }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

            try super::expectNoErrors(&result);

        }

    }

    let mut storage = super::testArena();

    let memory: 'test = &mut storage in {

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

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

            "record Token {} record Box { item: u32 } fn take(outer: Token) -> bool { return false; } fn f(box: Box, outer: Token) { let case Box { item } = box if take(outer) else { take(outer); return; }; }");

        try super::expectErrorKind(&result, resolver::ErrorKind::AffineUseAfterMove("outer"));

    }

}

/// Fallback expressions cannot access their new binding before initialization.

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

    for program in [

        "fn f(input: ?u32) -> u32 { let value = input else value; return value; }",

        "unsafe fn f(input: ?u32) -> u32 { let value = input else value; return value; }",

        "fn f(input: ?u32) -> u32 { let mut value = input else { value }; return value; }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

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

        }

    }

}

/// Each successful session allocation has distinct storage across loop iterations.

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

    for program in [

        "fn f 'r (s: &Session 'r) { for i in 0..3 { let p = try! s.fill(0 as u32, 2); set p[0] = i; let view: &'r [u32] = &p[..]; } }",

        "fn f 'r (s: &Session 'r) { let mut i: u32 = 0; while i < 3 { let p = try! s.new(0 as u32); set *p = i; let view: &'r u32 = &*p; set i += 1; } }",

        "fn f 'r (s: &Session 'r) { for i in 0..3 { if let p = try? s.fill(0 as u32, 2); p.len == 2 { set p[0] = i; let view: &'r [u32] = &p[..]; } } }",

        "fn f 'r (s: &Session 'r) { while let p = try? s.new(0 as u32) { set *p = 1; let view: &'r u32 = &*p; } }",

        "fn f 'r (s: &Session 'r) { loop { let p = try? s.new(0 as u32) else break; set *p = 1; let view: &'r u32 = &*p; } }",

        "fn f 'r (s: &Session 'r) { for i in 0..3 { if let _ = try? s.new(0 as u32) {} let _ = try! s.new(0 as u32); } }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Fresh allocations preserve loans on aliases and existing storage.

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

    for program in [

        "fn f 'r (s: &Session 'r) { for i in 0..3 { let p = try! s.fill(0 as u32, 2); let view: &'r [u32] = &p[..]; set p[0] = i; } }",

        "fn f 'r (s: &Session 'r) { let p = try! s.fill(0 as u32, 2); for i in 0..3 { set p[0] = i; let view: &'r [u32] = &p[..]; } }",

        "fn f 'r (s: &Session 'r, p: &'r mut u32) { for i in 0..3 { let view: &'r u32 = &*p; let fresh = try! s.new(0 as u32); set *p = i; } }",

        "fn f 'r (s: &Session 'r, p: &'r mut u32) { for i in 0..3 { let fresh = try! s.new(&*p); set *p = i; } }",

        "fn f 'r (s: &Session 'r) { while let p = try? s.new(0 as u32) { let view: &'r u32 = &*p; set *p = 1; } }",

        "fn f 'r (s: &Session 'r) { for i in 0..3 { if let p = try? s.new(0 as u32) { let view: &'r u32 = &*p; set *p = i; } } }",

        "fn f 'r (s: &Session 'r) { loop { let p = try? s.new(0 as u32) else break; let view: &'r u32 = &*p; set *p = 1; } }",

        "fn check 'r (p: &'r u32) -> bool { return *p == 0; } fn f 'r (s: &Session 'r) { while let p = try? s.new(0 as u32); check(&*p) { set *p = 1; } }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

            try super::expectErrorKind(&result, resolver::ErrorKind::BorrowConflict("p"));

        }

    }

}

/// Cell references give indirect cycles finite layouts in each declaration order.

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

    for program in [

        "record V: 'r + Copy { n: N 'r } record N: 'r + Copy { s: &'r cell S 'r } union S: 'r + Copy { Ready(V 'r), Pending }",

        "union S: 'r + Copy { Ready(V 'r), Pending } record V: 'r + Copy { n: N 'r } record N: 'r + Copy { s: &'r cell S 'r }",

        "record N: 'r + Copy { s: &'r cell S 'r } union S: 'r + Copy { Ready(V 'r), Pending } record V: 'r + Copy { n: N 'r }",

        "record V: Copy { n: N } record N: Copy { s: *cell S } union S: Copy { Ready(V), Pending }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

            try super::expectNoErrors(&result);

        }

    }

}

/// Deferred cell checks reject invalid payloads without a payload access.

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

    for program in [

        "record N: 'r + Copy { s: &'r cell S 'r } union S: 'r { Ready(N 'r), Pending }",

        "record N: Copy { s: *cell S } record S { value: u32 }",

    ] {

        let mut storage = super::testArena();

        let memory: 'test = &mut storage in {

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

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

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

        }

    }

    let mut storage = super::testArena();

    let memory: 'test = &mut storage in {

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

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

            "record N: Copy { s: *cell S } record S: Copy { bytes: [u64; 536870913] }");

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

    }

}

//! returns: 0

//! Fallback expressions use the enclosing scope before binding their result.

/// Return the optional payload or the outer fallback value.

fn choose(input: ?u32, value: u32) -> u32 {

    {

        let value = input else value;

        return value;

    }

}

/// Evaluate a fallback with its own local binding and conditional result.

fn chooseBlock(input: ?u32, value: u32) -> u32 {

    {

        let value = input else {

            let mut offset = value;

            if value > 10 {

                set offset += 1;

            }

            return offset;

        };

        return value;

    }

}

/// Check both paths through a fallback that shares the new binding's name.

@default fn main() -> u32 {

    assert choose(nil, 17) == 17;

    assert choose(23, 17) == 23;

    assert chooseBlock(nil, 17) == 18;

    assert chooseBlock(nil, 3) == 3;

    assert chooseBlock(23, 17) == 23;

    return 0;

}

//! returns: 0

//! session-support

//! Recoverable allocation publishes separate storage on every loop iteration.

use std::lang::alloc;

/// Exercise guarded bindings, loop bindings, and early-exit allocation failure.

@default fn main() -> u32 {

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

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

    use arena as storage in {

        for i in 0..3 {

            if let values = try? storage.fill(0 as u32, 2); values.len == 2 {

                set values[0] = i;

                let frozen: &'storage [u32] = &values[..];

                assert frozen[0] == i;

            } else {

                panic "main: allocation failed";

            }

        }

        let mut count: u32 = 0;

        while let value = try? storage.new(0 as u32); count < 3 {

            set *value = count;

            let frozen: &'storage u32 = &*value;

            assert *frozen == count;

            set count += 1;

        }

        assert count == 3;

        set count = 0;

        loop {

            let value = try? storage.new(0 as u32) else break;

            set *value = count;

            let frozen: &'storage u32 = &*value;

            assert *frozen == count;

            set count += 1;

        }

        assert count > 0;

    }

    alloc::reset(&mut arena);

    assert alloc::used(&arena) == 0;

    return 0;

}