Rework type inference logic to avoid redundant constraint gathering.

Previously, the front end would perform downwards and upwards
inference using separate TypeConstraintGatherer objects.  This meant
that any constraint gathering work performed during downwards
inference had to be repeated during upwards inference.

This change avoids the extra work by using a single
TypeConstraintGatherer object for both downwards and upwards
inference.

This should help pave the way to implementing support for
dart-lang/language#731 (improved inference
for fold etc.)

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

Author: stereotype441

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

@@ -19,6 +19,7 @@ import '../fasta_codes.dart';
 import '../names.dart';
 import '../problems.dart' show unhandled;
 import '../source/source_library_builder.dart' show SourceLibraryBuilder;
+import '../type_inference/type_constraint_gatherer.dart';
 import '../type_inference/type_inference_engine.dart';
 import '../type_inference/type_inferrer.dart';
 import '../type_inference/type_schema.dart' show UnknownType;
@@ -2027,17 +2028,20 @@ class InferenceVisitor
       inferredSpreadTypes = new Map<TreeNode, DartType>.identity();
       inferredConditionTypes = new Map<Expression, DartType>.identity();
     }
+    TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
       inferredTypes = [const UnknownType()];
-      inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
+      gatherer = inferrer.typeSchemaEnvironment.setupGenericTypeInference(
           listType,
           listClass.typeParameters,
-          null,
-          null,
           typeContext,
-          inferredTypes,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
+      inferrer.typeSchemaEnvironment.downwardsInfer(
+          gatherer,
+          listClass.typeParameters,
+          inferredTypes,
+          inferrer.libraryBuilder.library);
       inferredTypeArgument = inferredTypes[0];
       if (inferrer.dataForTesting != null) {
         inferrer.dataForTesting!.typeInferenceResult
@@ -2063,12 +2067,10 @@ class InferenceVisitor
       }
     }
     if (inferenceNeeded) {
-      inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
-          listType,
+      gatherer!.constrainArguments(formalTypes!, actualTypes!);
+      inferrer.typeSchemaEnvironment.upwardsInfer(
+          gatherer,
           listClass.typeParameters,
-          formalTypes,
-          actualTypes,
-          typeContext,
           inferredTypes!,
           inferrer.libraryBuilder.library);
       inferredTypeArgument = inferredTypes[0];
@@ -2711,17 +2713,20 @@ class InferenceVisitor
       inferredSpreadTypes = new Map<TreeNode, DartType>.identity();
       inferredConditionTypes = new Map<Expression, DartType>.identity();
     }
+    TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
       inferredTypes = [noInferredType, noInferredType];
-      inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
+      gatherer = inferrer.typeSchemaEnvironment.setupGenericTypeInference(
           mapType,
           mapClass.typeParameters,
-          null,
-          null,
           typeContext,
-          inferredTypes,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
+      inferrer.typeSchemaEnvironment.downwardsInfer(
+          gatherer,
+          mapClass.typeParameters,
+          inferredTypes,
+          inferrer.libraryBuilder.library);
       inferredKeyType = inferredTypes[0];
       inferredValueType = inferredTypes[1];
       if (inferrer.dataForTesting != null) {
@@ -2792,22 +2797,25 @@ class InferenceVisitor
         }
 
         List<DartType> inferredTypesForSet = <DartType>[noInferredType];
-        inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
-            setType,
+        // Note: we don't use the previously created gatherer because it was set
+        // up presuming that the literal would be a map; we now know that it
+        // needs to be a set.
+        TypeConstraintGatherer gatherer = inferrer.typeSchemaEnvironment
+            .setupGenericTypeInference(
+                setType,
+                inferrer.coreTypes.setClass.typeParameters,
+                typeContext,
+                inferrer.libraryBuilder.library,
+                isConst: node.isConst);
+        inferrer.typeSchemaEnvironment.downwardsInfer(
+            gatherer,
             inferrer.coreTypes.setClass.typeParameters,
-            null,
-            null,
-            typeContext,
             inferredTypesForSet,
-            inferrer.libraryBuilder.library,
-            isConst: node.isConst);
-        inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
-            inferrer.coreTypes.thisInterfaceType(inferrer.coreTypes.setClass,
-                inferrer.libraryBuilder.nonNullable),
+            inferrer.libraryBuilder.library);
+        gatherer.constrainArguments(formalTypesForSet, actualTypesForSet!);
+        inferrer.typeSchemaEnvironment.upwardsInfer(
+            gatherer,
             inferrer.coreTypes.setClass.typeParameters,
-            formalTypesForSet,
-            actualTypesForSet,
-            typeContext,
             inferredTypesForSet,
             inferrer.libraryBuilder.library);
         DartType inferredTypeArgument = inferredTypesForSet[0];
@@ -2855,12 +2863,10 @@ class InferenceVisitor
             NeverType.fromNullability(inferrer.libraryBuilder.nonNullable),
             replacement);
       }
-      inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
-          mapType,
+      gatherer!.constrainArguments(formalTypes!, actualTypes!);
+      inferrer.typeSchemaEnvironment.upwardsInfer(
+          gatherer,
           mapClass.typeParameters,
-          formalTypes,
-          actualTypes,
-          typeContext,
           inferredTypes!,
           inferrer.libraryBuilder.library);
       inferredKeyType = inferredTypes[0];
@@ -5977,17 +5983,20 @@ class InferenceVisitor
       inferredSpreadTypes = new Map<TreeNode, DartType>.identity();
       inferredConditionTypes = new Map<Expression, DartType>.identity();
     }
+    TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
       inferredTypes = [const UnknownType()];
