Allow SDKs to be analyzed that lack a definition of FutureOr<T>.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 11 matching lines @@
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
 import 'package:analyzer/src/dart/resolver/scope.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
+import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 export 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
 export 'package:analyzer/src/dart/resolver/scope.dart';
 export 'package:analyzer/src/generated/type_system.dart';
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
@@ skipping 4119 matching lines @@
     if (_returnStack.isEmpty) {
       return;
     }
 
     DartType inferred = _inferredReturn.last;
     inferred = _typeSystem.getLeastUpperBound(type, inferred);
     _inferredReturn[_inferredReturn.length - 1] = inferred;
   }
 
   /**
+   * Like [getContext] but expands a union type into a list of types.
+   */
+  Iterable<DartType> getTypes(AstNode node) {
+    DartType t = getContext(node);
+    if (t == null) {
+      return DartType.EMPTY_LIST;
+    }
+    if (t is InterfaceType && t.isDartAsyncFutureOr) {
+      var tArg = t.typeArguments[0]; // The T in FutureOr<T>
+      return [
+        _typeProvider.futureType.instantiate([tArg]),
+        tArg
+      ];
+    }
+    return [t];
+  }
+
+  /**
    * Match type [t1] against type [t2] as follows.
    * If `t1 = I<dynamic, ..., dynamic>`, then look for a supertype
    * of t1 of the form `K<S0, ..., Sm>` where `t2 = K<S0', ..., Sm'>`
    * If the supertype exists, use the constraints `S0 <: S0', ... Sm <: Sm'`
    * to derive a concrete instantation for I of the form `<T0, ..., Tn>`,
    * such that `I<T0, .., Tn> <: t2`
    */
   List<DartType> matchTypes(DartType t1, DartType t2) =>
       (t1 is InterfaceType && t2 is InterfaceType) ? _matchTypes(t1, t2) : null;
 
@@ skipping 184 matching lines @@
     */
   static DartType getType(AstNode node) {
     DartType t = getContext(node);
     if (t is InterfaceType && t.isDartAsyncFutureOr) {
       return t.typeArguments[0]; // The T in FutureOr<T>
     }
     return t;
   }
 
   /**
-   * Like [getContext] but expands a union type into a list of types.
-   */
-  Iterable<DartType> getTypes(AstNode node) {
-    DartType t = getContext(node);
-    if (t == null) {
-      return DartType.EMPTY_LIST;
-    }
-    if (t is InterfaceType && t.isDartAsyncFutureOr) {
-      var tArg = t.typeArguments[0]; // The T in FutureOr<T>
-      return [
-        _typeProvider.futureType.instantiate([tArg]),
-        tArg
-      ];
-    }
-    return [t];
-  }
-
-  /**
    * Attach contextual type information [type] to [node] for use during
    * inference.
    */
   static void setType(AstNode node, DartType type) {
     if (type == null || type.isDynamic) {
       clearType(node);
     } else {
       node?.setProperty(_typeProperty, type);
     }
   }
@@ skipping 5058 matching lines @@
     _stackTraceType = _getType(coreNamespace, "StackTrace");
     _streamType = _getType(asyncNamespace, "Stream");
     _stringType = _getType(coreNamespace, "String");
     _symbolType = _getType(coreNamespace, "Symbol");
     _typeType = _getType(coreNamespace, "Type");
     _undefinedType = UndefinedTypeImpl.instance;
     _futureDynamicType = _futureType.instantiate(<DartType>[_dynamicType]);
     _futureNullType = _futureType.instantiate(<DartType>[_nullType]);
     _iterableDynamicType = _iterableType.instantiate(<DartType>[_dynamicType]);
     _streamDynamicType = _streamType.instantiate(<DartType>[_dynamicType]);
+    // FutureOr<T> is still fairly new, so if we're analyzing an SDK that
+    // doesn't have it yet, create an element for it.
+    _futureOrType ??= createPlaceholderFutureOr(_futureType, _objectType);
+  }
+
+  /**
+   * Create an [InterfaceType] that can be used for `FutureOr<T>` if the SDK
+   * being analyzed does not contain its own `FutureOr<T>`.  This ensures that
+   * we can analyze older SDKs.
+   */
+  static InterfaceType createPlaceholderFutureOr(
+      InterfaceType futureType, InterfaceType objectType) {
+    var compilationUnit =
+        futureType.element.getAncestor((e) => e is CompilationUnitElement);
+    var element = ElementFactory.classElement('FutureOr', objectType, ['T']);
+    element.enclosingElement = compilationUnit;
+    return element.type;
   }
 }
 
 /**
  * Modes in which [TypeResolverVisitor] works.
  */
 enum TypeResolverMode {
   /**
    * Resolve all names types of all nodes.
    */
@@ skipping 1340 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }