[analyzer][cfe] Share constraint generation from bounded parameters

Part of #54902

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

@@ -434,6 +434,27 @@ abstract interface class TypeAnalyzerOperations<
   /// step too.
   TypeStructure? matchFutureOrInternal(TypeStructure type);
 
+  /// If [type] is a parameter type with empty nullability suffix, returns its
+  /// bound, whether it is its type parameter bound or its promoted bound.
+  /// Otherwise, returns null.
+  ///
+  /// In the example below matching the appearance of `X` in the parameters of
+  /// `foo` returns `num`, matching the appearance of `Y` in the parameters of
+  /// the function type `int Function<Y extends Object>(Y)` returns `Object`,
+  /// and matching the inferred type of the variable `z`, which is `X & int`,
+  /// `X` promoted to `int`, returns `int`. Matching a non-type parameter type,
+  /// such as `int`, would return null.
+  ///
+  ///   int foo<X extends num>(int Function<Y extends Object>(Y) f, X x) {
+  ///     if (x is int) {
+  ///       var z = x;
+  ///       return z;
+  ///     } else {
+  ///       return f(x);
+  ///     }
+  ///   }
+  TypeStructure? matchTypeParameterBoundInternal(TypeStructure type);
+
   /// If [type] is a parameter type that is of a kind used in type inference,
   /// returns the corresponding parameter.
   ///

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -3297,6 +3297,20 @@ class MiniAstOperations
     // TODO(paulberry): Implement greatest closure of types in mini ast.
     throw UnimplementedError();
   }
+
+  @override
+  Type? matchTypeParameterBoundInternal(Type type) {
+    if (type
+        case TypeParameterType(
+          :var promotion,
+          :var typeParameter,
+          nullabilitySuffix: NullabilitySuffix.none
+        )) {
+      return promotion ?? typeParameter.bound;
+    } else {
+      return null;
+    }
+  }
 }
 
 /// Representation of an expression or statement in the pseudo-Dart language

pkg/_fe_analyzer_shared/test/type_inference/type_constraint_gatherer_test.dart

@@ -828,6 +828,33 @@ main() {
       check(tcg._constraints).isEmpty();
     });
   });
+
+  group('matchTypeParameterBoundInternal', () {
+    test('Non-promoted parameter on LHS', () {
+      var tcg = _TypeConstraintGatherer({'T'});
+      check(tcg.performSubtypeConstraintGenerationInternal(
+              TypeParameterType(TypeRegistry.addTypeParameter('X')
+                ..bound = Type('Future<String>')),
+              Type('Future<T>'),
+              leftSchema: false,
+              astNodeForTesting: Node.placeholder()))
+          .isTrue();
+      check(tcg._constraints).unorderedEquals(['String <: T']);
+    });
+
+    test('Promoted parameter on LHS', () {
+      var tcg = _TypeConstraintGatherer({'T'});
+      check(tcg.performSubtypeConstraintGenerationInternal(
+              TypeParameterType(
+                  TypeRegistry.addTypeParameter('X')..bound = Type('Object'),
+                  promotion: Type('Future<num>')),
+              Type('Future<T>'),
+              leftSchema: false,
+              astNodeForTesting: Node.placeholder()))
+          .isTrue();
+      check(tcg._constraints).unorderedEquals(['num <: T']);
+    });
+  });
 }
 
 class _TypeConstraintGatherer extends TypeConstraintGenerator<Type,
@@ -948,6 +975,14 @@ class _TypeConstraintGatherer extends TypeConstraintGenerator<Type,
       return true;
     }
 
+    if (typeAnalyzerOperations.matchTypeParameterBoundInternal(p)
+        case var bound?) {
+      if (performSubtypeConstraintGenerationInternal(bound, q,
+          leftSchema: leftSchema, astNodeForTesting: astNodeForTesting)) {
+        return true;
+      }
+    }
+
     bool? result = performSubtypeConstraintGenerationForTypeDeclarationTypes(
         p, q,
         leftSchema: leftSchema, astNodeForTesting: astNodeForTesting);

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

