self in locally defined macro doesn't get rewritten

[athre0z]

Hi there and thanks for the great lib!

I just noticed that self, when referenced from a locally defined macro, is not correctly rewritten to _self.

#[async_trait::async_trait]
trait Magic {
    async fn foo(&self);
}

struct Bar {
    x: i32,
}

#[async_trait::async_trait]
impl Magic for Bar {
    async fn foo(&self) {
        macro_rules! ref_self {
            () => {
                // reference self somehow
                let _x = self.x;
            }
        }

        ref_self!();
    }
}

fn main() {}

expands to

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
trait Magic {
    fn foo<'life0, 'async_trait>(
        &'life0 self,
    ) -> ::core::pin::Pin<
        Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Send + 'async_trait>,
    >
    where
        'life0: 'async_trait,
        Self: 'async_trait;
}
struct Bar {
    x: i32,
}
impl Magic for Bar {
    fn foo<'life0, 'async_trait>(
        &'life0 self,
    ) -> ::core::pin::Pin<
        Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Send + 'async_trait>,
    >
    where
        'life0: 'async_trait,
        Self: 'async_trait,
    {
        #[allow(
            clippy::missing_docs_in_private_items,
            clippy::type_repetition_in_bounds,
            clippy::used_underscore_binding
        )]
        async fn __foo(_self: &Bar) {
            let _x = self.x;
        }
        Box::pin(__foo(self))
    }
}
fn main() {}

resulting in

error[E0434]: can't capture dynamic environment in a fn item
  --> src/main.rs:16:26
   |
16 |                 let _x = self.x;
   |                          ^^^^
...
20 |         ref_self!();
   |         ------------ in this macro invocation
   |
   = help: use the `|| { ... }` closure form instead

Currently, I just work around this by just passing it in as $self:ident.

[thomaseizinger]

I just updated to the latest version but this is still a problem for me in the case where macro_rules defines a trait implementation that uses async_trait.

The following code fails to compile:

fn main() {
    let _ = Bar.foo();
}

#[async_trait::async_trait]
trait Foo {
    async fn foo(&self);
}

macro_rules! impl_foo {
    ($target:ty) => {
        #[async_trait::async_trait]
        impl Foo for $target {
            async fn foo(&self) {

            }
        }
    };
}

struct Bar;

impl_foo!(Bar);

It expands to (using cargo expand):

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
fn main() {
    let _ = Bar.foo();
}
trait Foo {
    #[must_use]
    fn foo<'life0, 'async_trait>(
        &'life0 self,
    ) -> ::core::pin::Pin<
        Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Send + 'async_trait>,
    >
        where
            'life0: 'async_trait,
            Self: 'async_trait;
}
struct Bar;
impl Foo for Bar {
    fn foo<'life0, 'async_trait>(
        &'life0 self,
    ) -> ::core::pin::Pin<
        Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Send + 'async_trait>,
    >
        where
            'life0: 'async_trait,
            Self: 'async_trait,
    {
        #[allow(
        clippy::missing_docs_in_private_items,
        clippy::type_repetition_in_bounds,
        clippy::used_underscore_binding
        )]
        async fn __foo(_self: &Bar) {}
        Box::pin(__foo(self))
    }
}

Interestingly this compiles if you remove the prelude import stuff 🤔
Is there a different between what cargo expand and what rustc does?

[dtolnay]

That one is a rustc bug: #46 / rust-lang/rust#43081.

[dtolnay]

You should be able to work around it by using $target:tt or $($target:tt)* instead of $target:ty.