Show unapplied function references in call hierarchy

With swiftlang/swift#72930 we can use the `containedBy` instead of `calledBy` relation for the call hierarchy, which allows us to show unapplied function references in the call hierarchy as well.

rdar://123769825

Author: ahoppen

Sources/SKTestSupport/SkipUnless.swift

@@ -232,6 +232,34 @@ public enum SkipUnless {
     }
   }
 
+  /// Checks whether the index contains a fix that prevents it from adding relations to non-indexed locals
+  /// (https://github.com/apple/swift/pull/72930).
+  public static func indexOnlyHasContainedByRelationsToIndexedDecls(
+    file: StaticString = #file,
+    line: UInt = #line
+  ) async throws {
+    return try await skipUnlessSupportedByToolchain(swiftVersion: SwiftVersion(6, 0), file: file, line: line) {
+      let project = try await IndexedSingleSwiftFileTestProject(
+        """
+        func foo() {}
+
+        func 1️⃣testFunc(x: String) {
+          let myVar = foo
+        }
+        """
+      )
+      let prepare = try await project.testClient.send(
+        CallHierarchyPrepareRequest(
+          textDocument: TextDocumentIdentifier(project.fileURI),
+          position: project.positions["1️⃣"]
+        )
+      )
+      let initialItem = try XCTUnwrap(prepare?.only)
+      let calls = try await project.testClient.send(CallHierarchyOutgoingCallsRequest(item: initialItem))
+      return calls != []
+    }
+  }
+
   public static func longTestsEnabled() throws {
     if let value = ProcessInfo.processInfo.environment["SKIP_LONG_TESTS"], value == "1" || value == "YES" {
       throw XCTSkip("Long tests disabled using the `SKIP_LONG_TESTS` environment variable")

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -2134,16 +2134,14 @@ extension SourceKitLSPServer {
       return []
     }
     var callableUsrs = [data.usr]
-    // Calls to the accessors of a property count as calls to the property
-    callableUsrs += index.occurrences(relatedToUSR: data.usr, roles: .accessorOf).map(\.symbol.usr)
     // Also show calls to the functions that this method overrides. This includes overridden class methods and
     // satisfied protocol requirements.
     callableUsrs += index.occurrences(ofUSR: data.usr, roles: .overrideOf).flatMap { occurrence in
       occurrence.relations.filter { $0.roles.contains(.overrideOf) }.map(\.symbol.usr)
     }
     // callOccurrences are all the places that any of the USRs in callableUsrs is called.
     // We also load the `calledBy` roles to get the method that contains the reference to this call.
-    let callOccurrences = callableUsrs.flatMap { index.occurrences(ofUSR: $0, roles: .calledBy) }
+    let callOccurrences = callableUsrs.flatMap { index.occurrences(ofUSR: $0, roles: .containedBy) }
 
     // Maps functions that call a USR in `callableUSRs` to all the called occurrences of `callableUSRs` within the
     // function. If a function `foo` calls `bar` multiple times, `callersToCalls[foo]` will contain two call
@@ -2154,7 +2152,7 @@ extension SourceKitLSPServer {
     for call in callOccurrences {
       // Callers are all `calledBy` relations of a call to a USR in `callableUsrs`, ie. all the functions that contain a
       // call to a USR in callableUSRs. In practice, this should always be a single item.
-      let callers = call.relations.filter { $0.roles.contains(.calledBy) }.map(\.symbol)
+      let callers = call.relations.filter { $0.roles.contains(.containedBy) }.map(\.symbol)
       for caller in callers {
         callersToCalls[caller, default: []].append(call)
       }
@@ -2190,8 +2188,11 @@ extension SourceKitLSPServer {
       return []
     }
     let callableUsrs = [data.usr] + index.occurrences(relatedToUSR: data.usr, roles: .accessorOf).map(\.symbol.usr)
-    let callOccurrences = callableUsrs.flatMap { index.occurrences(relatedToUSR: $0, roles: .calledBy) }
+    let callOccurrences = callableUsrs.flatMap { index.occurrences(relatedToUSR: $0, roles: .containedBy) }
     let calls = callOccurrences.compactMap { occurrence -> CallHierarchyOutgoingCall? in
+      guard occurrence.symbol.kind.isCallable else {
+        return nil
+      }
       guard let location = indexToLSPLocation(occurrence.location) else {
         return nil
       }
@@ -2494,6 +2495,17 @@ extension IndexSymbolKind {
       return .null
     }
   }
+
+  var isCallable: Bool {
+    switch self {
+    case .function, .instanceMethod, .classMethod, .staticMethod, .constructor, .destructor, .conversionFunction:
+      return true
+    case .unknown, .module, .namespace, .namespaceAlias, .macro, .enum, .struct, .protocol, .extension, .union,
+      .typealias, .field, .enumConstant, .parameter, .using, .concept, .commentTag, .variable, .instanceProperty,
+      .class, .staticProperty, .classProperty:
+      return false
+    }
+  }
 }
 
 extension SymbolOccurrence {

Tests/SourceKitLSPTests/CallHierarchyTests.swift

@@ -229,6 +229,7 @@ final class CallHierarchyTests: XCTestCase {
   }
 
   func testIncomingCallHierarchyShowsSurroundingFunctionCall() async throws {
+    try await SkipUnless.indexOnlyHasContainedByRelationsToIndexedDecls()
     // We used to show `myVar` as the caller here
     let project = try await IndexedSingleSwiftFileTestProject(
       """
@@ -271,6 +272,7 @@ final class CallHierarchyTests: XCTestCase {
   }
 
   func testIncomingCallHierarchyFromComputedProperty() async throws {
+    try await SkipUnless.indexOnlyHasContainedByRelationsToIndexedDecls()
     let project = try await IndexedSingleSwiftFileTestProject(
       """
       func 1️⃣foo() {}
@@ -606,4 +608,88 @@ final class CallHierarchyTests: XCTestCase {
       ]
     )
   }
+
+  func testUnappliedFunctionReferenceInIncomingCallHierarchy() async throws {
+    try await SkipUnless.indexOnlyHasContainedByRelationsToIndexedDecls()
+    let project = try await IndexedSingleSwiftFileTestProject(
+      """
+      func 1️⃣foo() {}
+
+      func 2️⃣testFunc(x: String) {
+        let myVar = 3️⃣foo
+      }
+      """
+    )
+    let prepare = try await project.testClient.send(
+      CallHierarchyPrepareRequest(
+        textDocument: TextDocumentIdentifier(project.fileURI),
+        position: project.positions["1️⃣"]
+      )
+    )
+    let initialItem = try XCTUnwrap(prepare?.only)
+    let calls = try await project.testClient.send(CallHierarchyIncomingCallsRequest(item: initialItem))
+    XCTAssertEqual(
+      calls,
+      [
+        CallHierarchyIncomingCall(
+          from: CallHierarchyItem(
+            name: "testFunc(x:)",
+            kind: .function,
+            tags: nil,
+            detail: nil,
+            uri: project.fileURI,
+            range: Range(project.positions["2️⃣"]),
+            selectionRange: Range(project.positions["2️⃣"]),
+            data: .dictionary([
+              "usr": .string("s:4test0A4Func1xySS_tF"),
+              "uri": .string(project.fileURI.stringValue),
+            ])
+          ),
+          fromRanges: [Range(project.positions["3️⃣"])]
+        )
+      ]
+    )
+  }
+
+  func testUnappliedFunctionReferenceInOutgoingCallHierarchy() async throws {
+    try await SkipUnless.indexOnlyHasContainedByRelationsToIndexedDecls()
+    let project = try await IndexedSingleSwiftFileTestProject(
+      """
+      func 1️⃣foo() {}
+
+      func 2️⃣testFunc(x: String) {
+        let myVar = 3️⃣foo
+      }
+      """
+    )
+    let prepare = try await project.testClient.send(
+      CallHierarchyPrepareRequest(
+        textDocument: TextDocumentIdentifier(project.fileURI),
+        position: project.positions["2️⃣"]
+      )
+    )
+    let initialItem = try XCTUnwrap(prepare?.only)
+    let calls = try await project.testClient.send(CallHierarchyOutgoingCallsRequest(item: initialItem))
+    XCTAssertEqual(
+      calls,
+      [
+        CallHierarchyOutgoingCall(
+          to: CallHierarchyItem(
+            name: "foo()",
+            kind: .function,
+            tags: nil,
+            detail: nil,
+            uri: project.fileURI,
+            range: Range(project.positions["1️⃣"]),
+            selectionRange: Range(project.positions["1️⃣"]),
+            data: .dictionary([
+              "usr": .string("s:4test3fooyyF"),
+              "uri": .string(project.fileURI.stringValue),
+            ])
+          ),
+          fromRanges: [Range(project.positions["3️⃣"])]
+        )
+      ]
+    )
+  }
 }