-      inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
+      gatherer = inferrer.typeSchemaEnvironment.setupGenericTypeInference(
           setType,
           setClass.typeParameters,
-          null,
-          null,
           typeContext,
-          inferredTypes,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
+      inferrer.typeSchemaEnvironment.downwardsInfer(
+          gatherer,
+          setClass.typeParameters,
+          inferredTypes,
+          inferrer.libraryBuilder.library);
       inferredTypeArgument = inferredTypes[0];
       if (inferrer.dataForTesting != null) {
         inferrer.dataForTesting!.typeInferenceResult
@@ -6013,12 +6022,10 @@ class InferenceVisitor
       }
     }
     if (inferenceNeeded) {
-      inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
-          setType,
+      gatherer!.constrainArguments(formalTypes!, actualTypes!);
+      inferrer.typeSchemaEnvironment.upwardsInfer(
+          gatherer,
           setClass.typeParameters,
-          formalTypes,
-          actualTypes,
-          typeContext,
           inferredTypes!,
           inferrer.libraryBuilder.library);
       inferredTypeArgument = inferredTypes[0];

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

@@ -45,6 +45,18 @@ abstract class TypeConstraintGatherer {
   void addLowerBound(
       TypeConstraint constraint, DartType lower, Library clientLibrary);
 
+  /// Applies all the argument constraints implied by trying to make
+  /// [actualTypes] assignable to [formalTypes].
+  void constrainArguments(
+      List<DartType> formalTypes, List<DartType> actualTypes) {
+    assert(formalTypes.length == actualTypes.length);
+    for (int i = 0; i < formalTypes.length; i++) {
+      // Try to pass each argument to each parameter, recording any type
+      // parameter bounds that were implied by this assignment.
+      tryConstrainLower(formalTypes[i], actualTypes[i]);
+    }
+  }
+
   Member? getInterfaceMember(Class class_, Name name, {bool setter: false});
 
   InterfaceType? getTypeAsInstanceOf(InterfaceType type, Class superclass,

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

@@ -916,8 +916,12 @@ class TypeInferrerImpl implements TypeInferrer {
     DartType onType = extension.onType;
     List<DartType> inferredTypes =
         new List<DartType>.filled(typeParameters.length, const UnknownType());
-    typeSchemaEnvironment.inferGenericFunctionOrType(null, typeParameters,
-        [onType], [receiverType], null, inferredTypes, libraryBuilder.library);
+    TypeConstraintGatherer gatherer =
+        typeSchemaEnvironment.setupGenericTypeInference(
+            null, typeParameters, null, libraryBuilder.library);
+    gatherer.constrainArguments([onType], [receiverType]);
+    typeSchemaEnvironment.upwardsInfer(
+        gatherer, typeParameters, inferredTypes, libraryBuilder.library);
     return inferredTypes;
   }
 
@@ -2305,6 +2309,7 @@ class TypeInferrerImpl implements TypeInferrer {
       hoistedExpressions = localHoistedExpressions = <VariableDeclaration>[];
     }
 
+    TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
       // ignore: unnecessary_null_comparison
       if (isConst && typeContext != null) {
@@ -2317,16 +2322,15 @@ class TypeInferrerImpl implements TypeInferrer {
       }
       inferredTypes = new List<DartType>.filled(
           calleeTypeParameters.length, const UnknownType());
-      typeSchemaEnvironment.inferGenericFunctionOrType(
+      gatherer = typeSchemaEnvironment.setupGenericTypeInference(
           isNonNullableByDefault
               ? calleeType.returnType
               : legacyErasure(calleeType.returnType),
           calleeTypeParameters,
-          null,
-          null,
           typeContext,
-          inferredTypes,
           libraryBuilder.library);
+      typeSchemaEnvironment.downwardsInfer(gatherer, calleeTypeParameters,
+          inferredTypes, libraryBuilder.library);
       substitution =
           Substitution.fromPairs(calleeTypeParameters, inferredTypes);
     } else if (explicitTypeArguments != null &&
@@ -2588,14 +2592,9 @@ class TypeInferrerImpl implements TypeInferrer {
     }
 
     if (inferenceNeeded) {
-      typeSchemaEnvironment.inferGenericFunctionOrType(
-          calleeType.returnType,
-          calleeTypeParameters,
-          formalTypes,
-          actualTypes,
-          typeContext,
-          inferredTypes!,
-          libraryBuilder.library);
+      gatherer!.constrainArguments(formalTypes!, actualTypes!);
+      typeSchemaEnvironment.upwardsInfer(gatherer, calleeTypeParameters,
+          inferredTypes!, libraryBuilder.library);
       assert(inferredTypes.every((type) => isKnown(type)),
           "Unknown type(s) in inferred types: $inferredTypes.");
       assert(inferredTypes.every((type) => !hasPromotedTypeVariable(type)),
@@ -4138,14 +4137,11 @@ class TypeInferrerImpl implements TypeInferrer {
         List<DartType> inferredTypes = new List<DartType>.filled(
             typeParameters.length, const UnknownType());
         FunctionType instantiatedType = functionType.withoutTypeParameters;
-        typeSchemaEnvironment.inferGenericFunctionOrType(
-            instantiatedType,
-            typeParameters,
-            [],
-            [],
-            context,
-            inferredTypes,
-            libraryBuilder.library);
+        TypeConstraintGatherer gatherer =
+            typeSchemaEnvironment.setupGenericTypeInference(instantiatedType,
+                typeParameters, context, libraryBuilder.library);
+        typeSchemaEnvironment.upwardsInfer(
+            gatherer, typeParameters, inferredTypes, libraryBuilder.library);
         Substitution substitution =
             Substitution.fromPairs(typeParameters, inferredTypes);
         tearoffType = substitution.substituteType(instantiatedType);