Add tests for the jump to definition mapping (#99)

Author: rockbruno

Sources/SourceKitBazelBSP/RequestHandlers/TargetSourcesHandler.swift

@@ -61,33 +61,33 @@ final class TargetSourcesHandler {
         return BuildTargetSourcesResponse(items: srcs)
     }
 
-    private func computeCopyDestinations(for src: URI) -> [DocumentURI]? {
+    /// The path sourcekit-lsp has is the "real" path of the file,
+    /// but Bazel works by copying them over to the execroot.
+    /// This method calculates this fake path so that sourcekit-lsp can
+    /// map the file back to the original workspace path for features like jump to definition.
+    func computeCopyDestinations(for src: URI) -> [DocumentURI]? {
         guard let srcPath = src.fileURL?.path else {
             return nil
         }
 
-        var destinations: [DocumentURI] = []
+        let rootUri = initializedConfig.rootUri
 
-        let workspaceRoot = initializedConfig.rootUri
-        let execRoot = initializedConfig.executionRoot
-
-        func trimmedRelativePath(fullPath: String, base: String) -> String {
-            var relativePath = fullPath.dropFirst(base.count)
-            if relativePath.first == "/" {
-                relativePath = relativePath.dropFirst()
-            }
-            return String(relativePath)
+        guard srcPath.hasPrefix(rootUri) else {
+            return nil
         }
 
-        if srcPath.hasPrefix(workspaceRoot) {
-            // Workspace file -> single execroot location Bazel copies to.
-            // We need to tell the LSP about the path of each file in execution root to later help it mapping it again to original Workspace path.
-            let relativePath = trimmedRelativePath(fullPath: srcPath, base: workspaceRoot)
-            let destination = DocumentURI(filePath: execRoot + "/" + relativePath, isDirectory: false)
-            destinations.append(destination)
+        let execRoot = initializedConfig.executionRoot
+
+        var relativePath = srcPath.dropFirst(rootUri.count)
+        // Not sure how much we can assume about rootUri, so adding this as an edge-case check
+        if relativePath.first == "/" {
+            relativePath = relativePath.dropFirst()
         }
 
-        return destinations.isEmpty ? nil : destinations
+        let newPath = execRoot + "/" + String(relativePath)
+        return [
+            DocumentURI(filePath: newPath, isDirectory: false)
+        ]
     }
 
     func convertToSourceItems(_ targetSrcs: [URI]) -> [SourceItem] {
@@ -118,7 +118,7 @@ final class TargetSourcesHandler {
                     data: SourceKitSourceItemData(
                         language: language,
                         kind: kind,
-                        outputPath: nil,  // FIXME: Related to the same flag on initialize?
+                        outputPath: nil,
                         copyDestinations: copyDestinations
                     ).encodeToLSPAny()
                 )

Sources/SourceKitBazelBSP/Server/LSPConnection.swift

@@ -30,7 +30,12 @@ package protocol LSPTaskLogger: AnyObject {
 /// Extends the original sourcekit-lsp `Connection` type to include JSONRPCConnection's start method
 /// and task logging utilities.
 package protocol LSPConnection: Connection, LSPTaskLogger, AnyObject {
-    func start(receiveHandler: MessageHandler, closeHandler: nonisolated(nonsending) @escaping @Sendable () async -> Void)
+    // Workaround formatter issue: https://github.com/swiftlang/swift-format/issues/1081
+    // swift-format-ignore
+    func start(
+        receiveHandler: MessageHandler,
+        closeHandler: nonisolated(nonsending) @escaping @Sendable () async -> Void
+    )
 }
 
 extension JSONRPCConnection: LSPConnection {

Tests/SourceKitBazelBSPTests/Fakes/LSPConnectionFake.swift

@@ -28,7 +28,12 @@ final class LSPConnectionFake: LSPConnection {
     nonisolated(unsafe) private(set) var startReceivedHandler: MessageHandler?
     nonisolated(unsafe) private(set) var sentNotifications: [any NotificationType] = []
 
-    func start(receiveHandler: MessageHandler, closeHandler: nonisolated(nonsending) @escaping @Sendable () async -> Void) {
+    // Workaround formatter issue: https://github.com/swiftlang/swift-format/issues/1081
+    // swift-format-ignore
+    func start(
+        receiveHandler: MessageHandler,
+        closeHandler: nonisolated(nonsending) @escaping @Sendable () async -> Void
+    ) {
         startCalled = true
         startReceivedHandler = receiveHandler
     }

Tests/SourceKitBazelBSPTests/TargetSourcesHandlerTests.swift

@@ -0,0 +1,67 @@
+// Copyright (c) 2025 Spotify AB.
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import BazelProtobufBindings
+import BuildServerProtocol
+import Foundation
+import LanguageServerProtocol
+import Testing
+
+@testable import SourceKitBazelBSP
+
+@Suite
+struct TargetSourcesHandlerTests {
+    static func makeHandler() -> TargetSourcesHandler {
+        let baseConfig = BaseServerConfig(
+            bazelWrapper: "bazel",
+            targets: ["//HelloWorld", "//HelloWorld2"],
+            indexFlags: ["--config=index"],
+            filesToWatch: nil,
+            compileTopLevel: false
+        )
+
+        let initializedConfig = InitializedServerConfig(
+            baseConfig: baseConfig,
+            rootUri: "/path/to/project",
+            outputBase: "/tmp/output_base",
+            outputPath: "/tmp/output_path",
+            devDir: "/Applications/Xcode.app/Contents/Developer",
+            devToolchainPath: "/a/b/XcodeDefault.xctoolchain/",
+            executionRoot: "/tmp/output_path/execroot/_main",
+            sdkRootPaths: ["iphonesimulator": "bar"]
+        )
+
+        return TargetSourcesHandler(initializedConfig: initializedConfig, targetStore: BazelTargetStoreFake())
+    }
+
+    @Test
+    func canComputeCopyDestinations() throws {
+        let handler = Self.makeHandler()
+
+        let src = try URI(string: "file:///path/to/project/src/main.swift")
+        #expect(
+            handler.computeCopyDestinations(for: src) == [
+                DocumentURI(filePath: "/tmp/output_path/execroot/_main/src/main.swift", isDirectory: false)
+            ]
+        )
+
+        let externalSrc = try URI(string: "file:///other_path/to/project/src/main.swift")
+        #expect(handler.computeCopyDestinations(for: externalSrc) == nil)
+    }
+}