[analyzer] Represent FutureOr<...> as FutureOrTypeImpl.

This change introduces the class `FutureOrTypeImpl` to represent the
special types of the form `FutureOr<...>`, which were previously
represented as ordinary instances of `InterfaceType`.

This class mirrors the CFE's `FutureOrType` class. Adding it will
facilitate further code sharing between the analyzer and the CFE,
because it will allow code that's shared between the analyzer and CFE
to use `is` tests to recognize `FutureOr` types.

In a follow-up CL I intend to add a base class that is common to
analyzer and CFE `FutureOrType` representations.

Note that in https://dart-review.googlesource.com/c/sdk/+/396320, when
I introduced the `NullTypeImpl` class, I took pains to find all the
places in the analyzer that might call the `InterfaceTypeImpl`
constructor, and updated them so that if the type they are creating is
the `Null` type, they call the `NullTypeImpl` constructor
instead. That was tractable for the type `Null`, since there's
basically just a single `Null` type corresponding to a single
declaration in `dart:core`. At first I tried doing a similar thing for
`FutureOr`, but it proved to be a big pain, because `FutureOr` types
get created all over the place. It was difficult to be confident that
I'd updated all the necessary call sites. So instead I've put the
necessary logic in the `InterfaceTypeImpl` constructor itself (by
changing it into a factory constructor). This is a much lower risk
approach and I'm much happier with it. In a follow-up CL I'll change
the logic for `NullTypeImpl` to follow the same factory approach.

Change-Id: I54c6998f991456199076faeac995e433cc88845d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/396523
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -457,6 +457,34 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
   }
 }
 
+/// A concrete implementation of [DartType] representing types of the form
+/// `FutureOr<...>`.
+class FutureOrTypeImpl extends InterfaceTypeImpl {
+  FutureOrTypeImpl(
+      {required super.element,
+      required super.typeArgument,
+      required super.nullabilitySuffix,
+      super.alias})
+      : super._futureOr();
+
+  @override
+  bool get isDartAsyncFutureOr => true;
+
+  DartType get typeArgument => typeArguments[0];
+
+  @override
+  InterfaceTypeImpl withNullability(NullabilitySuffix nullabilitySuffix) {
+    if (this.nullabilitySuffix == nullabilitySuffix) return this;
+
+    return FutureOrTypeImpl(
+      element: element,
+      typeArgument: typeArgument,
+      nullabilitySuffix: nullabilitySuffix,
+      alias: alias,
+    );
+  }
+}
+
 class InstantiatedTypeAliasElementImpl implements InstantiatedTypeAliasElement {
   @override
   final TypeAliasElement element;
@@ -493,11 +521,33 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   /// Cached [MethodElement]s - members or raw elements.
   List<MethodElement>? _methods;
 
-  InterfaceTypeImpl({
+  factory InterfaceTypeImpl(
+      {required InterfaceElement element,
+      required List<DartType> typeArguments,
+      required NullabilitySuffix nullabilitySuffix,
+      InstantiatedTypeAliasElement? alias}) {
+    if (element.name == 'FutureOr' && element.library.isDartAsync) {
+      return FutureOrTypeImpl(
+          element: element,
+          typeArgument: typeArguments.isNotEmpty
+              ? typeArguments[0]
+              : InvalidTypeImpl.instance,
+          nullabilitySuffix: nullabilitySuffix,
+          alias: alias);
+    } else {
+      return InterfaceTypeImpl._(
+          element: element,
+          typeArguments: typeArguments,
+          nullabilitySuffix: nullabilitySuffix,
+          alias: alias);
+    }
+  }
+
+  InterfaceTypeImpl._({
     required this.element,
     required this.typeArguments,
     required this.nullabilitySuffix,
-    super.alias,
+    required super.alias,
   }) {
     if (element.name == 'Null' && element.library.isDartCore) {
       throw ArgumentError('NullTypeImpl should be used for `Null`');
@@ -519,6 +569,16 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
     }
   }
 
+  InterfaceTypeImpl._futureOr(
+      {required this.element,
+      required DartType typeArgument,
+      required this.nullabilitySuffix,
+      super.alias})
+      : typeArguments = [typeArgument] {
+    assert(element.name == 'FutureOr' && element.library.isDartAsync);
+    assert(this is FutureOrTypeImpl);
+  }
+
   InterfaceTypeImpl._null({required this.element, super.alias})
       : typeArguments = const [],
         nullabilitySuffix = NullabilitySuffix.none {
@@ -596,11 +656,6 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
     return element.name == "Future" && element.library.isDartAsync;
   }
 
-  @override
-  bool get isDartAsyncFutureOr {
-    return element.name == "FutureOr" && element.library.isDartAsync;
-  }
-
   @override
   bool get isDartAsyncStream {
     return element.name == "Stream" && element.library.isDartAsync;

pkg/analyzer/test/generated/non_error_resolver_test.dart

@@ -3082,6 +3082,16 @@ main() { lib1.f1(); lib.f2(); lib.f3(); }
 ''');
   }
 
+  test_type_parameter_extends_futureOr_of_extension_type() async {
+    await assertNoErrorsInCode('''
+import 'dart:async';
+
+extension type E(int i) {}
+
+void f<T extends FutureOr<E>>() {}
+''');
+  }
+
   test_typeArgument_boundToFunctionType() async {
     await assertNoErrorsInCode('''
 class A<T extends void Function(T)>{}