Issue 44223. Improve diagnostics for type arguments violating type parameter bounds.

Bug: #44223
Change-Id: Ia3ffddbc7d2a1be8455f642c5799d21051eefb1d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/184524
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -140,6 +140,7 @@ class GenericInferrer {
       if (considerExtendsClause && bound != null) {
         extendsClause = _TypeConstraint.fromExtends(
           typeParam,
+          bound,
           Substitution.fromPairs(typeFormals, inferredTypes)
               .substituteType(bound),
           isNonNullableByDefault: isNonNullableByDefault,
@@ -164,38 +165,38 @@ class GenericInferrer {
     // Check the inferred types against all of the constraints.
     var knownTypes = <TypeParameterElement, DartType>{};
     for (int i = 0; i < typeFormals.length; i++) {
-      TypeParameterElement typeParam = typeFormals[i];
-      var constraints = _constraints[typeParam]!;
-
-      var typeParamBound = typeParam.bound;
-      if (typeParamBound != null) {
-        typeParamBound = Substitution.fromPairs(typeFormals, inferredTypes)
-            .substituteType(typeParamBound);
-        typeParamBound = _toLegacyElementIfOptOut(typeParamBound);
-      } else {
-        typeParamBound = typeProvider.dynamicType;
-      }
+      TypeParameterElement parameter = typeFormals[i];
+      var constraints = _constraints[parameter]!;
 
       var inferred = inferredTypes[i];
       bool success =
           constraints.every((c) => c.isSatisfiedBy(_typeSystem, inferred));
-      if (success && !typeParamBound.isDynamic) {
-        // If everything else succeeded, check the `extends` constraint.
-        var extendsConstraint = _TypeConstraint.fromExtends(
-          typeParam,
-          typeParamBound,
-          isNonNullableByDefault: isNonNullableByDefault,
-        );
-        constraints.add(extendsConstraint);
-        success = extendsConstraint.isSatisfiedBy(_typeSystem, inferred);
+
+      // If everything else succeeded, check the `extends` constraint.
+      if (success) {
+        var parameterBoundRaw = parameter.bound;
+        if (parameterBoundRaw != null) {
+          var parameterBound =
+              Substitution.fromPairs(typeFormals, inferredTypes)
+                  .substituteType(parameterBoundRaw);
+          parameterBound = _toLegacyElementIfOptOut(parameterBound);
+          var extendsConstraint = _TypeConstraint.fromExtends(
+            parameter,
+            parameterBoundRaw,
+            parameterBound,
+            isNonNullableByDefault: isNonNullableByDefault,
+          );
+          constraints.add(extendsConstraint);
+          success = extendsConstraint.isSatisfiedBy(_typeSystem, inferred);
+        }
       }
 
       if (!success) {
         if (failAtError) return null;
         errorReporter?.reportErrorForNode(
             CompileTimeErrorCode.COULD_NOT_INFER,
             errorNode!,
-            [typeParam.name, _formatError(typeParam, inferred, constraints)]);
+            [parameter.name, _formatError(parameter, inferred, constraints)]);
 
         // Heuristic: even if we failed, keep the erroneous type.
         // It should satisfy at least some of the constraints (e.g. the return
@@ -209,7 +210,7 @@ class GenericInferrer {
         var typeFormalsStr = typeFormals.map(_elementStr).join(', ');
         errorReporter?.reportErrorForNode(
             CompileTimeErrorCode.COULD_NOT_INFER, errorNode!, [
-          typeParam.name,
+          parameter.name,
           ' Inferred candidate type ${_typeStr(inferred)} has type parameters'
               ' [$typeFormalsStr], but a function with'
               ' type parameters cannot be used as a type argument.'
@@ -223,7 +224,7 @@ class GenericInferrer {
       }
 
       if (UnknownInferredType.isKnown(inferred)) {
-        knownTypes[typeParam] = inferred;
+        knownTypes[parameter] = inferred;
       } else if (_typeSystem.strictInference) {
         // [typeParam] could not be inferred. A result will still be returned
         // by [infer], with [typeParam] filled in as its bounds. This is
@@ -538,11 +539,12 @@ class _TypeConstraint extends _TypeRange {
       : super(upper: upper, lower: lower);
 
   _TypeConstraint.fromExtends(
-      TypeParameterElement element, DartType extendsType,
+      TypeParameterElement element, DartType boundType, DartType extendsType,
       {required bool isNonNullableByDefault})
       : this(
             _TypeConstraintFromExtendsClause(
               element,
+              boundType,
               extendsType,
               isNonNullableByDefault: isNonNullableByDefault,
             ),
@@ -601,17 +603,31 @@ class _TypeConstraintFromArgument extends _TypeConstraintOrigin {
 
 class _TypeConstraintFromExtendsClause extends _TypeConstraintOrigin {
   final TypeParameterElement typeParam;
+
+  /// The declared bound of [typeParam], not `null`, because we create
+  /// this clause only when it is not `null`.
+  ///
+  /// For example `Iterable<T>` for `<T, E extends Iterable<T>>`.
+  final DartType boundType;
+
+  /// [boundType] in which type parameters are substituted with inferred
+  /// type arguments.
+  ///
+  /// For example `Iterable<int>` if `T` inferred to `int`.
   final DartType extendsType;
 
-  _TypeConstraintFromExtendsClause(this.typeParam, this.extendsType,
+  _TypeConstraintFromExtendsClause(
+      this.typeParam, this.boundType, this.extendsType,
       {required bool isNonNullableByDefault})
       : super(isNonNullableByDefault: isNonNullableByDefault);
 
   @override
   List<String> formatError() {
+    var boundStr = _typeStr(boundType);
+    var extendsStr = _typeStr(extendsType);
     return [
       "Type parameter '${typeParam.name}'",
-      "declared to extend '${_typeStr(extendsType)}'."
+      "is declared to extend '$boundStr' producing '$extendsStr'."
     ];
   }
 }

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

@@ -223,15 +223,16 @@ class ExtensionMemberResolver {
   ) {
     if (typeArgumentList != null) {
       for (var i = 0; i < typeArgumentTypes.length; i++) {
-        var argType = typeArgumentTypes[i];
-        var boundType = typeParameters[i].bound;
-        if (boundType != null) {
-          boundType = substitution.substituteType(boundType);
-          if (!_typeSystem.isSubtypeOf(argType, boundType)) {
+        var argument = typeArgumentTypes[i];
+        var parameter = typeParameters[i];
+        var parameterBound = parameter.bound;
+        if (parameterBound != null) {
+          parameterBound = substitution.substituteType(parameterBound);
+          if (!_typeSystem.isSubtypeOf(argument, parameterBound)) {
             _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
               typeArgumentList.arguments[i],
-              [argType, boundType],
+              [argument, parameter.name, parameterBound],
             );
           }
         }

pkg/analyzer/lib/src/error/codes.dart

@@ -10801,7 +10801,8 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
    * Parameters:
    * 0: the name of the type used in the instance creation that should be
    *    limited by the bound as specified in the class declaration
-   * 1: the name of the bounding type
+   * 1: the name of the type parameter
+   * 2: the substituted bound of the type parameter
    */
   // #### Description
   //
@@ -10830,9 +10831,11 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
   // ```
   static const CompileTimeErrorCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS =
       CompileTimeErrorCode(
-          'TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', "'{0}' doesn't extend '{1}'.",
-          correction: "Try using a type that is or is a subclass of '{1}'.",
-          hasPublishedDocs: true);
+    'TYPE_ARGUMENT_NOT_MATCHING_BOUNDS',
+    "'{0}' doesn't conform to the bound '{2}' of the type parameter '{1}'.",
+    correction: "Try using a type that is or is a subclass of '{2}'.",
+    hasPublishedDocs: true,
+  );
 
   /**
    * No parameters.

pkg/analyzer/lib/src/error/type_arguments_verifier.dart

@@ -234,7 +234,7 @@ class TypeArgumentsVerifier {
       if (!_typeSystem.isSubtypeOf(typeArgument, bound)) {
         issues ??= <_TypeArgumentIssue>[];
         issues.add(
-          _TypeArgumentIssue(i, typeParameter, typeArgument),
+          _TypeArgumentIssue(i, typeParameter, bound, typeArgument),
         );
       }
     }
@@ -250,7 +250,7 @@ class TypeArgumentsVerifier {
         _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
           _typeArgumentErrorNode(typeName, issue.index),
-          [issue.argument, issue.parameter],
+          [issue.argument, issue.parameter.name, issue.parameterBound],
         );
       }
       return;
@@ -284,7 +284,7 @@ class TypeArgumentsVerifier {
         _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
           _typeArgumentErrorNode(typeName, i),
-          [typeArgument, bound],
+          [typeArgument, typeParameter.name, bound],
         );
       }
     }
@@ -361,7 +361,8 @@ class TypeArgumentsVerifier {
           continue;
         }
 
-        var rawBound = fnTypeParams[i].bound;
+        var fnTypeParam = fnTypeParams[i];
+        var rawBound = fnTypeParam.bound;
         if (rawBound == null) {
           continue;
         }
@@ -372,7 +373,7 @@ class TypeArgumentsVerifier {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
               typeArgumentList[i],
-              [argType, bound]);
+              [argType, fnTypeParam.name, bound]);
         }
       }
     }
@@ -457,14 +458,22 @@ class _TypeArgumentIssue {
   /// The type parameter with the bound that was violated.
   final TypeParameterElement parameter;
 
-  /// The type argument that violated the bound.
+  /// The substituted bound of the [parameter].
+  final DartType parameterBound;
+
+  /// The type argument that violated the [parameterBound].
   final DartType argument;
 
-  _TypeArgumentIssue(this.index, this.parameter, this.argument);
+  _TypeArgumentIssue(
+    this.index,
+    this.parameter,
+    this.parameterBound,
+    this.argument,
+  );
 
   @override
   String toString() {
     return 'TypeArgumentIssue(index=$index, parameter=$parameter, '
-        'argument=$argument)';
+        'parameterBound=$parameterBound, argument=$argument)';
   }
 }

pkg/analyzer/test/generated/strong_mode_test.dart

@@ -1252,7 +1252,7 @@ test() {
 Couldn't infer type parameter 'T'.
 
 Tried to infer 'String' for 'T' which doesn't work:
-  Type parameter 'T' declared to extend 'num'.
+  Type parameter 'T' is declared to extend 'num' producing 'num'.
 The type 'String' was inferred from:
   Return type declared as 'T Function(T)'
               used where  'String Function(String)' is required.