rust/tests/ui/span/regionck-unboxed-closure-lifetimes.rs

#![feature(rustc_attrs)]
use std::ops::FnMut;

fn main() { #![rustc_error] // rust-lang/rust#49855
    let mut f;
    {
        let c = 1;
        let c_ref = &c;
        //~^ ERROR `c` does not live long enough
        f = move |a: isize, b: isize| { a + b + *c_ref };
    }
    f.use_mut();
}

trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { }  }
impl<T> Fake for T { }
Workaround rust-lang/rust#49855 by forcing rustc_error in any mode, including NLL. NOTE: I was careful to make each change in a manner that preserves the existing diagnostic output (usually by ensuring that no lines were added or removed). This means that the resulting source files are not as nice to read as they were at the start. But we will have to review these cases by hand anyway as follow-up work, so cleanup could reasonably happen then (or not at all). 2018-04-10 22:20:05 +00:00			`#![feature(rustc_attrs)]`
librustc: Tie up loose ends in unboxed closures. This patch primarily does two things: (1) it prevents lifetimes from leaking out of unboxed closures; (2) it allows unboxed closure type notation, call notation, and construction notation to construct closures matching any of the three traits. This breaks code that looked like: let mut f; { let x = &5i; f = \|&mut:\| x + 10; } Change this code to avoid having a reference escape. For example: { let x = &5i; let mut f; // <-- move here to avoid dangling reference f = \|&mut:\| x + 10; } I believe this is enough to consider unboxed closures essentially implemented. Further issues (for example, higher-rank lifetimes) should be filed as followups. Closes #14449. [breaking-change] 2014-07-30 05:08:39 +00:00			`use std::ops::FnMut;`

Workaround rust-lang/rust#49855 by forcing rustc_error in any mode, including NLL. NOTE: I was careful to make each change in a manner that preserves the existing diagnostic output (usually by ensuring that no lines were added or removed). This means that the resulting source files are not as nice to read as they were at the start. But we will have to review these cases by hand anyway as follow-up work, so cleanup could reasonably happen then (or not at all). 2018-04-10 22:20:05 +00:00			`fn main() { #![rustc_error] // rust-lang/rust#49855`
librustc: Tie up loose ends in unboxed closures. This patch primarily does two things: (1) it prevents lifetimes from leaking out of unboxed closures; (2) it allows unboxed closure type notation, call notation, and construction notation to construct closures matching any of the three traits. This breaks code that looked like: let mut f; { let x = &5i; f = \|&mut:\| x + 10; } Change this code to avoid having a reference escape. For example: { let x = &5i; let mut f; // <-- move here to avoid dangling reference f = \|&mut:\| x + 10; } I believe this is enough to consider unboxed closures essentially implemented. Further issues (for example, higher-rank lifetimes) should be filed as followups. Closes #14449. [breaking-change] 2014-07-30 05:08:39 +00:00			`let mut f;`
			`{`
			`let c = 1;`
Merge cfail and ui tests into ui tests 2017-11-20 12:13:27 +00:00			`let c_ref = &c;`
Point at var in short lived borrows 2017-12-14 01:27:23 +00:00			//~^ ERROR `c` does not live long enough
remove all kind annotations from closures 2015-02-01 17:44:15 +00:00			`f = move \|a: isize, b: isize\| { a + b + *c_ref };`
Point at var in short lived borrows 2017-12-14 01:27:23 +00:00			`}`
rust-lang/rust#51025: improve test robustness so that they work under NLL too. 2018-05-25 10:36:58 +00:00			`f.use_mut();`
librustc: Tie up loose ends in unboxed closures. This patch primarily does two things: (1) it prevents lifetimes from leaking out of unboxed closures; (2) it allows unboxed closure type notation, call notation, and construction notation to construct closures matching any of the three traits. This breaks code that looked like: let mut f; { let x = &5i; f = \|&mut:\| x + 10; } Change this code to avoid having a reference escape. For example: { let x = &5i; let mut f; // <-- move here to avoid dangling reference f = \|&mut:\| x + 10; } I believe this is enough to consider unboxed closures essentially implemented. Further issues (for example, higher-rank lifetimes) should be filed as followups. Closes #14449. [breaking-change] 2014-07-30 05:08:39 +00:00			`}`
rust-lang/rust#51025: improve test robustness so that they work under NLL too. 2018-05-25 10:36:58 +00:00
			`trait Fake { fn use_mut(&mut self) { } fn use_ref(&self) { } }`
			`impl<T> Fake for T { }`