Infer build settings from a sibling file if current file doesn’t have build settings

Author: ahoppen

Sources/BuildServerIntegration/BuildServerManager.swift

@@ -1119,6 +1119,64 @@ package actor BuildServerManager: QueueBasedMessageHandler {
     return settings
   }
 
+  /// Try finding a source file with the same language as `document` in the same directory as `document` and patch its
+  /// build settings to provide more accurate fallback settings than the generic fallback settings.
+  private func fallbackBuildSettingsInferredFromSiblingFile(
+    of document: DocumentURI,
+    target explicitlyRequestedTarget: BuildTargetIdentifier?,
+    language: Language?,
+    fallbackAfterTimeout: Bool
+  ) async throws -> FileBuildSettings? {
+    guard let documentFileURL = document.fileURL else {
+      return nil
+    }
+    let directory = documentFileURL.deletingLastPathComponent()
+    guard let language = language ?? Language(inferredFromFileExtension: document) else {
+      return nil
+    }
+    let siblingFile = try await self.sourceFilesAndDirectories().files.compactMap { (uri, info) -> DocumentURI? in
+      guard info.isBuildable, uri.fileURL?.deletingLastPathComponent() == directory else {
+        return nil
+      }
+      if let explicitlyRequestedTarget, !info.targets.contains(explicitlyRequestedTarget) {
+        return nil
+      }
+      // Only consider build settings from sibling files that appear to have the same language. In theory, we might skip
+      // valid sibling files because of this since non-standard file extension might be mapped to `language` by the
+      // build server, but this is a good first check to avoid requesting build settings for too many documents. And
+      // since all of this is fallback-logic, skipping over possibly valid files is not a correctness issue.
+      guard let siblingLanguage = Language(inferredFromFileExtension: uri), siblingLanguage == language else {
+        return nil
+      }
+      return uri
+    }.sorted(by: { $0.pseudoPath < $1.pseudoPath }).first
+
+    guard let siblingFile else {
+      return nil
+    }
+
+    let siblingSettings = await self.buildSettingsInferredFromMainFile(
+      for: siblingFile,
+      target: explicitlyRequestedTarget,
+      language: language,
+      fallbackAfterTimeout: fallbackAfterTimeout,
+      allowInferenceFromSiblingFile: false
+    )
+    guard var siblingSettings, !siblingSettings.isFallback else {
+      return nil
+    }
+    siblingSettings.isFallback = true
+    switch language.semanticKind {
+    case .swift:
+      siblingSettings.compilerArguments += [try documentFileURL.filePath]
+    case .clang:
+      siblingSettings = siblingSettings.patching(newFile: document, originalFile: siblingFile)
+    case nil:
+      return nil
+    }
+    return siblingSettings
+  }
+
   /// Returns the build settings for the given document.
   ///
   /// If the document doesn't have builds settings by itself, eg. because it is a C header file, the build settings will
