async await desugaring and tests

Author: cramertj

src/librustc/diagnostics.rs

@@ -2131,5 +2131,10 @@ register_diagnostics! {
     E0657, // `impl Trait` can only capture lifetimes bound at the fn level
     E0687, // in-band lifetimes cannot be used in `fn`/`Fn` syntax
     E0688, // in-band lifetimes cannot be mixed with explicit lifetime binders
-    E0697, // closures cannot be static
+
+    E0906, // closures cannot be static
+
+    E0703, // multiple different lifetimes used in arguments of `async fn`
+    E0704, // multiple elided lifetimes used in arguments of `async fn`
+    E0705, // `async` non-`move` closures with arguments are not currently supported
 }

src/librustc/hir/lowering.rs

@@ -99,6 +99,21 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
             ItemKind::Mod(..) if i.ident == keywords::Invalid.ident() => {
                 return visit::walk_item(self, i);
             }
+            ItemKind::Fn(_, FnHeader { asyncness: IsAsync::Async(async_node_id), .. }, ..) => {
+                // For async functions, we need to create their inner defs inside of a
+                // closure to match their desugared representation.
+                let fn_def_data = DefPathData::ValueNs(i.ident.name.as_interned_str());
+                let fn_def = self.create_def(i.id, fn_def_data, ITEM_LIKE_SPACE, i.span);
+                return self.with_parent(fn_def, |this| {
+                    let closure_def = this.create_def(async_node_id,
+                                          DefPathData::ClosureExpr,
+                                          REGULAR_SPACE,
+                                          i.span);
+                    this.with_parent(closure_def, |this| {
+                        visit::walk_item(this, i);
+                    })
+                });
+            }
             ItemKind::Mod(..) => DefPathData::Module(i.ident.name.as_interned_str()),
             ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) =>
                 DefPathData::ValueNs(i.ident.name.as_interned_str()),
