fix #27088, future then upwards inference

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/token.dart';
@@ skipping 5740 matching lines @@
   }
 
   /**
    * Prepares this [ResolverVisitor] to using it for incremental resolution.
    */
   void initForIncrementalResolution() {
     _overrideManager.enterScope();
   }
 
   /**
+   * Returns true if this method is `Future.then`.
+   *
+   * If so we will apply special typing rules in strong mode, to handle the
+   * implicit union of `S | Future<S>`
+   */
+  bool isFutureThen(Element element) {
+    return element is MethodElement &&
+        element.name == 'then' &&
+        element.enclosingElement.type.isDartAsyncFuture;
+  }
+
+  /**
    * Given a downward inference type [fnType], and the declared
    * [typeParameterList] for a function expression, determines if we can enable
    * downward inference and if so, returns the function type to use for
    * inference.
    *
    * This will return null if inference is not possible. This happens when
    * there is no way we can find a subtype of the function type, given the
    * provided type parameter list.
    */
   FunctionType matchFunctionTypeParameters(
@@ skipping 805 matching lines @@
       _overrideManager.enterScope();
       try {
         DartType functionType = InferenceContext.getType(node);
         if (functionType is FunctionType) {
           functionType =
               matchFunctionTypeParameters(node.typeParameters, functionType);
           if (functionType is FunctionType) {
             _inferFormalParameterList(node.parameters, functionType);
 
             DartType returnType;
-            if (_isFutureThenLambda(node)) {
+            if (isFutureThen(node.staticParameterElement?.enclosingElement)) {
               var futureThenType =
                   InferenceContext.getContext(node.parent) as FunctionType;
 
               // Pretend the return type of Future<T>.then<S> first parameter is
               //
               //     T -> (S | Future<S>)
               //
               // We can't represent this in Dart so we populate it here during
               // inference.
               returnType = FutureUnionType.from(
@@ skipping 790 matching lines @@
       //
       // Unsound to assume that [x = "hello";] never executed after the
       // if-statement. Of course, a dead-code analysis could point out that
       // [return] here is dead.
       return _isAbruptTerminationStatement(statements[size - 1]);
     }
     return false;
   }
 
   /**
-   * Returns true if this expression is being passed to `Future.then`.
-   *
-   * If so we will apply special typing rules in strong mode, to handle the
-   * implicit union of `S | Future<S>`
-   */
-  bool _isFutureThenLambda(FunctionExpression node) {
-    Element element = node.staticParameterElement?.enclosingElement;
-    return element is MethodElement &&
-        element.name == 'then' &&
-        element.enclosingElement.type.isDartAsyncFuture;
-  }
-
-  /**
    * Return `true` if the given variable is accessed within a closure in the given
    * [AstNode] and also mutated somewhere in variable scope. This information is only
    * available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [AstNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool _isVariableAccessedInClosure(Element variable, AstNode target) {
     _ResolverVisitor_isVariableAccessedInClosure visitor =
@@ skipping 3685 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }