Move async fn arguments into closure.

This commit takes advantage of `AsyncArgument` type that was added in a
previous commit to replace the arguments of the `async fn` in the HIR
and add statements to move the bindings from the new arguments to the
pattern from the old argument.

For example, the async function `foo` below:

    async fn foo((x, _y): (T, V)) {
        async move {
        }
    }

becomes:

    async fn foo(__arg0: (T, V)) {
        async move {
            let (x, _y) = __arg0;
        }
    }

Author: davidtwco

src/librustc/hir/lowering.rs

@@ -2819,12 +2819,18 @@ impl<'a> LoweringContext<'a> {
         asyncness: &IsAsync,
         body: &Block,
     ) -> hir::BodyId {
-        self.lower_body(Some(decl), |this| {
-            if let IsAsync::Async { closure_id, .. } = asyncness {
+        self.lower_body(Some(&decl), |this| {
+            if let IsAsync::Async { closure_id, ref arguments, .. } = asyncness {
+                let mut body = body.clone();
+
+                for a in arguments.iter().rev() {
+                    body.stmts.insert(0, a.stmt.clone());
+                }
+
                 let async_expr = this.make_async_expr(
                     CaptureBy::Value, *closure_id, None,
                     |this| {
-                        let body = this.lower_block(body, false);
+                        let body = this.lower_block(&body, false);
                         this.expr_block(body, ThinVec::new())
                     });
                 this.expr(body.span, async_expr, ThinVec::new())
@@ -2886,23 +2892,39 @@ impl<'a> LoweringContext<'a> {
             ItemKind::Fn(ref decl, ref header, ref generics, ref body) => {
                 let fn_def_id = self.resolver.definitions().local_def_id(id);
                 self.with_new_scopes(|this| {
-                    // Note: we don't need to change the return type from `T` to
-                    // `impl Future<Output = T>` here because lower_body
-                    // only cares about the input argument patterns in the function
-                    // declaration (decl), not the return types.
-                    let body_id = this.lower_async_body(decl, &header.asyncness.node, body);
+                    let mut lower_fn = |decl: &FnDecl| {
+                        // Note: we don't need to change the return type from `T` to
+                        // `impl Future<Output = T>` here because lower_body
+                        // only cares about the input argument patterns in the function
+                        // declaration (decl), not the return types.
+                        let body_id = this.lower_async_body(&decl, &header.asyncness.node, body);
+
+                        let (generics, fn_decl) = this.add_in_band_defs(
+                            generics,
+                            fn_def_id,
+                            AnonymousLifetimeMode::PassThrough,
+                            |this, idty| this.lower_fn_decl(
+                                &decl,
+                                Some((fn_def_id, idty)),
+                                true,
+                                header.asyncness.node.opt_return_id()
+                            ),
+                        );
 
-                    let (generics, fn_decl) = this.add_in_band_defs(
-                        generics,
-                        fn_def_id,
-                        AnonymousLifetimeMode::PassThrough,
-                        |this, idty| this.lower_fn_decl(
-                            decl,
-                            Some((fn_def_id, idty)),
-                            true,
-                            header.asyncness.node.opt_return_id()
-                        ),
-                    );
+                        (body_id, generics, fn_decl)
+                    };
+
+                    let (body_id, generics, fn_decl) = if let IsAsync::Async {
+                        arguments, ..
+                    } = &header.asyncness.node {
+                        let mut decl = decl.clone();
+                        // Replace the arguments of this async function with the generated
+                        // arguments that will be moved into the closure.
+                        decl.inputs = arguments.clone().drain(..).map(|a| a.arg).collect();
+                        lower_fn(&decl)
+                    } else {
+                        lower_fn(decl)
+                    };
 
                     hir::ItemKind::Fn(
                         fn_decl,

src/librustc/hir/map/def_collector.rs

@@ -73,11 +73,12 @@ impl<'a> DefCollector<'a> {
         decl: &'a FnDecl,
         body: &'a Block,
     ) {
-        let (closure_id, return_impl_trait_id) = match header.asyncness.node {
+        let (closure_id, return_impl_trait_id, arguments) = match &header.asyncness.node {
             IsAsync::Async {
                 closure_id,
                 return_impl_trait_id,
-            } => (closure_id, return_impl_trait_id),
+                arguments,
+            } => (closure_id, return_impl_trait_id, arguments),
             _ => unreachable!(),
         };
 
@@ -89,14 +90,28 @@ impl<'a> DefCollector<'a> {
             this.create_def(*return_impl_trait_id, DefPathData::ImplTrait, REGULAR_SPACE, span);
 
             visit::walk_generics(this, generics);
-            visit::walk_fn_decl(this, decl);
 
-            let closure_def = this.create_def(*closure_id,
-                                              DefPathData::ClosureExpr,
-                                              REGULAR_SPACE,
-                                              span);
+            // Walk the generated arguments for the `async fn`.
+            for a in arguments {
+                use visit::Visitor;
+                this.visit_ty(&a.arg.ty);
+            }
+
+            // We do not invoke `walk_fn_decl` as this will walk the arguments that are being
+            // replaced.
+            visit::walk_fn_ret_ty(this, &decl.output);
+
+            let closure_def = this.create_def(
+                *closure_id, DefPathData::ClosureExpr, REGULAR_SPACE, span,
+            );
             this.with_parent(closure_def, |this| {
-                visit::walk_block(this, body);
+                for a in arguments {
+                    use visit::Visitor;
+                    // Walk each of the generated statements before the regular block body.
+                    this.visit_stmt(&a.stmt);
+                }
+
+                visit::walk_block(this, &body);
             })
         })
     }

src/librustc_resolve/lib.rs

@@ -831,11 +831,20 @@ impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
 
         // Add each argument to the rib.
         let mut bindings_list = FxHashMap::default();
-        for argument in &declaration.inputs {
+        let mut add_argument = |argument: &ast::Arg| {
             self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);
             self.visit_ty(&argument.ty);
             debug!("(resolving function) recorded argument");
+        };
+
+        // Walk the generated async arguments if this is an `async fn`, otherwise walk the
+        // normal arguments.
+        if let IsAsync::Async { ref arguments, .. } = asyncness {
+            for a in arguments { add_argument(&a.arg); }
+        } else {
+            for a in &declaration.inputs { add_argument(a); }
         }
+
         visit::walk_fn_ret_ty(self, &declaration.output);
 
         // Resolve the function body, potentially inside the body of an async closure
@@ -846,9 +855,18 @@ impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
         }
 
         match function_kind {
-            FnKind::ItemFn(.., body) |
-            FnKind::Method(.., body) => {
-                self.visit_block(body);
+            FnKind::ItemFn(.., body) | FnKind::Method(.., body) => {
+                if let IsAsync::Async { ref arguments, .. } = asyncness {
+                    let mut body = body.clone();
+                    // Insert the generated statements into the body before attempting to
+                    // resolve names.
+                    for a in arguments {
+                        body.stmts.insert(0, a.stmt.clone());
+                    }
+                    self.visit_block(&body);
+                } else {
+                    self.visit_block(body);
+                }
             }
             FnKind::Closure(body) => {
                 self.visit_expr(body);