@@ -227,15 +242,32 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
 
         match expr.node {
             ExprKind::Mac(..) => return self.visit_macro_invoc(expr.id),
-            ExprKind::Closure(..) => {
-                let def = self.create_def(expr.id,
+            ExprKind::Closure(_, asyncness, ..) => {
+                let closure_def = self.create_def(expr.id,
                                           DefPathData::ClosureExpr,
                                           REGULAR_SPACE,
                                           expr.span);
-                self.parent_def = Some(def);
+                self.parent_def = Some(closure_def);
+
+                // Async closures desugar to closures inside of closures, so
+                // we must create two defs.
+                if let IsAsync::Async(async_id) = asyncness {
+                    let async_def = self.create_def(async_id,
+                                                    DefPathData::ClosureExpr,
+                                                    REGULAR_SPACE,
+                                                    expr.span);
+                    self.parent_def = Some(async_def);
+                }
+            }
+            ExprKind::Async(_, async_id, _) => {
+                let async_def = self.create_def(async_id,
+                                                DefPathData::ClosureExpr,
+                                                REGULAR_SPACE,
+                                                expr.span);
+                self.parent_def = Some(async_def);
             }
             _ => {}
-        }
+        };
 
         visit::walk_expr(self, expr);
         self.parent_def = parent_def;

src/librustc/hir/map/def_collector.rs

@@ -245,6 +245,16 @@ pub enum LifetimeName {
 }
 
 impl LifetimeName {
+    pub fn is_elided(self) -> bool {
+        match self {
+            LifetimeName::Implicit
+            | LifetimeName::Underscore => true,
+            LifetimeName::Fresh(_)
+            | LifetimeName::Static
+            | LifetimeName::Name(_) => false,
+        }
+    }
+
     pub fn name(&self) -> Name {
         use self::LifetimeName::*;
         match *self {

src/librustc/hir/mod.rs

@@ -409,6 +409,7 @@ impl_stable_hash_for!(enum ::syntax_pos::hygiene::ExpnFormat {
 });
 
 impl_stable_hash_for!(enum ::syntax_pos::hygiene::CompilerDesugaringKind {
+    Async,
     DotFill,
     QuestionMark,
     ExistentialReturnType,

src/librustc/ich/impls_syntax.rs

@@ -1245,7 +1245,10 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
                         (has_types || tcx.codegen_fn_attrs(def_id).requests_inline()) &&
                             !self.metadata_output_only();
                     let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir;
-                    if needs_inline || header.constness == hir::Constness::Const || always_encode_mir {
+                    if needs_inline
+                        || header.constness == hir::Constness::Const
+                        || always_encode_mir
+                    {
                         self.encode_optimized_mir(def_id)
                     } else {
                         None

src/librustc_metadata/encoder.rs

@@ -55,7 +55,7 @@ use syntax::util::lev_distance::find_best_match_for_name;
 
 use syntax::visit::{self, FnKind, Visitor};
 use syntax::attr;
-use syntax::ast::{Arm, BindingMode, Block, Crate, Expr, ExprKind};
+use syntax::ast::{Arm, IsAsync, BindingMode, Block, Crate, Expr, ExprKind, FnHeader};
 use syntax::ast::{FnDecl, ForeignItem, ForeignItemKind, GenericParamKind, Generics};
 use syntax::ast::{Item, ItemKind, ImplItem, ImplItemKind};
 use syntax::ast::{Label, Local, Mutability, Pat, PatKind, Path};
@@ -2054,13 +2054,54 @@ impl<'a> Resolver<'a> {
         self.check_proc_macro_attrs(&item.attrs);
 
         match item.node {
+            ItemKind::Fn(ref declaration,
+                         FnHeader { asyncness: IsAsync::Async(async_closure_id), .. },
+                         ref generics,
+                         ref body) => {
+                // Async functions are desugared from `async fn foo() { .. }`
+                // to `fn foo() { future_from_generator(move || ... ) }`,
+                // so we have to visit the body inside the closure scope
+                self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind), |this| {
+                    this.visit_vis(&item.vis);
+                    this.visit_ident(item.ident);
+                    this.visit_generics(generics);
+                    let rib_kind = ItemRibKind;
+                    this.ribs[ValueNS].push(Rib::new(rib_kind));
+                    this.label_ribs.push(Rib::new(rib_kind));
+                    let mut bindings_list = FxHashMap();
+                    for argument in &declaration.inputs {
+                        this.resolve_pattern(
+                            &argument.pat, PatternSource::FnParam, &mut bindings_list);
+                        this.visit_ty(&*argument.ty);
+                    }
+                    visit::walk_fn_ret_ty(this, &declaration.output);
+
+                    // Now resolve the inner closure
+                    {
+                        let rib_kind = ClosureRibKind(async_closure_id);
+                        this.ribs[ValueNS].push(Rib::new(rib_kind));
+                        this.label_ribs.push(Rib::new(rib_kind));
+                        // No need to resolve either arguments nor return type,
+                        // as this closure has neither
+
+                        // Resolve the body
+                        this.visit_block(body);
+                        this.label_ribs.pop();
+                        this.ribs[ValueNS].pop();
+                    }
+                    this.label_ribs.pop();
+                    this.ribs[ValueNS].pop();
+
+                    walk_list!(this, visit_attribute, &item.attrs);
+                })
+            }
             ItemKind::Enum(_, ref generics) |
             ItemKind::Ty(_, ref generics) |
             ItemKind::Struct(_, ref generics) |
             ItemKind::Union(_, ref generics) |
-            ItemKind::Fn(.., ref generics, _) => {
+            ItemKind::Fn(_, _, ref generics, _) => {
                 self.with_type_parameter_rib(HasTypeParameters(generics, ItemRibKind),
-                                             |this| visit::walk_item(this, item));
+                                         |this| visit::walk_item(this, item));
             }
 
             ItemKind::Impl(.., ref generics, ref opt_trait_ref, ref self_type, ref impl_items) =>
@@ -3888,6 +3929,49 @@ impl<'a> Resolver<'a> {
                 visit::walk_expr(self, expr);
                 self.current_type_ascription.pop();
             }
+            // Resolve the body of async exprs inside the async closure to which they desugar
+            ExprKind::Async(_, async_closure_id, ref block) => {
+                let rib_kind = ClosureRibKind(async_closure_id);
+                self.ribs[ValueNS].push(Rib::new(rib_kind));
+                self.label_ribs.push(Rib::new(rib_kind));
+                self.visit_block(&block);
+                self.label_ribs.pop();
+                self.ribs[ValueNS].pop();
+            }
+            // `async |x| ...` gets desugared to `|x| future_from_generator(|| ...)`, so we need to
+            // resolve the arguments within the proper scopes so that usages of them inside the
+            // closure are detected as upvars rather than normal closure arg usages.
+            ExprKind::Closure(
+                _, IsAsync::Async(inner_closure_id), _, ref fn_decl, ref body, _span) =>
+            {
+                let rib_kind = ClosureRibKind(expr.id);
+                self.ribs[ValueNS].push(Rib::new(rib_kind));
+                self.label_ribs.push(Rib::new(rib_kind));
+                // Resolve arguments:
+                let mut bindings_list = FxHashMap();
+                for argument in &fn_decl.inputs {
+                    self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);
+                    self.visit_ty(&argument.ty);
+                }
+                // No need to resolve return type-- the outer closure return type is
+                // FunctionRetTy::Default
+
+                // Now resolve the inner closure
+                {
+                    let rib_kind = ClosureRibKind(inner_closure_id);
+                    self.ribs[ValueNS].push(Rib::new(rib_kind));
+                    self.label_ribs.push(Rib::new(rib_kind));
+                    // No need to resolve arguments: the inner closure has none.
+                    // Resolve the return type:
+                    visit::walk_fn_ret_ty(self, &fn_decl.output);
+                    // Resolve the body
+                    self.visit_expr(body);
+                    self.label_ribs.pop();
+                    self.ribs[ValueNS].pop();
+                }
+                self.label_ribs.pop();
+                self.ribs[ValueNS].pop();
+            }
             _ => {
                 visit::walk_expr(self, expr);
             }

src/librustc_resolve/lib.rs

@@ -1555,7 +1555,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc
                     }
                 }
             }
-            ast::ExprKind::Closure(_, _, ref decl, ref body, _fn_decl_span) => {
+            ast::ExprKind::Closure(_, _, _, ref decl, ref body, _fn_decl_span) => {
                 let mut id = String::from("$");
                 id.push_str(&ex.id.to_string());
 

src/librustc_save_analysis/dump_visitor.rs

@@ -385,7 +385,7 @@ impl Sig for ast::Item {
                 if header.constness.node == ast::Constness::Const {
                     text.push_str("const ");
                 }
-                if header.asyncness == ast::IsAsync::Async {
+                if header.asyncness.is_async() {
                     text.push_str("async ");
                 }
                 if header.unsafety == ast::Unsafety::Unsafe {
@@ -920,7 +920,7 @@ fn make_method_signature(
     if m.header.constness.node == ast::Constness::Const {
         text.push_str("const ");
     }
-    if m.header.asyncness == ast::IsAsync::Async {
+    if m.header.asyncness.is_async() {
         text.push_str("async ");
     }
     if m.header.unsafety == ast::Unsafety::Unsafe {

src/librustc_save_analysis/sig.rs

@@ -1164,7 +1164,7 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
                     }
 
                     if let Node::NodeItem(item) = fcx.tcx.hir.get(fn_id) {
-                        if let Item_::ItemFn(_, _, _, _, ref generics, _) = item.node {
+                        if let Item_::ItemFn(_, _, ref generics, _) = item.node {
                             if !generics.params.is_empty() {
                                 fcx.tcx.sess.span_err(
                                     span,