Exclusivity

// A `&var` borrow is exclusive. While it is alive, it is the only way to reach the value: no
// second `&var` borrow, and no reading the value by its own name either. Read-only `&` borrows
// have no such limit, because any number of readers can look at a value without harming it.
//
// "While it is alive" is shorter than it looks. A borrow ends at its last use, not at the end of
// the block it was made in, so a borrow that has finished its work is no obstacle.
//
// The rule exists for functions like `Merge` below. It takes two accounts and is written for two
// different ones. Handed the same account twice, it would add the balance to itself and then wipe
// it out. Exclusivity makes that call impossible to write.
import Io::PrintLine;

struct Account {
    owner: char8[..];
    balance: int32;
}

// Moves everything from one account into another.
func Merge(into: &var Account, from: &var Account) {
    into.balance += from.balance;
    from.balance = 0;
}

// Two read-only borrows of the same account are fine: neither can change it.
func Richer(left: &Account, right: &Account) -> char8[..] {
    let owner = left.balance >= right.balance ? left.owner : right.owner;
    return owner;
}

func Main() -> int {
    var alice = Account { owner: "Alice", balance: 100 };
    var bob = Account { owner: "Bob", balance: 20 };

    // Two different accounts: two exclusive borrows that do not overlap.
    Merge(alice, bob);
    PrintLine("after merge: Alice {}, Bob {}", alice.balance, bob.balance);

    // The same account twice is refused:
    //
    //     Merge(alice, alice);
    //
    // error: call arguments create overlapping exclusive borrows of 'alice'
    //   note: an earlier argument borrows the same storage at 40:11
    //   help: split the accesses into non-overlapping calls

    // Shared borrows may overlap freely.
    PrintLine("richer of Alice and Alice: {}", Richer(alice, alice));

    // A local `&var` borrow. Its last use is the second line below, and from there on `alice`
    // is free again, so reading it by name is accepted.
    let wallet: &var Account = alice;
    wallet.balance -= 30;
    wallet.balance -= 20;
    PrintLine("after spending: Alice {}", alice.balance);

    // Move that `PrintLine` above the second `wallet` line and `wallet` is still alive when
    // `alice` is read:
    //
    // error: cannot read 'alice.balance' while 'wallet' holds an exclusive borrow
    //   note: exclusive borrow begins at 51:32
    //   help: read through 'wallet' or wait until its last use
    return 0;
}