Async fn loses mut pattern when passed to attribute macro

[dtolnay]

Cargo.toml

[package]
name = "repro"
version = "0.0.0"
edition = "2018"

[lib]
proc-macro = true

src/lib.rs

extern crate proc_macro;
use proc_macro::TokenStream;

#[proc_macro_attribute]
pub fn attr(_args: TokenStream, input: TokenStream) -> TokenStream {
    println!("{}", input);
    TokenStream::new()
}

src/main.rs

#[repro::attr]
async fn f(mut x: u8) {}

fn main() {}

Between nightly-2019-05-07 and nightly-2019-05-08, the mut pattern that should be part of the macro input went missing. a19cf18...cfdc84a

$ cargo +nightly-2019-05-07 check
   Compiling repro v0.0.0
async fn f(mut x: u8) { }

$ cargo +nightly-2019-05-08 check
   Compiling repro v0.0.0
async fn f(x: u8) { }

Originally reported by @kjvalencik in dtolnay/syn#632.
Mentioning @taiki-e @cramertj @davidtwco because #60535 looks relevant and is in the right commit range.

[kjvalencik]

FYI, &mut is not lost.

[davidtwco]

Thanks for the report, I'll look into this.

[taiki-e]

Hmm, seems it was too early to remove mut with this timing:

rust/src/libsyntax/parse/parser.rs

Lines 8813 to 8820 in ef01f29

	// Remove mutability from arguments. If this is not a simple pattern,
	// those arguments are replaced by `__argN`, so there is no need to do this.
	if let PatKind::Ident(BindingMode::ByValue(mutability @ Mutability::Mutable), ..) =
	&mut input.pat.node
	{
	assert!(is_simple_pattern);
	*mutability = Mutability::Immutable;
	}

[taiki-e]

This problem only occurs with by-value binding(and simple patterns), so...

async fn foo(mut x: A) { ... }

// desugaring (current master)
fn foo(x: A) -> ... { // removed mutability
    async move {
        let mut x = x;
        ...
    }
}

// Probably it should desugar like this
fn foo(__arg0: A) -> ... {
    async move {
        let mut x = __arg0;
        ...
    }
}

[davidtwco]

I've filed #60676 with a fix.

[taiki-e]

@davidtwco Thanks for the fix!