E0623 highlights wrong parameter in async fn

[SNCPlay42]

struct Struct { }

impl Struct {
    async fn async_fn(self: &Struct, f: &u32) -> &u32 {
        f
    }
    
    fn sync_fn(self: &Struct, f: &u32) -> &u32 {
        f
    }
}

Output (playground)

   Compiling playground v0.0.1 (/playground)
error[E0623]: lifetime mismatch
 --> src/main.rs:5:9
  |
4 |     async fn async_fn(self: &Struct, f: &u32) -> &u32 {
  |                             -------              ----
  |                             |
  |                             this parameter and the return type are declared with different lifetimes...
5 |         f
  |         ^ ...but data from `f` is returned here

error[E0623]: lifetime mismatch
 --> src/main.rs:9:9
  |
8 |     fn sync_fn(self: &Struct, f: &u32) -> &u32 {
  |                                  ----     ----
  |                                  |
  |                                  this parameter and the return type are declared with different lifetimes...
9 |         f
  |         ^ ...but data from `f` is returned here

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0623`.
error: could not compile `playground`.

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

The error in sync_fn is correct, but the one for async_fn incorrectly claims the return type lifetime is different from self's lifetime, when they are in fact the same per the elision rules.

[ayazhafiz]

related: #63499

[tmandry]

Seems related to #74072. Triaging as On Deck since this is an incorrect diagnostic which can cause confusion.

[SNCPlay42]

Another case:

async fn async_fn(x: &i32, y: &mut &i32) {
    *y = x;
}

fn sync_fn(x: &i32, y: &mut &i32) {
    *y = x;
}

Output (playground)

error[E0623]: lifetime mismatch
 --> src/main.rs:2:10
  |
1 | async fn async_fn(x: &i32, y: &mut &i32) {
  |                                    ----  -
  |                                    |
  |                                    this parameter and the return type are declared with different lifetimes...
2 |     *y = x;
  |          ^ ...but data from `x` is returned here

error[E0623]: lifetime mismatch
 --> src/main.rs:6:10
  |
5 | fn sync_fn(x: &i32, y: &mut &i32) {
  |               ----          ----
  |               |
  |               these two types are declared with different lifetimes...
6 |     *y = x;
  |          ^ ...but data from `x` flows into `y` here

The error message for async_fn refers to returning when no returning is involved!

[SNCPlay42]

Output for the async functions in both cases with #![feature(nll)]: (playground)

error: lifetime may not live long enough
 --> src/main.rs:4:5
  |
3 | async fn async_fn(x: &i32, y: &mut &i32) {
  |                      -             - let's call the lifetime of this reference `'2`
  |                      |
  |                      let's call the lifetime of this reference `'1`
4 |     *y = x;
  |     ^^^^^^ assignment requires that `'1` must outlive `'2`

error: lifetime may not live long enough
  --> src/main.rs:11:9
   |
10 |     async fn async_fn(self: &Struct, f: &u32) -> &u32 {
   |                             -           - let's call the lifetime of this reference `'1`
   |                             |
   |                             let's call the lifetime of this reference `'2`
11 |         f
   |         ^ associated function was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`

Looks like this can be tagged as fixed by NLL.

[eholk]

@SNCPlay42 - since this is tagged as fixed by NLL, do you think we can go ahead and close the whole issue?

[tmandry]

This still reproduces for me. Adding #![feature(nll)] does fix the issue, I'm not sure what we're using that feature for nowadays.

[eholk]

@rustbot claim

[eholk]

I think we can make some more significant improvements to the error message here, since it's taken me awhile to figure out what it's really trying to tell me. Since this issue was filed, the error message has changed slightly (probably because of this change. Here's the current error message:

   Compiling playground v0.0.1 (/playground)
error[E0623]: lifetime mismatch
 --> src/main.rs:5:9
  |
4 |     async fn async_fn(self: &Struct, f: &u32) -> &u32 {
  |                             -------              ----
  |                             |                    |
  |                             |                    this `async fn` implicitly returns an `impl Future<Output = &u32>`
  |                             this parameter and the returned future are declared with different lifetimes...
5 |         f
  |         ^ ...but data from `f` is held across an await point here

error[E0623]: lifetime mismatch
 --> src/main.rs:9:9
  |
8 |     fn sync_fn(self: &Struct, f: &u32) -> &u32 {
  |                                  ----     ----
  |                                  |
  |                                  this parameter and the return type are declared with different lifetimes...
9 |         f
  |         ^ ...but data from `f` is returned here

For more information about this error, try `rustc --explain E0623`.
error: could not compile `playground` due to 2 previous errors

To me the most confusing thing, in both the sync and async case, is that it's not clear how the parameters and the return values are declared with different lifetimes. I thought "they aren't declared with any lifetime, can't the compiler infer one that works?" So I tried a similar example that does not use an impl:

fn sync_fn(_: &i32, f: &u32) -> &u32 {
    f
}

For this one, the error is:

error[E0106]: missing lifetime specifier
 --> src/lib.rs:1:33
  |
1 | fn sync_fn(_: &i32, f: &u32) -> &u32 {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from argument 1 or `f`
help: consider introducing a named lifetime parameter
  |
1 | fn sync_fn<'a>(_: &'a i32, f: &'a u32) -> &'a u32 {
  |           ^^^^    ^^^^^^^     ^^^^^^^     ^^^

For more information about this error, try `rustc --explain E0106`.
error: could not compile `playground` due to previous error

This one is a lot clearer to me. Basically, the compiler is saying "there are too many lifetimes here and I can't tell which ones you meant to relate to which others. Please be more explicit to help me figure it out."

In the impl case, it seems like we have a lifetime elision rule that assumes returned references are borrowed from self. I think in both the sync and async examples, it'd be nice to have the error message explicitly call out that the return value is borrowed from self.

[SNCPlay42]

In the impl case, it seems like we have a lifetime elision rule that assumes returned references are borrowed from self. I think in both the sync and async examples, it'd be nice to have the error message explicitly call out that the return value is borrowed from self.

See #74597

[eholk]

I'm going to unassign myself from this for I can focus more on the generator captures issue.

[tmandry]

@rustbot claim

[eholk]

@rustbot label +AsyncAwait-Polish

[tmandry]

There is a remaining issue not fixed by #92183 which I'll attempt to elucidate here.

In try_report_anon_anon_conflict, we are reporting an error with two anonymous lifetimes. We rely on the fact that anonymous lifetimes can only be introduced in parameters, and the only other place they can appear is the return type. To check if the conflict occurs in the return type, we check to see if either lifetime appears in the return type. If it does, we highlight the return type and the parameter corresponding to the other lifetime.

This is a little broken. Just because a lifetime appears in the return type does not necessarily mean the return type had anything to do with the current error. We want to know what types the failing lifetime obligation came from, and the span of those types. For example, for each lifetime it could be

• The return type
• The type of the parameter that introduced the lifetime
• An associated type embedded in either of the above (e.g., impl Future<Output = &'a i32>)

[estebank]

Current output:

error: lifetime may not live long enough
 --> src/main.rs:5:9
  |
4 |     async fn async_fn(self: &Struct, f: &u32) -> &u32 {
  |                             -           - let's call the lifetime of this reference `'1`
  |                             |
  |                             let's call the lifetime of this reference `'2`
5 |         f
  |         ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
  |
help: consider introducing a named lifetime parameter and update trait if needed
  |
4 |     async fn async_fn<'a>(self: &'a Struct, f: &'a u32) -> &u32 {
  |                      ++++        ++             ++

error: lifetime may not live long enough
 --> src/main.rs:9:9
  |
8 |     fn sync_fn(self: &Struct, f: &u32) -> &u32 {
  |                      -           - let's call the lifetime of this reference `'1`
  |                      |
  |                      let's call the lifetime of this reference `'2`
9 |         f
  |         ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
  |
help: consider introducing a named lifetime parameter and update trait if needed
  |
8 |     fn sync_fn<'a>(self: &'a Struct, f: &'a u32) -> &u32 {
  |               ++++        ++             ++