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 486 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;
+      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;
+      }
       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 1445 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));
+      DartType returnContext = InferenceContext.getContext(node);
+      DartType returnType;
+      if (returnContext is FutureUnionType) {
+        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;
   }
 }