fix #28008, fix #28009 implement FutureOr<T>

pkg/analyzer/lib/src/generated/static_type_analyzer.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.static_type_analyzer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 793 matching lines @@
     DartType staticPropagatedType =
         _computePropagatedReturnType(staticMethodElement);
     _resolver.recordPropagatedTypeIfBetter(node, staticPropagatedType);
     // Check for special cases.
     bool needPropagatedType = true;
     String methodName = methodNameNode.name;
     if (!_strongMode && methodName == "then") {
       Expression target = node.realTarget;
       if (target != null) {
         DartType targetType = target.bestType;
-        if (_isAsyncFutureType(targetType)) {
+        if (targetType.isDartAsyncFuture) {
           // Future.then(closure) return type is:
           // 1) the returned Future type, if the closure returns a Future;
           // 2) Future<valueType>, if the closure returns a value.
           NodeList<Expression> arguments = node.argumentList.arguments;
           if (arguments.length == 1) {
             // TODO(brianwilkerson) Handle the case where both arguments are
             // provided.
             Expression closureArg = arguments[0];
             if (closureArg is FunctionExpression) {
               FunctionExpression closureExpr = closureArg;
@@ skipping 586 matching lines @@
     DartType staticType1 = _getDefiniteType(expr1);
     DartType staticType2 = _getDefiniteType(expr2);
     if (staticType1 == null) {
       // TODO(brianwilkerson) Determine whether this can still happen.
       staticType1 = _dynamicType;
     }
     if (staticType2 == null) {
       // TODO(brianwilkerson) Determine whether this can still happen.
       staticType2 = _dynamicType;
     }
+
     DartType staticType =
-        _typeSystem.getLeastUpperBound(staticType1, staticType2);
-    if (staticType == null) {
-      staticType = _dynamicType;
-    }
+        _typeSystem.getLeastUpperBound(staticType1, staticType2) ??
+            _dynamicType;
+
     _recordStaticType(node, staticType);
     DartType propagatedType1 = expr1.propagatedType;
     DartType propagatedType2 = expr2.propagatedType;
     if (propagatedType1 != null || propagatedType2 != null) {
       if (propagatedType1 == null) {
         propagatedType1 = staticType1;
       }
       if (propagatedType2 == null) {
         propagatedType2 = staticType2;
       }
@@ skipping 76 matching lines @@
    *
    * See also [FunctionBody.isAsynchronous], [FunctionBody.isGenerator].
    */
   DartType _computeReturnTypeOfFunction(FunctionBody body, DartType type) {
     if (body.isGenerator) {
       InterfaceType genericType = body.isAsynchronous
           ? _typeProvider.streamType
           : _typeProvider.iterableType;
       return genericType.instantiate(<DartType>[type]);
     } else if (body.isAsynchronous) {
+      if (type.isDartAsyncFutureOr) {
+        type = (type as InterfaceType).typeArguments[0];
+      }
       return _typeProvider.futureType
           .instantiate(<DartType>[type.flattenFutures(_typeSystem)]);
     } else {
       return type;
     }
   }
 
   /**
    * Compute the static return type of the method or function represented by the given element.
    *
@@ skipping 422 matching lines @@
 
       List<DartType> paramTypes = <DartType>[];
       List<DartType> argTypes = <DartType>[];
       for (int i = 0, length = rawParameters.length; i < length; i++) {
         ParameterElement parameter = rawParameters[i];
         if (parameter != null) {
           paramTypes.add(parameter.type);
           argTypes.add(argumentList.arguments[i].staticType);
         }
       }
-
-      // Special case Future<T>.then upwards inference. It has signature:
-      //
-      //     <S>(T -> (S | Future<S>)) -> Future<S>
-      //
-      // Based on the first argument type, we'll pick one of these signatures:
-      //
-      //     <S>(T -> S) -> Future<S>
-      //     <S>(T -> Future<S>) -> Future<S>
-      //
-      // ... and finish the inference using that.
-      if (argTypes.isNotEmpty && _resolver.isFutureThen(fnType.element)) {
-        var firstArgType = argTypes[0];
-        var firstParamType = paramTypes[0] as FunctionType;
-        if (firstArgType is FunctionType) {
-          var argReturnType = firstArgType.returnType;
-          // Skip the inference if we have the top type. It can only lead to
-          // worse inference. For example, this happens when the lambda returns
-          // S or Future<S> in a conditional.
-          if (!argReturnType.isObject && !argReturnType.isDynamic) {
-            DartType paramReturnType = fnType.typeFormals[0].type;
-            if (_resolver.isSubtypeOfFuture(argReturnType)) {
-              // Given an argument of (T) -> Future<S>, instantiate with <S>
-              paramReturnType =
-                  _typeProvider.futureType.instantiate([paramReturnType]);
-            }
-
-            // Adjust the expected parameter type to have this return type.
-            var function = new FunctionElementImpl(firstParamType.name, -1)
-              ..isSynthetic = true
-              ..shareParameters(firstParamType.parameters)
-              ..returnType = paramReturnType;
-            function.type = new FunctionTypeImpl(function);
-            // Use this as the expected 1st parameter type.
-            paramTypes[0] = function.type;
-          }
-        }
-      }
       return ts.inferGenericFunctionCall(fnType, paramTypes, argTypes,
           fnType.returnType, InferenceContext.getContext(node),
           errorReporter: _resolver.errorReporter, errorNode: errorNode);
     }
     return null;
   }
 
   /**
    * Given an instance creation of a possibly generic type, infer the type
    * arguments using the current context type as well as the argument types.
@@ skipping 62 matching lines @@
 
     // If we had a better type from the function body, use it.
     //
     // This helps in a few cases:
     // * ExpressionFunctionBody, when the surrounding context had a better type.
     // * BlockFunctionBody, if we inferred a type from yield/return.
     // * we also normalize bottom to dynamic here.
     if (_strongMode &&
         (computedType.isDartCoreNull || computedType.isDynamic)) {
       DartType contextType = InferenceContext.getContext(body);
-      if (contextType is FutureUnionType) {
-        // TODO(jmesserly): can we do something better here?
-        computedType = body.isAsynchronous ? contextType.type : _dynamicType;
-      } else {
-        computedType = contextType ?? _dynamicType;
-      }
+      computedType = contextType ?? _dynamicType;
       recordInference = !computedType.isDynamic;
     }
 
     computedType = _computeReturnTypeOfFunction(body, computedType);
     functionElement.returnType = computedType;
     _recordPropagatedTypeOfFunction(functionElement, node.body);
     _recordStaticType(node, functionElement.type);
     if (recordInference) {
       _resolver.inferenceContext.recordInference(node, functionElement.type);
     }
@@ skipping 117 matching lines @@
         inferredType != null &&
         _typeProvider.nonSubtypableTypes.contains(inferredType)) {
       _recordStaticType(id, inferredType);
       _recordStaticType(node, inferredType);
       return true;
     }
     return false;
   }
 
   /**
-   * Return `true` if the given [Type] is the `Future` form the 'dart:async'
-   * library.
-   */
-  bool _isAsyncFutureType(DartType type) =>
-      type is InterfaceType &&
-      type.name == "Future" &&
-      _isAsyncLibrary(type.element.library);
-
-  /**
-   * Return `true` if the given library is the 'dart:async' library.
-   *
-   * @param library the library being tested
-   * @return `true` if the library is 'dart:async'
-   */
-  bool _isAsyncLibrary(LibraryElement library) => library.name == "dart.async";
-
-  /**
    * Return `true` if the given library is the 'dart:html' library.
    *
    * @param library the library being tested
    * @return `true` if the library is 'dart:html'
    */
   bool _isHtmlLibrary(LibraryElement library) =>
       library != null && "dart.dom.html" == library.name;
 
   /**
    * Return `true` if the given [node] is not a type literal.
@@ skipping 167 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(result, type);
     }
     return null;
   }
 }