Don’t repeat a function in incomingCalls if it contains multiple calls to the same function

Eg. if we have the following, and we get the call hierarchy of `foo`, we only want to show `bar` once, with multiple `fromRanges` instead of having two entries for `bar` in the call hierarchy.

```swift
func foo() {}
func bar() {
  foo()
  foo()
}
```

Author: ahoppen

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -2128,27 +2128,44 @@ extension SourceKitLSPServer {
     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 calls = callOccurrences.flatMap { occurrence -> [CallHierarchyIncomingCall] in
-      guard let location = indexToLSPLocation(occurrence.location) else {
-        return []
+
+    // 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
+    // `SymbolOccurrence`s.
+    // This way, we can group multiple calls to `bar` within `foo` to a single item with multiple `fromRanges`.
+    var callersToCalls: [Symbol: [SymbolOccurrence]] = [:]
+
+    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.symbol.kind.isCallable }.map(\.symbol)
+      for caller in callers {
+        callersToCalls[caller, default: []].append(call)
       }
-      return occurrence.relations.filter { $0.symbol.kind.isCallable }
-        .map { related in
-          // Resolve the caller's definition to find its location
-          let definition = index.primaryDefinitionOrDeclarationOccurrence(ofUSR: related.symbol.usr)
-          let definitionSymbolLocation = definition?.location
-          let definitionLocation = definitionSymbolLocation.flatMap(indexToLSPLocation)
-
-          return CallHierarchyIncomingCall(
-            from: indexToLSPCallHierarchyItem(
-              symbol: related.symbol,
-              containerName: definition?.containerName,
-              location: definitionLocation ?? location  // Use occurrence location as fallback
-            ),
-            fromRanges: [location.range]
-          )
-        }
+    }
+
+    let calls = callersToCalls.compactMap { (caller: Symbol, calls: [SymbolOccurrence]) -> CallHierarchyIncomingCall? in
+      // Resolve the caller's definition to find its location
+      let definition = index.primaryDefinitionOrDeclarationOccurrence(ofUSR: caller.usr)
+      let definitionSymbolLocation = definition?.location
+      let definitionLocation = definitionSymbolLocation.flatMap(indexToLSPLocation)
+
+      let locations = calls.compactMap { indexToLSPLocation($0.location) }.sorted()
+      guard !locations.isEmpty else {
+        return nil
+      }
+
+      return CallHierarchyIncomingCall(
+        from: indexToLSPCallHierarchyItem(
+          symbol: caller,
+          containerName: definition?.containerName,
+          location: definitionLocation ?? locations.first!
+        ),
+        fromRanges: locations.map(\.range)
+      )
     }
     return calls.sorted(by: { $0.from.name < $1.from.name })
   }

Tests/SourceKitLSPTests/CallHierarchyTests.swift

@@ -348,24 +348,8 @@ final class CallHierarchyTests: XCTestCase {
               "uri": .string(project.fileURI.stringValue),
             ])
           ),
-          fromRanges: [Range(project.positions["3️⃣"])]
-        ),
-        CallHierarchyIncomingCall(
-          from: CallHierarchyItem(
-            name: "testFunc()",
-            kind: .function,
-            tags: nil,
-            detail: nil,
-            uri: project.fileURI,
-            range: Range(project.positions["2️⃣"]),
-            selectionRange: Range(project.positions["2️⃣"]),
-            data: .dictionary([
-              "usr": .string("s:4test0A4FuncyyF"),
-              "uri": .string(project.fileURI.stringValue),
-            ])
-          ),
-          fromRanges: [Range(project.positions["4️⃣"])]
-        ),
+          fromRanges: [Range(project.positions["3️⃣"]), Range(project.positions["4️⃣"])]
+        )
       ]
     )
   }