return_position_impl_trait_in_trait lifetimes on self

[gilescope]

The following compiles:

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=b0b57210e4369ac10e2dd694644cfbaf

But if you take away <'a> then the code doesn't compile. It compiles if self rather than &self is used. Is this as good as it gets? Would have expected this to work without the 'as. (I appreicate this is work in progress, hope this helps, sorry if it's a dupe).

[cjgillot]

What do you mean "if you take away <'a>"? Where do you take those from? Which &self becomes self?

[Jules-Bertholet]

I think @gilescope means that

#![feature(async_fn_in_trait)]
#![feature(return_position_impl_trait_in_trait)]
use core::future::Future;

pub trait Trait {
    fn foo(&self) -> impl Future<Output = ()>;
}

pub struct S;

impl Trait for S {
    async fn foo(&self) -> () {}
}

fails to compile, while

#![feature(async_fn_in_trait)]
#![feature(return_position_impl_trait_in_trait)]
use core::future::Future;

pub trait Trait<'a> {
    fn foo(&'a self) -> impl Future<Output = ()>;
}

pub struct S;

impl<'a> Trait<'a> for S {
    async fn foo(&'a self) -> () {}
}

compiles fine.

[eholk]

You can also make this compile by changing the return type in the trait definition to be -> impl Future<Output = ()> + '_, which is basically what async fn desugars too.

#![feature(async_fn_in_trait)]
#![feature(return_position_impl_trait_in_trait)]
use core::future::Future;

pub trait Trait {
	fn foo(&self) -> impl Future<Output = ()> + '_;
}

pub struct S;

impl Trait for S {
	async fn foo(&self) -> () {}
}

[eholk]

After discussing at wg-async triage, it looks like the behavior here is correct but the error messages are unclear. In particular, it'd be good for the error message to mention + '_ somehow to suggest how to workaround this issue and match the async fn desugaring.

[vincenzopalazzo]

As discussed during the triage I will try to improve the suggestion here!

@rustbot claim

[compiler-errors]

Given:

#![feature(async_fn_in_trait)]
#![feature(return_position_impl_trait_in_trait)]

use core::future::Future;

pub trait Trait {
    fn foo(&self) -> impl Future<Output = ()>;
}

pub struct S;

impl Trait for S {
    async fn foo(&self) -> () {}
}

The error message is now:

error: return type captures more lifetimes than trait definition
  --> src/lib.rs:13:28
   |
13 |     async fn foo(&self) -> () {}
   |                  -         ^^
   |                  |
   |                  this lifetime was captured
   |
note: hidden type must only reference lifetimes captured by this impl trait
  --> src/lib.rs:7:22
   |
7  |     fn foo(&self) -> impl Future<Output = ()>;
   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
   = note: hidden type inferred to be `impl Future<Output = ()>`

I consider this to be sufficiently improved.