NLL: `if let` not detecting proper lifetime

[Ekleog]

Hello,

I have recently been pointed to this example:

#![feature(nll)]

fn find_best(vec: &mut Vec<i32>) -> Option<&mut i32> {
    vec.get_mut(0)
}

fn foo(vec: &mut Vec<i32>) -> &mut i32 {
    if let Some(best) = find_best(vec) {
        best
    } else {
        &mut vec[1]
    }
}

fn main() {
    let mut x = vec![1, 2, 3];
    *foo(&mut x) = 42;
}

To me, the code looks sane, and looks like it should compile with NLL enabled (as the borrow to vec ends at the end of the if block, and shouldn't propagate to the else block), yet it looks like it doesn't.

Hope that helps, and as always thank you for your work on rustc!

[jonhoo]

Another similar example (playground):

#![feature(nll)]

struct Packet<'a> {
    b: &'a [u8],
}

impl<'a> Packet<'a> {
    fn new(b: &'a [u8]) -> Option<Self> {
        Some(Packet { b: b })
    }
}

struct PacketReader {
    bytes: Vec<u8>,
}

impl PacketReader {
    fn poll<'a>(&'a mut self) -> Packet<'a> {
        loop {
            if let Some(p) = Packet::new(&self.bytes[..]) {
                return p;
            }

            // we need to read some more
            self.bytes.truncate(0);
        }
    }
}

This produces:

error[E0502]: cannot borrow `self.bytes` as mutable because it is also borrowed as immutable
  --> src/lib.rs:25:13
   |
20 |             if let Some(p) = Packet::new(&self.bytes[..]) {
   |                                           ---------- immutable borrow occurs here
...
25 |             self.bytes.truncate(0);
   |             ^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
   |
note: immutable borrowed value must be valid for the lifetime 'a as defined on the method body at 18:13...
  --> src/lib.rs:18:13
   |
18 |     fn poll<'a>(&'a mut self) -> Packet<'a> {
   |             ^^

error: aborting due to previous error

[jonhoo]

Actually, maybe the above example is really #51526?

[ia0]

I think I have a similar issue, but inside the if branch, not in the else or after.

#[derive(Debug)]
struct NotCopy(u8);
struct Foo(Vec<NotCopy>);
impl Foo {
    fn iter(&self) -> impl Iterator<Item = (NotCopy, &NotCopy)> {
        self.0.iter().map(|x| (NotCopy(x.0), x))
    }
    fn iter2(&self) -> impl Iterator<Item = NotCopy> + '_ {
        self.iter().map(|(x, _)| x)
    }
    fn work(&mut self) {
        // let x = self.iter2().find(|_| true); if let Some(x) = x {
        if let Some(x) = self.iter2().find(|_| true) {
            self.0.push(x);
        }
    }
}

fn main() {
    let mut v = Foo(vec![NotCopy(0)]);
    v.work();
    println!("{:?}", v.0);
}

error[E0502]: cannot borrow `self.0` as mutable because it is also borrowed as immutable
  --> src/main.rs:15:13
   |
14 |         if let Some(x) = self.iter2().find(|_| true) {
   |                          ------------
   |                          |
   |                          immutable borrow occurs here
   |                          a temporary with access to the immutable borrow is created here ...
15 |             self.0.push(x);
   |             ^^^^^^ mutable borrow occurs here
16 |         }
17 |     }
   |     - ... and the immutable borrow might be used here, when that temporary is dropped and runs the destructor for type `impl std::iter::Iterator`
   |
   = note: The temporary is part of an expression at the end of a block. Consider adding semicolon after the expression so its temporaries are dropped sooner, before the local variables declared by the block are dropped.

The workaround is to uncomment the commented line and comment the one after.

[est31]

Not 100% sure but this might be the same as #103108 ... with #107251 as a proposed PR to address it.

[est31]

Just checked with a local build: #107251 does not fix this, it's therefore a different issue than #103108.