Fix background indexing behavior if a source file is included in two targets via a symlink

Consider the following scenario: A project has target A containing A.swift an target B containing B.swift. B.swift is a symlink to A.swift. When A.swift is modified, both the dependencies of A and B need to be marked as having an out-of-date preparation status, not just A.

Author: ahoppen

Sources/BuildSystemIntegration/BuildSystemManager.swift

@@ -671,6 +671,26 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
     return languageFromBuildSystem ?? Language(inferredFromFileExtension: document)
   }
 
+  /// Returns the URIs of all source files in the project that have the same realpath as a document in `documents` but
+  /// are not in `documents`.
+  ///
+  /// This is useful in the following scenario: A project has target A containing A.swift an target B containing B.swift
+  /// B.swift is a symlink to A.swift. When A.swift is modified, both the dependencies of A and B need to be marked as
+  /// having an out-of-date preparation status, not just A.
+  package func sourceFilesWithSameRealpath(as documents: [DocumentURI]) async -> [DocumentURI] {
+    let realPaths = Set(documents.map { $0.symlinkTarget ?? $0 })
+    return await orLog("") {
+      var result: [DocumentURI] = []
+      let filesAndDirectories = try await sourceFilesAndDirectories(includeNonBuildableFiles: true)
+      for file in filesAndDirectories.files.keys {
+        if realPaths.contains(file.symlinkTarget ?? file) && !realPaths.contains(file) {
+          result.append(file)
+        }
+      }
+      return result
+    } ?? []
+  }
+
   /// Returns all the targets that the document is part of.
   package func targets(for document: DocumentURI) async -> Set<BuildTargetIdentifier> {
     return await orLog("Getting targets for source file") {
@@ -1155,10 +1175,10 @@ package actor BuildSystemManager: QueueBasedMessageHandler {
     var targetsWithUpdatedDependencies: Set<BuildTargetIdentifier> = []
     // If a Swift file within a target is updated, reload all the other files within the target since they might be
     // referring to a function in the updated file.
-    let targetsWithChangedSwiftFiles =
-      await events
-      .filter { Language(inferredFromFileExtension: $0.uri) == .swift }
-      .asyncFlatMap { await self.targets(for: $0.uri) }
+    var swiftFiles = events.filter { Language(inferredFromFileExtension: $0.uri) == .swift }.map(\.uri)
+    swiftFiles += await sourceFilesWithSameRealpath(as: swiftFiles)
+
+    let targetsWithChangedSwiftFiles = await swiftFiles.asyncFlatMap { await self.targets(for: $0) }
     targetsWithUpdatedDependencies.formUnion(targetsWithChangedSwiftFiles)
 
     // If a `.swiftmodule` file is updated, this means that we have performed a build / are

Sources/BuildSystemIntegration/SwiftPMBuildSystem.swift

@@ -582,7 +582,7 @@ package actor SwiftPMBuildSystem: BuiltInBuildSystem {
         SourceItem(
           uri: DocumentURI($0),
           kind: $0.isDirectory ? .directory : .file,
-          generated: false,
+          generated: false
         )
       }
       result.append(SourcesItem(target: target, sources: sources))

Sources/SKTestSupport/MultiFileTestProject.swift

@@ -88,7 +88,9 @@ package class MultiFileTestProject {
   /// File contents can also contain `$TEST_DIR`, which gets replaced by the temporary directory.
   package init(
     files: [RelativeFileLocation: String],
-    workspaces: (URL) async throws -> [WorkspaceFolder] = { [WorkspaceFolder(uri: DocumentURI($0))] },
+    workspaces: (_ scratchDirectory: URL) async throws -> [WorkspaceFolder] = {
+      [WorkspaceFolder(uri: DocumentURI($0))]
+    },
     initializationOptions: LSPAny? = nil,
     capabilities: ClientCapabilities = ClientCapabilities(),
     options: SourceKitLSPOptions = .testDefault(),

Sources/SKTestSupport/SwiftPMTestProject.swift

@@ -163,7 +163,9 @@ package class SwiftPMTestProject: MultiFileTestProject {
   package init(
     files: [RelativeFileLocation: String],
     manifest: String = SwiftPMTestProject.defaultPackageManifest,
-    workspaces: (URL) async throws -> [WorkspaceFolder] = { [WorkspaceFolder(uri: DocumentURI($0))] },
+    workspaces: (_ scratchDirectory: URL) async throws -> [WorkspaceFolder] = {
+      [WorkspaceFolder(uri: DocumentURI($0))]
+    },
     initializationOptions: LSPAny? = nil,
     capabilities: ClientCapabilities = ClientCapabilities(),
     options: SourceKitLSPOptions = .testDefault(),

Sources/SemanticIndex/SemanticIndexManager.swift

@@ -348,8 +348,9 @@ package final actor SemanticIndexManager {
   package func filesDidChange(_ events: [FileEvent]) async {
     // We only re-index the files that were changed and don't re-index any of their dependencies. See the
     // `Documentation/Files_To_Reindex.md` file.
-    let changedFiles = events.map(\.uri)
+    var changedFiles = events.map(\.uri)
     await indexStoreUpToDateTracker.markOutOfDate(changedFiles)
+    changedFiles += await buildSystemManager.sourceFilesWithSameRealpath(as: changedFiles)
 
     let targets = await changedFiles.asyncMap { await buildSystemManager.targets(for: $0) }.flatMap { $0 }
     let dependentTargets = await buildSystemManager.targets(dependingOn: Set(targets))

Tests/SourceKitLSPTests/BackgroundIndexingTests.swift

@@ -1631,6 +1631,63 @@ final class BackgroundIndexingTests: XCTestCase {
       return completionAfterEdit.items.map(\.label) == ["self", "test()"]
     }
   }
+
+  func testSymlinkedTargetReferringToSameSourceFile() async throws {
+    let project = try await SwiftPMTestProject(
+      files: [
+        "LibA/LibA.swift": """
+        public let myVar: String
+        """,
+        "Client/Client.swift": """
+        import LibASymlink
+
+        func test() {
+          print(1️⃣myVar)
+        }
+        """,
+      ],
+      manifest: """
+        let package = Package(
+          name: "MyLibrary",
+          targets: [
+           .target(name: "LibA"),
+           .target(name: "LibASymlink"),
+           .target(name: "Client", dependencies: ["LibASymlink"]),
+          ]
+        )
+        """,
+      workspaces: { scratchDirectory in
+        let sources = scratchDirectory.appendingPathComponent("Sources")
+        try FileManager.default.createSymbolicLink(
+          at: sources.appendingPathComponent("LibASymlink"),
+          withDestinationURL: sources.appendingPathComponent("LibA")
+        )
+        return [WorkspaceFolder(uri: DocumentURI(scratchDirectory))]
+      },
+      enableBackgroundIndexing: true
+    )
+
+    let (uri, positions) = try project.openDocument("Client.swift")
+    let preEditHover = try await project.testClient.send(
+      HoverRequest(textDocument: TextDocumentIdentifier(uri), position: positions["1️⃣"])
+    )
+    let preEditHoverContent = try XCTUnwrap(preEditHover?.contents.markupContent?.value)
+    XCTAssert(
+      preEditHoverContent.contains("String"),
+      "Pre edit hover content '\(preEditHoverContent)' does not contain 'String'"
+    )
+
+    let libAUri = try project.uri(for: "LibA.swift")
+    try "public let myVar: Int".write(to: try XCTUnwrap(libAUri.fileURL), atomically: true, encoding: .utf8)
+    project.testClient.send(DidChangeWatchedFilesNotification(changes: [FileEvent(uri: libAUri, type: .changed)]))
+
+    try await repeatUntilExpectedResult {
+      let postEditHover = try await project.testClient.send(
+        HoverRequest(textDocument: TextDocumentIdentifier(uri), position: positions["1️⃣"])
+      )
+      return try XCTUnwrap(postEditHover?.contents.markupContent?.value).contains("Int")
+    }
+  }
 }
 
 extension HoverResponseContents {