[model] Share inferTypeParameterFromAll between Analyzer and CFE

Part of #54902

Change-Id: I2b9da9868925dbdede49d5a11f8b0558400886e3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/445060
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

@@ -807,6 +807,29 @@ abstract interface class TypeAnalyzerOperations<
     required bool grounded,
     required bool isContravariant,
   });
+
+  /// Chooses types from all available sources at the final stage of inference.
+  SharedType inferTypeParameterFromAll(
+    SharedType? typeFromPreviousInference,
+    MergedTypeConstraint<Variable, TypeDeclarationType, TypeDeclaration>
+    constraint,
+    SharedType? extendsConstraint, {
+    bool isContravariant = false,
+    bool isLegacyCovariant = true,
+    required Map<
+      SharedTypeParameter,
+      MergedTypeConstraint<Variable, TypeDeclarationType, TypeDeclaration>
+    >
+    constraints,
+    required SharedTypeParameter typeParameterToInfer,
+    required List<SharedTypeParameter> typeParametersToInfer,
+    required TypeConstraintGenerationDataForTesting<Variable, Object>?
+    dataForTesting,
+    required bool inferenceUsingBoundsIsEnabled,
+  });
+
+  /// True if [typeParameter] doesn't have an explicit bound.
+  bool isBoundOmitted(SharedTypeParameter typeParameter);
 }
 
 mixin TypeAnalyzerOperationsMixin<
@@ -1178,6 +1201,66 @@ mixin TypeAnalyzerOperationsMixin<
       }
     }
   }
+
+  @override
+  SharedType inferTypeParameterFromAll(
+    SharedType? typeFromPreviousInference,
+    MergedTypeConstraint<Variable, TypeDeclarationType, TypeDeclaration>
+    constraint,
+    SharedType? extendsConstraint, {
+    bool isContravariant = false,
+    bool isLegacyCovariant = true,
+    required Map<
+      SharedTypeParameter,
+      MergedTypeConstraint<Variable, TypeDeclarationType, TypeDeclaration>
+    >
+    constraints,
+    required SharedTypeParameter typeParameterToInfer,
+    required List<SharedTypeParameter> typeParametersToInfer,
+    required TypeConstraintGenerationDataForTesting<Variable, Object>?
+    dataForTesting,
+    required bool inferenceUsingBoundsIsEnabled,
+  }) {
+    // See if we already fixed this type in a previous inference step.
+    // If so, then we aren't allowed to change it unless [isLegacyCovariant] is
+    // false.
+    if (typeFromPreviousInference != null &&
+        isLegacyCovariant &&
+        isKnownType(new SharedTypeSchemaView(typeFromPreviousInference))) {
+      return typeFromPreviousInference;
+    }
+
+    if (inferenceUsingBoundsIsEnabled &&
+        constraint.lower is! SharedUnknownTypeSchemaView &&
+        !isBoundOmitted(typeParameterToInfer)) {
+      MergedTypeConstraint constraintFromBound = mergeInConstraintsFromBound(
+        typeParameterToInfer: typeParameterToInfer,
+        typeParametersToInfer:
+            typeParametersToInfer.cast<SharedTypeParameterView>(),
+        lower: constraint.lower.unwrapTypeSchemaView(),
+        inferencePhaseConstraints: constraints,
+        dataForTesting: dataForTesting,
+        inferenceUsingBoundsIsEnabled: inferenceUsingBoundsIsEnabled,
+      );
+
+      constraint.mergeInTypeSchemaUpper(constraintFromBound.upper, this);
+      constraint.mergeInTypeSchemaLower(constraintFromBound.lower, this);
+    }
+
+    if (extendsConstraint != null) {
+      constraint = constraint.clone();
+      constraint.mergeInTypeSchemaUpper(
+        new SharedTypeSchemaView(extendsConstraint),
+        this,
+      );
+    }
+
+    return chooseTypeFromConstraint(
+      constraint,
+      grounded: true,
+      isContravariant: isContravariant,
+    );
+  }
 }
 
 /// Abstract interface of a type constraint generator.

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -3713,6 +3713,12 @@ class MiniAstOperations
     // TODO(paulberry): Implement leastClosureOfSchema in mini ast.
     throw UnimplementedError();
   }
+
+  @override
+  bool isBoundOmitted(SharedTypeParameter typeParameter) {
+    // TODO(paulberry): Implement isBoundOmitted in mini ast.
+    throw UnimplementedError();
+  }
 }
 
 /// Representation of an expression or statement in the pseudo-Dart language

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

