Issue 52313. Support for FutureOr in canBeSubtypeOf().

Bug: #52313
Change-Id: I95792ce457e7a1f3f9d8d4f61565b28a2eb0c004
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/302442
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/element/type_system.dart

@@ -182,6 +182,22 @@ class TypeSystemImpl implements TypeSystem {
         return true;
       }
 
+      // FutureOr<T> = T || Future<T>
+      // So, we attempt to match both to the right.
+      if (left.isDartAsyncFutureOr) {
+        final base = futureOrBase(left);
+        final future = typeProvider.futureType(base);
+        return canBeSubtypeOf(base, right) || canBeSubtypeOf(future, right);
+      }
+
+      // FutureOr<T> = T || Future<T>
+      // So, we attempt to match both to the left.
+      if (right.isDartAsyncFutureOr) {
+        final base = futureOrBase(right);
+        final future = typeProvider.futureType(base);
+        return canBeSubtypeOf(left, base) || canBeSubtypeOf(left, future);
+      }
+
       bool canBeSubtypeOfInterfaces(InterfaceType left, InterfaceType right) {
         assert(left.element == right.element);
         final leftArguments = left.typeArguments;

pkg/analyzer/test/src/diagnostics/pattern_never_matches_value_type_test.dart

@@ -217,6 +217,33 @@ mixin class R {}
 ''');
   }
 
+  test_interfaceType2_matchedFinal_requiredFutureOrIt() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+
+void f(A x) {
+  if (x case FutureOr<A> _) {}
+}
+''');
+  }
+
+  test_interfaceType2_matchedFinal_requiredFutureOrOther() async {
+    await assertErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+class B {}
+
+void f(A x) {
+  if (x case FutureOr<B> _) {}
+}
+''', [
+      error(WarningCode.PATTERN_NEVER_MATCHES_VALUE_TYPE, 78, 11),
+    ]);
+  }
+
   test_interfaceType2_matchedFinal_requiredUnrelated() async {
     await assertErrorsInCode('''
 void f(A x) {
@@ -230,6 +257,69 @@ class R {}
     ]);
   }
 
+  test_interfaceType2_matchedFutureFinal_requiredFutureOrIt() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+
+void f(Future<A> x) {
+  if (x case FutureOr<A> _) {}
+}
+''');
+  }
+
+  test_interfaceType2_matchedFutureOrFinal_requiredFutureIt() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+
+void f(FutureOr<A> x) {
+  if (x case Future<A> _) {}
+}
+''');
+  }
+
+  test_interfaceType2_matchedFutureOrFinal_requiredFutureOrIt() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+
+void f(FutureOr<A> x) {
+  if (x case FutureOr<A> _) {}
+}
+''');
+  }
+
+  test_interfaceType2_matchedFutureOrFinal_requiredIt() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+
+void f(FutureOr<A> x) {
+  if (x case A _) {}
+}
+''');
+  }
+
+  /// `Future` is an interface, so there can be a class that implements both
+  /// `B` and `Future<A>`.
+  test_interfaceType2_matchedFutureOrFinal_requiredOther() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+final class A {}
+class B {}
+
+void f(FutureOr<A> x) {
+  if (x case B _) {}
+}
+''');
+  }
+
   test_interfaceType2_matchedInt_requiredDouble() async {
     await assertNoErrorsInCode('''
 void f(int x) {