Analyzer function refs: report more disallowed instantiations

Only the following short list of elements are allowed to be type-
instantiated: top-level function, local function, instance method,
constructor, type.

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

Author: srawlins

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

@@ -225,7 +225,11 @@ class FunctionReferenceResolver {
       // Continue to resolve type.
     }
 
-    // TODO(srawlins): If PropertyAccessorElement, report error.
+    if (member is PropertyAccessorElement) {
+      function.accept(_resolver);
+      _resolveDisallowedExpression(node, member.returnType);
+      return;
+    }
 
     _resolve(node: node, rawType: member.type, name: propertyName.name);
   }
@@ -298,9 +302,11 @@ class FunctionReferenceResolver {
       return;
     }
 
-    // TODO(srawlins): Need to report cases where [methodElement] is not
-    // generic. The 'test_instanceGetter_explicitReceiver' test case needs to
-    // be updated to handle this.
+    if (methodElement is PropertyAccessorElement) {
+      function.accept(_resolver);
+      _resolveDisallowedExpression(node, methodElement.returnType);
+      return;
+    }
 
     function.accept(_resolver);
     node.staticType = DynamicTypeImpl.instance;
@@ -388,8 +394,6 @@ class FunctionReferenceResolver {
     PrefixedIdentifier prefix,
     Element element,
   ) {
-    // TODO(srawlins): Handle `loadLibrary`, as in `p.loadLibrary<int>;`.
-
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiply = element;
       element = multiply.conflictingElements[0];
@@ -472,17 +476,25 @@ class FunctionReferenceResolver {
           // Continue to assign types.
         }
 
+        if (method is PropertyAccessorElement) {
+          _resolveDisallowedExpression(node, method.returnType);
+          return;
+        }
+
         function.staticElement = method;
         function.staticType = method.type;
         _resolve(node: node, rawType: method.type, name: function.name);
         return;
       } else {
-        // TODO(srawlins): Report CompileTimeErrorCode.UNDEFINED_METHOD.
+        _resolver.errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.UNDEFINED_METHOD,
+          function,
+          [function.name, enclosingClass],
+        );
+        function.staticType = DynamicTypeImpl.instance;
+        node.staticType = DynamicTypeImpl.instance;
         return;
       }
-
-      // TODO(srawlins): if `(target is PropertyAccessorElement)`, report an
-      // error.
     }
 
     // Classes and type aliases are checked first so as to include a
@@ -504,18 +516,34 @@ class FunctionReferenceResolver {
         _resolveTypeAlias(node: node, element: element, typeAlias: function);
         return;
       }
-    } else if (element is ExecutableElement) {
+    } else if (element is MethodElement) {
       function.staticElement = element;
       function.staticType = element.type;
       _resolve(node: node, rawType: element.type, name: element.name);
       return;
+    } else if (element is FunctionElement) {
+      function.staticElement = element;
+      function.staticType = element.type;
+      _resolve(node: node, rawType: element.type, name: element.name);
+      return;
+    } else if (element is PropertyAccessorElement) {
+      function.staticElement = element;
+      function.staticType = element.returnType;
+      _resolveDisallowedExpression(node, element.returnType);
+      return;
+    } else if (element is ExecutableElement) {
+      function.staticElement = element;
+      function.staticType = element.type;
+      _resolveDisallowedExpression(node, element.type);
+      return;
     } else if (element is VariableElement) {
       function.staticElement = element;
       function.staticType = element.type;
       _resolveDisallowedExpression(node, element.type);
       return;
     } else {
-      node.staticType = DynamicTypeImpl.instance;
+      _resolveDisallowedExpression(node, DynamicTypeImpl.instance);
+      return;
     }
   }
 

pkg/analyzer/test/src/dart/resolution/function_reference_test.dart

@@ -41,6 +41,26 @@ bar() {
     assertType(reference, 'dynamic');
   }
 
+  test_extensionGetter_extensionOverride() async {
+    await assertErrorsInCode('''
+class A {}
+
+extension E on A {
+  int get foo => 0;
+}
+
+bar(A a) {
+  E(a).foo<int>;
+}
+''', [
+      error(
+          CompileTimeErrorCode.DISALLOWED_TYPE_INSTANTIATION_EXPRESSION, 67, 8),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
+  }
+
   test_extensionMethod() async {
     await assertNoErrorsInCode('''
 class A {}
@@ -175,21 +195,41 @@ extension E on A {
         reference, findElement.method('foo'), 'void Function(int)');
   }
 
+  test_instanceGetter() async {
+    await assertErrorsInCode('''
+abstract class A {
+  late void Function<T>(T) foo;
+
+  bar() {
+    foo<int>;
+  }
+}
+
+''', [
+      error(
+          CompileTimeErrorCode.DISALLOWED_TYPE_INSTANTIATION_EXPRESSION, 66, 3),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'void Function(int)');
+  }
+
   test_instanceGetter_explicitReceiver() async {
-    // This test is here to assert that the resolver does not throw, but in the
-    // future, an error should be reported here as well.
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 class A {
-  int foo = 0;
+  late void Function<T>(T) foo;
 }
 
 bar(A a) {
   a.foo<int>;
 }
-''');
+''', [
+      error(
+          CompileTimeErrorCode.DISALLOWED_TYPE_INSTANTIATION_EXPRESSION, 58, 5),
+    ]);
 
     var reference = findNode.functionReference('foo<int>;');
-    assertType(reference, 'dynamic');
+    assertType(reference, 'void Function(int)');
   }
 
   test_instanceMethod() async {
@@ -430,6 +470,21 @@ class B extends A {
         reference, findElement.method('foo'), 'void Function(int)');
   }
 
+  test_instanceMethod_unknown() async {
+    await assertErrorsInCode('''
+class A {
+  bar() {
+    foo<int>;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_METHOD, 24, 3),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
+  }
+
   test_localFunction() async {
     await assertNoErrorsInCode('''
 void bar() {
@@ -722,7 +777,20 @@ void bar() {
     );
   }
 
-  test_topLevelVariable_prefix_unknown() async {
+  test_topLevelFunction_prefix_unknownPrefix() async {
+    await assertErrorsInCode('''
+bar() {
+  prefix.foo<int>;
+}
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_IDENTIFIER, 10, 6),
+    ]);
+
+    var reference = findNode.functionReference('foo<int>;');
+    assertType(reference, 'dynamic');
+  }
+
+  test_topLevelVariable_prefix_unknownIdentifier() async {
     newFile('$testPackageLibPath/a.dart', content: '');
     await assertErrorsInCode('''
 import 'a.dart' as prefix;