Simplify target discovery (#131)

Author: rockbruno

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetDiscoverer.swift

@@ -46,15 +46,11 @@ final class BazelTargetQuerier {
     private var aqueryCache = [String: ProcessedAqueryResult]()
 
     private static func queryDepsString(forTargets targets: [String]) -> String {
-        var query = ""
-        for target in targets {
-            if query == "" {
-                query = "deps(\(target))"
-            } else {
-                query += " union deps(\(target))"
-            }
-        }
-        return query
+        return unionString(forTargets: targets.map { "deps(\($0))" })
+    }
+
+    private static func unionString(forTargets targets: [String]) -> String {
+        return targets.joined(separator: " union ")
     }
 
     init(
@@ -84,30 +80,28 @@ final class BazelTargetQuerier {
             throw BazelTargetQuerierError.noTargets
         }
 
-        var kindsToFilterFor = Set(supportedDependencyRuleTypes.map { $0.rawValue }).sorted()
-
+        var dependencyKindsFilter = supportedDependencyRuleTypes.map { $0.rawValue }
         // We need to also use the `alias` mnemonic for this query to work properly.
         // This is because --output proto doesn't follow the aliases automatically,
         // so we need this info to do it ourselves.
-        kindsToFilterFor.append("alias")
-
+        dependencyKindsFilter.append("alias")
         // Always fetch source information.
         // FIXME: Need to also handle `generated file`
-        kindsToFilterFor.append("source file")
+        dependencyKindsFilter.append("source file")
 
+        var topLevelKindsFilter = supportedTopLevelRuleTypes.map { $0.rawValue }
         // If we're searching for test rules, we need to also include their test bundle rules.
         // Otherwise we won't be able to map test dependencies back to their top level parents.
         let testBundleRules = supportedTopLevelRuleTypes.compactMap { $0.testBundleRule }
-        kindsToFilterFor.append(contentsOf: testBundleRules)
+        topLevelKindsFilter.append(contentsOf: testBundleRules)
 
         // Collect the top-level targets -> collect these targets' dependencies
         let providedTargetsQuerySet = "set(\(userProvidedTargets.joined(separator: " ")))"
-        let dependencyKindsFilter = kindsToFilterFor.joined(separator: "|")
         let topLevelTargetsQuery = """
-            let topLevelTargets = kind("rule", \(providedTargetsQuerySet)) in \
+            let topLevelTargets = kind("\(topLevelKindsFilter.joined(separator: "|"))", \(providedTargetsQuerySet)) in \
               $topLevelTargets \
               union \
-              kind("\(dependencyKindsFilter)", deps($topLevelTargets))
+              kind("\(dependencyKindsFilter.joined(separator: "|"))", deps($topLevelTargets))
             """
 
         let cacheKey = "QUERY_TARGETS+\(topLevelTargetsQuery)"
@@ -134,7 +128,6 @@ final class BazelTargetQuerier {
         let processedCqueryResult = try parser.processCquery(
             from: output,
             testBundleRules: testBundleRules,
-            userProvidedTargets: userProvidedTargets,
             supportedDependencyRuleTypes: supportedDependencyRuleTypes,
             supportedTopLevelRuleTypes: supportedTopLevelRuleTypes,
             rootUri: config.rootUri,

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetQuerier.swift

@@ -34,7 +34,6 @@ enum BazelTargetQuerierParserError: Error, LocalizedError {
     case indexOutOfBounds(Int, Int)
     case unexpectedLanguageRule(String, String)
     case unexpectedTargetType(Int)
-    case unsupportedTopLevelTargetType(String, String, [TopLevelRuleType])
     case noTopLevelTargets([TopLevelRuleType])
     case missingPathExtension(String)
     case unexpectedFileExtension(String)
@@ -56,11 +55,6 @@ enum BazelTargetQuerierParserError: Error, LocalizedError {
         case .unexpectedLanguageRule(let target, let ruleClass):
             return "Could not determine \(target)'s language: Unexpected rule \(ruleClass)"
         case .unexpectedTargetType(let type): return "Parsed unexpected target type: \(type)"
-        case .unsupportedTopLevelTargetType(let target, let type, let supportedTypes):
-            return """
-                Unsupported top-level target type: '\(type)' for target: \
-                '\(target)' supported types: \(supportedTypes.map { $0.rawValue }.joined(separator: ", "))
-                """
         case .noTopLevelTargets(let rules):
             return """
                 No top-level targets found in the query of kind: \
@@ -77,7 +71,6 @@ protocol BazelTargetQuerierParser: AnyObject {
     func processCquery(
         from data: Data,
         testBundleRules: [String],
-        userProvidedTargets: [String],
         supportedDependencyRuleTypes: [DependencyRuleType],
         supportedTopLevelRuleTypes: [TopLevelRuleType],
         rootUri: String,
@@ -97,7 +90,6 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
     func processCquery(
         from data: Data,
         testBundleRules: [String],
-        userProvidedTargets: [String],
         supportedDependencyRuleTypes: [DependencyRuleType],
         supportedTopLevelRuleTypes: [TopLevelRuleType],
         rootUri: String,
@@ -158,22 +150,11 @@ final class BazelTargetQuerierParserImpl: BazelTargetQuerierParser {
         let supportedTopLevelRuleTypesSet = Set(supportedTopLevelRuleTypes)
         var topLevelTargets: [(BlazeQuery_Target, TopLevelRuleType)] = []
         var dependencyTargets: [BlazeQuery_Target] = []
-        // Convert the user's provided targets to full labels if needed, since this is what
-        // the cquery result will contain.
-        let userProvidedTargetsSet = Set(userProvidedTargets.map { $0.toFullLabel() })
         for target in allRules {
             let kind = target.rule.ruleClass
-            let name = target.rule.name
-            if userProvidedTargetsSet.contains(name) {
-                guard let topLevelRuleType = TopLevelRuleType(rawValue: kind),
-                    supportedTopLevelRuleTypesSet.contains(topLevelRuleType)
-                else {
-                    throw BazelTargetQuerierParserError.unsupportedTopLevelTargetType(
-                        name,
-                        kind,
-                        supportedTopLevelRuleTypes
-                    )
-                }
+            if let topLevelRuleType = TopLevelRuleType(rawValue: kind),
+                supportedTopLevelRuleTypesSet.contains(topLevelRuleType)
+            {
                 topLevelTargets.append((target, topLevelRuleType))
             } else {
                 dependencyTargets.append(target)

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetQuerierParser.swift

@@ -68,51 +68,12 @@ struct Serve: ParsableCommand {
     func run() throws {
         logger.info("`serve` invoked, initializing BSP server...")
 
-        let topLevelRulesToDiscover: [TopLevelRuleType]
-        if !topLevelRuleToDiscover.isEmpty {
-            topLevelRulesToDiscover = topLevelRuleToDiscover
-        } else {
-            topLevelRulesToDiscover = TopLevelRuleType.allCases
-        }
-        let dependencyRulesToDiscover: [DependencyRuleType]
-        if !dependencyRuleToDiscover.isEmpty {
-            dependencyRulesToDiscover = dependencyRuleToDiscover
-        } else {
-            dependencyRulesToDiscover = DependencyRuleType.allCases
-        }
+        let topLevelRulesToDiscover: [TopLevelRuleType] =
+            topLevelRuleToDiscover.isEmpty ? TopLevelRuleType.allCases : topLevelRuleToDiscover
+        let dependencyRulesToDiscover: [DependencyRuleType] =
+            dependencyRuleToDiscover.isEmpty ? DependencyRuleType.allCases : dependencyRuleToDiscover
         let indexFlags = indexFlag.map { "--" + $0 }
-        let targets: [String]
-        if !target.isEmpty {
-            var expandedTargets = [String]()
-            var targetsToExpand = [String]()
-            for _target in target {
-                if _target.hasSuffix("...") {
-                    targetsToExpand.append(_target)
-                } else {
-                    expandedTargets.append(_target)
-                }
-            }
-            if !targetsToExpand.isEmpty {
-                expandedTargets.append(
-                    contentsOf: try expandWildcardTargets(
-                        bazelWrapper: bazelWrapper,
-                        targets: targetsToExpand,
-                        topLevelRuleToDiscover: topLevelRulesToDiscover,
-                        indexFlags: indexFlags
-                    )
-                )
-            }
-            targets = expandedTargets
-        } else {
-            // If the user provided no specific targets, try to discover them
-            // in the workspace.
-            targets = try expandWildcardTargets(
-                bazelWrapper: bazelWrapper,
-                targets: ["..."],
-                topLevelRuleToDiscover: topLevelRulesToDiscover,
-                indexFlags: indexFlags
-            )
-        }
+        let targets = target.isEmpty ? ["//..."] : target
 
         let config = BaseServerConfig(
             bazelWrapper: bazelWrapper,
@@ -129,29 +90,4 @@ struct Serve: ParsableCommand {
         let server = SourceKitBazelBSPServer(baseConfig: config)
         server.run()
     }
-
-    private func expandWildcardTargets(
-        bazelWrapper: String,
-        targets: [String],
-        topLevelRuleToDiscover: [TopLevelRuleType],
-        indexFlags: [String]
-    ) throws -> [String] {
-        let targetsString = targets.joined(separator: ", ")
-        logger.warning(
-            "Will expand wildcard targets (\(targetsString, privacy: .public)). This can cause the BSP to perform poorly if we find too many targets. Prefer passing explicit targets via --targets if possible."
-        )
-        do {
-            return try BazelTargetDiscoverer.discoverTargets(
-                for: topLevelRuleToDiscover,
-                bazelWrapper: bazelWrapper,
-                locations: targets,
-                additionalFlags: indexFlags,
-            )
-        } catch {
-            logger.error(
-                "Failed to initialize server: Could not expand wildcard targets (\(targetsString, privacy: .public)). Please check your Bazel configuration or try specifying targets explicitly with `--target` instead. Failure: \(error, privacy: .public)"
-            )
-            throw error
-        }
-    }
 }