@@ -530,12 +530,16 @@ class GenericInferrer {
         }
       } else {
         inferredTypes[i] =
-            _inferTypeParameterFromAll(
+            _typeSystemOperations.inferTypeParameterFromAll(
+                  previouslyInferredType,
                   constraint,
-                  extendsClause,
+                  extendsClause?.upper.unwrapTypeSchemaView(),
                   isContravariant: typeParam.variance.isContravariant,
                   typeParameterToInfer: typeParam,
-                  inferencePhaseConstraints: inferencePhaseConstraints,
+                  constraints: inferencePhaseConstraints,
+                  dataForTesting: null,
+                  inferenceUsingBoundsIsEnabled: inferenceUsingBoundsIsEnabled,
+                  typeParametersToInfer: _typeFormals,
                 )
                 as TypeImpl;
       }
@@ -603,49 +607,6 @@ class GenericInferrer {
         'Consider passing explicit type argument(s) to the generic.\n\n';
   }
 
-  SharedType _inferTypeParameterFromAll(
-    MergedTypeConstraint constraint,
-    MergedTypeConstraint? extendsClause, {
-    required bool isContravariant,
-    required TypeParameterElementImpl typeParameterToInfer,
-    required Map<TypeParameterElementImpl, MergedTypeConstraint>
-    inferencePhaseConstraints,
-  }) {
-    if (extendsClause != null) {
-      MergedTypeConstraint? boundConstraint;
-      if (inferenceUsingBoundsIsEnabled) {
-        if (!identical(
-          constraint.lower.unwrapTypeSchemaView(),
-          UnknownInferredType.instance,
-        )) {
-          boundConstraint = _typeSystemOperations.mergeInConstraintsFromBound(
-            typeParameterToInfer: typeParameterToInfer,
-            typeParametersToInfer: _typeFormals.cast<SharedTypeParameterView>(),
-            lower: constraint.lower.unwrapTypeSchemaView(),
-            inferencePhaseConstraints: inferencePhaseConstraints,
-            dataForTesting: dataForTesting,
-            inferenceUsingBoundsIsEnabled: inferenceUsingBoundsIsEnabled,
-          );
-        }
-      }
-
-      constraint = _squashConstraints([
-        constraint,
-        extendsClause,
-        if (boundConstraint != null &&
-            !boundConstraint.isEmpty(_typeSystemOperations))
-          boundConstraint,
-      ]);
-    }
-
-    var choice = _typeSystemOperations.chooseTypeFromConstraint(
-      constraint,
-      grounded: true,
-      isContravariant: isContravariant,
-    );
-    return choice;
-  }
-
   SharedType _inferTypeParameterFromContext(
     MergedTypeConstraint constraint,
     MergedTypeConstraint? extendsClause, {

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

@@ -636,6 +636,11 @@ class TypeSystemOperations
     return type.unwrapTypeView<TypeImpl>().isBottom;
   }
 
+  @override
+  bool isBoundOmitted(SharedTypeParameter typeParameter) {
+    return typeParameter.boundShared == null;
+  }
+
   @override
   bool isDartCoreFunctionInternal(TypeImpl type) {
     return type.nullabilitySuffix == NullabilitySuffix.none &&

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

@@ -1055,6 +1055,23 @@ class OperationsCfe
         schema.unwrapTypeSchemaView(),
         coreTypes: typeEnvironment.coreTypes));
   }
+
+  @override
+  bool isBoundOmitted(covariant StructuralParameter structuralParameter) {
+    // If the bound was omitted by the programmer, the Kernel representation for
+    // the parameter will look similar to the following:
+    //
+    //     T extends Object = dynamic
+    //
+    // Note that it's not possible to receive [Object] as [TypeParameter.bound]
+    // and `dynamic` as [TypeParameter.defaultType] from the front end in any
+    // other way.
+    DartType bound = structuralParameter.bound;
+    return bound is InterfaceType &&
+        identical(bound.classReference,
+            typeEnvironment.coreTypes.objectClass.reference) &&
+        structuralParameter.defaultType is DynamicType;
+  }
 }
 
 /// Type inference results used for testing.

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

@@ -130,21 +130,6 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
     return operandType;
   }
 
