Verify that function reference type arguments match bounds

Bug: #46233
Change-Id: Id83a1fbbb058ed04c4433a380ed08799b047c11e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/204520
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: srawlins

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

@@ -167,9 +167,6 @@ class FunctionReferenceResolver {
     var invokeType = rawType.instantiate(typeArguments);
     node.typeArgumentTypes = typeArguments;
     node.staticType = invokeType;
-
-    // TODO(srawlins): Verify that type arguments conform to bounds. This will
-    // probably be done later, not in this resolution phase.
   }
 
   void _resolveFunctionReferenceMethod({

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

@@ -33,10 +33,22 @@ class TypeArgumentsVerifier {
       _libraryElement.typeSystem as TypeSystemImpl;
 
   void checkFunctionExpressionInvocation(FunctionExpressionInvocation node) {
-    _checkTypeArguments(node);
+    _checkTypeArguments(
+      node.typeArguments?.arguments,
+      node.function.staticType,
+      node.staticInvokeType,
+    );
     _checkForImplicitDynamicInvoke(node);
   }
 
+  void checkFunctionReference(FunctionReference node) {
+    _checkTypeArguments(
+      node.typeArguments?.arguments,
+      node.function.staticType,
+      node.staticType,
+    );
+  }
+
   void checkListLiteral(ListLiteral node) {
     var typeArguments = node.typeArguments;
     if (typeArguments != null) {
@@ -68,7 +80,11 @@ class TypeArgumentsVerifier {
   }
 
   void checkMethodInvocation(MethodInvocation node) {
-    _checkTypeArguments(node);
+    _checkTypeArguments(
+      node.typeArguments?.arguments,
+      node.function.staticType,
+      node.staticInvokeType,
+    );
     _checkForImplicitDynamicInvoke(node);
   }
 
@@ -324,63 +340,65 @@ class TypeArgumentsVerifier {
     }
   }
 
-  /// Verify that the given [typeArguments] are all within their bounds, as
-  /// defined by the given [element].
-  void _checkTypeArguments(InvocationExpression node) {
-    var typeArgumentList = node.typeArguments?.arguments;
+  /// Verify that each type argument in [typeArgumentList] is within its bounds,
+  /// as defined by [genericType].
+  void _checkTypeArguments(
+    List<TypeAnnotation>? typeArgumentList,
+    DartType? genericType,
+    DartType? instantiatedType,
+  ) {
     if (typeArgumentList == null) {
       return;
     }
 
-    var genericType = node.function.staticType;
-    var instantiatedType = node.staticInvokeType;
-    if (genericType is FunctionType && instantiatedType is FunctionType) {
-      var fnTypeParams = genericType.typeFormals;
-      var typeArgs = typeArgumentList.map((t) => t.typeOrThrow).toList();
-
-      // If the amount mismatches, clean up the lists to be substitutable. The
-      // mismatch in size is reported elsewhere, but we must successfully
-      // perform substitution to validate bounds on mismatched lists.
-      final providedLength = math.min(typeArgs.length, fnTypeParams.length);
-      fnTypeParams = fnTypeParams.sublist(0, providedLength);
-      typeArgs = typeArgs.sublist(0, providedLength);
-
-      for (int i = 0; i < providedLength; i++) {
-        // Check the `extends` clause for the type parameter, if any.
-        //
-        // Also substitute to handle cases like this:
-        //
-        //     <TFrom, TTo extends TFrom>
-        //     <TFrom, TTo extends Iterable<TFrom>>
-        //     <T extends Cloneable<T>>
-        //
-        DartType argType = typeArgs[i];
-
-        if (argType is FunctionType && argType.typeFormals.isNotEmpty) {
-          if (!_libraryElement.featureSet.isEnabled(Feature.generic_metadata)) {
-            _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode
-                  .GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT,
-              typeArgumentList[i],
-            );
-            continue;
-          }
-        }
+    if (genericType is! FunctionType || instantiatedType is! FunctionType) {
+      return;
+    }
 
-        var fnTypeParam = fnTypeParams[i];
-        var rawBound = fnTypeParam.bound;
-        if (rawBound == null) {
+    var fnTypeParams = genericType.typeFormals;
+    var typeArgs = typeArgumentList.map((t) => t.typeOrThrow).toList();
+
+    // If the amount mismatches, clean up the lists to be substitutable. The
+    // mismatch in size is reported elsewhere, but we must successfully
+    // perform substitution to validate bounds on mismatched lists.
+    var providedLength = math.min(typeArgs.length, fnTypeParams.length);
+    fnTypeParams = fnTypeParams.sublist(0, providedLength);
+    typeArgs = typeArgs.sublist(0, providedLength);
+
+    for (int i = 0; i < providedLength; i++) {
+      // Check the `extends` clause for the type parameter, if any.
+      //
+      // Also substitute to handle cases like this:
+      //
+      //     <TFrom, TTo extends TFrom>
+      //     <TFrom, TTo extends Iterable<TFrom>>
+      //     <T extends Cloneable<T>>
+      //
+      DartType argType = typeArgs[i];
+
+      if (argType is FunctionType && argType.typeFormals.isNotEmpty) {
+        if (!_libraryElement.featureSet.isEnabled(Feature.generic_metadata)) {
+          _errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.GENERIC_FUNCTION_TYPE_CANNOT_BE_TYPE_ARGUMENT,
+            typeArgumentList[i],
+          );
           continue;
         }
+      }
 
-        var substitution = Substitution.fromPairs(fnTypeParams, typeArgs);
-        var bound = substitution.substituteType(rawBound);
-        if (!_typeSystem.isSubtypeOf(argType, bound)) {
-          _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
-              typeArgumentList[i],
-              [argType, fnTypeParam.name, bound]);
-        }
+      var fnTypeParam = fnTypeParams[i];
+      var rawBound = fnTypeParam.bound;
+      if (rawBound == null) {
+        continue;
+      }
+
+      var substitution = Substitution.fromPairs(fnTypeParams, typeArgs);
+      var bound = substitution.substituteType(rawBound);
+      if (!_typeSystem.isSubtypeOf(argType, bound)) {
+        _errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
+            typeArgumentList[i],
+            [argType, fnTypeParam.name, bound]);
       }
     }
   }

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -756,6 +756,11 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     super.visitFunctionExpressionInvocation(node);
   }
 
+  @override
+  void visitFunctionReference(FunctionReference node) {
+    _typeArgumentsVerifier.checkFunctionReference(node);
+  }
+
   @override
   void visitFunctionTypeAlias(FunctionTypeAlias node) {
     _checkForBuiltInIdentifierAsName(

pkg/analyzer/test/src/diagnostics/type_argument_not_matching_bounds_test.dart

@@ -451,6 +451,32 @@ main() {
 ''');
   }
 
+  test_functionReference() async {
+    await assertErrorsInCode('''
+void bar(void Function<T extends num>(T a) foo) {
+  foo<String>;
+}
+''', [
+      error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 56, 6),
+    ]);
+  }
+
+  test_functionReference_matching() async {
+    await assertNoErrorsInCode('''
+void bar(void Function<T extends num>(T a) foo) {
+  foo<int>;
+}
+''');
+  }
+
+  test_functionReference_regularBounded() async {
+    await assertNoErrorsInCode('''
+void bar(void Function<T>(T a) foo) {
+  foo<String>;
+}
+''');
+  }
+
   test_genericFunctionTypeArgument_invariant() async {
     await assertErrorsInCode(r'''
 typedef F = T Function<T>(T);