Resolve deferred function literals in stages.

This change allows function literals in invocations to be inferred in
dependency order.  For example, given the following code:

    U f<T, U>(T Function() g, U Function(T) h) => h(g());
    test() {
      var x = f(() => 0, (y) => [y]);
    }

The function literal `() => 0` is inferred first, causing the type
parameter `T` to be assigned the type `int`.  Then, `(y) => [x]` is
inferred with the benefit of this type assignment, so `y` gets the
type `int`, and consequently, `U` gets assigned the type `List<int>`.

This completes the support for
dart-lang/language#731 (improved inference
for fold etc.)

Change-Id: I48c22693720a1cc8bbf435643e863834e07f02b1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/243002
Reviewed-by: Chloe Stefantsova <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart

@@ -2037,7 +2037,7 @@ class InferenceVisitor
           typeContext,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
-      inferrer.typeSchemaEnvironment.downwardsInfer(
+      inferrer.typeSchemaEnvironment.partialInfer(
           gatherer,
           listClass.typeParameters,
           inferredTypes,
@@ -2722,7 +2722,7 @@ class InferenceVisitor
           typeContext,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
-      inferrer.typeSchemaEnvironment.downwardsInfer(
+      inferrer.typeSchemaEnvironment.partialInfer(
           gatherer,
           mapClass.typeParameters,
           inferredTypes,
@@ -2807,7 +2807,7 @@ class InferenceVisitor
                 typeContext,
                 inferrer.libraryBuilder.library,
                 isConst: node.isConst);
-        inferrer.typeSchemaEnvironment.downwardsInfer(
+        inferrer.typeSchemaEnvironment.partialInfer(
             gatherer,
             inferrer.coreTypes.setClass.typeParameters,
             inferredTypesForSet,
@@ -5992,7 +5992,7 @@ class InferenceVisitor
           typeContext,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
-      inferrer.typeSchemaEnvironment.downwardsInfer(
+      inferrer.typeSchemaEnvironment.partialInfer(
           gatherer,
           setClass.typeParameters,
           inferredTypes,

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart

@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
+import 'package:_fe_analyzer_shared/src/deferred_function_literal_heuristic.dart';
 import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart';
 import 'package:_fe_analyzer_shared/src/testing/id.dart';
 import 'package:_fe_analyzer_shared/src/util/link.dart';
@@ -82,6 +83,59 @@ bool isOverloadableArithmeticOperator(String name) {
       identical(name, '%');
 }
 
+/// Given a [FunctionExpression], computes a set whose elements consist of (a)
+/// an integer corresponding to the zero-based index of each positional
+/// parameter of the function expression that has an explicit type annotation,
+/// and (b) a string corresponding to the name of each named parameter of the
+/// function expression that has an explicit type annotation.
+Set<Object> _computeExplicitlyTypedParameterSet(
+    FunctionExpression functionExpression) {
+  Set<Object> result = {};
+  int unnamedParameterIndex = 0;
+  for (VariableDeclaration positionalParameter
+      in functionExpression.function.positionalParameters) {
+    int key = unnamedParameterIndex++;
+    if (!(positionalParameter as VariableDeclarationImpl).isImplicitlyTyped) {
+      result.add(key);
+    }
+  }
+  for (VariableDeclaration namedParameter
+      in functionExpression.function.namedParameters) {
+    String key = namedParameter.name!;
+    if (!(namedParameter as VariableDeclarationImpl).isImplicitlyTyped) {
+      result.add(key);
+    }
+  }
+  return result;
+}
+
+/// Given an function type, computes a map based on the parameters whose keys
+/// are either the parameter name (for named parameters) or the zero-based
+/// integer index (for unnamed parameters), and whose values are the parameter
+/// types.
+Map<Object, DartType> _computeParameterMap(FunctionType functionType) => {
+      for (int i = 0; i < functionType.positionalParameters.length; i++)
+        i: functionType.positionalParameters[i],
+      for (NamedType namedType in functionType.namedParameters)
+        namedType.name: namedType.type
+    };
+
+/// Computes a list of [_ParamInfo] objects corresponding to the invocation
+/// parameters that were *not* deferred.
+List<_ParamInfo> _computeUndeferredParamInfo(List<DartType> formalTypes,
+    List<_DeferredParamInfo> deferredFunctionLiterals) {
+  // TODO(paulberry): test that the right thing happens when evaluation order differs from classic (positional/named) order.
+  Set<int> evaluationOrderIndicesAlreadyCovered = {
+    for (_DeferredParamInfo functionLiteral in deferredFunctionLiterals)
+      functionLiteral.evaluationOrderIndex
+  };
+  return [
+    for (int i = 0; i < formalTypes.length; i++)
+      if (!evaluationOrderIndicesAlreadyCovered.contains(i))
+        new _ParamInfo(formalTypes[i])
+  ];
+}
+
 /// Enum denoting the kinds of contravariance check that might need to be
 /// inserted for a method call.
 enum MethodContravarianceCheckKind {
@@ -2290,7 +2344,8 @@ class TypeInferrerImpl implements TypeInferrer {
         explicitTypeArguments == null &&
         calleeTypeParameters.isNotEmpty;
     bool typeChecksNeeded = !isTopLevel;
-    bool useFormalAndActualTypes = typeChecksNeeded ||
+    bool useFormalAndActualTypes = inferenceNeeded ||
+        typeChecksNeeded ||
         isSpecialCasedBinaryOperator ||
         isSpecialCasedTernaryOperator;
 
@@ -2331,7 +2386,7 @@ class TypeInferrerImpl implements TypeInferrer {
           calleeTypeParameters,
           typeContext,
           libraryBuilder.library);
-      typeSchemaEnvironment.downwardsInfer(gatherer, calleeTypeParameters,
+      typeSchemaEnvironment.partialInfer(gatherer, calleeTypeParameters,
           inferredTypes, libraryBuilder.library);
       substitution =
           Substitution.fromPairs(calleeTypeParameters, inferredTypes);
@@ -2471,6 +2526,7 @@ class TypeInferrerImpl implements TypeInferrer {
         (deferredFunctionLiterals ??= []).add(new _DeferredParamInfo(
             formalType: formalType,
             argumentExpression: argumentExpression,
+            unparenthesizedExpression: unparenthesizedExpression,
             isNamed: !isExpression,
             evaluationOrderIndex: evaluationOrderIndex,
             index: index));
@@ -2510,26 +2566,44 @@ class TypeInferrerImpl implements TypeInferrer {
       }
     }
     if (deferredFunctionLiterals != null) {
-      for (_DeferredParamInfo deferredArgument in deferredFunctionLiterals) {
-        ExpressionInferenceResult result = inferArgument(
-            deferredArgument.formalType, deferredArgument.argumentExpression,
-            isNamed: deferredArgument.isNamed);
-        DartType inferredType = _computeInferredType(result);
-        Expression expression = result.expression;
-        identicalInfo?[deferredArgument.evaluationOrderIndex] =
-            flowAnalysis.equalityOperand_end(expression, inferredType);
-        if (deferredArgument.isNamed) {
-          NamedExpression namedArgument =
-              arguments.named[deferredArgument.index];
-          namedArgument.value = expression..parent = namedArgument;
-        } else {
-          arguments.positional[deferredArgument.index] = expression
-            ..parent = arguments;
+      bool isFirstStage = true;
+      for (List<_DeferredParamInfo> stage in new _FunctionLiteralDependencies(
+              deferredFunctionLiterals,
+              calleeType.typeParameters.toSet(),
+              inferenceNeeded
+                  ? _computeUndeferredParamInfo(
+                      formalTypes!, deferredFunctionLiterals)
+                  : const [])
+          .planReconciliationStages()) {
+        if (gatherer != null && !isFirstStage) {
+          typeSchemaEnvironment.partialInfer(gatherer, calleeTypeParameters,
+              inferredTypes!, libraryBuilder.library);
+          substitution =
+              Substitution.fromPairs(calleeTypeParameters, inferredTypes);
         }
-        gatherer?.tryConstrainLower(deferredArgument.formalType, inferredType);
-        if (useFormalAndActualTypes) {
-          actualTypes![deferredArgument.evaluationOrderIndex] = inferredType;
+        for (_DeferredParamInfo deferredArgument in stage) {
+          ExpressionInferenceResult result = inferArgument(
+              deferredArgument.formalType, deferredArgument.argumentExpression,
+              isNamed: deferredArgument.isNamed);
+          DartType inferredType = _computeInferredType(result);
+          Expression expression = result.expression;
+          identicalInfo?[deferredArgument.evaluationOrderIndex] =
+              flowAnalysis.equalityOperand_end(expression, inferredType);
+          if (deferredArgument.isNamed) {
+            NamedExpression namedArgument =
+                arguments.named[deferredArgument.index];
+            namedArgument.value = expression..parent = namedArgument;
+          } else {
+            arguments.positional[deferredArgument.index] = expression
+              ..parent = arguments;
+          }
+          gatherer?.tryConstrainLower(
+              deferredArgument.formalType, inferredType);
+          if (useFormalAndActualTypes) {
+            actualTypes![deferredArgument.evaluationOrderIndex] = inferredType;
+          }
         }
+        isFirstStage = false;
       }
     }
     if (identicalInfo != null) {
@@ -5967,15 +6041,14 @@ class ImplicitInstantiation {
 /// Information about an invocation argument that needs to be resolved later due
 /// to the fact that it's a function literal and the `inference-update-1`
 /// feature is enabled.
-class _DeferredParamInfo {
-  /// The (unsubstituted) type of the formal parameter corresponding to this
-  /// argument.
-  final DartType formalType;
-
+class _DeferredParamInfo extends _ParamInfo {
   /// The argument expression (possibly wrapped in an arbitrary number of
   /// ParenthesizedExpressions).
   final Expression argumentExpression;
 
+  /// The unparenthesized argument expression.
+  final FunctionExpression unparenthesizedExpression;
+
   /// Indicates whether this is a named argument.
   final bool isNamed;
 
@@ -5988,9 +6061,63 @@ class _DeferredParamInfo {
   final int index;
 
   _DeferredParamInfo(
-      {required this.formalType,
+      {required DartType formalType,
       required this.argumentExpression,
+      required this.unparenthesizedExpression,
       required this.isNamed,
       required this.evaluationOrderIndex,
-      required this.index});
+      required this.index})
+      : super(formalType);
+}
+
+/// Extension of the shared [FunctionLiteralDependencies] logic used by the
+/// front end.
+class _FunctionLiteralDependencies extends FunctionLiteralDependencies<
+    TypeParameter, _ParamInfo, _DeferredParamInfo> {
+  _FunctionLiteralDependencies(
+      Iterable<_DeferredParamInfo> deferredParamInfo,
+      Iterable<TypeParameter> typeVariables,
+      List<_ParamInfo> undeferredParamInfo)
+      : super(deferredParamInfo, typeVariables, undeferredParamInfo);
+
+  @override
+  Iterable<TypeParameter> typeVarsFreeInParamParams(
+      _DeferredParamInfo paramInfo) {
+    DartType type = paramInfo.formalType;
+    if (type is FunctionType) {
+      Map<Object, DartType> parameterMap = _computeParameterMap(type);
+      Set<Object> explicitlyTypedParameters =
+          _computeExplicitlyTypedParameterSet(
+              paramInfo.unparenthesizedExpression);
+      Set<TypeParameter> result = {};
+      for (MapEntry<Object, DartType> entry in parameterMap.entries) {
+        if (explicitlyTypedParameters.contains(entry.key)) continue;
+        result.addAll(allFreeTypeVariables(entry.value));
+      }
+      return result;
+    } else {
+      return const [];
+    }
+  }
+
+  @override
+  Iterable<TypeParameter> typeVarsFreeInParamReturns(_ParamInfo paramInfo) {
+    DartType type = paramInfo.formalType;
+    if (type is FunctionType) {
+      return allFreeTypeVariables(type.returnType);
+    } else {
+      return allFreeTypeVariables(type);
+    }
+  }
+}
+
+/// Information about an invocation argument that may or may not have already
+/// been resolved, as part of the deferred resolution mechanism for the
+/// `inference-update-1` feature.
+class _ParamInfo {
+  /// The (unsubstituted) type of the formal parameter corresponding to this
+  /// argument.
+  final DartType formalType;
+
+  _ParamInfo(this.formalType);
 }

pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.dart

@@ -128,9 +128,9 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
         getStandardLowerBound(constraint.upper, upper, clientLibrary);
   }
 
-  /// Performs downwards inference, producing a set of inferred types that may
-  /// contain references to the "unknown type".
-  void downwardsInfer(
+  /// Performs partial (either downwards or horizontal) inference, producing a
+  /// set of inferred types that may contain references to the "unknown type".
+  void partialInfer(
           TypeConstraintGatherer gatherer,
           List<TypeParameter> typeParametersToInfer,
           List<DartType> inferredTypes,

pkg/front_end/test/fasta/type_inference/type_schema_environment_test_base.dart

@@ -171,8 +171,8 @@ abstract class TypeSchemaEnvironmentTestBase {
               returnContextTypeNode,
               testLibrary);
       if (formalTypeNodes == null) {
-        typeSchemaEnvironment.downwardsInfer(gatherer,
-            typeParameterNodesToInfer, inferredTypeNodes, testLibrary);
+        typeSchemaEnvironment.partialInfer(gatherer, typeParameterNodesToInfer,
+            inferredTypeNodes, testLibrary);
       } else {
         gatherer.constrainArguments(formalTypeNodes, actualTypeNodes!);
         typeSchemaEnvironment.upwardsInfer(gatherer, typeParameterNodesToInfer,

pkg/front_end/test/spell_checking_list_code.txt

@@ -577,6 +577,7 @@ history
 hit
 hoc
 hopefully
+horizontal
 href
 html
 https
@@ -1399,6 +1400,7 @@ uncommon
 unconditionally
 unconstrained
 undeclare
+undeferred
 undergo
 undermine
 undo

pkg/front_end/test/spell_checking_list_tests.txt

@@ -323,6 +323,7 @@ hkt
 home
 hoo
 hook
+horizontally
 hosted
 hosting
 hot
@@ -714,6 +715,7 @@ y's
 year
 yxxx
 yy
+zeroth
 zipf's
 zyx
 zz