Add missing check for async body when suggesting await on futures.

Author: metamuffin

compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs

@@ -1836,9 +1836,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             if should_suggest_fixes
                 && !matches!(terr, TypeError::RegionsInsufficientlyPolymorphic(..))
             {
+                let hir = self.tcx.hir_node_by_def_id(cause.body_id);
                 self.suggest_tuple_pattern(cause, &exp_found, diag);
                 self.suggest_accessing_field_where_appropriate(cause, &exp_found, diag);
-                self.suggest_await_on_expect_found(cause, span, &exp_found, diag);
+                self.suggest_await_on_expect_found(cause, span, hir, &exp_found, diag);
                 self.suggest_function_pointers(cause, span, &exp_found, diag);
                 self.suggest_turning_stmt_into_expr(cause, &exp_found, diag);
             }

compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs

@@ -159,6 +159,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         &self,
         cause: &ObligationCause<'tcx>,
         exp_span: Span,
+        hir: hir::Node<'_>,
         exp_found: &ty::error::ExpectedFound<Ty<'tcx>>,
         diag: &mut Diag<'_>,
     ) {
@@ -167,6 +168,23 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             exp_span, exp_found.expected, exp_found.found,
         );
 
+        let is_async_block = matches!(
+            hir,
+            rustc_hir::Node::Expr(rustc_hir::Expr {
+                kind: rustc_hir::ExprKind::Closure(rustc_hir::Closure {
+                    kind: rustc_hir::ClosureKind::Coroutine(rustc_hir::CoroutineKind::Desugared(
+                        rustc_hir::CoroutineDesugaring::Async,
+                        _
+                    )),
+                    ..
+                }),
+                ..
+            })
+        );
+        if !is_async_block {
+            return;
+        }
+
         if let ObligationCauseCode::CompareImplItem { .. } = cause.code() {
             return;
         }

tests/ui/async-await/coroutine-desc.stderr

@@ -30,7 +30,6 @@ LL |     fun(one(), two());
    |     |   expected all arguments to be this future type because they need to match the type of this parameter
    |     arguments to this function are incorrect
    |
-   = help: consider `await`ing on both `Future`s
    = note: distinct uses of `impl Trait` result in different opaque types
 note: function defined here
   --> $DIR/coroutine-desc.rs:7:4

tests/ui/async-await/dont-suggest-missing-await.stderr

@@ -6,20 +6,11 @@ LL |         take_u32(x)
    |         |
    |         arguments to this function are incorrect
    |
-note: calling an async function returns a future
-  --> $DIR/dont-suggest-missing-await.rs:14:18
-   |
-LL |         take_u32(x)
-   |                  ^
 note: function defined here
   --> $DIR/dont-suggest-missing-await.rs:5:4
    |
 LL | fn take_u32(x: u32) {}
    |    ^^^^^^^^ ------
-help: consider `await`ing on the `Future`
-   |
-LL |         take_u32(x.await)
-   |                   ++++++
 
 error: aborting due to 1 previous error
 

tests/ui/impl-trait/issue-102605.stderr

@@ -14,20 +14,11 @@ LL |     convert_result(foo())
    |     |
    |     arguments to this function are incorrect
    |
-note: calling an async function returns a future
-  --> $DIR/issue-102605.rs:13:20
-   |
-LL |     convert_result(foo())
-   |                    ^^^^^
 note: function defined here
   --> $DIR/issue-102605.rs:7:4
    |
 LL | fn convert_result<T, E>(r: Result<T, E>) -> Option<T> {
    |    ^^^^^^^^^^^^^^       ---------------
-help: consider `await`ing on the `Future`
-   |
-LL |     convert_result(foo().await)
-   |                         ++++++
 help: try wrapping the expression in `Err`
    |
 LL |     convert_result(Err(foo()))