[analysis_server] Fix Call Hierarchy target selection for tear-offs

This fixes `_findTargetNode` on function tear-offs. Previously it would take the parent node of many `SimpleIdentifiers` which in the case of a tear-off could be some random expression.

Now we only return something other than the `node` in some very specific cases where we're trying to handle constructors (so that the type name is not considered a call for named constructors, but is considered the constructor for unnamed constructors).

Fixes #61736

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

Author: DanTup

pkg/analysis_server/lib/src/computer/computer_call_hierarchy.dart

@@ -9,6 +9,7 @@ import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/source/source_range.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/element_locator.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 
@@ -342,32 +343,23 @@ class DartCallHierarchyComputer {
   /// Finds a target node for call hierarchy navigation at [offset].
   AstNode? _findTargetNode(int offset) {
     var node = _result.unit.nodeCovering(offset: offset);
-    if (node is SimpleIdentifier &&
-        node.parent != null &&
-        node.parent is! VariableDeclaration &&
-        node.parent is! AssignmentExpression) {
-      node = node.parent;
-    }
 
     // For consistency with other places, we only treat the type name as the
     // constructor for unnamed constructor (since we use the constructors name
-    // as the target).
-    if (node is NamedType) {
-      var parent = node.parent;
-      if (parent is ConstructorName) {
-        var name = parent.name;
-        if (name != null && offset < name.offset) {
-          return null;
-        }
-      }
-    } else if (node is ConstructorDeclaration) {
-      var name = node.name;
-      if (name != null && offset < name.offset) {
-        return null;
-      }
-    }
-
-    return node;
+    // as the target otherwise).
+    return switch (node) {
+      // Type name in a named constructor reference, not considered a call.
+      NamedType(parent: ConstructorName(:var name?))
+          when offset < name.offset =>
+        null,
+      // Type name in a named constructor declaration, not considered a call.
+      Identifier(parent: ConstructorDeclaration(:var name?))
+          when offset < name.offset =>
+        null,
+      // Type name in an unnamed constructor declaration, use the constructor.
+      Identifier(parent: ConstructorDeclaration(name: null)) => node.parent,
+      _ => node,
+    };
   }
 
   /// Return the [Element] of the given [node], or `null` if [node] is `null`,

pkg/analysis_server/test/lsp/call_hierarchy_test.dart

@@ -1500,6 +1500,60 @@ void myFunction() {}
     );
   }
 
+  Future<void> test_functionTearOff() async {
+    var mainCode = TestCode.parse('''
+import 'other.dart';
+
+void main() {
+  myFunct^ion;
+}
+''');
+
+    var otherCode = TestCode.parse('''
+void myFunction() {}
+''');
+
+    await expectResults(
+      mainCode: mainCode,
+      otherCode: otherCode,
+      expectedResult: CallHierarchyItem(
+        name: 'myFunction',
+        detail: 'other.dart', // Containing file name
+        kind: SymbolKind.Function,
+        uri: otherFileUri,
+        range: rangeOfString(otherCode, 'void myFunction() {}'),
+        selectionRange: rangeOfString(otherCode, 'myFunction'),
+      ),
+    );
+  }
+
+  Future<void> test_functionTearOff_prefixed() async {
+    var mainCode = TestCode.parse('''
+import 'other.dart' as other;
+
+void main() {
+  other.myFunct^ion;
+}
+''');
+
+    var otherCode = TestCode.parse('''
+void myFunction() {}
+''');
+
+    await expectResults(
+      mainCode: mainCode,
+      otherCode: otherCode,
+      expectedResult: CallHierarchyItem(
+        name: 'myFunction',
+        detail: 'other.dart', // Containing file name
+        kind: SymbolKind.Function,
+        uri: otherFileUri,
+        range: rangeOfString(otherCode, 'void myFunction() {}'),
+        selectionRange: rangeOfString(otherCode, 'myFunction'),
+      ),
+    );
+  }
+
   Future<void> test_implicitConstructorCall() async {
     // Even if a constructor is implicit, we might want to be able to get the
     // incoming calls, so invoking it here should still return an element

pkg/analysis_server/test/src/computer/call_hierarchy_computer_test.dart

@@ -596,6 +596,60 @@ void f() {
     );
   }
 
+  Future<void> test_functionTearOff() async {
+    var code = parseCode('''
+import 'other.dart';
+
+void f() {
+  myFun^ction;
+}
+''');
+
+    var otherCode = parseCode('''
+[!void myFunction() {}!]
+''');
+
+    newFile(otherFile, otherCode.code);
+    await expectTarget(
+      code,
+      _isItem(
+        CallHierarchyKind.function,
+        'myFunction',
+        otherFile,
+        containerName: 'other.dart',
+        nameRange: rangeAtSearch('myFunction', otherCode),
+        codeRange: otherCode.range.sourceRange,
+      ),
+    );
+  }
+
+  Future<void> test_functionTearOff_prefixed() async {
+    var code = parseCode('''
+import 'other.dart' as other;
+
+void f() {
+  other.myFun^ction;
+}
+''');
+
+    var otherCode = parseCode('''
+[!void myFunction() {}!]
+''');
+
+    newFile(otherFile, otherCode.code);
+    await expectTarget(
+      code,
+      _isItem(
+        CallHierarchyKind.function,
+        'myFunction',
+        otherFile,
+        containerName: 'other.dart',
+        nameRange: rangeAtSearch('myFunction', otherCode),
+        codeRange: otherCode.range.sourceRange,
+      ),
+    );
+  }
+
   Future<void> test_getter() async {
     var code = parseCode('''
 class Foo {