Ensure that partial inference results aren't refined by later partial inference stages.

As part of the implementation of
dart-lang/language#731 (improved inference
for fold etc.), I expanded the front end's type inference logic so
that instead of just having a downward phase and an upward phase, it
could have 3 or more phases.  The function that previously did
downward inference became repurposed to do "partial inference" (which
could either be the first, downward stage, or a later, horizontal
stage).  However, I failed to generalize the logic that prevents types
assigned by one inference stage from being refined by later
stages--previously this logic was only needed for upward inference,
but now it's needed for horizontal inference stages as well.  (This
logic is needed because of Dart's "runtime checked covariance"
behavior--it means that we want to stick with the type from downward
inference, even if a later horizontal inference stage is able to find
a more precise type, because that more precise type may lead to
runtime failures).

As part of this change I've re-architected the inference methods so
that they are responsible for creating and returning the list of
inferred types.  This makes the inference logic more similar between
the front end and analyzer, and is easier to read IMHO.  The total
number of list allocations is the same as before.

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

Author: stereotype441

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

@@ -2030,23 +2030,15 @@ class InferenceVisitor
     }
     TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
-      inferredTypes = [const UnknownType()];
       gatherer = inferrer.typeSchemaEnvironment.setupGenericTypeInference(
           listType,
           listClass.typeParameters,
           typeContext,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
-      inferrer.typeSchemaEnvironment.partialInfer(
-          gatherer,
-          listClass.typeParameters,
-          inferredTypes,
-          inferrer.libraryBuilder.library);
+      inferredTypes = inferrer.typeSchemaEnvironment.partialInfer(gatherer,
+          listClass.typeParameters, null, inferrer.libraryBuilder.library);
       inferredTypeArgument = inferredTypes[0];
-      if (inferrer.dataForTesting != null) {
-        inferrer.dataForTesting!.typeInferenceResult
-            .inferredTypeArguments[node] = inferredTypes;
-      }
     } else {
       inferredTypeArgument = node.typeArgument;
     }
