Nested closures give suboptimal move suggestion

[oli-obk]

The following code needs a move on the map closure, but the suggestion first tells us to add it to the flat_map closure. After following that suggestion, the next error will tell us to put it on the map closure. This terminates correctly, but should suggest the final thing immediately. Note that with many nested levels of closures, there will be one error-fix-recompile cycle per nested closure until we get it working.

pub struct X;

pub fn foo<'a>(
    bar: &'a X,
) -> impl Iterator<Item = ()> + 'a {
    Some(()).iter().flat_map(|()| {
        Some(()).iter().map(|()| { bar; })
    })
}

(Playground)

Errors:

   Compiling playground v0.0.1 (/playground)
error: captured variable cannot escape `FnMut` closure body
 --> src/lib.rs:7:9
  |
6 |     Some(()).iter().flat_map(move |()| {
  |                                      - inferred to be a `FnMut` closure
7 |         Some(()).iter().map(|()| { bar; })
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returns a reference to a captured variable which escapes the closure body
  |
  = note: `FnMut` closures only have access to their captured variables while they are executing...
  = note: ...therefore, they cannot allow references to captured variables to escape

error: aborting due to previous error

error: Could not compile `playground`.

To learn more, run the command again with --verbose.

[estebank]

Note that both moves are needed.

[oli-obk]

Oh... hmm... I thought I had a situation where only the inner one is needed. I'll investigate more.

[estebank]

Triage: little change.

Current output:

error[E0373]: closure may outlive the current function, but it borrows `bar`, which is owned by the current function
 --> src/lib.rs:6:30
  |
6 |     Some(()).iter().flat_map(|()| {
  |                              ^^^^ may outlive borrowed value `bar`
7 |         Some(()).iter().map(|()| { bar; })
  |                                    --- `bar` is borrowed here
  |
note: closure is returned here
 --> src/lib.rs:6:5
  |
6 | /     Some(()).iter().flat_map(|()| {
7 | |         Some(()).iter().map(|()| { bar; })
8 | |     })
  | |______^
help: to force the closure to take ownership of `bar` (and any other referenced variables), use the `move` keyword
  |
6 |     Some(()).iter().flat_map(move |()| {
  |                              ++++

and when applying the suggestion we fail to suggest the second necessary move:

error: captured variable cannot escape `FnMut` closure body
 --> src/lib.rs:7:9
  |
4 |     bar: &'a X,
  |     --- variable defined here
5 | ) -> impl Iterator<Item = ()> + 'a {
6 |     Some(()).iter().flat_map(move |()| {
  |                                      - inferred to be a `FnMut` closure
7 |         Some(()).iter().map(|()| { bar; })
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^---^^^^
  |         |                          |
  |         |                          variable captured here
  |         returns a reference to a captured variable which escapes the closure body
  |
  = note: `FnMut` closures only have access to their captured variables while they are executing...
  = note: ...therefore, they cannot allow references to captured variables to escape

[safinaskar]

@estebank , the compiler still gives bad advice. Please, reopen the bug. Consider this code:

fn main() {
    let get = |path: &str| || {
        assert!(path.starts_with('/'));
    };
}

Playground: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=7d311a40c9b0662af5b2894f7ce8e6eb
Playground currently uses nightly 75a0be9 (as reported by playground), which (as well as I understand) includes recent fix ( 6b94f4d ). But still compiler error is bad:

Compiling playground v0.0.1 (/playground)
warning: unused variable: `get`
 --> src/main.rs:2:9
  |
2 |     let get = |path: &str| || {
  |         ^^^ help: if this is intentional, prefix it with an underscore: `_get`
  |
  = note: `#[warn(unused_variables)]` on by default

error: lifetime may not live long enough
 --> src/main.rs:2:28
  |
2 |       let get = |path: &str| || {
  |  ______________________-___-_^
  | |                      |   |
  | |                      |   return type of closure `[closure@src/main.rs:2:28: 2:30]` contains a lifetime `'2`
  | |                      let's call the lifetime of this reference `'1`
3 | |         assert!(path.starts_with('/'));
4 | |     };
  | |_____^ returning this value requires that `'1` must outlive `'2`
  |
help: consider adding 'move' keyword before the nested closure
  |
2 |     let get = |path: &str| move || {
  |                            ++++

warning: `playground` (bin "playground") generated 1 warning
error: could not compile `playground` due to previous error; 1 warning emitted

The compiler suggests adding move before ||. But after this change the code still doesn't compile! So compiler's advice is unhelpful

[estebank]

I'm not entirely sure what we should suggest in that case, if anything.