record await span inside GeneratorInteriorTypeCause

Author: csmoe

src/librustc_middle/ty/context.rs

@@ -298,14 +298,14 @@ pub struct ResolvedOpaqueTy<'tcx> {
 ///
 /// ```ignore (pseudo-Rust)
 /// async move {
-///     let x: T = ...;
+///     let x: T = expr;
 ///     foo.await
 ///     ...
 /// }
 /// ```
 ///
-/// Here, we would store the type `T`, the span of the value `x`, and the "scope-span" for
-/// the scope that contains `x`.
+/// Here, we would store the type `T`, the span of the value `x`, the "scope-span" for
+/// the scope that contains `x`, the expr `T` evaluated from, and the span of `foo.await`.
 #[derive(RustcEncodable, RustcDecodable, Clone, Debug, Eq, Hash, PartialEq, HashStable)]
 pub struct GeneratorInteriorTypeCause<'tcx> {
     /// Type of the captured binding.
@@ -314,6 +314,8 @@ pub struct GeneratorInteriorTypeCause<'tcx> {
     pub span: Span,
     /// Span of the scope of the captured binding.
     pub scope_span: Option<Span>,
+    /// Span of `.await` statement.
+    pub await_span: Span,
     /// Expr which the type evaluated from.
     pub expr: Option<hir::HirId>,
 }

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

@@ -125,6 +125,7 @@ pub trait InferCtxtExt<'tcx> {
         err: &mut DiagnosticBuilder<'_>,
         target_span: Span,
         scope_span: &Option<Span>,
+        await_span: Span,
         expr: Option<hir::HirId>,
         snippet: String,
         inner_generator_body: Option<&hir::Body<'_>>,
@@ -1260,20 +1261,31 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                         ty_matches(ty)
                     })
                     .map(|expr| expr.span);
-                let ty::GeneratorInteriorTypeCause { span, scope_span, expr, .. } = cause;
-                (span, source_map.span_to_snippet(*span), scope_span, expr, from_awaited_ty)
+                let ty::GeneratorInteriorTypeCause { span, scope_span, await_span, expr, .. } =
+                    cause;
+                (
+                    span,
+                    source_map.span_to_snippet(*span),
+                    scope_span,
+                    await_span,
+                    expr,
+                    from_awaited_ty,
+                )
             });
 
         debug!(
             "maybe_note_obligation_cause_for_async_await: target_ty={:?} \
-                generator_interior_types={:?} target_span={:?}",
-            target_ty, tables.generator_interior_types, target_span
+                generator_interior_types={:?} target_span={:?} await_span={:?}",
+            target_ty, tables.generator_interior_types, target_span, await_span
         );
-        if let Some((target_span, Ok(snippet), scope_span, expr, from_awaited_ty)) = target_span {
+        if let Some((target_span, Ok(snippet), scope_span, await_span, expr, from_awaited_ty)) =
+            target_span
+        {
             self.note_obligation_cause_for_async_await(
                 err,
                 *target_span,
                 scope_span,
+                await_span,
                 *expr,
                 snippet,
                 generator_body,
@@ -1298,6 +1310,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
         err: &mut DiagnosticBuilder<'_>,
         target_span: Span,
         scope_span: &Option<Span>,
+        await_span: Span,
         expr: Option<hir::HirId>,
         snippet: String,
         inner_generator_body: Option<&hir::Body<'_>>,
@@ -1373,12 +1386,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
         if let Some(await_span) = from_awaited_ty {
             // The type causing this obligation is one being awaited at await_span.
             let mut span = MultiSpan::from_span(await_span);
-
-            span.push_span_label(
-                await_span,
-                format!("await occurs here on type `{}`, which {}", target_ty, trait_explanation),
-            );
-
             err.span_note(
                 span,
                 &format!(
@@ -1392,7 +1399,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                 "note_obligation_cause_for_async_await generator_interior_types: {:#?}",
                 tables.generator_interior_types
             );
-            let await_span = tables.generator_interior_types.iter().map(|t| t.span).last().unwrap();
             let mut span = MultiSpan::from_span(await_span);
             span.push_span_label(
                 await_span,

src/librustc_typeck/check/generator_interior.rs

@@ -96,6 +96,7 @@ impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> {
                         span: source_span,
                         ty: &ty,
                         scope_span,
+                        await_span: yield_data.span,
                         expr: expr.map(|e| e.hir_id),
                     })
                     .or_insert(entries);