Incorrect lint: needless_lifetimes

[vmalloc]

I tried this code:

pub async fn send<'a>(&self, client: &'a Client) -> Result<Request<'a>> {
       ...
        Ok(Request::new(client, self.request_id))
    }

Clippy complains that this violates "needless_lifetimes". However trying to elide them cannot succeed due to the &self reference:

pub async fn send(&self, client: &Client) -> Result<Request<'_>> {
       ...
        Ok(Request::new(client, self.request_id))
    }

Fails:

pub async fn send<'a>(&self, client: &Client) -> Result<Request<'_>> {
   |                           -----                      -------------------------
   |                           |
   |                           this parameter and the return type are declared with different lifetimes...
...
Ok(Request::new(client, self.order_id))
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...but data from `client` is returned here

I'm not sure if there is actually an option for elision here at all...

Meta

• cargo clippy -V: clippy 0.0.212 (bb37a0f 2020-06-16)
• rustc -Vv:

rustc 1.44.1 (c7087fe00 2020-06-17)
binary: rustc
commit-hash: c7087fe00d2ba919df1d813c040a5d47e43b0fe7
commit-date: 2020-06-17
host: x86_64-apple-darwin
release: 1.44.1
LLVM version: 9.0

Thanks in advance!

[piegamesde]

I can reproduce this, even without self:

pub async fn wrap_something<'a>(
    to_wrap: &'a mut Wrapped,
    unrelated: &Unrelated,
) -> Wrapper<'a> {

As far as I can tell, there is no possibility of eliding this, as the type system doesn't know from which of the arguments it should borrow without explicit lifetimes.

[mahkoh]

Parameter lifetimes cannot be elided in async functions:

pub async fn transaction<'a>(con: &'a mut PgClient) -> Result<Transaction<'a>> {

// does not compile
pub async fn transaction(con: &mut PgClient) -> Result<Transaction> {

Note that this only applies to async functions.

[cppforliving]

It seems to be a duplicate of #4746

[flip1995]

Copying my comment from the other issue:

Reproducer: Playground

use std::sync::MutexGuard;

struct Foo;

impl Foo {
    // doesn't get linted without async
    pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
        guard
    }
}

This is a self contained reproducer.

[HyeonuPark]

I've reduced it further.

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=1556b5afa098a4f6578bb3999d82e9d4

async fn foo<'a>(_x: &i32, y: &'a str) -> &'a str {
    y
}

warning: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
 --> src/lib.rs:1:1
  |
1 | async fn foo<'a>(_x: &i32, y: &'a str) -> &'a str {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(clippy::needless_lifetimes)]` on by default
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes

And this doesn't triggers it.

async fn foo<'a, 'b>(_x: &'b i32, y: &'a str) -> &'a str {
    y
}

[tofay]

In the async case, _x's lifetime is being ignored as it's hitting this check:

rust-clippy/clippy_lints/src/lifetimes.rs

Lines 327 to 328 in e6665e4

	} else if let LifetimeName::Param(ParamName::Fresh(_)) = lt.name {
	// Fresh lifetimes generated should be ignored.

The lint then only has 'a in the input and output lifetimes, and assumes 'a can be elided.