Warm-up build and (hopefully) better updates handling

Author: khlopko

Sources/XcodeBSP/BackgroundRefreshCoordinator.swift

@@ -0,0 +1,42 @@
+import Foundation
+import Logging
+
+protocol RefreshTrigger: Sendable {
+    func requestRefresh(reason: String) async
+}
+
+actor BackgroundRefreshCoordinator: RefreshTrigger {
+    typealias RefreshAction = @Sendable (_ reason: String) async -> Void
+
+    private let logger: Logger
+    private let refreshAction: RefreshAction
+
+    private var isRefreshing: Bool
+
+    init(logger: Logger, refreshAction: @escaping RefreshAction) {
+        self.logger = logger
+        self.refreshAction = refreshAction
+        isRefreshing = false
+    }
+
+    func requestRefresh(reason: String) async {
+        guard isRefreshing == false else {
+            logger.trace("background refresh request coalesced; already in flight (reason=\(reason))")
+            return
+        }
+
+        isRefreshing = true
+        logger.trace("background refresh scheduled (reason=\(reason))")
+
+        Task { [refreshAction, logger] in
+            logger.trace("background refresh started (reason=\(reason))")
+            await refreshAction(reason)
+            logger.trace("background refresh finished (reason=\(reason))")
+            self.markRefreshFinished()
+        }
+    }
+
+    private func markRefreshFinished() {
+        isRefreshing = false
+    }
+}

Sources/XcodeBSP/BuildGraphService.swift

@@ -34,6 +34,7 @@ actor BuildGraphService {
 
     private let projectName: String
     private var snapshotCache: BuildGraphSnapshot?
+    private var warmupTasksByScheme: [String: Task<Void, Error>]
 
     init(
         xcodebuild: any XcodeBuildClient,
@@ -44,6 +45,7 @@ actor BuildGraphService {
         self.logger = logger
         self.configProvider = configProvider
         projectName = URL(filePath: FileManager.default.currentDirectoryPath).lastPathComponent
+        warmupTasksByScheme = [:]
     }
 
     func snapshot(decoder: JSONDecoder) async throws -> BuildGraphSnapshot {
@@ -57,8 +59,34 @@ actor BuildGraphService {
     }
 
     func refresh(decoder: JSONDecoder, checkCache: Bool) async throws -> BuildGraphRefreshResult {
+        let refreshStart = Date()
+        var checkpointStart = refreshStart
+        var refreshSummary = "failed"
+
+        func durationMs(since start: Date) -> Int {
+            Int(Date().timeIntervalSince(start) * 1_000)
+        }
+
+        func logCheckpoint(_ name: String) {
+            let now = Date()
+            let stepMs = Int(now.timeIntervalSince(checkpointStart) * 1_000)
+            let totalMs = Int(now.timeIntervalSince(refreshStart) * 1_000)
+            logger.debug(
+                "build graph refresh checkpoint \(name) (stepMs: \(stepMs), totalMs: \(totalMs))"
+            )
+            checkpointStart = now
+        }
+
+        logger.debug("build graph refresh started (checkCache: \(checkCache))")
+        defer {
+            logger.debug(
+                "build graph refresh finished (status: \(refreshSummary), totalMs: \(durationMs(since: refreshStart)))"
+            )
+        }
+
         let config = try configProvider.load(decoder: decoder)
         let schemes = try resolveSchemes(config: config, checkCache: checkCache)
+        logCheckpoint("config+schemes (schemes: \(schemes.count))")
 
         var targets: [BuildGraphTarget] = []
         var filesByTargetURI: [String: [String]] = [:]
@@ -125,6 +153,7 @@ actor BuildGraphService {
                 }
             }
         }
+        logCheckpoint("build targets+options (targets: \(targets.count), filesByTarget: \(filesByTargetURI.count))")
 
         let targetsByFilePath = targetsByFile.mapValues { Array($0).sorted() }
 
@@ -136,12 +165,14 @@ actor BuildGraphService {
                 }
             }
         }
+        logCheckpoint("flatten options by file (files: \(optionsByFilePath.count))")
 
         let indexStorePath = preferredIndexStorePath(
             candidates: indexStoreCandidates,
             schemes: schemes,
             checkCache: checkCache
         )