@@ -1135,7 +1193,8 @@ package actor BuildServerManager: QueueBasedMessageHandler {
     for document: DocumentURI,
     target explicitlyRequestedTarget: BuildTargetIdentifier? = nil,
     language: Language?,
-    fallbackAfterTimeout: Bool
+    fallbackAfterTimeout: Bool,
+    allowInferenceFromSiblingFile: Bool = true
   ) async -> FileBuildSettings? {
     func mainFileAndSettings(
       basedOn document: DocumentURI
@@ -1171,6 +1230,19 @@ package actor BuildServerManager: QueueBasedMessageHandler {
           fallbackAfterTimeout: fallbackAfterTimeout
         )
       }
+      if settings?.isFallback ?? true, allowInferenceFromSiblingFile {
+        let settingsFromSibling = await orLog("Inferring build settings from sibling file") {
+          try await self.fallbackBuildSettingsInferredFromSiblingFile(
+            of: document,
+            target: explicitlyRequestedTarget,
+            language: language,
+            fallbackAfterTimeout: fallbackAfterTimeout
+          )
+        }
+        if let settingsFromSibling {
+          return (mainFile, settingsFromSibling)
+        }
+      }
       guard let settings else {
         return nil
       }

Tests/SourceKitLSPTests/SwiftPMIntegrationTests.swift

@@ -111,80 +111,66 @@ final class SwiftPMIntegrationTests: XCTestCase {
       enableBackgroundIndexing: true
     )
 
+    // First, create a new in-memory file and verify that we get some basic functionality for it
+
     let newFileUrl = project.scratchDirectory
       .appending(components: "Sources", "MyLibrary", "Other.swift")
     let newFileUri = DocumentURI(newFileUrl)
 
     let newFileContents = """
       func baz(l: Lib)  {
         l.2️⃣foo()
+        #warning("A manual warning")
       }
       """
-    try await extractMarkers(newFileContents).textWithoutMarkers.writeWithRetry(to: newFileUrl)
-
-    // Check that we don't get cross-file code completion before we send a `DidChangeWatchedFilesNotification` to make
-    // sure we didn't include the file in the initial retrieval of build settings.
-    let (oldFileUri, oldFilePositions) = try project.openDocument("Lib.swift")
     let newFilePositions = project.testClient.openDocument(newFileContents, uri: newFileUri)
 
-    let completionsBeforeDidChangeNotification = try await project.testClient.send(
+    try await extractMarkers(newFileContents).textWithoutMarkers.writeWithRetry(to: newFileUrl)
+    let completionsBeforeSave = try await project.testClient.send(
       CompletionRequest(textDocument: TextDocumentIdentifier(newFileUri), position: newFilePositions["2️⃣"])
     )
-    XCTAssertEqual(completionsBeforeDidChangeNotification.items, [])
+    XCTAssertEqual(Set(completionsBeforeSave.items.map(\.label)), ["foo()", "self"])
+
+    // We shouldn't get diagnostics for the new file yet since we still consider the build settings inferred from a
+    // sibling file fallback settings.
+    let diagnosticsBeforeSave = try await project.testClient.send(
+      DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(newFileUri))
+    )
+    XCTAssertEqual(diagnosticsBeforeSave.fullReport?.items, [])
+
+    let (oldFileUri, oldFilePositions) = try project.openDocument("Lib.swift")
+    // Check that we don't get completions for `baz` (defined in the new file) in the old file yet because the new file
+    // is not part of the package manifest yet.
+    let oldFileCompletionsBeforeSave = try await project.testClient.send(
+      CompletionRequest(textDocument: TextDocumentIdentifier(oldFileUri), position: oldFilePositions["1️⃣"])
+    )
+    XCTAssert(!oldFileCompletionsBeforeSave.items.contains(where: { $0.label == "baz(l: Lib)" }))
+
+    // Now save the file to disk, which adds it to the package graph, which should enable more functionality.
 
-    // Send a `DidChangeWatchedFilesNotification` and verify that we now get cross-file code completion.
+    try await extractMarkers(newFileContents).textWithoutMarkers.writeWithRetry(to: newFileUrl)
     project.testClient.send(
       DidChangeWatchedFilesNotification(changes: [
         FileEvent(uri: newFileUri, type: .created)
       ])
     )
-
     // Ensure that the DidChangeWatchedFilesNotification is handled before we continue.
     try await project.testClient.send(SynchronizeRequest(index: true))
 
-    let completions = try await project.testClient.send(
+    // Check that we still get completions in the new file, now get diagnostics in the new file and also see functions
+    // from the new file in the old file
+    let completionsAfterSave = try await project.testClient.send(
       CompletionRequest(textDocument: TextDocumentIdentifier(newFileUri), position: newFilePositions["2️⃣"])
     )
-
-    XCTAssertEqual(
-      completions.items.clearingUnstableValues,
-      [
-        CompletionItem(
-          label: "foo()",
-          kind: .method,
-          detail: "Void",
-          deprecated: false,
-          sortText: nil,
-          filterText: "foo()",
-          insertText: "foo()",
-          insertTextFormat: .plain,
-          textEdit: .textEdit(
-            TextEdit(range: Range(newFilePositions["2️⃣"]), newText: "foo()")
-          )
-        ),
-        CompletionItem(
-          label: "self",
-          kind: .keyword,
-          detail: "Lib",
-          deprecated: false,
-          sortText: nil,
-          filterText: "self",
-          insertText: "self",
-          insertTextFormat: .plain,
-          textEdit: .textEdit(
-            TextEdit(range: Range(newFilePositions["2️⃣"]), newText: "self")
-          )
-        ),
-      ]
+    XCTAssertEqual(Set(completionsAfterSave.items.map(\.label)), ["foo()", "self"])
+    let diagnosticsAfterSave = try await project.testClient.send(
+      DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(newFileUri))
     )
-
-    // Check that we get code completion for `baz` (defined in the new file) in the old file.
-    // I.e. check that the existing file's build settings have been updated to include the new file.
-
-    let oldFileCompletions = try await project.testClient.send(
+    XCTAssertEqual(diagnosticsAfterSave.fullReport?.items.map(\.message), ["A manual warning"])
+    let oldFileCompletionsAfterSave = try await project.testClient.send(
       CompletionRequest(textDocument: TextDocumentIdentifier(oldFileUri), position: oldFilePositions["1️⃣"])
     )
-    XCTAssert(oldFileCompletions.items.contains(where: { $0.label == "baz(l: Lib)" }))
+    assertContains(oldFileCompletionsAfterSave.items.map(\.label), "baz(l: Lib)")
   }
 
   func testNestedPackage() async throws {