Recover from malformed trait bounds of the form Fn<'a>()

[fmease]

The following code:

fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}

currently produces a heap of semi-helpful diagnostics:

stderr (7 errors)

error: unexpected lifetime `'a` in pattern
 --> src/lib.rs:1:26
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |                          ^^ help: remove the lifetime

error: expected one of `:` or `|`, found `->`
 --> src/lib.rs:1:34
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |                                  ^^ expected one of `:` or `|`

error: expected one of `)`, `+`, `,`, or `::`, found `(`
 --> src/lib.rs:1:24
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |                        ^
  |                        |
  |                        expected one of `)`, `+`, `,`, or `::`
  |                        help: missing `,`

error[E0261]: use of undeclared lifetime name `'a`
 --> src/lib.rs:1:21
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |                     ^^ undeclared lifetime
  |
  = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'a` lifetime
  |
1 | fn f(_: impl for<'a> FnOnce<'a>(&'a str) -> bool) {}
  |              +++++++
help: consider introducing lifetime `'a` here
  |
1 | fn f<'a>(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |     ++++

error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change
 --> src/lib.rs:1:14
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |              ^^^^^^^^^^ help: use parenthetical notation instead: `FnOnce() -> ()`
  |
  = note: see issue #29625 <https://github.com/rust-lang/rust/issues/29625> for more information

error[E0107]: this trait takes 0 lifetime arguments but 1 lifetime argument was supplied
 --> src/lib.rs:1:14
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |              ^^^^^^---- help: remove these generics
  |              |
  |              expected 0 lifetime arguments

error[E0107]: this trait takes 1 generic argument but 0 generic arguments were supplied
 --> src/lib.rs:1:14
  |
1 | fn f(_: impl FnOnce<'a>(&'a str) -> bool) {}
  |              ^^^^^^ expected 1 generic argument
  |
help: add missing generic argument
  |
1 | fn f(_: impl FnOnce<'a, Args>(&'a str) -> bool) {}
  |                       ++++++

when instead we could special-case this and emit a single (or at least fewer) diagnostic that suggests the following:

- impl FnOnce<'a>(&'a str) -> bool
+ impl for<'a> FnOnce(&'a str) -> bool

---

If the bound in not inside impl Trait, like in:

fn f<F>(_: F) where F: FnOnce<'a>(&'a str) -> bool {}

we currently emit the following:

error: expected one of `+`, `,`, `::`, or `{`, found `(`
 --> src/lib.rs:1:34
  |
1 | fn f<F>(_: F) where F: FnOnce<'a>(&'a str) -> bool {}
  |                                  ^ expected one of `+`, `,`, `::`, or `{`

which is less verbose for sure but still, we should provide the same suggestion I propose above.

Related issue: #103487.

@rustbot label A-parser A-suggestion-diagnostics D-newcomer-roadblock

[ohno418]

I'd like to take a look.
@rustbot claim

[ohno418]

@fmease
I'm wondering if taking an approach that suggests using higher-rank trait bounds (for<'a> Fn) for an Fn-family trait with a lifetime parameter. Is it appropriate?
I'm concerned that it may not a comprehensive solution because HRTB can be used outside of the Fn-family traits (as I understand).
Or is it okay only for the Fn-family traits for now?

[fmease]

I am not sure I fully understand what you mean.

Fn-family trait with a lifetime parameter

As you probably know, none of Fn, FnMut, FnOnce take a lifetime parameter and probably never will. Of course, you could define such a trait with unstable features but there is no way to use them, so it's not relevant:

#![feature(unboxed_closures)]

#[rustc_paren_sugar]
pub trait Tr<'a, T> { type Output; }

pub fn f(_: impl Tr(i32)) {} //~ ERROR this trait takes 1 lifetime argument but
                             //        0 lifetime arguments were supplied

Or is it okay only for the Fn-family traits for now?

Yes, I'd say so. I wouldn't look for names however (like FnOnce, std::ops::FnMut, …) but just look for an opening parenthesis ( after a generic parameter list. This way, we can emit the same suggestion for the following case (where the name is X):

fn f(_: impl X<'a>(&'a str)) {}
use FnOnce as X;

[ohno418]

just look for an opening parenthesis ( after a generic parameter list.

Ah, definitely. Thank you!