Using anonymous lifetimes fails to compile

[udoprog]

The following:

struct Baz;

#[async_trait]
trait Foo {
    async fn test(value: &Baz);
}

struct Bar<'a>(&'a ());

#[async_trait]
impl Foo for Bar<'_> {
    async fn test(value: &Baz) {
    }
}

Results in:

error[E0261]: use of undeclared lifetime name `'_`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0261`.
error: Could not compile `oxidize`.

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

[dtolnay]

Thanks! I won't be able to fix this right away but I would accept a PR with a fix. We need to figure out where the macro is incorrectly copying the '_ into the macro output and figure out what it should be putting there instead.

[udoprog]

Well, looked briefly, but this is over my head.
Compiler: rustc 1.38.0-nightly (8a58268b5 2019-07-31)

This is the generated code:

impl Foo for Bar<'_> {
    fn test<'life0, 'async_trait>(
        value: &'life0 Baz,
    ) -> core::pin::Pin<
        Box<dyn core::future::Future<Output = ()> + core::marker::Send + 'async_trait>,
    >
    where
        'life0: 'async_trait,
    {
        async fn __test(value: &Baz) {}
        core::pin::Pin::from(Box::new(__test(value)))
    }
}

Which doesn't compile.
But then there's this which does (what you get after naming the lifetime to 'a):

impl<'a> Foo for Bar<'a> {
    fn test<'life0, 'async_trait>(
        value: &'life0 Baz,
    ) -> core::pin::Pin<
        Box<dyn core::future::Future<Output = ()> + core::marker::Send + 'async_trait>,
    >
    where
        'life0: 'async_trait,
    {
        async fn __test<'a>(value: &Baz) {}
        core::pin::Pin::from(Box::new(__test(value)))
    }
}

Then there's this that does work:

impl Foo for Bar<'_> {
    fn test<'life0, 'async_trait>(
        value: &'life0 Baz,
    ) -> core::pin::Pin<
        Box<dyn core::future::Future<Output = ()> + core::marker::Send + 'async_trait>,
    >
    where
        'life0: 'async_trait,
    {
        core::pin::Pin::from(Box::new(async move {}))
    }
}

But just including the async fn __test(value: &Baz) {} in the function body breaks it again.

So this seems to be some subtle interaction with how rustc deals with the desugaring of the nested async fn, which is beyond my understanding.

[dtolnay]

I guess it's a compiler bug. Let's close in favor of tracking this in rust-lang/rust#63225. Thanks!