Add support for parsing external repos as well (#135)

Author: rockbruno

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetQuerier.swift

@@ -143,6 +143,7 @@ final class BazelTargetQuerier {
             supportedDependencyRuleTypes: supportedDependencyRuleTypes,
             supportedTopLevelRuleTypes: supportedTopLevelRuleTypes,
             rootUri: config.rootUri,
+            workspaceName: config.workspaceName,
             executionRoot: config.executionRoot,
             toolchainPath: config.devToolchainPath,
         )

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetQuerierParser.swift

@@ -36,7 +36,6 @@ enum BazelTargetQuerierParserError: Error, LocalizedError {
     case unexpectedTargetType(Int)
     case noTopLevelTargets([TopLevelRuleType])
     case missingPathExtension(String)
-    case unexpectedFileExtension(String)
 
     var errorDescription: String? {
         switch self {
@@ -61,7 +60,6 @@ enum BazelTargetQuerierParserError: Error, LocalizedError {
                 \(rules.map { $0.rawValue }.joined(separator: ", "))
                 """
         case .missingPathExtension(let path): return "Missing path extension for \(path)"
-        case .unexpectedFileExtension(let pathExtension): return "Unexpected file extension: \(pathExtension)"
         }
     }
 }
@@ -74,6 +72,7 @@ protocol BazelTargetQuerierParser: AnyObject {
         supportedDependencyRuleTypes: [DependencyRuleType],
         supportedTopLevelRuleTypes: [TopLevelRuleType],
         rootUri: String,
+        workspaceName: String,
         executionRoot: String,
         toolchainPath: String,
     ) throws -> ProcessedCqueryResult
@@ -93,17 +92,12 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
         supportedDependencyRuleTypes: [DependencyRuleType],
         supportedTopLevelRuleTypes: [TopLevelRuleType],
         rootUri: String,
+        workspaceName: String,
         executionRoot: String,
         toolchainPath: String,
     ) throws -> ProcessedCqueryResult {
         let cquery = try BazelProtobufBindings.parseCqueryResult(data: data)
-        let targets = cquery.results
-            .map { $0.target }
-            .filter {
-                // Ignore external labels.
-                // FIXME: I guess _technically_ we could index those, but skipping for now.
-                return !$0.rule.name.hasPrefix("@")
-            }
+        let targets = cquery.results.map { $0.target }
 
         let supportedDependencyRuleTypesSet = Set(supportedDependencyRuleTypes)
         let testBundleRulesSet = Set(testBundleRules)
@@ -184,7 +178,7 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
             let label = target.rule.name
             depLabelToUriMap[label] = (
                 BuildTargetIdentifier(
-                    uri: try label.toTargetId(rootUri: rootUri)
+                    uri: try label.toTargetId(rootUri: rootUri, workspaceName: workspaceName, executionRoot: executionRoot)
                 ), label
             )
         }
@@ -219,7 +213,7 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
             }
             depLabelToUriMap[label] = (
                 BuildTargetIdentifier(
-                    uri: try realLabel.toTargetId(rootUri: rootUri)
+                    uri: try realLabel.toTargetId(rootUri: rootUri, workspaceName: workspaceName, executionRoot: executionRoot)
                 ), realLabel
             )
         }
@@ -233,9 +227,9 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
             }
 
             let rule = target.rule
-            let idUri: URI = try rule.name.toTargetId(rootUri: rootUri)
+            let idUri: URI = try rule.name.toTargetId(rootUri: rootUri, workspaceName: workspaceName, executionRoot: executionRoot)
             let id = BuildTargetIdentifier(uri: idUri)
-            let baseDirectory: URI = try rule.name.toBaseDirectory(rootUri: rootUri)
+            let baseDirectory: URI? = idUri.toBaseDirectory()
 
             let sourcesItem = try processSrcsAttr(
                 rule: rule,
@@ -377,17 +371,10 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
         let hdrsAttribute = rule.attribute.first { $0.name == "hdrs" }?.stringListValue ?? []
         let srcs: [URI] = (srcsAttribute + hdrsAttribute).compactMap {
             guard let srcUri = srcToUriMap[$0] else {
-                // If the file is not part of the original array provided to this function,
-                // then this is likely a generated file.
-                // FIXME: Generated files are handled by the `generated file` mmnemonic,
-                // which we don't handle today. Ignoring them for now.
-                logger.debug(
-                    "Skipping \($0, privacy: .public): Source does not exist, most likely a generated file."
-                )
                 return nil
             }
             return srcUri
-        }.sorted(by: { $0.stringValue < $1.stringValue })
+        }
         return SourcesItem(
             target: targetId,
             sources: try srcs.map {
@@ -408,12 +395,18 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
         guard let pathExtension = src.fileURL?.pathExtension else {
             throw BazelTargetQuerierParserError.missingPathExtension(src.stringValue)
         }
-        guard let extensionKind = SupportedExtension(rawValue: pathExtension) else {
-            throw BazelTargetQuerierParserError.unexpectedFileExtension(pathExtension)
+        let kind: SourceKitSourceItemKind
+        let language: Language?
+
+        if let extensionKind = SupportedExtension(rawValue: pathExtension) {
+            kind = extensionKind.kind
+            language = extensionKind.language
+        } else {
+            logger.error("Unexpected file extension \(pathExtension) for \(src.stringValue). Will recover by setting `language` to `nil`.")
+            kind = .source
+            language = nil
         }
 
-        let kind: SourceKitSourceItemKind = extensionKind.kind
-        let language: Language = extensionKind.language
         let copyDestinations = srcCopyDestinations(for: src, rootUri: rootUri, executionRoot: executionRoot)
 
         return SourceItem(
@@ -468,16 +461,14 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
         let attrName = isBuildTestRule ? "targets" : "deps"
         let thisRule = rule.name
         let depsAttribute = rule.attribute.first { $0.name == attrName }?.stringListValue ?? []
-        return depsAttribute.compactMap { label in
+        let implDeps = rule.attribute.first { $0.name == "implementation_deps" }?.stringListValue ?? []
+        return (depsAttribute + implDeps).compactMap { label in
             guard let (depUri, depRealLabel) = depLabelToUriMap[label] else {
-                logger.debug(
-                    "Skipping dependency \(label, privacy: .public): not considered a valid dependency"
-                )
                 return nil
             }
             dependencyGraph[thisRule, default: []].append(depRealLabel)
             return depUri
-        }.sorted(by: { $0.uri.stringValue < $1.uri.stringValue })
+        }
     }
 
     private func traverseGraph(
@@ -625,51 +616,62 @@ extension Array {
 extension String {
     /// Converts a Bazel label into a URI and returns a unique target id.
     ///
-    /// file://<path-to-root>/<package-name>___<target-name>
+    /// For local labels: file://<path-to-root>/<package-name>___<target-name>
+    /// For external labels: file://<execution-root>/external/<repo-name>/<package-name>___<target-name>
     ///
-    fileprivate func toTargetId(rootUri: String) throws -> URI {
-        let (packageName, targetName) = try splitTargetLabel()
-        let path = "file://" + rootUri + "/" + packageName + "___" + targetName
+    fileprivate func toTargetId(rootUri: String, workspaceName: String, executionRoot: String) throws -> URI {
+        let (repoName, packageName, targetName) = try splitTargetLabel(workspaceName: workspaceName)
+        let packagePath = packageName.isEmpty ? "" : "/" + packageName
+        let path: String
+        if repoName == workspaceName {
+            path = "file://" + rootUri + packagePath + "/" + targetName
+        } else {
+            // External repo: use execution root + external path
+            path = "file://" + executionRoot + "/external/" + repoName + packagePath + "/" + targetName
+        }
         guard let uri = try? URI(string: path) else {
             throw BazelTargetQuerierParserError.convertUriFailed(path)
         }
         return uri
     }
 
-    /// Fetches the base directory of a target based on its id.
-    ///
-    /// file://<path-to-root>/<package-name>
-    ///
-    fileprivate func toBaseDirectory(rootUri: String) throws -> URI {
-        let (packageName, _) = try splitTargetLabel()
-
-        let fileScheme = "file://" + rootUri + "/" + packageName
-
-        guard let uri = try? URI(string: fileScheme) else {
-            throw BazelTargetQuerierParserError.convertUriFailed(fileScheme)
-        }
-
-        return uri
-    }
-
-    /// Splits a full Bazel label into a tuple of its package and target names.
-    fileprivate func splitTargetLabel() throws -> (packageName: String, targetName: String) {
+    /// Splits a full Bazel label into a tuple of its repo, package, and target names.
+    /// For local labels (//package:target), the repo name is the provided workspace name.
+    /// For external labels (@repo//package:target), the repo name is extracted.
+    fileprivate func splitTargetLabel(workspaceName: String) throws -> (repoName: String, packageName: String, targetName: String) {
         let components = split(separator: ":")
 
         guard components.count == 2 else {
             throw BazelTargetQuerierParserError.incorrectName(self)
         }
 
-        let packageName =
-            if components[0].starts(with: "//") {
-                String(components[0].dropFirst(2))
-            } else {
-                String(components[0])
-            }
-
+        let repoAndPackage = components[0]
         let targetName = String(components[1])
 
-        return (packageName: packageName, targetName: targetName)
+        let repoName: String
+        let packageName: String
+
+        if repoAndPackage.hasPrefix("@//") {
+            // Alias for the main repo.
+            repoName = workspaceName
+            packageName = String(repoAndPackage.dropFirst(3))
+        } else if repoAndPackage.hasPrefix("//") {
+            // Also the main repo.
+            repoName = workspaceName
+            packageName = String(repoAndPackage.dropFirst(2))
+        } else if repoAndPackage.hasPrefix("@") && repoAndPackage.contains("//") {
+            // External label
+            let withoutAt = repoAndPackage.dropFirst()
+            guard let slashIndex = withoutAt.firstIndex(of: "/") else {
+                throw BazelTargetQuerierParserError.incorrectName(self)
+            }
+            repoName = String(withoutAt[..<slashIndex])
+            packageName = String(withoutAt[slashIndex...].dropFirst(2))
+        } else {
+            throw BazelTargetQuerierParserError.incorrectName(self)
+        }
+
+        return (repoName: repoName, packageName: packageName, targetName: targetName)
     }
 
     // Converts a Bazel label to its "full" equivalent, if needed.
@@ -686,3 +688,13 @@ extension String {
         }
     }
 }
+
+extension URI {
+    /// Fetches the base directory of a target by dropping the last path component (target name) from the URI.
+    fileprivate func toBaseDirectory() -> URI? {
+        guard let url = fileURL else {
+            return nil
+        }
+        return URI(url.deletingLastPathComponent())
+    }
+}

Sources/SourceKitBazelBSP/RequestHandlers/InitializeHandler.swift

@@ -109,6 +109,10 @@ final class InitializeHandler {
         )
         logger.debug("executionRoot: \(executionRoot, privacy: .public)")
 
+        // The workspace name is the last component of the execution root path.
+        let workspaceName = URL(fileURLWithPath: executionRoot).lastPathComponent
+        logger.debug("workspaceName: \(workspaceName, privacy: .public)")
+
         // Collecting the rest of the env's details
         let devDir: String = try commandRunner.run("xcode-select --print-path")
         let xcodeVersion: String = try commandRunner.run(
@@ -125,6 +129,7 @@ final class InitializeHandler {
         return InitializedServerConfig(
             baseConfig: baseConfig,
             rootUri: rootUri,
+            workspaceName: workspaceName,
             outputBase: outputBase,
             outputPath: outputPath,
             devDir: devDir,

Sources/SourceKitBazelBSP/RequestHandlers/SKOptions/BazelTargetCompilerArgsExtractor.swift

@@ -27,7 +27,6 @@ import struct os.OSAllocatedUnfairLock
 private let logger = makeFileLevelBSPLogger()
 
 enum BazelTargetCompilerArgsExtractorError: Error, LocalizedError {
-    case invalidCUri(String)
     case invalidTarget(String)
     case sdkRootNotFound(String)
     case targetNotFound(String)
@@ -39,7 +38,6 @@ enum BazelTargetCompilerArgsExtractorError: Error, LocalizedError {
 
     var errorDescription: String? {
         switch self {
-        case .invalidCUri(let uri): return "Unexpected C-type URI missing root URI prefix: \(uri)"
         case .invalidTarget(let target): return "Expected to receive a build_test target, but got: \(target)"
         case .sdkRootNotFound(let sdk): return "sdkRootPath not found for \(sdk). Is it installed?"
         case .targetNotFound(let target): return "Target \(target) not found in the aquery output."
@@ -77,8 +75,13 @@ final class BazelTargetCompilerArgsExtractor {
     private let config: InitializedServerConfig
     private var argsCache = [String: [String]]()
 
+    private let localFilePrefix: String
+    private let externalFilePrefix: String
+
     init(config: InitializedServerConfig) {
         self.config = config
+        self.localFilePrefix = "file://" + config.rootUri + "/"
+        self.externalFilePrefix = "file://" + config.outputBase + "/"
     }
 
     func getParsingStrategy(for uri: URI, language: Language, targetUri: URI) throws -> ParsingStrategy {
@@ -93,11 +96,14 @@ final class BazelTargetCompilerArgsExtractor {
             }
             // Make the path relative, as this is what aquery will return
             let fullUri = uri.stringValue
-            let prefixToCut = "file://" + config.rootUri + "/"
-            guard fullUri.hasPrefix(prefixToCut) else {
-                throw BazelTargetCompilerArgsExtractorError.invalidCUri(fullUri)
+            let parsedFile: String
+            if fullUri.hasPrefix(self.localFilePrefix) {
+                parsedFile = String(fullUri.dropFirst(localFilePrefix.count))
+            } else if fullUri.hasPrefix(self.externalFilePrefix) {
+                parsedFile = String(fullUri.dropFirst(externalFilePrefix.count))
+            } else {
+                parsedFile = String(fullUri.dropFirst("file://".count))
             }
-            let parsedFile = String(fullUri.dropFirst(prefixToCut.count))
             if let xflag = language.xflag {
                 return .cImpl(parsedFile, xflag)
             }
@@ -190,7 +196,14 @@ final class BazelTargetCompilerArgsExtractor {
         fromAquery aquery: ProcessedAqueryResult,
         strategy: ParsingStrategy
     ) throws -> Analysis_Action {
-        let bazelTarget = platformInfo.label
+        let bazelTarget: String = {
+            let base = platformInfo.label
+            guard base.hasPrefix("@") else {
+                return base
+            }
+            // External labels show up as `@@` in the aquery.
+            return "@\(base)"
+        }()
         guard let target = aquery.targets[bazelTarget] else {
             throw BazelTargetCompilerArgsExtractorError.targetNotFound(bazelTarget)
         }

Sources/SourceKitBazelBSP/Server/InitializedServerConfig.swift

@@ -24,6 +24,7 @@ import Foundation
 struct InitializedServerConfig: Equatable {
     let baseConfig: BaseServerConfig
     let rootUri: String
+    let workspaceName: String
     let outputBase: String
     let outputPath: String
     let devDir: String

Tests/SourceKitBazelBSPTests/BazelTargetCompilerArgsExtractorTests.swift

@@ -64,6 +64,7 @@ struct BazelTargetCompilerArgsExtractorTests {
                 compileTopLevel: compileTopLevel
             ),
             rootUri: mockRootUri,
+            workspaceName: "_main",
             outputBase: mockOutputBase,
             outputPath: mockOutputPath,
             devDir: mockDevDir,
@@ -239,7 +240,7 @@ let expectedSwiftResult: [String] = [
     "-Xfrontend",
     "-const-gather-protocols-file",
     "-Xfrontend",
-    "/private/var/tmp/_bazel_user/hash123/external/rules_swift+/swift/toolchains/config/const_protocols_to_gather.json",
+    "/private/var/tmp/_bazel_user/hash123/execroot/__main__/external/rules_swift+/swift/toolchains/config/const_protocols_to_gather.json",
     "-DDEBUG",
     "-Onone",
     "-whole-module-optimization",