fix #25944, improve Future.then inference

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/token.dart';
@@ skipping 487 matching lines @@
       computedType = _dynamicType;
     }
 
     // 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.isBottom || computedType.isDynamic)) {
-      computedType = InferenceContext.getType(body) ?? _dynamicType;
+      TypeContext contextType = InferenceContext.getType(body);
+      if (contextType is FutureUnionTypeContext) {
+        // TODO(jmesserly): can we do something better here?
+        computedType = body.isAsynchronous ? contextType.type : _dynamicType;
+      } else {
+        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 139 matching lines @@
         }
       }
       _recordStaticType(
           node, _typeProvider.listType.instantiate(<DartType>[staticType]));
       return null;
     }
 
     // If there are no type arguments and we are in strong mode, try to infer
     // some arguments.
     if (_strongMode) {
-      DartType contextType = InferenceContext.getType(node);
+      DartType contextType = InferenceContext.getNonFutureType(node);
 
       // If we have a type from the context, use it.
       if (contextType is InterfaceType &&
           contextType.typeArguments.length == 1 &&
           contextType.element == _typeProvider.listType.element) {
         _resolver.inferenceContext.recordInference(node, contextType);
         _recordStaticType(node, contextType);
         return null;
       }
 
@@ skipping 62 matching lines @@
       _recordStaticType(
           node,
           _typeProvider.mapType
               .instantiate(<DartType>[staticKeyType, staticValueType]));
       return null;
     }
 
     // If we have no explicit type arguments, and we are in strong mode
     // then try to infer type arguments.
     if (_strongMode) {
-      DartType contextType = InferenceContext.getType(node);
+      DartType contextType = InferenceContext.getNonFutureType(node);
       // If we have a context type, use that for inference.
       if (contextType is InterfaceType &&
           contextType.typeArguments.length == 2 &&
           contextType.element == _typeProvider.mapType.element) {
         _resolver.inferenceContext.recordInference(node, contextType);
         _recordStaticType(node, contextType);
         return null;
       }
 
       // Otherwise, try to infer a type from the keys and values.
@@ skipping 351 matching lines @@
           _getPropertyPropagatedType(staticElement, propagatedType);
     } else if (staticElement is ExecutableElement) {
       staticType = staticElement.type;
     } else if (staticElement is TypeParameterElement) {
       staticType = staticElement.type;
     } else if (staticElement is VariableElement) {
       staticType = staticElement.type;
     }
     if (_strongMode) {
       staticType = _inferGenericInstantiationFromContext(
-          InferenceContext.getType(node), staticType);
+          InferenceContext.getNonFutureType(node), staticType);
     }
     if (!(_strongMode &&
         _inferObjectAccess(node, staticType, prefixedIdentifier))) {
       _recordStaticType(prefixedIdentifier, staticType);
       _recordStaticType(node, staticType);
     }
     Element propagatedElement = prefixedIdentifier.propagatedElement;
     // HACK: special case for object getters ([hashCode] and [runtimeType]) on
     // dynamic expressions. More special cases in [visitMethodInvocation].
     if (propagatedElement == null) {
@@ skipping 112 matching lines @@
     DartType staticType = _dynamicType;
     if (staticElement is MethodElement) {
       staticType = staticElement.type;
     } else if (staticElement is PropertyAccessorElement) {
       staticType = _getTypeOfProperty(staticElement);
     } else {
       // TODO(brianwilkerson) Report this internal error.
     }
     if (_strongMode) {
       staticType = _inferGenericInstantiationFromContext(
-          InferenceContext.getType(node), staticType);
+          InferenceContext.getNonFutureType(node), staticType);
     }
     if (!(_strongMode && _inferObjectAccess(node, staticType, propertyName))) {
       _recordStaticType(propertyName, staticType);
       _recordStaticType(node, staticType);
     }
     Element propagatedElement = propertyName.propagatedElement;
     DartType propagatedType = _overrideManager.getType(propagatedElement);
     if (propagatedElement is MethodElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is PropertyAccessorElement) {
@@ skipping 83 matching lines @@
       staticType = _promoteManager.getStaticType(variable);
     } else if (element is PrefixElement) {
       return null;
     } else if (element is DynamicElementImpl) {
       staticType = _typeProvider.typeType;
     } else {
       staticType = _dynamicType;
     }
     if (_strongMode) {
       staticType = _inferGenericInstantiationFromContext(
-          InferenceContext.getType(node), staticType);
+          InferenceContext.getNonFutureType(node), staticType);
     }
     _recordStaticType(node, staticType);
     // TODO(brianwilkerson) I think we want to repeat the logic above using the
     // propagated element to get another candidate for the propagated type.
     DartType propagatedType = _getPropertyPropagatedType(element, null);
     if (propagatedType == null) {
       DartType overriddenType = _overrideManager.getType(element);
       if (propagatedType == null ||
           overriddenType != null &&
               overriddenType.isMoreSpecificThan(propagatedType)) {
@@ skipping 593 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);
         }
       }
 
-      return ts.inferGenericFunctionCall(_typeProvider, fnType, paramTypes,
-          argTypes, InferenceContext.getType(node));
+      TypeContext returnContext = InferenceContext.getType(node);
+      DartType returnType;
+      if (returnContext is FutureUnionTypeContext) {
+        returnType = fnType.returnType.isDartAsyncFuture
+            ? returnContext.futureOfType
+            : returnContext.type;
+      } else {
+        returnType = returnContext as DartType;
+      }
+      return ts.inferGenericFunctionCall(
+          _typeProvider, fnType, paramTypes, argTypes, returnType);
     }
     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.
    */
   void _inferInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorName constructor = node.constructorName;
@@ skipping 356 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(_typeProvider, result, type);
     }
     return null;
   }
 }