[model] Share constraint solving for one type variable Analyzer/CFE

Part of #54902

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

Author: chloestefantsova

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer_operations.dart

@@ -769,6 +769,44 @@ abstract interface class TypeAnalyzerOperations<
   /// The least closure of a type schema is defined in
   /// https://github.com/dart-lang/language/blob/main/accepted/future-releases/0323-null-aware-elements/feature-specification.md
   SharedTypeView leastClosureOfSchema(SharedTypeSchemaView schema);
+
+  /// Computes the constraint solution for a type parameter based on a given
+  /// set of constraints.
+  ///
+  /// For example given:
+  ///
+  ///     bool Function(T) makeComparer<T>(T x) => (T y) => x == y;
+  ///
+  ///     main() {
+  ///       bool Function(num) t = makeComparer/* infer <num> */(42);
+  ///       print(t(42.0)); /// false, no error.
+  ///     }
+  ///
+  /// The constraints we collect are:
+  ///
+  /// * `num <: T`
+  /// * `int <: T`
+  ///
+  /// ... and no upper bound. Therefore the lower bound is the best choice.
+  ///
+  /// If [grounded] is `true`, then the returned type is guaranteed to be a
+  /// known type (i.e. it will not contain any instances of `?`) if it is
+  /// constrained at all.  The returned type for unconstrained variables is
+  /// `?`.
+  ///
+  /// If [isContravariant] is `true`, then we are solving for a contravariant
+  /// type parameter which means we choose the upper bound rather than the
+  /// lower bound for normally covariant type parameters.
+  ///
+  /// The algorithm for computing the constraint solution for a type variable
+  /// is described in
+  /// https://github.com/dart-lang/language/blob/main/resources/type-system/inference.md#constraint-solution-for-a-type-variable.
+  SharedType chooseTypeFromConstraint(
+    MergedTypeConstraint<Variable, TypeDeclarationType, TypeDeclaration>
+    constraint, {
+    required bool grounded,
+    required bool isContravariant,
+  });
 }
 
 mixin TypeAnalyzerOperationsMixin<
@@ -1083,6 +1121,63 @@ mixin TypeAnalyzerOperationsMixin<
   SharedTypeSchemaView typeToSchema(SharedTypeView type) {
     return new SharedTypeSchemaView(type.unwrapTypeView());
   }
+
+  @override
+  SharedType chooseTypeFromConstraint(
+    MergedTypeConstraint<Variable, TypeDeclarationType, TypeDeclaration>
+    constraint, {
+    required bool grounded,
+    required bool isContravariant,
+  }) {
+    if (!isContravariant) {
+      // Prefer the known bound, if any.
+      if (isKnownType(constraint.lower)) {
+        return constraint.lower.unwrapTypeSchemaView();
+      }
+      if (isKnownType(constraint.upper)) {
+        return constraint.upper.unwrapTypeSchemaView();
+      }
+
+      // Otherwise take whatever bound has partial information,
+      // e.g. `Iterable<?>`
+      if (constraint.lower is! SharedUnknownTypeSchemaView) {
+        return grounded
+            ? leastClosureOfSchema(constraint.lower).unwrapTypeView()
+            : constraint.lower.unwrapTypeSchemaView();
+      } else if (constraint.upper is! SharedUnknownTypeSchemaView) {
+        return grounded
+            ? greatestClosureOfSchema(constraint.upper).unwrapTypeView()
+            : constraint.upper.unwrapTypeSchemaView();
+      } else {
+        assert(constraint.lower is SharedUnknownTypeSchemaView);
+        return constraint.lower.unwrapTypeSchemaView();
+      }
+    } else {
+      // Prefer the known bound, if any.
+      if (isKnownType(constraint.upper)) {
+        return constraint.upper.unwrapTypeSchemaView();
+      }
+      if (isKnownType(constraint.lower)) {
+        return constraint.lower.unwrapTypeSchemaView();
+      }
+
+      // Otherwise take whatever bound has partial information,
+      // e.g. `Iterable<?>`
+      if (constraint.upper is! SharedUnknownTypeSchemaView) {
+        // Coverage-ignore-block(suite): Not run.
+        return grounded
+            ? greatestClosureOfSchema(constraint.upper).unwrapTypeView()
+            : constraint.upper.unwrapTypeSchemaView();
+      } else if (constraint.lower is! SharedUnknownTypeSchemaView) {
+        return grounded
+            ? leastClosureOfSchema(constraint.lower).unwrapTypeView()
+            : constraint.lower.unwrapTypeSchemaView();
+      } else {
+        assert(constraint.upper is SharedUnknownTypeSchemaView);
+        return constraint.upper.unwrapTypeSchemaView();
+      }
+    }
+  }
 }
 
 /// Abstract interface of a type constraint generator.