@@ -2068,11 +2060,15 @@ class InferenceVisitor
     }
     if (inferenceNeeded) {
       gatherer!.constrainArguments(formalTypes!, actualTypes!);
-      inferrer.typeSchemaEnvironment.upwardsInfer(
+      inferredTypes = inferrer.typeSchemaEnvironment.upwardsInfer(
           gatherer,
           listClass.typeParameters,
           inferredTypes!,
           inferrer.libraryBuilder.library);
+      if (inferrer.dataForTesting != null) {
+        inferrer.dataForTesting!.typeInferenceResult
+            .inferredTypeArguments[node] = inferredTypes;
+      }
       inferredTypeArgument = inferredTypes[0];
       inferrer.instrumentation?.record(
           inferrer.uriForInstrumentation,
@@ -2715,24 +2711,16 @@ class InferenceVisitor
     }
     TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
-      inferredTypes = [noInferredType, noInferredType];
       gatherer = inferrer.typeSchemaEnvironment.setupGenericTypeInference(
           mapType,
           mapClass.typeParameters,
           typeContext,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
-      inferrer.typeSchemaEnvironment.partialInfer(
-          gatherer,
-          mapClass.typeParameters,
-          inferredTypes,
-          inferrer.libraryBuilder.library);
+      inferredTypes = inferrer.typeSchemaEnvironment.partialInfer(gatherer,
+          mapClass.typeParameters, null, inferrer.libraryBuilder.library);
       inferredKeyType = inferredTypes[0];
       inferredValueType = inferredTypes[1];
-      if (inferrer.dataForTesting != null) {
-        inferrer.dataForTesting!.typeInferenceResult
-            .inferredTypeArguments[node] = inferredTypes;
-      }
     } else {
       inferredKeyType = node.keyType;
       inferredValueType = node.valueType;
@@ -2796,7 +2784,6 @@ class InferenceVisitor
           formalTypesForSet.add(setType.typeArguments[0]);
         }
 
-        List<DartType> inferredTypesForSet = <DartType>[noInferredType];
         // 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.
@@ -2807,13 +2794,11 @@ class InferenceVisitor
                 typeContext,
                 inferrer.libraryBuilder.library,
                 isConst: node.isConst);
-        inferrer.typeSchemaEnvironment.partialInfer(
-            gatherer,
-            inferrer.coreTypes.setClass.typeParameters,
-            inferredTypesForSet,
-            inferrer.libraryBuilder.library);
+        List<DartType> inferredTypesForSet = inferrer.typeSchemaEnvironment
+            .partialInfer(gatherer, inferrer.coreTypes.setClass.typeParameters,
+                null, inferrer.libraryBuilder.library);
         gatherer.constrainArguments(formalTypesForSet, actualTypesForSet!);
-        inferrer.typeSchemaEnvironment.upwardsInfer(
+        inferredTypesForSet = inferrer.typeSchemaEnvironment.upwardsInfer(
             gatherer,
             inferrer.coreTypes.setClass.typeParameters,
             inferredTypesForSet,
@@ -2864,11 +2849,15 @@ class InferenceVisitor
             replacement);
       }
       gatherer!.constrainArguments(formalTypes!, actualTypes!);
-      inferrer.typeSchemaEnvironment.upwardsInfer(
+      inferredTypes = inferrer.typeSchemaEnvironment.upwardsInfer(
           gatherer,
           mapClass.typeParameters,
           inferredTypes!,
           inferrer.libraryBuilder.library);
+      if (inferrer.dataForTesting != null) {
+        inferrer.dataForTesting!.typeInferenceResult
+            .inferredTypeArguments[node] = inferredTypes;
+      }
       inferredKeyType = inferredTypes[0];
       inferredValueType = inferredTypes[1];
       inferrer.instrumentation?.record(
@@ -5985,23 +5974,15 @@ class InferenceVisitor
     }
     TypeConstraintGatherer? gatherer;
     if (inferenceNeeded) {
-      inferredTypes = [const UnknownType()];
       gatherer = inferrer.typeSchemaEnvironment.setupGenericTypeInference(
           setType,
           setClass.typeParameters,
           typeContext,
           inferrer.libraryBuilder.library,
           isConst: node.isConst);
-      inferrer.typeSchemaEnvironment.partialInfer(
-          gatherer,
-          setClass.typeParameters,
-          inferredTypes,
-          inferrer.libraryBuilder.library);
+      inferredTypes = inferrer.typeSchemaEnvironment.partialInfer(gatherer,
+          setClass.typeParameters, null, inferrer.libraryBuilder.library);
       inferredTypeArgument = inferredTypes[0];
-      if (inferrer.dataForTesting != null) {
-        inferrer.dataForTesting!.typeInferenceResult
-            .inferredTypeArguments[node] = inferredTypes;
-      }
     } else {
       inferredTypeArgument = node.typeArgument;
     }
@@ -6023,11 +6004,15 @@ class InferenceVisitor
     }
     if (inferenceNeeded) {
       gatherer!.constrainArguments(formalTypes!, actualTypes!);
-      inferrer.typeSchemaEnvironment.upwardsInfer(
+      inferredTypes = inferrer.typeSchemaEnvironment.upwardsInfer(
           gatherer,
           setClass.typeParameters,
           inferredTypes!,
           inferrer.libraryBuilder.library);
+      if (inferrer.dataForTesting != null) {
+        inferrer.dataForTesting!.typeInferenceResult
+            .inferredTypeArguments[node] = inferredTypes;
+      }
       inferredTypeArgument = inferredTypes[0];
       inferrer.instrumentation?.record(
           inferrer.uriForInstrumentation,

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

@@ -978,7 +978,7 @@ class TypeInferrerImpl implements TypeInferrer {
         typeSchemaEnvironment.setupGenericTypeInference(
             null, typeParameters, null, libraryBuilder.library);
     gatherer.constrainArguments([onType], [receiverType]);
-    typeSchemaEnvironment.upwardsInfer(
+    inferredTypes = typeSchemaEnvironment.upwardsInfer(
         gatherer, typeParameters, inferredTypes, libraryBuilder.library);
     return inferredTypes;
   }
@@ -2378,17 +2378,15 @@ class TypeInferrerImpl implements TypeInferrer {
                     : coreTypes.objectLegacyRawType)
             .substituteType(typeContext);
       }
-      inferredTypes = new List<DartType>.filled(
-          calleeTypeParameters.length, const UnknownType());
       gatherer = typeSchemaEnvironment.setupGenericTypeInference(
           isNonNullableByDefault
               ? calleeType.returnType
               : legacyErasure(calleeType.returnType),
           calleeTypeParameters,
           typeContext,
           libraryBuilder.library);
-      typeSchemaEnvironment.partialInfer(gatherer, calleeTypeParameters,
-          inferredTypes, libraryBuilder.library);
+      inferredTypes = typeSchemaEnvironment.partialInfer(
+          gatherer, calleeTypeParameters, null, libraryBuilder.library);
       substitution =
           Substitution.fromPairs(calleeTypeParameters, inferredTypes);
     } else if (explicitTypeArguments != null &&
@@ -2579,8 +2577,8 @@ class TypeInferrerImpl implements TypeInferrer {
                   : const [])
           .planReconciliationStages()) {
         if (gatherer != null && !isFirstStage) {
-          typeSchemaEnvironment.partialInfer(gatherer, calleeTypeParameters,
-              inferredTypes!, libraryBuilder.library);
+          inferredTypes = typeSchemaEnvironment.partialInfer(gatherer,
+              calleeTypeParameters, inferredTypes, libraryBuilder.library);
           substitution =
               Substitution.fromPairs(calleeTypeParameters, inferredTypes);
         }
@@ -2706,8 +2704,8 @@ class TypeInferrerImpl implements TypeInferrer {
     }
 
     if (inferenceNeeded) {
-      typeSchemaEnvironment.upwardsInfer(gatherer!, calleeTypeParameters,
-          inferredTypes!, libraryBuilder.library);
+      inferredTypes = 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)),
@@ -4255,7 +4253,7 @@ class TypeInferrerImpl implements TypeInferrer {
         TypeConstraintGatherer gatherer =
             typeSchemaEnvironment.setupGenericTypeInference(instantiatedType,
                 typeParameters, context, libraryBuilder.library);
-        typeSchemaEnvironment.upwardsInfer(
+        inferredTypes = typeSchemaEnvironment.upwardsInfer(
             gatherer, typeParameters, inferredTypes, libraryBuilder.library);
         Substitution substitution =
             Substitution.fromPairs(typeParameters, inferredTypes);