Correct handling of arguments in async fn

[taiki-e]

Fixes #60509
Fixes #60566

r? @cramertj or @davidtwco

Done

[Centril]

cc @matthewjasper @eddyb -- Can you please double check this?

[eddyb]

@davidtwco This is the hack that we'd want to move to HIR lowering but we can't because of rustc_resolve interacting with upvars, right?

[davidtwco]

@eddyb Yeah, we'll presumably want to lower to the same HIR in the end. Because of the interaction with rustc_resolve, it's easier to insert the statements/replace the arguments in the AST during name resolution so it can make the correct locals resolve to Def::Upvar. If we didn't construct them here, then these same types would need to be constructed in rustc_resolve and in HIR lowering.

Other places, like the def collector, that use these constructed types would be able to get away with just using NodeIds that we'd create here (much like the IsAsync type worked previously), and we'd only construct the actual statements and arguments during HIR lowering.

[taiki-e]

by-ref binding:

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

// desugaring (current master)
fn foo(ref x: A) -> ... { //~ ERROR temporary value dropped while borrowed [E0716]
    async move {
        let ref x = x;
        ...
    }
}

// desugaring (this PR)
fn foo(__arg0: A) -> ... {
    async move {
        let mut __arg0 = __arg0; // here always mutable binding
        let ref x = __arg0;
        ...
    }
}

by-value binding:

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

// desugaring (current master)
fn foo(mut x: A) -> ... { //~ WARNING variable does not need to be mutable
    async move {
        let mut x = x;
        ...
    }
}

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

other patterns:

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

// desugaring (current master)
fn foo(__arg0: (A, A)) -> ... {
    async move {
        let __arg0 = __arg0;
        let (mut x, y) = __arg0; //~ ERROR cannot borrow `__arg0.0` as mutable, as `__arg0` is not declared as mutable [E0596]
        ...
    }
}

// desugaring (this PR), it is handled in the same way as by-ref binding.
fn foo(__arg0: A) -> ... {
    async move {
        let mut __arg0 = __arg0; // here always mutable binding
        let (mut x, y) = __arg0;
        ...
    }
}

[taiki-e]

I somehow forgot to write this, sorry.

[taiki-e]

The reason by-ref binding isn't be desugared like the following is that it breaks the drop order (57ec63c is the test used when this was checked locally. Also this is the branch used when I checked it: taiki-e@2cb3031).

fn foo(x: A) -> ... {
    async move {
        let ref x = x;
        ...
    }
}

[cramertj]

@bors r+

[bors]

📌 Commit 57ec63c has been approved by cramertj