linter: unawaited_futures: catch Future subtypes

Change-Id: Iabdfc1ec4984d6717cc3d85729b577fb2385e749
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/424401
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

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

@@ -5,6 +5,7 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 
 import '../analyzer.dart';
 import '../extensions.dart';
@@ -51,10 +52,7 @@ class _Visitor extends SimpleAstVisitor<void> {
     if (expr is AssignmentExpression) return;
 
     var type = expr.staticType;
-    if (type == null) {
-      return;
-    }
-    if (!type.implementsInterface('Future', 'dart.async')) {
+    if (type == null || !type.isOrImplementsFuture) {
       return;
     }
 
@@ -96,7 +94,7 @@ class _Visitor extends SimpleAstVisitor<void> {
   bool _isMapClass(Element? e) =>
       e is ClassElement && e.name3 == 'Map' && e.library2.name3 == 'dart.core';
 
-  /// Detects Map.putIfAbsent invocations.
+  /// Detects `Map.putIfAbsent` invocations.
   bool _isMapPutIfAbsentInvocation(Expression expr) =>
       expr is MethodInvocation &&
       expr.methodName.name == 'putIfAbsent' &&
@@ -107,11 +105,23 @@ class _Visitor extends SimpleAstVisitor<void> {
       return;
     }
 
-    // TODO(srawlins): Check whether `expr`'s static type _implements_ `Future`.
-    if ((expr.staticType?.isDartAsyncFuture ?? false) &&
-        _isEnclosedInAsyncFunctionBody(expr) &&
-        expr is! AssignmentExpression) {
+    var type = expr.staticType;
+    if (type == null || !type.isOrImplementsFuture) {
+      return;
+    }
+
+    if (_isEnclosedInAsyncFunctionBody(expr) && expr is! AssignmentExpression) {
       rule.reportAtNode(expr);
     }
   }
 }
+
+extension on DartType {
+  /// Whether this type is `Future` from dart:async, or is a subtype thereof.
+  bool get isOrImplementsFuture {
+    var typeElement = element3;
+    if (typeElement is! InterfaceElement) return false;
+    return isDartAsyncFuture ||
+        typeElement.allSupertypes.any((t) => t.isDartAsyncFuture);
+  }
+}

pkg/linter/test/rules/unawaited_futures_test.dart

@@ -57,20 +57,6 @@ void f<T extends Future<void>>(T p) async {
 ''');
   }
 
-  test_classImplementsFuture() async {
-    // https://github.com/dart-lang/linter/issues/2211
-    await assertDiagnostics(
-      r'''
-void f(Future2 p) async {
-  g(p);
-}
-Future2 g(Future2 p) => p;
-abstract class Future2 implements Future {}
-''',
-      [lint(28, 5)],
-    );
-  }
-
   test_functionCall_assigned() async {
     await assertNoDiagnostics(r'''
 Future<int> f() async {
@@ -90,6 +76,20 @@ Future<int> g() => Future.value(0);
 ''');
   }
 
+  test_functionCall_classImplementsFuture() async {
+    // https://github.com/dart-lang/linter/issues/2211
+    await assertDiagnostics(
+      r'''
+void f(Future2 p) async {
+  g(p);
+}
+Future2 g(Future2 p) => p;
+abstract class Future2 implements Future {}
+''',
+      [lint(28, 5)],
+    );
+  }
+
   test_functionCall_inListContext() async {
     await assertNoDiagnostics(r'''
 void f() async {
@@ -123,6 +123,20 @@ Future<int> g() => Future.value(0);
 ''');
   }
 
+  test_functionCall_interpolated_unawaited_classImplementsFuture() async {
+    await assertDiagnostics(
+      r'''
+void f() async {
+  '${g()}';
+}
+Future2<int> g() => f2;
+abstract class Future2<T> implements Future<T> {}
+external Future2<int> f2;
+''',
+      [lint(22, 3)],
+    );
+  }
+
   test_functionCall_nullableFuture_unawaited() async {
     await assertDiagnostics(
       r'''