[DAS] Fixes broken discarded futures tests

Bug: #59887
Change-Id: I6c8204771b70d49091f882e5b7f875b158724b89
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/417900
Commit-Queue: Brian Wilkerson <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Auto-Submit: Felipe Morschel <[email protected]>

Author: FMorschel

pkg/analysis_server/test/src/services/correction/fix/wrap_in_unawaited_test.dart

@@ -72,11 +72,19 @@ import 'dart:async';
 
 FutureOr<void> g() async { }
 
-Future<void> f() {
+void f() {
   g();
 }
 ''');
-    await assertNoFix();
+    await assertHasFix('''
+import 'dart:async';
+
+FutureOr<void> g() async { }
+
+void f() {
+  unawaited(g());
+}
+''');
   }
 }
 

pkg/linter/lib/src/rules/discarded_futures.dart

@@ -49,6 +49,14 @@ class _Visitor extends SimpleAstVisitor<void> {
     var expr = node.expression;
     if (expr is AssignmentExpression) return;
 
+    if (_isEnclosedInAsyncFunctionBody(node)) {
+      return;
+    }
+
+    if (expr case AwaitExpression(:var expression)) {
+      expr = expression;
+    }
+
     var type = expr.staticType;
     if (type == null) {
       return;
@@ -60,11 +68,7 @@ class _Visitor extends SimpleAstVisitor<void> {
         return;
       }
 
-      if (_isNotEnclosedInAsyncFunctionBody(node)) {
-        // Future expression statement that isn't awaited in synchronous
-        // function: while this is legal, it's a very frequent sign of an error.
-        _reportOnExpression(expr);
-      }
+      _reportOnExpression(expr);
     }
   }
 
@@ -73,6 +77,11 @@ class _Visitor extends SimpleAstVisitor<void> {
     _visit(node.expression);
   }
 
+  bool _isEnclosedInAsyncFunctionBody(AstNode node) {
+    var enclosingFunctionBody = node.thisOrAncestorOfType<FunctionBody>();
+    return enclosingFunctionBody?.isAsynchronous ?? false;
+  }
+
   /// Detects `Future.delayed(duration, [computation])` creations with a
   /// computation.
   bool _isFutureDelayedInstanceCreationWithComputation(Expression expr) =>
@@ -90,12 +99,6 @@ class _Visitor extends SimpleAstVisitor<void> {
       expr.methodName.name == 'putIfAbsent' &&
       _isMapClass(expr.methodName.element?.enclosingElement2);
 
-  bool _isNotEnclosedInAsyncFunctionBody(AstNode node) {
-    var enclosingFunctionBody = node.thisOrAncestorOfType<FunctionBody>();
-    var isAsyncBody = enclosingFunctionBody?.isAsynchronous ?? false;
-    return !isAsyncBody;
-  }
-
   void _reportOnExpression(Expression expr) {
     rule.reportLint(switch (expr) {
       MethodInvocation(:var methodName) => methodName,
@@ -109,7 +112,7 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   void _visit(Expression expr) {
     if ((expr.staticType.isFutureOrFutureOr) &&
-        _isNotEnclosedInAsyncFunctionBody(expr) &&
+        !_isEnclosedInAsyncFunctionBody(expr) &&
         expr is! AssignmentExpression) {
       _reportOnExpression(expr);
     }

pkg/linter/test/rules/discarded_futures_test.dart

@@ -258,6 +258,36 @@ Future<int> g() async => 0;
 ''');
   }
 
+  Future<void> test_discardedFuture_awaited() async {
+    await assertDiagnostics(
+      '''
+void f() {
+  // ignore: await_in_wrong_context
+  await g();
+}
+
+Future<void> g() async { }
+''',
+      [lint(55, 1)],
+    );
+  }
+
+  Future<void> test_discardedFuture_awaited_method() async {
+    await assertDiagnostics(
+      '''
+class C {
+  void f() {
+    // ignore: await_in_wrong_context
+    await g();
+  }
+
+  Future<void> g() async { }
+}
+''',
+      [lint(71, 1)],
+    );
+  }
+
   Future<void> test_field_assignment() async {
     await assertDiagnostics(
       r'''