Remove build test suffix requirement

This removes the requirement to suffix `*_build_test` targets at all. They are considered top-level targets now and used to collect the platform information similarly to other rules like `ios_application`

Author: luispadron

.bazelignore

@@ -0,0 +1,3 @@
+.build
+.git
+Example

Example/HelloWorld/BUILD

@@ -229,7 +229,4 @@ setup_sourcekit_bsp(
 		"//HelloWorld:HelloWorldMacTests",
 		"//HelloWorld:HelloWorldMacCLIApp",
     ],
-    build_test_suffix = "_(PLAT)_skbsp",
-	build_test_platform_placeholder = "(PLAT)",
-    index_build_batch_size = 10,
 )

README.md

@@ -31,9 +31,8 @@
 
 - Make sure your Bazel project is using compatible versions of all iOS-related Bazel rulesets (available on each release's description) and is configured to generate Swift/Obj-C indexing data and debug symbols, either by default or under a specific config.
   - Detailed information around configuring Bazel flags is currently WIP, but you can currently check out the [example project](./Example) for an example.
-- Make sure all libraries that you'd like to use the BSP for have accompanying `(platform)_build_test` rules that directly targets them and have a predictable suffix that includes the platform name. Example naming scheme: `(lib_name)_{ios,watchos,tvos,macos,visionos}_skbsp`
-  - This is because Bazel is currently missing a couple of important features we need in order to make this work in a clean way. This requirement is thus only temporary and you can expect it to be removed in the future as we evolve the tool and those missing features are introduced.
-  - Keep in mind that our current focus are iOS targets, so as of writing your mileage may vary when it comes to other Apple platforms.
+- Make sure all libraries that you'd like to use the BSP for have accompanying top-level targets (e.g. `ios_application`, `ios_build_test`, etc.) that directly depends on them.
+  - Keep in mind that our current focus are iOS targets, so as of writing your mileage may vary when it comes to other Apple platforms, file an issue if you run into any problems.
 - Download and install [the official Swift extension](https://marketplace.visualstudio.com/items?itemName=swiftlang.swift-vscode) for Cursor / VSCode.
 - On Cursor / VSCode, open a workspace containing the repository in question.
 - On the settings page for the Swift extension, enable `SourceKit-LSP: Background Indexing` at the **workspace level**. It **has** to be workspace settings; this specific setting is not supported at the folder level.
@@ -72,7 +71,7 @@ This will result in a `.bsp/skbsp.json` file being added to your workspace. User
 
 #### After Integrating
 
-- Reload your workspace (`Cmd+Shift+P -> Reload Window`)
+- Reload your workspace (`Cmd+Shift+P -> Reload Window`) or restart the language server (`Cmd+Shift+P -> Swift: Restart LSP Server`)
 
 After following these steps, the `SourceKit Language Server` output tab (_Cmd+Shift+U_) should show up when opening Swift or Obj-C files, and indexing-related actions will start popping up at the bottom of the IDE after a while alongside a new `SourceKit-LSP: Indexing` output tab when working with those files.
 

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetStore.swift

@@ -43,7 +43,6 @@ protocol BazelTargetStore: AnyObject {
 // including the top-level parent that the target is built against.
 struct BazelTargetPlatformInfo {
     let label: String
-    let buildTestLabel: String
     let topLevelParentLabel: String
     let topLevelParentRuleType: TopLevelRuleType
 
@@ -96,6 +95,15 @@ final class BazelTargetStoreImpl: BazelTargetStore {
     // These are collected from the top-level targets that depend on them.
     static let supportedKinds: Set<String> = ["source file", "swift_library", "objc_library"]
 
+    // The mnemonics representing compilation acitons
+    static let compileMnemonics: Set<String> = ["SwiftCompile", "ObjcCompile", "CppCompile"]
+
+    // The mnemonics representing top-level rule actions
+    // - `BundleTreeApp` for finding bundling rules like `ios_unit_test`, `ios_application`
+    // - `SignBinary` for finding macOS CLI app rules like `macos_command_line_application`
+    // - `TestRunner` for finding build test rules like `ios_build_test`
+    static let topLevelMnemonics: Set<String> = ["BundleTreeApp", "SignBinary", "TestRunner"]
+
     // Users of BazelTargetStore are expected to acquire this lock before reading or writing any of the internal state.
     // This is to prevent race conditions between concurrent requests. It's easier to have each request handle critical sections
     // on their own instead of trying to solve it entirely within this class.
@@ -172,16 +180,16 @@ final class BazelTargetStoreImpl: BazelTargetStore {
         // FIXME: When a target can compile to multiple platforms, the way Xcode handles it is by selecting
         // the one matching your selected simulator in the IDE. We don't have any sort of special IDE integration
         // at the moment, so for now we just select the first parent.
-        let parentToUse = parents[0]
-        let rule = try topLevelRuleType(forBazelLabel: parentToUse)
-        let baseSuffix = initializedConfig.baseConfig.buildTestSuffix
-        let platformPlaceholder = initializedConfig.baseConfig.buildTestPlatformPlaceholder
-        let platformBuildSuffix = baseSuffix.replacingOccurrences(of: platformPlaceholder, with: rule.platform)
+        let topLevelParent = parents[0]
+        if parents.count > 1 {
+            logger.warning("Target \(uri.description, privacy: .public) has multiple top-level parents will use first one: \(topLevelParent, privacy: .public)")
+        }
+
+        let topLevelRuleType = try topLevelRuleType(forBazelLabel: topLevelParent)
         return BazelTargetPlatformInfo(
             label: bazelLabel,
-            buildTestLabel: "\(bazelLabel)\(platformBuildSuffix)",
-            topLevelParentLabel: parentToUse,
-            topLevelParentRuleType: rule,
+            topLevelParentLabel: topLevelParent,
+            topLevelParentRuleType: topLevelRuleType
         )
     }
 
@@ -267,13 +275,13 @@ final class BazelTargetStoreImpl: BazelTargetStore {
 
         // Now, run a broad aquery against all top-level targets
         // to get the compiler arguments for all targets we're interested in.
-        // We pass BundleTreeApp and SignBinary as a trick to gain access to the parent's configuration id.
+        // We pass top-level mnemonics in addition to compile ones as a method to gain access to the parent's configuration id.
         // We can then use this to locate the exact variant of the target we are looking for.
         // BundleTreeApp is used by most rule types, while SignBinary is for macOS CLI apps specifically.
         targetsAqueryResult = try bazelTargetAquerier.aquery(
             targets: topLevelLabelToRuleMap.keys.map { $0 },
             config: initializedConfig,
-            mnemonics: ["SwiftCompile", "ObjcCompile", "CppCompile", "BundleTreeApp", "SignBinary"],
+            mnemonics: Self.compileMnemonics.union(Self.topLevelMnemonics),
             additionalFlags: [
                 "--noinclude_artifacts",
                 "--noinclude_aspects",

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/TopLevelRuleType.swift

@@ -24,38 +24,48 @@ public enum TopLevelRuleType: String, CaseIterable, ExpressibleByArgument {
     case iosApplication = "ios_application"
     case iosUnitTest = "ios_unit_test"
     case iosUiTest = "ios_ui_test"
+    case iosBuildTest = "ios_build_test"
     case watchosApplication = "watchos_application"
     case watchosUnitTest = "watchos_unit_test"
     case watchosUiTest = "watchos_ui_test"
+    case watchosBuildTest = "watchos_build_test"
     case macosApplication = "macos_application"
     case macosCommandLineApplication = "macos_command_line_application"
     case macosUnitTest = "macos_unit_test"
     case macosUiTest = "macos_ui_test"
+    case macosBuildTest = "macos_build_test"
     case tvosApplication = "tvos_application"
     case tvosUnitTest = "tvos_unit_test"
     case tvosUiTest = "tvos_ui_test"
+    case tvosBuildTest = "tvos_build_test"
     case visionosApplication = "visionos_application"
     case visionosUnitTest = "visionos_unit_test"
     case visionosUiTest = "visionos_ui_test"
+    case visionosBuildTest = "visionos_build_test"
 
     var platform: String {
         switch self {
         case .iosApplication: return "ios"
         case .iosUnitTest: return "ios"
         case .iosUiTest: return "ios"
+        case .iosBuildTest: return "ios"
         case .watchosApplication: return "watchos"
         case .watchosUnitTest: return "watchos"
         case .watchosUiTest: return "watchos"
+        case .watchosBuildTest: return "watchos"
         case .macosApplication: return "macos"
         case .macosCommandLineApplication: return "macos"
         case .macosUnitTest: return "macos"
         case .macosUiTest: return "macos"
+        case .macosBuildTest: return "macos"
         case .tvosApplication: return "tvos"
         case .tvosUnitTest: return "tvos"
         case .tvosUiTest: return "tvos"
+        case .tvosBuildTest: return "tvos"
         case .visionosApplication: return "visionos"
         case .visionosUnitTest: return "visionos"
         case .visionosUiTest: return "visionos"
+        case .visionosBuildTest: return "visionos"
         }
     }
 
@@ -75,19 +85,24 @@ public enum TopLevelRuleType: String, CaseIterable, ExpressibleByArgument {
         case .iosApplication: return "iphonesimulator"
         case .iosUnitTest: return "iphonesimulator"
         case .iosUiTest: return "iphonesimulator"
+        case .iosBuildTest: return "iphonesimulator"
         case .watchosApplication: return "watchsimulator"
         case .watchosUnitTest: return "watchsimulator"
         case .watchosUiTest: return "watchsimulator"
+        case .watchosBuildTest: return "watchsimulator"
         case .macosApplication: return "macosx"
         case .macosCommandLineApplication: return "macosx"
         case .macosUnitTest: return "macosx"
         case .macosUiTest: return "macosx"
+        case .macosBuildTest: return "macosx"
         case .tvosApplication: return "appletvsimulator"
         case .tvosUnitTest: return "appletvsimulator"
         case .tvosUiTest: return "appletvsimulator"
+        case .tvosBuildTest: return "appletvsimulator"
         case .visionosApplication: return "xrsimulator"
         case .visionosUnitTest: return "xrsimulator"
         case .visionosUiTest: return "xrsimulator"
+        case .visionosBuildTest: return "xrsimulator"
         }
     }
 }

Sources/SourceKitBazelBSP/RequestHandlers/PrepareHandler.swift

@@ -86,7 +86,7 @@ final class PrepareHandler {
             )
             didStartTask = true
             nonisolated(unsafe) let reply = reply
-            try build(bazelLabels: platformInfo.map { $0.buildTestLabel }, id: id) { [connection] error in
+            try build(bazelLabels: platformInfo.map { $0.topLevelParentLabel }, id: id) { [connection] error in
                 if let error = error {
                     connection?.finishTask(id: taskId, status: .error)
                     reply(.failure(error))

Sources/SourceKitBazelBSP/RequestHandlers/SKOptions/BazelTargetCompilerArgsExtractor.swift

@@ -32,7 +32,7 @@ enum BazelTargetCompilerArgsExtractorError: Error, LocalizedError {
     case sdkRootNotFound(String)
     case parentTargetNotFound(String, String)
     case parentActionNotFound(String, UInt32)
-    case multipleParentActions(String, String)
+    case multipleParentActions(String, String, [String])
     case targetNotFound(String)
     case actionNotFound(String, UInt32)
     case multipleTargetActions(String, UInt32)
@@ -49,8 +49,8 @@ enum BazelTargetCompilerArgsExtractorError: Error, LocalizedError {
             return "Parent target \(parent) of \(target) was not found in the aquery output."
         case .parentActionNotFound(let parent, let id):
             return "Parent action \(id) for parent \(parent) not found in the aquery output."
-        case .multipleParentActions(let parent, let target):
-            return "Multiple parent actions found for parent \(parent) of \(target). This is unexpected."
+        case .multipleParentActions(let parent, let target, let mnemonics):
+            return "Multiple parent actions found for parent \(parent) of \(target) with mnemonics: \(mnemonics)"
         case .targetNotFound(let target): return "Target \(target) not found in the aquery output."
         case .actionNotFound(let target, let id):
             return "Action \(id) for target \(target) not found in the aquery output."
@@ -131,6 +131,7 @@ final class BazelTargetCompilerArgsExtractor {
         fromAquery aquery: AqueryResult,
         forTarget platformInfo: BazelTargetPlatformInfo,
         withStrategy strategy: ParsingStrategy,
+        compileMnemonics: Set<String>
     ) throws -> [String] {
         // Ignore Obj-C header requests as these don't compile.
         if case .cHeader = strategy {
@@ -169,7 +170,8 @@ final class BazelTargetCompilerArgsExtractor {
             forTarget: platformInfo,
             fromAquery: aquery,
             basedOn: parentAction,
-            strategy: strategy
+            strategy: strategy,
+            compileMnemonics: compileMnemonics
         )
 
         // Then, extract the compiler arguments for the target file from the resulting aquery.
@@ -229,7 +231,11 @@ final class BazelTargetCompilerArgsExtractor {
             throw BazelTargetCompilerArgsExtractorError.parentActionNotFound(effectiveParentLabel, parentTarget.id)
         }
         guard parentActions.count == 1 else {
-            throw BazelTargetCompilerArgsExtractorError.multipleParentActions(effectiveParentLabel, bazelTarget)
+            throw BazelTargetCompilerArgsExtractorError.multipleParentActions(
+                effectiveParentLabel,
+                bazelTarget,
+                parentActions.map(\.mnemonic)
+            )
         }
         let parentAction = parentActions[0]
         let parentConfigurationId = parentAction.configurationID
@@ -240,7 +246,8 @@ final class BazelTargetCompilerArgsExtractor {
         forTarget platformInfo: BazelTargetPlatformInfo,
         fromAquery aquery: AqueryResult,
         basedOn parentAction: ParentData,
-        strategy: ParsingStrategy
+        strategy: ParsingStrategy,
+        compileMnemonics: Set<String>,
     ) throws -> Analysis_Action {
         let bazelTarget = platformInfo.label
         guard let target = aquery.targets[bazelTarget] else {
@@ -249,12 +256,15 @@ final class BazelTargetCompilerArgsExtractor {
         guard let actions = aquery.actions[target.id] else {
             throw BazelTargetCompilerArgsExtractorError.actionNotFound(bazelTarget, target.id)
         }
+
         // `actions` will contain all different configurations for the target we're processing.
         // We need to now locate the one that matches the configuration from the parent action
         // we're using as a reference.
         var candidateActions = actions.filter {
             $0.configurationID == parentAction.configurationID
         }
+        let compileActions = actions.filter { compileMnemonics.contains($0.mnemonic) }
+
         let contentBeingQueried: String
         switch strategy {
         case .swiftModule, .cHeader:
@@ -272,12 +282,30 @@ final class BazelTargetCompilerArgsExtractor {
                 return false
             }
         }
+
         guard candidateActions.count > 0 else {
-            throw BazelTargetCompilerArgsExtractorError.relevantTargetActionsNotFound(contentBeingQueried)
+            guard compileActions.count > 0 else {
+                logger.fault(
+                    "No actions for: \(contentBeingQueried) with parent id: \(parentAction.configurationID, privacy: .public) or compile mnemonic found: \(actions.map(\.mnemonic).joined(separator: " "), privacy: .public)"
+                )
+                throw BazelTargetCompilerArgsExtractorError.relevantTargetActionsNotFound(contentBeingQueried)
+            }
+            guard compileActions.count == 1 else {
+                logger.fault(
+                    "Ambigious compile actions found for: \(contentBeingQueried): \(compileActions.map(\.mnemonic).joined(separator: " "), privacy: .public)"
+                )
+                throw BazelTargetCompilerArgsExtractorError.multipleTargetActions(contentBeingQueried, target.id)
+            }
+            logger.debug(
+                "Did not determine matching parent action for: \(contentBeingQueried, privacy: .public), falling back to compile action"
+            )
+            return compileActions[0]
         }
+
         guard candidateActions.count == 1 else {
             throw BazelTargetCompilerArgsExtractorError.multipleTargetActions(contentBeingQueried, target.id)
         }
+
         return candidateActions[0]
     }
 

Sources/SourceKitBazelBSP/RequestHandlers/SKOptions/SKOptionsHandler.swift

@@ -89,6 +89,7 @@ final class SKOptionsHandler {
             fromAquery: aqueryResult,
             forTarget: platformInfo,
             withStrategy: strategy,
+            compileMnemonics: BazelTargetStoreImpl.compileMnemonics
         )
 
         // If no compiler arguments are found, return nil to avoid sourcekit indexing with no input files

Sources/SourceKitBazelBSP/Server/BaseServerConfig.swift

@@ -28,8 +28,6 @@ package struct BaseServerConfig: Equatable {
     let bazelWrapper: String
     let targets: [String]
     let indexFlags: [String]
-    let buildTestSuffix: String
-    let buildTestPlatformPlaceholder: String
     let filesToWatch: String?
     let useSeparateOutputBaseForAquery: Bool
     let indexBuildBatchSize: Int?
@@ -38,17 +36,13 @@ package struct BaseServerConfig: Equatable {
         bazelWrapper: String,
         targets: [String],
         indexFlags: [String],
-        buildTestSuffix: String,
-        buildTestPlatformPlaceholder: String,
         filesToWatch: String?,
         useSeparateOutputBaseForAquery: Bool = false,
         indexBuildBatchSize: Int? = nil
     ) {
         self.bazelWrapper = bazelWrapper
         self.targets = targets
         self.indexFlags = indexFlags
-        self.buildTestSuffix = buildTestSuffix
-        self.buildTestPlatformPlaceholder = buildTestPlatformPlaceholder
         self.filesToWatch = filesToWatch
         self.useSeparateOutputBaseForAquery = useSeparateOutputBaseForAquery
         self.indexBuildBatchSize = indexBuildBatchSize

Sources/SourceKitBazelBSP/Server/LSPConnection.swift

@@ -30,7 +30,10 @@ 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: @escaping @Sendable () async -> Void)
+    func start(
+        receiveHandler: MessageHandler,
+        closeHandler: @escaping @Sendable () async -> Void
+    )
 }
 
 extension JSONRPCConnection: LSPConnection {