"late bound lifetime parameters" error should have a number and help text

[cole-miller]

Currently (tested on stable and nightly) if you try to compile this code

fn f<'a>() {}
fn main() { let _ = f::<'static>; }

you get this error message:

error: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
 --> src/main.rs:4:17
  |
4 |     let _ = f::<'static>;
  |                 ^^^^^^^
  |
note: the late bound lifetime parameter is introduced here
 --> src/main.rs:1:6
  |
1 | fn f<'a>() {}
  |      ^^

There is no error number (like E0208) to pass to rustc --explain. There's also no mention that you can fix this error without changing the meaning of the code at all by putting a vacuous where clause in the signature of f, like this:

fn f<'a>() where 'a: 'a {}

See #42868 for background. (I'm not sure when that compatibility lint became a hard error; it seems to have happened without that tracking issue being updated. Maybe that has something to do with why the error has no number or help.)

I think:

• this error should have a number and accompanying rustc --explain text that discusses the early- vs. late-bound lifetime distinction and why specifying late-bound lifetime parameters explicitly is not allowed
• it should also have a help line that suggests adding where 'a: 'a

Here is the URLO thread that prompted this issue:

https://users.rust-lang.org/t/what-is-the-meaning-of-a-a-in-rust-lifetime-parameters/53570

cc @petrochenkov

[jyn514]

@cole-miller are you interested in adding the --explain text? There's instructions at https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-codes.html?highlight=code#diagnostic-codes, it should be fairly simple.

[cole-miller]

@jyn514 sure thing! While I'm waiting for ./x.py test tidy... how much harder would it be to add the help hint at the same time? I can always take a look at previous PRs to get a sense of what's required.

[jyn514]

Not too much harder I think :) See #76143 for an example of both.

[QuineDot]

* this error should have a number and accompanying `rustc --explain` text that discusses the early- vs. late-bound lifetime distinction and why specifying late-bound lifetime parameters explicitly is not allowed

I agree this is needed no matter what.

* it should also have a `help` line that suggests adding `where 'a: 'a`

I'm not sure this is the best solution though.

If there are no early bound lifetimes, just leaving off the lifetime specifier (as implied by the lint) also works:

let _ = f; // just leave off the lifetime specifier
let _: for<'a> fn() = f; // With type ascription

In more complicated situations, the type ascription may be needed to specify the early bound lifetimes, but can sometimes still be used without forcing an early bound:

struct Foo<'a, 'b> { a: &'a(), b: &'b () }
// There is an implicit late bound parameter due to &Foo; 'a and 'b are early bound
fn mixed<'a: 'a, 'b: 'b>(_: &Foo<'a, 'b>) -> Foo<'a, 'b> { todo!() }

// This happens to work but no lifetimes can be specified without lint or error
let _ = mixed;

// For example, this triggers the lint as a warning; specifying 1 or 3+ lifetimes triggers an error:
// let _ = mixed::<'static, 'static>;

// type ascription allows specifying the lifetimes without warning or error
let _: for<'a> fn(&'a Foo<'static, 'static>) -> Foo<'static, 'static> = mixed;

However, it is sometimes necessary to force a lifetime to be early bound, as discussed in issue 42868 and friends. I don't know how tractable it is to detect when the force-early-bound workaround is or isn't required. On the third hand, if I understand the conversation in issue 42508, sometimes type ascription works where forcing an early bound does not.

without changing the meaning of the code at all

Not quite:

// These compiled with `mixed` defined as above.  The first version fires the lint as a warning.
let _ = mixed::<'static, 'static>;
let _: for<'a> fn(&'a Foo<'static, 'static>) -> Foo<'static, 'static> = mixed;

// Apply the suggested hint:
fn mixed<'a: 'a, 'b: 'b, 'c: 'c>(_: &'c Foo<'a, 'b>) -> Foo<'a, 'b> { todo!() }

// This now fails: expected 3 lifetime arguments
let _ = mixed::<'static, 'static>;

// This now fails: one type is more general than the other
let _: for<'a> fn(&'a Foo<'static, 'static>) -> Foo<'static, 'static> = mixed;

[GroteGnoom]

Hi, @cole-miller could you claim this? Then it's easier to see which issues are not yet being worked on.

[cole-miller]

@rustbot claim

[Milo123459]

Any work being done on this? I'd love to implement this as my first contribution.