fix #27134, future unions in downwards generic method inference

[email protected], [email protected]

Review URL: https://codereview.chromium.org/2280463002 .

Author: John Messerly

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

@@ -7260,7 +7260,7 @@ class ResolverVisitor extends ScopedVisitor {
     DartType contextType = node.staticInvokeType;
     if (contextType is FunctionType) {
       DartType originalType = node.function.staticType;
-      DartType returnContextType = InferenceContext.getType(node);
+      DartType returnContextType = InferenceContext.getContext(node);
       TypeSystem ts = typeSystem;
       if (returnContextType != null &&
           node.typeArguments == null &&

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

@@ -1944,16 +1944,6 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
         }
       }
 
-      DartType returnContext = InferenceContext.getContext(node);
-      DartType returnType;
-      if (returnContext is FutureUnionType) {
-        returnType = _resolver.isSubtypeOfFuture(fnType.returnType)
-            ? returnContext.futureOfType
-            : returnContext.type;
-      } else {
-        returnType = returnContext;
-      }
-
       // Special case Future<T>.then upwards inference. It has signature:
       //
       //     <S>(T -> (S | Future<S>)) -> Future<S>
@@ -1991,8 +1981,8 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
           }
         }
       }
-      return ts.inferGenericFunctionCall(
-          _typeProvider, fnType, paramTypes, argTypes, returnType);
+      return ts.inferGenericFunctionCall(_typeProvider, fnType, paramTypes,
+          argTypes, InferenceContext.getContext(node));
     }
     return null;
   }

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

@@ -277,6 +277,16 @@ class StrongTypeSystemImpl extends TypeSystem {
       return fnType;
     }
 
+    // If we're in a future union context, choose either the Future<T> or the T
+    // based on the function's return type.
+    if (returnContextType is FutureUnionType) {
+      var futureUnion = returnContextType as FutureUnionType;
+      returnContextType =
+          isSubtypeOf(fnType.returnType, typeProvider.futureDynamicType)
+              ? futureUnion.futureOfType
+              : futureUnion.type;
+    }
+
     // Create a TypeSystem that will allow certain type parameters to be
     // inferred. It will optimistically assume these type parameters can be
     // subtypes (or supertypes) as necessary, and track the constraints that

pkg/analyzer/test/src/task/strong/inferred_type_test.dart

@@ -1676,6 +1676,24 @@ $downwards<int> g3(bool x) async {
     checkFile(build(downwards: "Future", upwards: "MyFuture"));
   }
 
+  void test_futureUnion_downwardsGenericMethods() {
+    // Regression test for https://github.com/dart-lang/sdk/issues/27134
+    //
+    // We need to take a future union into account for both directions of
+    // generic method inference.
+    checkFile(r'''
+import 'dart:async';
+
+foo() async {
+  Future<List<A>> f1 = null;
+  Future<List<A>> f2 = null;
+  List<List<A>> merged = await Future.wait(/*info:INFERRED_TYPE_LITERAL*/[f1, f2]);
+}
+
+class A {}
+    ''');
+  }
+
   void test_futureUnion_downwards() {
     String build({String declared, String downwards, String upwards}) {
       // TODO(leafp): The use of matchTypes in visitInstanceCreationExpression