Update WatchedFileChangeHandler.swift to listen for created and deleted changes (#38)

* Update WatchedFileChangeHandler.swift to listen for created and deleted changes

* Add 'WatchedFileChangeHandlerTests.swift'

Author: josh-arnold-1

Sources/SourceKitBazelBSP/RequestHandlers/BazelTargetStoreProtocol.swift

@@ -0,0 +1,33 @@
+// Copyright (c) 2025 Spotify AB.
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import BuildServerProtocol
+import LanguageServerProtocol
+
+/// Protocol defining the minimal interface needed for a target store
+protocol BazelTargetStoreProtocol {
+    /// Clear any cached target information
+    func clearCache()
+
+    /// Fetch and update target information from Bazel
+    func fetchTargets() throws -> [BuildTarget]
+
+    /// Get the BSP URIs of targets that contain a given source file
+    func bspURIs(containingSrc src: URI) throws -> [URI]
+}

Sources/SourceKitBazelBSP/RequestHandlers/BuildTargets/BazelTargetStore.swift

@@ -34,8 +34,7 @@ enum BazelTargetStoreError: Error, LocalizedError {
 
 /// Abstraction that can queries, processes, and stores the project's dependency graph and its files.
 /// Used by many of the requests to calculate and provide data about the project's targets.
-final class BazelTargetStore {
-
+final class BazelTargetStore: BazelTargetStoreProtocol {
     // The list of rules we currently care about and can process
     static let supportedRuleTypes: Set<String> = ["source file", "swift_library", "objc_library"]
 
@@ -75,6 +74,7 @@ final class BazelTargetStore {
         return bspURIs
     }
 
+    @discardableResult
     func fetchTargets() throws -> [BuildTarget] {
         var targetData: [(BuildTarget, [URI])] = []
         let targets: [BlazeQuery_Target] = try bazelTargetQuerier.queryTargets(

Sources/SourceKitBazelBSP/RequestHandlers/InitializeHandler.swift

@@ -142,7 +142,7 @@ final class InitializeHandler {
         let rootUri = initializedConfig.rootUri
         if let filesToWatch = initializedConfig.baseConfig.filesToWatch {
             watchers = filesToWatch.components(separatedBy: ",").map {
-                FileSystemWatcher(globPattern: rootUri + "/" + $0)
+                FileSystemWatcher(globPattern: rootUri + "/" + $0, kind: [.change, .create, .delete])
             }
         } else {
             watchers = nil

Sources/SourceKitBazelBSP/RequestHandlers/InvalidatedTargetObserver.swift

@@ -0,0 +1,32 @@
+// Copyright (c) 2025 Spotify AB.
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import BuildServerProtocol
+import LanguageServerProtocol
+
+/// Represents a target that was affected by a file change
+struct AffectedTarget: Hashable {
+    let uri: URI  // Build target URI, not document URI
+    let kind: FileChangeType
+}
+
+/// Protocol for objects that need to be notified when build targets are invalidated
+protocol InvalidatedTargetObserver: AnyObject {
+    func invalidate(targets: Set<AffectedTarget>) throws
+}

Sources/SourceKitBazelBSP/RequestHandlers/PrepareHandler.swift

@@ -87,8 +87,10 @@ final class PrepareHandler {
 }
 
 extension PrepareHandler: InvalidatedTargetObserver {
-    func invalidate(targets: Set<URI>) throws {
-        buildCache.subtract(targets)
+    func invalidate(targets: Set<AffectedTarget>) throws {
+        // Extract just the URIs from the affected targets for the build cache
+        let targetURIs = Set(targets.map(\.uri))
+        buildCache.subtract(targetURIs)
     }
 
     func invalidateBuildCache() {

Sources/SourceKitBazelBSP/RequestHandlers/SKOptions/SKOptionsHandler.swift

@@ -26,7 +26,7 @@ private let logger = makeFileLevelBSPLogger()
 /// Handles the `textDocument/sourceKitOptions` request.
 ///
 /// Returns the compiler arguments for the provided target based on previously gathered information.
-final class SKOptionsHandler {
+final class SKOptionsHandler: InvalidatedTargetObserver {
 
     private let initializedConfig: InitializedServerConfig
     private let targetStore: BazelTargetStore
@@ -86,4 +86,13 @@ final class SKOptionsHandler {
             workingDirectory: initializedConfig.rootUri
         )
     }
+
+    // MARK: - InvalidatedTargetObserver
+
+    func invalidate(targets: Set<AffectedTarget>) throws {
+        // Only clear cache if at least one file was created or deleted
+        if targets.contains(where: { $0.kind == .created || $0.kind == .deleted }) {
+            extractor.clearCache()
+        }
+    }
 }

Sources/SourceKitBazelBSP/RequestHandlers/WatchedFileChangeHandler.swift

@@ -21,45 +21,119 @@ import BuildServerProtocol
 import Foundation
 import LanguageServerProtocol
 
-protocol InvalidatedTargetObserver: AnyObject {
-    func invalidate(targets: Set<URI>) throws
-}
+private let logger = makeFileLevelBSPLogger()
 
 /// Handles the file changing notification.
 ///
 /// This is intended to tell the LSP which targets are invalidated by a change.
 final class WatchedFileChangeHandler {
-
-    private let targetStore: BazelTargetStore
+    private let targetStore: BazelTargetStoreProtocol
     private var observers: [any InvalidatedTargetObserver]
     private weak var connection: LSPConnection?
 
-    init(targetStore: BazelTargetStore, observers: [any InvalidatedTargetObserver] = [], connection: LSPConnection) {
+    init(
+        targetStore: BazelTargetStoreProtocol,
+        observers: [any InvalidatedTargetObserver] = [],
+        connection: LSPConnection
+    ) {
         self.targetStore = targetStore
         self.observers = observers
         self.connection = connection
     }
 
     func onWatchedFilesDidChange(_ notification: OnWatchedFilesDidChangeNotification) throws {
-        // FIXME: This only deals with changes, not deletions or creations
-        // For those, we need to invalidate the compilation options cache too
-        // and probably also re-compile the app
-        let changes = notification.changes.filter { $0.type == .changed }.map { $0.uri }
-        var affectedTargets: Set<URI> = []
-        for change in changes {
-            let targetsForSrc = try targetStore.bspURIs(containingSrc: change)
-            for target in targetsForSrc {
-                affectedTargets.insert(target)
+        // First, calculate deleted targets before we clear them from the targetStore
+        let deletedTargets = {
+            do {
+                return try notification.changes
+                    .filter { $0.type == .deleted }
+                    .flatMap { change -> [AffectedTarget] in
+                        try targetStore.bspURIs(containingSrc: change.uri)
+                            .map { AffectedTarget(uri: $0, kind: change.type) }
+                    }
+            } catch {
+                logger.error("Error calculating deleted targets: \(error)")
+                return []
+            }
+        }()
+
+        // If there are any 'created' files, we need to clear the targetStore and fetch targets again
+        // Otherwise, the targetStore won't know about them
+        if notification.changes.contains(where: { $0.type == .created }) {
+            targetStore.clearCache()
+            do {
+                _ = try targetStore.fetchTargets()
+            } catch {
+                logger.error("Error fetching targets after file creation: \(error)")
+                // Continue processing with existing target store data
             }
         }
+
+        // Now that the targetStore knows about the newly created files, we can calculate the created targets
+        let createdTargets = {
+            do {
+                return try notification.changes
+                    .filter { $0.type == .created }
+                    .flatMap { change -> [AffectedTarget] in
+                        try targetStore.bspURIs(containingSrc: change.uri)
+                            .map { AffectedTarget(uri: $0, kind: change.type) }
+                    }
+            } catch {
+                logger.error("Error calculating created targets: \(error)")
+                return []
+            }
+        }()
+
+        // Finally, calculate the changed targets
+        let changedTargets = {
+            do {
+                return try notification.changes
+                    .filter { $0.type == .changed }
+                    .flatMap { change -> [AffectedTarget] in
+                        try targetStore.bspURIs(containingSrc: change.uri)
+                            .map { AffectedTarget(uri: $0, kind: change.type) }
+                    }
+            } catch {
+                logger.error("Error calculating changed targets: \(error)")
+                return []
+            }
+        }()
+
+        let affectedTargets: Set<AffectedTarget> = Set(deletedTargets + createdTargets + changedTargets)
+
+        // Invalidate our observers about the affected targets
         for observer in observers {
-            try observer.invalidate(targets: affectedTargets)
+            do {
+                try observer.invalidate(targets: affectedTargets)
+            } catch {
+                logger.error("Error invalidating observer: \(error)")
+                // Continue with other observers
+            }
         }
+
+        // Notify SK-LSP about the affected targets
         let response = OnBuildTargetDidChangeNotification(
-            changes: affectedTargets.map {
-                BuildTargetEvent(target: BuildTargetIdentifier(uri: $0), kind: .changed, dataKind: nil, data: nil)
+            changes: affectedTargets.map { target in
+                BuildTargetEvent(
+                    target: BuildTargetIdentifier(uri: target.uri),
+                    kind: target.kind.buildTargetEventKind,
+                    dataKind: nil,
+                    data: nil
+                )
             }
         )
+
         connection?.send(response)
     }
 }
+
+extension FileChangeType {
+    fileprivate var buildTargetEventKind: BuildTargetEventKind? {
+        switch self {
+        case .changed: return .changed
+        case .created: return .created
+        case .deleted: return .deleted
+        default: return nil
+        }
+    }
+}

Sources/SourceKitBazelBSP/Server/SourceKitBazelBSPServer.swift

@@ -94,7 +94,7 @@ package final class SourceKitBazelBSPServer {
         // OnWatchedFilesDidChangeNotification
         let watchedFileChangeHandler = WatchedFileChangeHandler(
             targetStore: targetStore,
-            observers: [prepareHandler],
+            observers: [prepareHandler, skOptionsHandler],
             connection: connection
         )
         registry.register(notificationHandler: watchedFileChangeHandler.onWatchedFilesDidChange)