Optimize the dependency graph calculation (#51)

* Optimize the dependency graph calculation

* Handle the example watch app correctly

* Lint

Author: rockbruno

Example/HelloWorld/BUILD

@@ -155,13 +155,13 @@ ios_application(
 watchos_application(
     name = "HelloWorldWatchApp",
     bundle_id = "com.example.HelloWorld.Watch",
-    extensions = [":HelloWorld-WatchExtension"],
+    extensions = [":HelloWorldWatchExtension"],
     infoplists = ["Resources/WatchApp-Info.plist"],
     minimum_os_version = WATCHOS_MINIMUM_OS_VERSION,
 )
 
 watchos_extension(
-    name = "HelloWorldWatchExt",
+    name = "HelloWorldWatchExtension",
     bundle_id = "com.example.HelloWorld.Watch.extension",
     infoplists = ["Resources/WatchExt-Info.plist"],
     minimum_os_version = WATCHOS_MINIMUM_OS_VERSION,

Package.swift

@@ -31,6 +31,9 @@ let package = Package(
                     name: "ArgumentParser",
                     package: "swift-argument-parser"
                 ),
+            ],
+            exclude: [
+                "BUILD",
             ]
         ),
         .target(
@@ -46,6 +49,9 @@ let package = Package(
                     package: "sourcekit-lsp"
                 ),
             ],
+            exclude: [
+                "BUILD",
+            ]
         ),
         .testTarget(
             name: "SourceKitBazelBSPTests",
@@ -62,6 +68,7 @@ let package = Package(
                 .product(name: "SwiftProtobuf", package: "swift-protobuf")
             ],
             exclude: [
+                "BUILD",
                 "README.md",
                 "protos/analysis_v2.proto",
                 "protos/build.proto",

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetQuerier.swift

@@ -46,7 +46,7 @@ final class BazelTargetQuerier {
 
     private var topLevelRuleCache = [String: [(String, TopLevelRuleType)]]()
     private var queryCache = [String: [BlazeQuery_Target]]()
-    private var dependencyLabelsCache = [String: [String]]()
+    private var dependencyGraphCache = [String: [String: [String]]]()
 
     static func queryDepsString(forTargets targets: [String]) -> String {
         var query = ""
@@ -137,38 +137,59 @@ final class BazelTargetQuerier {
         return targets
     }
 
-    func queryDependencyLabels(
-        ofTarget target: String,
+    func queryDependencyGraph(
+        ofTargets targets: [String],
         forConfig config: BaseServerConfig,
         rootUri: String,
         kinds: Set<String>
-    ) throws -> [String] {
+    ) throws -> [String: [String]] {
         guard !kinds.isEmpty else {
             throw BazelTargetQuerierError.noKinds
         }
 
         let kindsFilter = kinds.sorted().joined(separator: "|")
 
-        let cacheKey = "\(kindsFilter)+\(target)"
+        var depsQuery = Self.queryDepsString(forTargets: targets)
+        for target in targets {
+            // Include the top-level target itself so that we can later traverse the graph correctly.
+            depsQuery += " union \(target)"
+        }
+
+        let cacheKey = "\(kindsFilter)+\(depsQuery)"
 
-        logger.info("Processing dependency labels request for \(cacheKey)")
+        logger.info("Processing dependency graph request for \(cacheKey)")
 
-        if let cached = dependencyLabelsCache[cacheKey] {
+        if let cached = dependencyGraphCache[cacheKey] {
             logger.debug("Returning cached results")
             return cached
         }
 
-        let cmd = "query \"kind('\(kindsFilter)', deps(\(target)))\" --output label"
+        let cmd = "query \"kind('\(kindsFilter)', \(depsQuery))\" --output graph"
         let output: String = try commandRunner.run(config.bazelWrapper + " " + cmd, cwd: rootUri)
-        let result = output.components(separatedBy: "\n")
+        let rawGraph = output.components(separatedBy: "\n").filter {
+            $0.hasPrefix("  \"")
+        }
+
+        var graph = [String: [String]]()
+        for line in rawGraph {
+            let parts = line.components(separatedBy: "\"")
+            // Example line:
+            //   "//path/to/target" -> "//path/to/target2\n//path/to/target3"
+            guard parts.count == 5 else {
+                continue
+            }
+            let source = parts[1]
+            let targets = parts[3].components(separatedBy: "\n")
+            graph[source, default: []].append(contentsOf: targets)
+        }
 
-        dependencyLabelsCache[cacheKey] = result
-        return result
+        dependencyGraphCache[cacheKey] = graph
+        return graph
     }
 
     func clearCache() {
         topLevelRuleCache = [:]
         queryCache = [:]
-        dependencyLabelsCache = [:]
+        dependencyGraphCache = [:]
     }
 }

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetStore.swift

@@ -138,11 +138,15 @@ final class BazelTargetStoreImpl: BazelTargetStore {
             forConfig: initializedConfig.baseConfig,
             rootUri: initializedConfig.rootUri,
         )
+        let topLevelTargets = topLevelTargetData.map { $0.0 }
 
         logger.debug("Queried top-level target data: \(topLevelTargetData)")
 
+        // Parse the target dependencies for the top-level targets.
+        // This doesn't include information about which top-level app a target belongs to,
+        // but we'll fill that in below.
         let targets: [BlazeQuery_Target] = try bazelTargetQuerier.queryTargetDependencies(
-            forTargets: topLevelTargetData.map { $0.0 },
+            forTargets: topLevelTargets,
             forConfig: initializedConfig.baseConfig,
             rootUri: initializedConfig.rootUri,
             kinds: Self.supportedKinds
@@ -174,13 +178,24 @@ final class BazelTargetStoreImpl: BazelTargetStore {
 
         // We need to now map which targets belong to which top-level apps,
         // to further support the target / platform combo differentiation mentioned above.
-        for (topLevelTarget, _) in topLevelTargetData {
-            let deps = try bazelTargetQuerier.queryDependencyLabels(
-                ofTarget: topLevelTarget,
-                forConfig: initializedConfig.baseConfig,
-                rootUri: initializedConfig.rootUri,
-                kinds: Self.supportedKinds
-            )
+
+        // We need to include the top-level data here as well to be able to traverse the graph correctly.
+        let depGraphKinds = Self.supportedKinds.union(TopLevelRuleType.allCases.map { $0.rawValue })
+
+        let depGraph = try bazelTargetQuerier.queryDependencyGraph(
+            ofTargets: topLevelTargets,
+            forConfig: initializedConfig.baseConfig,
+            rootUri: initializedConfig.rootUri,
+            kinds: depGraphKinds
+        )
+
+        // We should ignore any app -> app nodes as we don't want to follow things such
+        // as the watchos_application field in ios_application rules. Otherwise some targets
+        // will be misclassified.
+        let targetsToIgnore = Set(topLevelTargets)
+
+        for topLevelTarget in topLevelTargets {
+            let deps = traverseGraph(from: topLevelTarget, in: depGraph, ignoring: targetsToIgnore)
             for dep in deps {
                 guard availableBazelLabels.contains(dep) else {
                     // Ignore any labels that we also ignored above
@@ -193,6 +208,26 @@ final class BazelTargetStoreImpl: BazelTargetStore {
         return targetData.map { $0.0 }
     }
 
+    private func traverseGraph(from target: String, in graph: [String: [String]], ignoring: Set<String>) -> Set<String>
+    {
+        var visited = Set<String>()
+        var result = Set<String>()
+        var queue: [String] = graph[target, default: []]
+        while let curr = queue.popLast() {
+            guard !ignoring.contains(curr) else {
+                continue
+            }
+            result.insert(curr)
+            for dep in graph[curr, default: []] {
+                if !visited.contains(dep) {
+                    visited.insert(dep)
+                    queue.append(dep)
+                }
+            }
+        }
+        return result
+    }
+
     func clearCache() {
         bspURIsToBazelLabelsMap = [:]
         bspURIsToSrcsMap = [:]