@@ -14,7 +14,6 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
-import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_schema.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
@@ -326,10 +325,10 @@ class TypeConstraintGatherer extends shared.TypeConstraintGenerator<
     // variable `X & B`), the match holds with constraint set `C`:
     //   If `B` is a subtype match for `Q` with constraint set `C`.
     // Note: we have already eliminated the case that `X` is a variable in `L`.
-    if (P_nullability == NullabilitySuffix.none && P is TypeParameterTypeImpl) {
-      var B = P.promotedBound ?? P.element.bound;
-      if (B != null &&
-          trySubtypeMatch(B, Q, leftSchema, nodeForTesting: nodeForTesting)) {
+    if (typeAnalyzerOperations.matchTypeParameterBoundInternal(P)
+        case var bound?) {
+      if (performSubtypeConstraintGenerationInternal(bound, Q,
+          leftSchema: leftSchema, astNodeForTesting: nodeForTesting)) {
         return true;
       }
     }

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

@@ -736,6 +736,16 @@ class TypeSystemOperations
     }
   }
 
+  @override
+  DartType? matchTypeParameterBoundInternal(DartType type) {
+    if (type is TypeParameterTypeImpl &&
+        type.nullabilitySuffix == NullabilitySuffix.none) {
+      return type.promotedBound ?? type.element.bound;
+    } else {
+      return null;
+    }
+  }
+
   @override
   SharedTypeView<DartType> normalize(SharedTypeView<DartType> type) {
     return SharedTypeView(typeSystem.normalize(type.unwrapTypeView()));

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

@@ -428,17 +428,11 @@ class TypeConstraintGatherer extends shared.TypeConstraintGenerator<
     //
     // If B is a subtype match for Q with constraint set C.  Note that we have
     // already eliminated the case that X is a variable in L.
-    if (p is TypeParameterType) {
-      if (_isNullabilityAwareSubtypeMatch(p.bound, q,
-          constrainSupertype: constrainSupertype,
-          treeNodeForTesting: treeNodeForTesting)) {
-        return true;
-      }
-    } else if (p is StructuralParameterType) {
-      // Coverage-ignore-block(suite): Not run.
-      if (_isNullabilityAwareSubtypeMatch(p.bound, q,
-          constrainSupertype: constrainSupertype,
-          treeNodeForTesting: treeNodeForTesting)) {
+    if (typeAnalyzerOperations.matchTypeParameterBoundInternal(p)
+        case DartType bound?) {
+      if (performSubtypeConstraintGenerationInternal(bound, q,
+          leftSchema: constrainSupertype,
+          astNodeForTesting: treeNodeForTesting)) {
         return true;
       }
     }

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

@@ -1013,6 +1013,23 @@ class OperationsCfe
                 .functionRawType(Nullability.nonNullable))
         .eliminateToLeast(type);
   }
+
+  @override
+  DartType? matchTypeParameterBoundInternal(DartType type) {
+    if (type.nullabilitySuffix != NullabilitySuffix.none) {
+      return null;
+    }
+    if (type is TypeParameterType) {
+      return type.parameter.bound;
+    } else if (type is StructuralParameterType) {
+      // Coverage-ignore-block(suite): Not run.
+      return type.parameter.bound;
+    } else if (type is IntersectionType) {
+      return type.right;
+    } else {
+      return null;
+    }
+  }
 }
 
 /// Type inference results used for testing.

pkg/front_end/test/coverage_suite_expected.dart

@@ -1046,7 +1046,7 @@ const Map<String, ({int hitCount, int missCount})> _expect = {
   ),
   // 100.0%.
   "package:front_end/src/type_inference/type_inference_engine.dart": (
-    hitCount: 536,
+    hitCount: 545,
     missCount: 0,
   ),
   // 100.0%.