if let keeps borrows too long

[oxalica]

Borrows in patterns are kept during the whole if let expression, including the else branch, which is counterintuitive and annoying.
For example, this doesn't compile.

let mut x = Some(1);
if let Some(&ref p) = x.as_ref() {
    // do something with p
} else {
    x = Some(2); // error: x is still borrowed
}

To pass the borrow check, you have to write ugly code like this.

let mut x = Some(1);
let mut flag = false;
if let Some(&ref p) = x.as_ref() {
    // do something with p
} else {
    flag = true;
}
if flag {
    x = Some(2);
}

[qnighy]

This seems to be the known limitation of the current borrow checker. #35132 is one of the similar issues.

[oxalica]

Unlike match mentioned in #35132, if let with else has two braces and seems to have two different lexical scope naturally, and borrows should only live the first scope.
On the other hand, although non-lexical lifetimes do fix both issues, I think this one is easier to resolve by simply desugering code like the latter I've shown.

[qnighy]

So you meant to change desugaring of if let, the current behavior of which leads to the very NLL example?
To me it looks a bit difficult to apply your desugaring in general, since if let can have types other than ().

Perhaps rust-lang/rfcs#2068 is also related?

[codyps]

I don't think desugaring will be an issue. At least handling a return value works with the example below (using fake macro-like syntax, and likely in need of some NoDrop to avoid issues where the expression is Drop)

if let $p:pattern = $ei:expr {
    $em:expr
} else {
    $ef:expr
}

Transformed to:

{
    let mut flag = false;
    let mut v = if let $p = $ei {
       $em
    } else {
        flag = true;
        unsafe { uninitialized() }
    };
    if flag {
        v = $ef;
    }
    v
}

A specific example (https://play.rust-lang.org/?gist=205359c0924e50efa8974f1f73250419&version=stable)

let mut x = Some(1);
let res = {
    let mut flag = false;
    let mut v = if let Some(&ref p) = x.as_ref() {
        // do something with p
        println!("{}", p);
        p * 3
    } else {
        flag = true;
        unsafe { std::mem::uninitialized() }
    };
    if flag {
        x = Some(2);
        v = 7;
    }
   v
};

[scottmcm]

There are flagless desugars too, like

loop {
    {
        if let $p:pattern = $ei:expr {
            break $em:expr
        }
    }
    break $ef:expr
}

(Or the nicer version with labeled blocks, if inside the compiler or if that RFC is accepted)

[memoryruins]

Triage: OP's example now compiles on 2018.
2015 errors:

error[E0506]: cannot assign to `x` because it is borrowed
 --> src/main.rs:6:9
  |
3 |     if let Some(&ref p) = x.as_ref() {
  |                           - borrow of `x` occurs here
...
6 |         x = Some(2); // error: x is still borrowed
  |         ^^^^^^^^^^^ assignment to borrowed `x` occurs here

rustc: 1.32.0