analyzer: Report bad type arg on implicit call

Fixes #49671

Also adds many more test cases for bad implicit 'call' calls.

Change-Id: I87a50c1b527c66e6a75b07087ccdb195a862b1fd
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/400744
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: srawlins

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

@@ -155,9 +155,15 @@ class TypeArgumentsVerifier {
   }
 
   void checkFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    // For some function expressions, like an implicit 'call' invocation, the
+    // function type is on `node`'s `element`. For anonymous function
+    // expressions, the function is on `node`'s `function`.
+    // TODO(srawlins): It seems that `node.function`, the Expression, should
+    // always have the static type of the `call` method.
+    var functionType = node.element?.type ?? node.function.staticType;
     _checkInvocationTypeArguments(
       node.typeArguments?.arguments,
-      node.function.staticType,
+      functionType,
       node.staticInvokeType,
     );
   }

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

@@ -1011,16 +1011,13 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
 
   @override
   void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
-    Expression functionExpression = node.function;
+    var functionExpression = node.function;
 
     if (functionExpression is ExtensionOverride) {
       return super.visitFunctionExpressionInvocation(node);
     }
 
-    DartType expressionType = functionExpression.typeOrThrow;
-    if (expressionType is FunctionType) {
-      _typeArgumentsVerifier.checkFunctionExpressionInvocation(node);
-    }
+    _typeArgumentsVerifier.checkFunctionExpressionInvocation(node);
     _requiredParametersVerifier.visitFunctionExpressionInvocation(node);
     _constArgumentsVerifier.visitFunctionExpressionInvocation(node);
     _checkUseVerifier.checkFunctionExpressionInvocation(node);

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

@@ -1799,14 +1799,14 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     }
   }
 
-  /// Returns the result of an implicit `this.` lookup for the identifier string
-  /// [id] in a getter context, or `null` if no match was found.
+  /// Returns the result of an implicit `this.` lookup for the identifier [node]
+  /// in a getter context, or `null` if no match was found.
   LexicalLookupResult? thisLookupGetter(SimpleIdentifier node) {
     return ThisLookup.lookupGetter(this, node);
   }
 
-  /// Returns the result of an implicit `this.` lookup for the identifier string
-  /// [id] in a setter context, or `null` if no match was found.
+  /// Returns the result of an implicit `this.` lookup for the identifier [node]
+  /// in a setter context, or `null` if no match was found.
   LexicalLookupResult? thisLookupSetter(SimpleIdentifier node) {
     return ThisLookup.lookupSetter(this, node);
   }

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

@@ -166,6 +166,30 @@ class C {
     ]);
   }
 
+  test_functionExpressionInvocation() async {
+    await assertErrorsInCode(r'''
+void f() {
+  (<T extends num>() {})<String>();
+}
+''', [
+      error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 36, 6),
+    ]);
+  }
+
+  test_functionExpressionInvocation_implicitCall() async {
+    await assertErrorsInCode(r'''
+class C {
+  void call<T extends num>() {}
+}
+
+void f(C c) {
+  c<String>();
+}
+''', [
+      error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 63, 6),
+    ]);
+  }
+
   test_functionReference() async {
     await assertErrorsInCode('''
 void foo<T extends num>(T a) {}

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

@@ -94,6 +94,56 @@ dynamic<int> v;
     ]);
   }
 
+  test_functionInvocation_tooFew() async {
+    await assertErrorsInCode('''
+void f() {
+  g<int>();
+}
+void g<T, U>() {}
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD, 14, 5),
+    ]);
+  }
+
+  test_functionInvocation_tooMany() async {
+    await assertErrorsInCode('''
+void f() {
+  g<int, String>();
+}
+void g<T>() {}
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD, 14, 13),
+    ]);
+  }
+
+  test_functionReference_implicitCallTearoff_tooFew() async {
+    await assertErrorsInCode('''
+f(C c) {
+  c<int>;
+}
+class C {
+  void call<T, U>() {}
+}
+''', [
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 12, 5),
+    ]);
+  }
+
+  test_functionReference_implicitCallTearoff_tooMany() async {
+    await assertErrorsInCode('''
+f(C c) {
+  c<int, String>;
+}
+class C {
+  void call<T>() {}
+}
+''', [
+      error(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_FUNCTION, 12, 13),
+    ]);
+  }
+
   test_functionReference_tooFew() async {
     await assertErrorsInCode('''
 f() {
@@ -227,6 +277,32 @@ void f() {}
     ]);
   }
 
+  test_methodInvocation_tooFew() async {
+    await assertErrorsInCode('''
+void f(C c) {
+  c.g<int>();
+}
+class C {
+  void g<T, U>() {}
+}
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD, 19, 5),
+    ]);
+  }
+
+  test_methodInvocation_tooMany() async {
+    await assertErrorsInCode('''
+void f(C c) {
+  c.g<int, String>();
+}
+class C {
+  void g<T>() {}
+}
+''', [
+      error(CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD, 19, 13),
+    ]);
+  }
+
   test_new_nonGeneric() async {
     await assertErrorsInCode('''
 class C {}