pkg/analyzer/lib/src/dart/element/generic_inferrer.dart

@@ -474,74 +474,6 @@ class GenericInferrer {
     }
   }
 
-  /// Choose the bound that was implied by the return type, if any.
-  ///
-  /// Which bound this is depends on what positions the type parameter
-  /// appears in. If the type only appears only in a contravariant position,
-  /// we will choose the lower bound instead.
-  ///
-  /// For example given:
-  ///
-  ///     Func1<T, bool> makeComparer<T>(T x) => (T y) => x() == y;
-  ///
-  ///     main() {
-  ///       Func1<num, bool> t = makeComparer/* infer <num> */(42);
-  ///       print(t(42.0)); /// false, no error.
-  ///     }
-  ///
-  /// The constraints we collect are:
-  ///
-  /// * `num <: T`
-  /// * `int <: T`
-  ///
-  /// ... and no upper bound. Therefore the lower bound is the best choice.
-  ///
-  /// If [isContravariant] is `true`, then we are solving for a contravariant
-  /// type parameter which means we choose the upper bound rather than the
-  /// lower bound for normally covariant type parameters.
-  TypeImpl _chooseTypeFromConstraint(
-    MergedTypeConstraint constraint, {
-    bool toKnownType = false,
-    required bool isContravariant,
-  }) {
-    TypeImpl upper = constraint.upper.unwrapTypeSchemaView();
-    TypeImpl lower = constraint.lower.unwrapTypeSchemaView();
-    // Prefer the known bound, if any.
-    // Otherwise take whatever bound has partial information, e.g. `Iterable<?>`
-    //
-    // For both of those, prefer the lower bound (arbitrary heuristic) or upper
-    // bound if [isContravariant] is `true`
-    if (isContravariant) {
-      if (_typeSystemOperations.isKnownType(SharedTypeSchemaView(upper))) {
-        return upper;
-      }
-      if (_typeSystemOperations.isKnownType(SharedTypeSchemaView(lower))) {
-        return lower;
-      }
-      if (!identical(UnknownInferredType.instance, upper)) {
-        return toKnownType ? _typeSystem.greatestClosureOfSchema(upper) : upper;
-      }
-      if (!identical(UnknownInferredType.instance, lower)) {
-        return toKnownType ? _typeSystem.leastClosureOfSchema(lower) : lower;
-      }
-      return upper;
-    } else {
-      if (_typeSystemOperations.isKnownType(SharedTypeSchemaView(lower))) {
-        return lower;
-      }
-      if (_typeSystemOperations.isKnownType(SharedTypeSchemaView(upper))) {
-        return upper;
-      }
-      if (!identical(UnknownInferredType.instance, lower)) {
-        return toKnownType ? _typeSystem.leastClosureOfSchema(lower) : lower;
-      }
-      if (!identical(UnknownInferredType.instance, upper)) {
-        return toKnownType ? _typeSystem.greatestClosureOfSchema(upper) : upper;
-      }
-      return lower;
-    }
-  }
-
   /// Computes (or recomputes) a set of inferred types based on the constraints
   /// that have been recorded so far.
   List<TypeImpl> _chooseTypes({required bool preliminary}) {
@@ -579,13 +511,15 @@ class GenericInferrer {
       if (previouslyInferredType != null) {
         inferredTypes[i] = previouslyInferredType;
       } else if (preliminary) {
-        var inferredType = _inferTypeParameterFromContext(
-          constraint,
-          extendsClause,
-          isContravariant: typeParam.variance.isContravariant,
-          typeParameterToInfer: typeParam,
-          inferencePhaseConstraints: inferencePhaseConstraints,
-        );
+        var inferredType =
+            _inferTypeParameterFromContext(
+                  constraint,
+                  extendsClause,
+                  isContravariant: typeParam.variance.isContravariant,
+                  typeParameterToInfer: typeParam,
+                  inferencePhaseConstraints: inferencePhaseConstraints,
+                )
+                as TypeImpl;
 
         inferredTypes[i] = inferredType;
         if (typeParam.isLegacyCovariant &&
@@ -595,13 +529,15 @@ class GenericInferrer {
           _typesInferredSoFar[typeParam] = inferredType;
         }
       } else {
-        inferredTypes[i] = _inferTypeParameterFromAll(
-          constraint,
-          extendsClause,
-          isContravariant: typeParam.variance.isContravariant,
-          typeParameterToInfer: typeParam,
-          inferencePhaseConstraints: inferencePhaseConstraints,
-        );
+        inferredTypes[i] =
+            _inferTypeParameterFromAll(
+                  constraint,
+                  extendsClause,
+                  isContravariant: typeParam.variance.isContravariant,
+                  typeParameterToInfer: typeParam,
+                  inferencePhaseConstraints: inferencePhaseConstraints,
+                )
+                as TypeImpl;
       }
     }
 
@@ -667,7 +603,7 @@ class GenericInferrer {
         'Consider passing explicit type argument(s) to the generic.\n\n';
   }
 
-  TypeImpl _inferTypeParameterFromAll(
+  SharedType _inferTypeParameterFromAll(
     MergedTypeConstraint constraint,
     MergedTypeConstraint? extendsClause, {
     required bool isContravariant,
@@ -702,15 +638,15 @@ class GenericInferrer {
       ]);
     }
 
-    var choice = _chooseTypeFromConstraint(
+    var choice = _typeSystemOperations.chooseTypeFromConstraint(
       constraint,
-      toKnownType: true,
+      grounded: true,
       isContravariant: isContravariant,
     );
     return choice;
   }
 
-  TypeImpl _inferTypeParameterFromContext(
+  SharedType _inferTypeParameterFromContext(
     MergedTypeConstraint constraint,
     MergedTypeConstraint? extendsClause, {
     required bool isContravariant,
@@ -721,8 +657,9 @@ class GenericInferrer {
     // Both bits of the bound information should be available at the same time.
     assert(extendsClause == null || typeParameterToInfer.bound != null);
 
-    TypeImpl t = _chooseTypeFromConstraint(
+    SharedType t = _typeSystemOperations.chooseTypeFromConstraint(
       constraint,
+      grounded: false,
       isContravariant: isContravariant,
     );
     if (!_typeSystemOperations.isKnownType(SharedTypeSchemaView(t))) {
@@ -761,8 +698,9 @@ class GenericInferrer {
             !boundConstraint.isEmpty(_typeSystemOperations))
           boundConstraint,
       ]);
-      return _chooseTypeFromConstraint(
+      return _typeSystemOperations.chooseTypeFromConstraint(
         constraint,
+        grounded: false,
         isContravariant: isContravariant,
       );
     }

pkg/front_end/lib/src/type_inference/standard_bounds.dart

@@ -21,7 +21,7 @@ mixin TypeSchemaStandardBounds on StandardBounds {
   DartType leastClosureForUpperBound(DartType typeSchema) {
     //  - We replace all uses of `T1 <: T2` in the `UP` algorithm by `S1 <: S2`
     //  where `Si` is the least closure of `Ti` with respect to `_`.
-    return leastClosure(typeSchema, coreTypes: coreTypes);
+    return leastClosure(typeSchema, coreTypes: hierarchy.coreTypes);
   }
 
   @override

pkg/front_end/lib/src/type_inference/type_inference_engine.dart

@@ -1038,15 +1038,13 @@ class OperationsCfe
   @override
   SharedTypeView greatestClosureOfSchema(SharedTypeSchemaView schema,
       {SharedTypeView? topType}) {
-    return new SharedTypeView(
-        type_schema_elimination.greatestClosure(schema.unwrapTypeSchemaView(),
-            topType: topType?.unwrapTypeView() ??
-                // Coverage-ignore(suite): Not run.
-                typeEnvironment.coreTypes.objectNullableRawType));
+    return new SharedTypeView(type_schema_elimination.greatestClosure(
+        schema.unwrapTypeSchemaView(),
+        topType: topType?.unwrapTypeView() ??
+            typeEnvironment.coreTypes.objectNullableRawType));
   }
 
   @override
-  // Coverage-ignore(suite): Not run.
   SharedTypeView leastClosureOfSchema(SharedTypeSchemaView schema) {
     return new SharedTypeView(type_schema_elimination.leastClosure(
         schema.unwrapTypeSchemaView(),