+        logCheckpoint("resolve index store path")
 
         let snapshot = BuildGraphSnapshot(
             targets: targets.sorted(by: { $0.uri < $1.uri }),
@@ -157,6 +188,7 @@ actor BuildGraphService {
 
         let changedTargetURIs = changedTargetURIs(previous: previous, current: snapshot)
         let changedOptionsByFilePath = changedOptionsByFilePath(previous: previous, current: snapshot)
+        logCheckpoint("compute snapshot diff (changedTargets: \(changedTargetURIs.count), changedFiles: \(changedOptionsByFilePath.count))")
 
         logger.trace(
             """
@@ -166,6 +198,13 @@ actor BuildGraphService {
             """
         )
 
+        refreshSummary =
+            """
+            success, checkCache: \(checkCache), schemes: \(schemes.count), targets: \(snapshot.targets.count), \
+            filesByTarget: \(snapshot.filesByTargetURI.count), optionsByFile: \(snapshot.optionsByFilePath.count), \
+            changedTargets: \(changedTargetURIs.count), changedFiles: \(changedOptionsByFilePath.count)
+            """
+
         return BuildGraphRefreshResult(
             snapshot: snapshot,
             changedTargetURIs: changedTargetURIs,
@@ -176,6 +215,27 @@ actor BuildGraphService {
     func invalidate() {
         snapshotCache = nil
     }
+
+    func warmupBuild(forScheme scheme: String) async throws {
+        if let task = warmupTasksByScheme[scheme] {
+            try await task.value
+            return
+        }
+
+        let task = Task<Void, Error> { [xcodebuild] in
+            try xcodebuild.warmupBuild(forScheme: scheme)
+        }
+        warmupTasksByScheme[scheme] = task
+
+        do {
+            try await task.value
+        } catch {
+            warmupTasksByScheme[scheme] = nil
+            throw error
+        }
+
+        warmupTasksByScheme[scheme] = nil
+    }
 }
 
 extension BuildGraphService {
@@ -198,22 +258,8 @@ extension BuildGraphService {
     }
 
     private func settingsForIndex(forScheme scheme: String, checkCache: Bool) throws -> XcodeBuild.SettingsForIndex {
-        do {
-            logger.trace("invoking xcodebuild.settingsForIndex(forScheme: \(scheme), checkCache: \(checkCache))")
-            let settings = try xcodebuild.settingsForIndex(forScheme: scheme, checkCache: checkCache)
-            if settings.isEmpty, checkCache {
-                logger.trace("invoking xcodebuild.settingsForIndex(forScheme: \(scheme), checkCache: false) because cached settings are empty")
-                return try xcodebuild.settingsForIndex(forScheme: scheme, checkCache: false)
-            }
-            return settings
-        } catch {
-            guard checkCache else {
-                throw error
-            }
-
-            logger.trace("invoking xcodebuild.settingsForIndex(forScheme: \(scheme), checkCache: false) after failure with cached result")
-            return try xcodebuild.settingsForIndex(forScheme: scheme, checkCache: false)
-        }
+        logger.trace("invoking xcodebuild.settingsForIndex(forScheme: \(scheme), checkCache: \(checkCache))")
+        return try xcodebuild.settingsForIndex(forScheme: scheme, checkCache: checkCache)
     }
 
     private func makeTargetURI(scheme: String, target: String?) -> String {
@@ -283,9 +329,22 @@ extension BuildGraphService {
     }
 
     private func sanitizedCompilerArguments(from settings: XcodeBuild.FileSettings) -> [String] {
-        var arguments = settings.swiftASTCommandArguments ?? []
-        arguments.append(contentsOf: settings.clangASTCommandArguments ?? [])
-        arguments.append(contentsOf: settings.clangPCHCommandArguments ?? [])
+        var arguments = stripCompilerExecutable(
+            from: settings.swiftASTCommandArguments ?? [],
+            expectedCompilers: ["swiftc", "swift-frontend"]
+        )
+        arguments.append(
+            contentsOf: stripCompilerExecutable(
+                from: settings.clangASTCommandArguments ?? [],
+                expectedCompilers: ["clang", "clang++", "cc", "c++"]
+            )
+        )
+        arguments.append(
+            contentsOf: stripCompilerExecutable(
+                from: settings.clangPCHCommandArguments ?? [],
+                expectedCompilers: ["clang", "clang++", "cc", "c++"]
+            )
+        )
 
         arguments = arguments.filter { $0 != "-use-frontend-parseable-output" }
         for (index, argument) in arguments.enumerated().reversed() {
@@ -300,6 +359,33 @@ extension BuildGraphService {
         return removeMissingSDK(arguments: arguments)
     }
 
+    private func stripCompilerExecutable(from arguments: [String], expectedCompilers: [String]) -> [String] {
+        let commands = Set(expectedCompilers.map { $0.lowercased() })
+        guard arguments.isEmpty == false else {
+            return arguments
+        }
+
+        if arguments.count > 1, isCommand(arguments[0], oneOf: ["xcrun"]), isCommand(arguments[1], oneOf: commands) {
+            return Array(arguments.dropFirst(2))
+        }
+
+        if isCommand(arguments[0], oneOf: commands) {
+            return Array(arguments.dropFirst())
+        }
+
+        return arguments
+    }
+
+    private func isCommand(_ argument: String, oneOf commands: Set<String>) -> Bool {
+        let lowercased = argument.lowercased()
+        if commands.contains(lowercased) {
+            return true
+        }
+
+        let basename = URL(filePath: argument).lastPathComponent.lowercased()
+        return commands.contains(basename)
+    }
+
     private func removeMissingSDK(arguments: [String]) -> [String] {
         var sanitized = arguments
         for (index, argument) in arguments.enumerated().reversed() {
@@ -317,6 +403,7 @@ extension BuildGraphService {
         return sanitized
     }
 
+
     private func workingDirectory(arguments: [String]) -> String? {
         for (index, argument) in arguments.enumerated() {
             if argument == "-working-directory", index + 1 < arguments.count {

Sources/XcodeBSP/BuildServerProtocol/Handlers/BuildTargetPrepare.swift

@@ -33,17 +33,43 @@ extension BuildTargetPrepare: MethodHandler {
     func handle(request: Request<Params>, decoder: JSONDecoder) async throws -> Result {
         await state.beginUpdate()
         do {
-            let refresh = try await graph.refresh(decoder: decoder, checkCache: true)
-            await state.recordRefreshChanges(refresh)
+            let initialRefresh = try await graph.refresh(decoder: decoder, checkCache: true)
+            await state.recordRefreshChanges(initialRefresh)
 
-            for target in request.params.targets {
+            let preparedTargets = request.params.targets.compactMap { target -> (TargetID, PreparedTarget)? in
                 guard let parsedTarget = parseTarget(fromURI: target.uri) else {
                     logger.error("failed to extract scheme from target uri: \(target.uri)")
-                    continue
+                    return nil
+                }
+                return (target, parsedTarget)
+            }
+
+            let warmupSchemes = schemesRequiringWarmup(
+                preparedTargets: preparedTargets,
+                snapshot: initialRefresh.snapshot
+            )
+
+            var snapshot = initialRefresh.snapshot
+            if warmupSchemes.isEmpty == false {
+                for scheme in warmupSchemes {
+                    do {
+                        logger.debug("buildTarget/prepare warmup build started for scheme \(scheme)")
+                        try await graph.warmupBuild(forScheme: scheme)
+                        logger.debug("buildTarget/prepare warmup build completed for scheme \(scheme)")
+                    } catch {
+                        logger.error("buildTarget/prepare warmup build failed for scheme \(scheme): \(error)")
+                    }
                 }
 
+                let refreshed = try await graph.refresh(decoder: decoder, checkCache: true)
+                await state.recordRefreshChanges(refreshed)
+                snapshot = refreshed.snapshot
+            }
+
+            for (target, parsedTarget) in preparedTargets {
+
                 let lookupURI = canonicalTargetURI(scheme: parsedTarget.scheme, target: parsedTarget.target)
-                let optionsByFile = refresh.snapshot.optionsByTargetURI[target.uri] ?? refresh.snapshot.optionsByTargetURI[lookupURI] ?? [:]
+                let optionsByFile = snapshot.optionsByTargetURI[target.uri] ?? snapshot.optionsByTargetURI[lookupURI] ?? [:]
                 if optionsByFile.isEmpty {
                     logger.debug("buildTarget/prepare produced no compiler arguments for \(target.uri)")
                     continue
@@ -111,6 +137,65 @@ extension BuildTargetPrepare {
         let fallbackTarget = target.map { "&target=\($0)" } ?? ""
         return components.string ?? "xcode://\(projectName)?scheme=\(scheme)\(fallbackTarget)"
     }
+
+    private func schemesRequiringWarmup(
+        preparedTargets: [(TargetID, PreparedTarget)],
+        snapshot: BuildGraphSnapshot
+    ) -> [String] {
+        var schemes: Set<String> = []
+
+        for (target, parsedTarget) in preparedTargets {
+            let lookupURI = canonicalTargetURI(scheme: parsedTarget.scheme, target: parsedTarget.target)
+            let optionsByFile = snapshot.optionsByTargetURI[target.uri] ?? snapshot.optionsByTargetURI[lookupURI] ?? [:]
+            guard optionsByFile.isEmpty == false else {
+                continue
+            }
+
+            /*
+            if optionsByFile.values.contains(where: { hasMissingCriticalPaths(arguments: $0.options) }) {
+            */
+                schemes.insert(parsedTarget.scheme)
+            /*
+            }
+            */
+        }
+
+        return schemes.sorted()
+    }
+
+    private func hasMissingCriticalPaths(arguments: [String]) -> Bool {
+        var index = 0
+        while index < arguments.count {
+            let argument = arguments[index]
+
+            if argument == "-fmodule-map-file", index + 1 < arguments.count {
+                if FileManager.default.fileExists(atPath: arguments[index + 1]) == false {
+                    return true
+                }
+            } else if argument.hasPrefix("-fmodule-map-file=") {
+                let path = String(argument.dropFirst("-fmodule-map-file=".count))
+                if FileManager.default.fileExists(atPath: path) == false {
+                    return true
+                }
+            } else if argument == "-Xcc", index + 1 < arguments.count {
+                let wrapped = arguments[index + 1]
+                if wrapped == "-fmodule-map-file", index + 3 < arguments.count, arguments[index + 2] == "-Xcc" {
+                    if FileManager.default.fileExists(atPath: arguments[index + 3]) == false {
+                        return true
+                    }
+                } else if wrapped.hasPrefix("-fmodule-map-file=") {
+                    let path = String(wrapped.dropFirst("-fmodule-map-file=".count))
+                    if FileManager.default.fileExists(atPath: path) == false {
+                        return true
+                    }
+                }
+            }
+
+            index += 1
+        }
+
+        return false
+    }
 }
 
 extension BuildTargetPrepare {