When is a reference being 'used' in non-lexical lifetimes? - rust

Question

struct Object {
alive: bool,
name: String,
}
impl Object {
// the comments are what I thought the compiler was supposed to give
fn test(&mut self) {
let alive = &mut self.alive; // seems like there is mutable borrow here
self.name = String::from("dead"); // another mutable borrow
*alive = false; // mutable borrow later used here
}
}
fn print(x: &Object) {
println!("Hello {:?}", x);
}
A non-lexical lifetime is supposed to be when a reference stops living after it's last use. I am confused on what that use is.
alive is a mutable borrow to self.alive and then self is used to do self.name = String::from("dead");. After this it looks like alive is used again in *alive = false. Except this code compiles.
If I change the code to this:
fn test(&mut self) {
let alive = &mut self.alive;
print(self);
self.name = String::from("dead");
*alive = false;
}
then the code gives this error
error[E0502]: cannot borrow `*self` as immutable because it is also borrowed as mutable [10/58]
--> src/main.rs:45:15
|
44 | let alive = &mut self.alive;
| --------------- mutable borrow occurs here
45 | print(self);
| ^^^^ immutable borrow occurs here
46 | self.name = String::from("dead");
47 | *alive = false;
| -------------- mutable borrow later used here
. Does this mean that references are only 'used' when they are in functions and not when dereferenced with * or the dot notation? How does the first example compile even though it seems like the the reference scopes are overlapping?

Answer 1

Does this mean that references are only 'used' when they are in functions and not when dereferenced with * or the dot notation?
You are close. Non-lexical lifetimes aren't a factor here, but the borrow checker has more tricks up its sleeves. It knows that the fields of a struct are distinct objects and can be borrowed independently.
From the Rust Nomicon on Splitting Borrows:
It does understand structs sufficiently to know that it's possible to borrow disjoint fields of a struct simultaneously. So this works today:
struct Foo {
a: i32,
b: i32,
c: i32,
}
let mut x = Foo {a: 0, b: 0, c: 0};
let a = &mut x.a;
let b = &mut x.b;
let c = &x.c;
*b += 1;
let c2 = &x.c;
*a += 10;
println!("{} {} {} {}", a, b, c, c2);
So in your code, there can be exclusive references to both self.alive and self.name because borrow checker knows they aren't referencing the same object. Adding the print(self) needs to reference the whole self and conflicts with the borrow given to alive.