False positive: single_use_lifetimes

[Nugine]

I tried this code:

#[deny(single_use_lifetimes)]

// error: lifetime parameter `'a` only used once
async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
    s3
}

fn foo<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
    s3
}

fn main() {}

I expected to see this happen: the code is correct.

Instead, this happened:

error: lifetime parameter `'a` only used once
 --> src/main.rs:4:14
  |
4 | async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
  |              ^^ this lifetime...                           -- ...is used only here
  |
note: the lint level is defined here
 --> src/main.rs:1:8
  |
1 | #[deny(single_use_lifetimes)]
  |        ^^^^^^^^^^^^^^^^^^^^

Just swap the functions, then the code compiles:

#[deny(single_use_lifetimes)]

fn foo<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
    s3
}

async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
    s3
}

fn main() {}

Update 20201014:

The examples may be misleading.
I forgot that #[deny(single_use_lifetimes)] takes effect on a single item.
It was a typo.

Here is a new example. It should be correct. But the compiler does not accept it.

#![deny(single_use_lifetimes)]

// error: lifetime parameter `'a` only used once
async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
    s3
}

Meta

rustc --version --verbose:

rustc 1.46.0 (04488afe3 2020-08-24)
binary: rustc
commit-hash: 04488afe34512aa4c33566eb16d8c912a3ae04f9
commit-date: 2020-08-24
host: x86_64-unknown-linux-gnu
release: 1.46.0
LLVM version: 10.0

rustc +nightly --version --verbose:

rustc 1.48.0-nightly (8b4085359 2020-09-23)
binary: rustc
commit-hash: 8b4085359ae798dedb05c95ad42520557bd25320
commit-date: 2020-09-23
host: x86_64-unknown-linux-gnu
release: 1.48.0-nightly
LLVM version: 11.0

[tmandry]

Very strange. I'm thinking we have some stateful HIR lowering code that is hanging onto state it shouldn't.

[camelid]

This bug existed as far back as November 2019 (when async/.await was stabilized), so it's not a recent regression.

[Dylan-DPC-zz]

Marking this as P-medium based on the wg-prioritization discussion

[sapessi]

I did some digging into this. I'm brand new to the compiler so slowly learning the architecture along the way. Below are some thoughts on what I've seen so far.

The desugared HIR for both samples is the same:

async first

#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
// edition:2018

// error: lifetime parameter `'a` only used once
#[deny(single_use_lifetimes)]
async fn bar<'a, '_>(s1: String, s2: &'_ str, s3: &'a str)
 ->
     /*impl Trait*/ #[lang = "from_generator"](move |mut _task_context|
                                                   {
                                                       let s1 = s1;
                                                       let s2 = s2;
                                                       let s3 = s3;
                                                       { let _t = { s3 }; _t }
                                                   })

fn foo<'a>(s1: String, s2: &str, s3: &'a str) -> &'a str { s3 }

fn main() { }

async last

#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
// check-pass
// edition:2018

// error: lifetime parameter `'a` only used once
#[deny(single_use_lifetimes)]
fn foo<'a>(s1: String, s2: &str, s3: &'a str) -> &'a str { s3 }

async fn bar<'a, '_>(s1: String, s2: &'_ str, s3: &'a str)
 ->
     /*impl Trait*/ #[lang = "from_generator"](move |mut _task_context|
                                                   {
                                                       let s1 = s1;
                                                       let s2 = s2;
                                                       let s3 = s3;
                                                       { let _t = { s3 }; _t }
                                                   })

fn main() { }

As expected both resolves the same set of lifetimes (from rustc_resolve::late::lifetimes) and process them in the same order (since they are sorted). Dump from the lifetime_uses property at the first iteration:

async first

2:rustcDEBUG rustc_resolve::late::lifetimes lifetime_uses: {
	DefId(0:12 ~ issue_77175[317d]::bar::'_): Many, 
	DefId(0:4 ~ issue_77175[317d]::bar::'a): Many, 
	DefId(0:11 ~ issue_77175[317d]::bar::{opaque#0}::'_): Many, 
	DefId(0:10 ~ issue_77175[317d]::bar::{opaque#0}::'a): One(lifetime(HirId { owner: DefId(0:5 ~ issue_77175[317d]::bar::{opaque#0}), local_id: 1 }: 'a))
}

async last

2:rustcDEBUG rustc_resolve::late::lifetimes lifetime_uses: {
	DefId(0:12 ~ issue_77175_reverse[317d]::bar::'_): Many, 
	DefId(0:11 ~ issue_77175_reverse[317d]::bar::{opaque#0}::'_): Many, 
	DefId(0:6 ~ issue_77175_reverse[317d]::bar::'a): Many, 
	DefId(0:10 ~ issue_77175_reverse[317d]::bar::{opaque#0}::'a): One(lifetime(HirId { owner: DefId(0:7 ~ issue_77175_reverse[317d]::bar::{opaque#0}), local_id: 1 }: 'a))
}

Interestingly both included the 'a lifetime as used only once in the opaque/desugared async function and both trigger the lint. However, for the second case (async last) the compilation still succeeds - this is really confusing and I'm probably missing something big about the compiler architecture. Need to dig deeper.

[Nugine]

The examples may be misleading.
I forgot that #[deny(single_use_lifetimes)] takes effect on a single item.
It was a typo.

Here is a new example.

#![deny(single_use_lifetimes)]

// error: lifetime parameter `'a` only used once
async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str {
    s3
}

[sapessi]

Makes sense. Then the behavior is no longer magical and makes a lot of sense.