-  bool hasOmittedBound(StructuralParameter parameter) {
-    // If the bound was omitted by the programmer, the Kernel representation for
-    // the parameter will look similar to the following:
-    //
-    //     T extends Object = dynamic
-    //
-    // Note that it's not possible to receive [Object] as [TypeParameter.bound]
-    // and `dynamic` as [TypeParameter.defaultType] from the front end in any
-    // other way.
-    DartType bound = parameter.bound;
-    return bound is InterfaceType &&
-        identical(bound.classReference, coreTypes.objectClass.reference) &&
-        parameter.defaultType is DynamicType;
-  }
-
   /// Use the given [constraints] to substitute for type parameters.
   ///
   /// [typeParametersToInfer] is the set of type parameters that should be
@@ -175,7 +160,7 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
 
       DartType typeParamBound = typeParam.bound;
       DartType? extendsConstraint;
-      if (!hasOmittedBound(typeParam)) {
+      if (!operations.isBoundOmitted(typeParam)) {
         extendsConstraint = new FunctionTypeInstantiator.fromIterables(
                 typeParametersToInfer, inferredTypes)
             .substitute(typeParamBound);
@@ -194,12 +179,11 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
                 inferenceUsingBoundsIsEnabled: inferenceUsingBoundsIsEnabled)
             as DartType;
       } else {
-        inferredTypes[i] = _inferTypeParameterFromAll(
+        inferredTypes[i] = operations.inferTypeParameterFromAll(
                 previouslyInferredTypes?[i], constraint, extendsConstraint,
                 isContravariant:
                     typeParam.variance == shared.Variance.contravariant,
                 isLegacyCovariant: typeParam.isLegacyCovariant,
-                operations: operations,
                 constraints: constraints,
                 typeParameterToInfer: typeParam,
                 typeParametersToInfer: typeParametersToInfer,
@@ -366,53 +350,6 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
     return inferredTypes;
   }
 
-  SharedType _inferTypeParameterFromAll(DartType? typeFromPreviousInference,
-      MergedTypeConstraint constraint, DartType? extendsConstraint,
-      {bool isContravariant = false,
-      bool isLegacyCovariant = true,
-      required OperationsCfe operations,
-      required Map<StructuralParameter, MergedTypeConstraint> constraints,
-      required StructuralParameter typeParameterToInfer,
-      required List<StructuralParameter> typeParametersToInfer,
-      required InferenceDataForTesting? dataForTesting,
-      required bool inferenceUsingBoundsIsEnabled}) {
-    // See if we already fixed this type in a previous inference step.
-    // If so, then we aren't allowed to change it unless [isLegacyCovariant] is
-    // false.
-    if (typeFromPreviousInference != null &&
-        isLegacyCovariant &&
-        operations
-            .isKnownType(new SharedTypeSchemaView(typeFromPreviousInference))) {
-      return typeFromPreviousInference;
-    }
-
-    if (inferenceUsingBoundsIsEnabled &&
-        constraint.lower is! SharedUnknownTypeSchemaView &&
-        !hasOmittedBound(typeParameterToInfer)) {
-      MergedTypeConstraint constraintFromBound =
-          operations.mergeInConstraintsFromBound(
-              typeParameterToInfer: typeParameterToInfer,
-              typeParametersToInfer:
-                  typeParametersToInfer.cast<SharedTypeParameterView>(),
-              lower: constraint.lower.unwrapTypeSchemaView<DartType>(),
-              inferencePhaseConstraints: constraints,
-              dataForTesting: dataForTesting,
-              inferenceUsingBoundsIsEnabled: inferenceUsingBoundsIsEnabled);
-
-      constraint.mergeInTypeSchemaUpper(constraintFromBound.upper, operations);
-      constraint.mergeInTypeSchemaLower(constraintFromBound.lower, operations);
-    }
-
-    if (extendsConstraint != null) {
-      constraint = constraint.clone();
-      constraint.mergeInTypeSchemaUpper(
-          new SharedTypeSchemaView(extendsConstraint), operations);
-    }
-
-    return operations.chooseTypeFromConstraint(constraint,
-        grounded: true, isContravariant: isContravariant);
-  }
-
   SharedType _inferTypeParameterFromContext(DartType? typeFromPreviousInference,
       MergedTypeConstraint constraint, DartType? extendsConstraint,
       {bool isLegacyCovariant = true,
@@ -448,7 +385,7 @@ class TypeSchemaEnvironment extends HierarchyBasedTypeEnvironment
 
     if (inferenceUsingBoundsIsEnabled &&
         constraint.lower is! SharedUnknownTypeSchemaView &&
-        !hasOmittedBound(typeParameterToInfer)) {
+        !operations.isBoundOmitted(typeParameterToInfer)) {
       // Coverage-ignore-block(suite): Not run.
       MergedTypeConstraint constraintFromBound =
           operations.mergeInConstraintsFromBound(