rust/tests/ui/borrowck/borrowck-closures-unique-imm.rs

struct Foo {
    x: isize,
}

pub fn main() {
    let mut this = &mut Foo {
        x: 1,
    };
    let mut r = || {
        let p = &this.x;
        &mut this.x; //~ ERROR cannot borrow
        p.use_ref();
    };
    r()
}

trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { }  }
impl<T> Fake for T { }
librustc: Record unique immutable borrows in the restrictions table. This fixes borrow checking for closures. Code like this will break: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { let p = &this.x; &mut this.x; }; r() } Change this code to not take multiple mutable references to the same value. For example: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { &mut this.x; }; r() } Closes #16361. [breaking-change] 2014-08-12 16:25:41 -05:00			`struct Foo {`
Update compile fail tests to use isize. 2015-01-08 04:54:35 -06:00			`x: isize,`
librustc: Record unique immutable borrows in the restrictions table. This fixes borrow checking for closures. Code like this will break: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { let p = &this.x; &mut this.x; }; r() } Change this code to not take multiple mutable references to the same value. For example: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { &mut this.x; }; r() } Closes #16361. [breaking-change] 2014-08-12 16:25:41 -05:00			`}`

			`pub fn main() {`
			`let mut this = &mut Foo {`
			`x: 1,`
			`};`
remove all kind annotations from closures 2015-02-01 11:44:15 -06:00			`let mut r = \|\| {`
librustc: Record unique immutable borrows in the restrictions table. This fixes borrow checking for closures. Code like this will break: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { let p = &this.x; &mut this.x; }; r() } Change this code to not take multiple mutable references to the same value. For example: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { &mut this.x; }; r() } Closes #16361. [breaking-change] 2014-08-12 16:25:41 -05:00			`let p = &this.x;`
			`&mut this.x; //~ ERROR cannot borrow`
Updated the most glaring instances of weak tests w.r.t. NLL that came from #53196. See also the bulletpoint list on #53351. 2018-08-14 18:16:05 -05:00			`p.use_ref();`
librustc: Record unique immutable borrows in the restrictions table. This fixes borrow checking for closures. Code like this will break: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { let p = &this.x; &mut this.x; }; r() } Change this code to not take multiple mutable references to the same value. For example: struct Foo { x: int, } pub fn main() { let mut this = &mut Foo { x: 1, }; let r = \|\| { &mut this.x; }; r() } Closes #16361. [breaking-change] 2014-08-12 16:25:41 -05:00			`};`
			`r()`
			`}`
Updated the most glaring instances of weak tests w.r.t. NLL that came from #53196. See also the bulletpoint list on #53351. 2018-08-14 18:16:05 -05:00
			`trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { } }`
			`impl<T> Fake for T { }`