Borrow checker doesn't realize borrow ends in both branches

[jonhoo]

The following code fails to compile, even though there are no outstanding references to procs after the if let:

use std::sync::Mutex;
let g = Mutex::new(Mutex::new(String::new()));
let procs = g.lock().unwrap();
let q = procs.lock().ok();
let _sp = if let Some(_p) = q {
    Some(0)
} else {
    None
};
drop(procs);

with

error[E0505]: cannot move out of `procs` because it is borrowed
  --> src/main.rs:13:6
   |
7  | let q = procs.lock().ok();
   |         ----- borrow of `procs` occurs here
...
13 | drop(procs);
   |      ^^^^^ move out of `procs` occurs here
14 | }
   | - borrow might be used here, when `q` is dropped and runs the destructor for type `std::option::Option<std::sync::MutexGuard<'_, std::string::String>>`

If the if let is replace with an equivalent map on the other hand, the code compiles just fine:

use std::sync::Mutex;
let g = Mutex::new(Mutex::new(String::new()));
let procs = g.lock().unwrap();
let q = procs.lock().ok();
let _sp = q.map(|_p| {
    0
});
drop(procs);

This could be related to #47680 or #57165, I'm not sure. Happens on both 2015 and 2018 editions.

[jonhoo]

Interestingly enough, this works:

use std::sync::Mutex;
let g = Mutex::new(Mutex::new(String::new()));
let procs = g.lock().unwrap();
let mut q = procs.lock().ok();
let _sp = if let Some(ref _p) = q {
    Some(0)
} else {
    None
};
drop(q);
drop(procs);

Though the explicit drop(q) is needed.

[jonhoo]

Looking at it some more, I guess dropping is the key here. The map version and the version with Some(ref _p) both explicitly drop q before procs, whereas the failing version assumes that q is dropped before procs. But of course, that's not true, since q is implicitly dropped at the end of scope. So, I think this is a user issue 👼

[jonhoo]

Actually, on second though, I think the first code sample should work, since q should presumably be dropped when we destruct it with the if let Some?

[goffrie]

Actually, on second though, I think the first code sample should work, since q should presumably be dropped when we destruct it with the if let Some?

if let Some(_p) = q doesn't actually destruct q as such - it moves out _p in the Some case, but overall leaves q partially initialized. If you force a full move from q by using if let Some(_p) = {q}, or by using q.map(|_p| 0), your snippet compiles.

[jonhoo]

Ah, yes, you're right! Thanks!