Borrow checker gets confused by a conditionally returned borrows

[huonw]

fn foo<'a>(x: &'a mut int) -> &'a mut int {
    {
        let y = &mut *x;
        if *y == 1 {
            return y;
        }
    }
    {
        let y = &mut *x;
        if *y == 2 {
            return y;
        }
    }
    fail!()
}

fn main() {}

conditional-return.rs:11:21: 11:28 error: cannot borrow `*x` because it is already borrowed as mutable
conditional-return.rs:11         let mut y = &mut *x;
                                             ^~~~~~~
conditional-return.rs:5:21: 5:28 note: previous borrow of `*x` as mutable occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `*x` until the borrow ends
conditional-return.rs:5         let mut y = &mut *x;
                                            ^~~~~~~
conditional-return.rs:17:2: 17:2 note: previous borrow ends here
conditional-return.rs:3 fn foo<'a>(x: &'a mut int) -> &'a mut int {
...
conditional-return.rs:17 }
                         ^

Can be worked around by going via * with some unsafe:

fn foo<'a>(x: &'a mut int) -> &'a mut int {
    {
        let y = &mut *x;
        let yy: *mut int = y;
        unsafe {
            if *yy == 1 {
                return &mut *yy;
            }
        }
    }
    {
        let y = &mut *x;
        let yy: *mut int = y;
        unsafe {
            if *yy == 2 {
                return &mut *yy;
            }
        }
    }
    fail!()
}

fn main() {}

[huonw]

cc @nikomatsakis

[flaper87]

cc @flaper87

[nikomatsakis]

This is not a bug, actually. Or, put another way, it's a dup of #6393.

[nikomatsakis]

The problem is that the borrow let y = &mut *x must borrow x for the entire lifetime 'a, not just for the block, because y is returned (that is, y escapes the block).

[TyOverby]

Here is another case of this bug in action:

/// Try to fetch a resource.  If the resource has not been loaded yet, block
/// until it is loaded.                                                     
fn fetch_block<'a>(&'a mut self, path: &str) -> Result<&'a Vec<u8>, E> {    
    loop {                                                                  
        match self.fetch(path) {                                            
            Ok(Some(x)) => { return Ok(x); },                               
            Ok(None) => { continue; },                                      
            Err(e) => { return Err(e); }                                    
        }                                                                   
    }                                                                       
}                          

/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:62:19: 62:23 error: cannot borrow `*self` as mutable more than once at a time
/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:62             match self.fetch(path) {
                                                                           ^~~~
/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:62:19: 62:23 note: previous borrow of `*self` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `*self` until the borrow ends
/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:62             match self.fetch(path) {
                                                                           ^~~~
/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:68:6: 68:6 note: previous borrow ends here
/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:60     fn fetch_block<'a>(&'a mut self, path: &str) -> Result<&'a Vec<u8>, E> {
...
/Users/tyoverby/workspace/rust/asset_store/src/lib.rs:68     }
                                                             ^
error: aborting due to previous error

[nikomatsakis]

This is a dup of #6393. What is happening is that the borrow extends to the end of the scope -- which is outside of the fn as a whole. Since the returns in all these cases are conditional, the borrow is considered to remain in force for the remainder of the fn.