Refactor cursorInfoFromDisk to share the underlying logic of invoking cursor info

Author: ahoppen

Sources/SourceKitLSP/CMakeLists.txt

@@ -44,7 +44,6 @@ target_sources(SourceKitLSP PRIVATE
   Swift/CodeCompletionSession.swift
   Swift/CommentXML.swift
   Swift/CursorInfo.swift
-  Swift/CursorInfoFromDisk.swift
   Swift/Diagnostic.swift
   Swift/DiagnosticReportManager.swift
   Swift/DocumentFormatting.swift
@@ -77,6 +76,7 @@ target_sources(SourceKitLSP PRIVATE
   Swift/SyntaxHighlightingTokens.swift
   Swift/SyntaxTreeManager.swift
   Swift/VariableTypeInfo.swift
+  Swift/WithSnapshotFromDiskOpenedInSourcekitd.swift
 )
 set_target_properties(SourceKitLSP PROPERTIES
   INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})

Sources/SourceKitLSP/Documentation/DoccDocumentationHandler.swift

@@ -81,13 +81,18 @@ extension DocumentationLanguageService {
           )
         }
         let position = symbolSnapshot.position(of: symbolOccurrence.location)
-        let cursorInfo = try await languageService.cursorInfoFromDisk(
-          symbolOccurrence.location.documentUri,
-          position..<position,
-          includeSymbolGraph: true,
+        let symbolGraph = try await languageService.withSnapshotFromDiskOpenedInSourcekitd(
+          uri: symbolOccurrence.location.documentUri,
           fallbackSettingsAfterTimeout: false
-        )
-        guard let symbolGraph = cursorInfo.symbolGraph else {
+        ) { snapshot, compileCommand in
+          try await languageService.cursorInfo(
+            snapshot,
+            compileCommand: compileCommand,
+            Range(position),
+            includeSymbolGraph: true
+          ).symbolGraph
+        }
+        guard let symbolGraph else {
           throw ResponseError.internalError("Unable to retrieve symbol graph for \(symbolOccurrence.symbol.name)")
         }
         return try await documentationManager.renderDocCDocumentation(

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -29,7 +29,7 @@ import struct TSCBasic.AbsolutePath
 import protocol TSCBasic.FileSystem
 
 #if canImport(DocCDocumentation)
-package import DocCDocumentation
+import DocCDocumentation
 #endif
 
 /// Disambiguate LanguageServerProtocol.Language and IndexstoreDB.Language

Sources/SourceKitLSP/Swift/CursorInfo.swift

@@ -46,8 +46,14 @@ struct CursorInfo {
     self.documentation = documentation
   }
 
+  /// `snapshot` is the snapshot from which the cursor info was invoked. It is necessary to pass that snapshot in here
+  /// because snapshot might not be open in `documentManager` if cursor info was invoked using file contents from disk
+  /// using `cursorInfoFromDisk` and thus we couldn't convert positions if the snapshot wasn't passed in explicitly.
+  /// For all document other than `snapshot`, `documentManager` is used to find the latest snapshot of a document to
+  /// convert positions.
   init?(
     _ dict: SKDResponseDictionary,
+    snapshot: DocumentSnapshot,
     documentManager: DocumentManager,
     sourcekitd: some SourceKitD
   ) {
@@ -63,7 +69,13 @@ struct CursorInfo {
       let column: Int = dict[keys.column]
     {
       let uri = DocumentURI(filePath: filepath, isDirectory: false)
-      if let snapshot = documentManager.latestSnapshotOrDisk(uri, language: .swift) {
+      let snapshot: DocumentSnapshot? =
+        if snapshot.uri.sourcekitdSourceFile == filepath {
+          snapshot
+        } else {
+          documentManager.latestSnapshotOrDisk(uri, language: .swift)
+        }
+      if let snapshot {
         let position = snapshot.positionOf(zeroBasedLine: line - 1, utf8Column: column - 1)
         location = Location(uri: uri, range: Range(position))
       } else {
@@ -133,14 +145,13 @@ extension SwiftLanguageService {
   ///   - fallbackSettingsAfterTimeout: Whether fallback build settings should be used for the cursor info request if no
   ///     build settings can be retrieved within a timeout.
   func cursorInfo(
-    _ uri: DocumentURI,
+    _ snapshot: DocumentSnapshot,
+    compileCommand: SwiftCompileCommand?,
     _ range: Range<Position>,
     includeSymbolGraph: Bool = false,
-    fallbackSettingsAfterTimeout: Bool,
     additionalParameters appendAdditionalParameters: ((SKDRequestDictionary) -> Void)? = nil
   ) async throws -> (cursorInfo: [CursorInfo], refactorActions: [SemanticRefactorCommand], symbolGraph: String?) {
     let documentManager = try self.documentManager
-    let snapshot = try await self.latestSnapshot(for: uri)
 
     let offsetRange = snapshot.utf8OffsetRange(of: range)
 
@@ -154,31 +165,46 @@ extension SwiftLanguageService {
       keys.sourceFile: snapshot.uri.sourcekitdSourceFile,
       keys.primaryFile: snapshot.uri.primaryFile?.pseudoPath,
       keys.retrieveSymbolGraph: includeSymbolGraph ? 1 : 0,
-      keys.compilerArgs: await self.compileCommand(for: uri, fallbackAfterTimeout: fallbackSettingsAfterTimeout)?
-        .compilerArgs as [SKDRequestValue]?,
+      keys.compilerArgs: compileCommand?.compilerArgs as [SKDRequestValue]?,
     ])
 
     appendAdditionalParameters?(skreq)
 
     let dict = try await sendSourcekitdRequest(skreq, fileContents: snapshot.text)
 
     var cursorInfoResults: [CursorInfo] = []
-    if let cursorInfo = CursorInfo(dict, documentManager: documentManager, sourcekitd: sourcekitd) {
+    if let cursorInfo = CursorInfo(dict, snapshot: snapshot, documentManager: documentManager, sourcekitd: sourcekitd) {
       cursorInfoResults.append(cursorInfo)
     }
     cursorInfoResults +=
       dict[keys.secondarySymbols]?
-      .compactMap { CursorInfo($0, documentManager: documentManager, sourcekitd: sourcekitd) } ?? []
+      .compactMap { CursorInfo($0, snapshot: snapshot, documentManager: documentManager, sourcekitd: sourcekitd) } ?? []
     let refactorActions =
       [SemanticRefactorCommand](
         array: dict[keys.refactorActions],
         range: range,
-        textDocument: TextDocumentIdentifier(uri),
+        textDocument: TextDocumentIdentifier(snapshot.uri),
         keys,
         self.sourcekitd.api
       ) ?? []
     let symbolGraph: String? = dict[keys.symbolGraph]
 
     return (cursorInfoResults, refactorActions, symbolGraph)
   }
+
+  func cursorInfo(
+    _ uri: DocumentURI,
+    _ range: Range<Position>,
+    includeSymbolGraph: Bool = false,
+    fallbackSettingsAfterTimeout: Bool,
+    additionalParameters appendAdditionalParameters: ((SKDRequestDictionary) -> Void)? = nil
+  ) async throws -> (cursorInfo: [CursorInfo], refactorActions: [SemanticRefactorCommand], symbolGraph: String?) {
+    return try await self.cursorInfo(
+      self.latestSnapshot(for: uri),
+      compileCommand: await self.compileCommand(for: uri, fallbackAfterTimeout: fallbackSettingsAfterTimeout),
+      range,
+      includeSymbolGraph: includeSymbolGraph,
+      additionalParameters: appendAdditionalParameters
+    )
+  }
 }

Sources/SourceKitLSP/Swift/CursorInfoFromDisk.swift

@@ -14,7 +14,6 @@ import Foundation
 import LanguageServerProtocol
 
 /// Represents url of generated interface reference document.
-
 package struct GeneratedInterfaceDocumentURLData: Hashable, ReferenceURLData {
   package static let documentType = "generated-swift-interface"
 

Sources/SourceKitLSP/Swift/GeneratedInterfaceDocumentURLData.swift

@@ -528,7 +528,7 @@ extension SwiftLanguageService {
 
   // MARK: - Text synchronization
 
-  private func openDocumentSourcekitdRequest(
+  func openDocumentSourcekitdRequest(
     snapshot: DocumentSnapshot,
     compileCommand: SwiftCompileCommand?
   ) -> SKDRequestDictionary {
@@ -568,7 +568,9 @@ extension SwiftLanguageService {
       buildSettingsForOpenFiles[snapshot.uri] = buildSettings
 
       let req = openDocumentSourcekitdRequest(snapshot: snapshot, compileCommand: buildSettings)
-      _ = try? await self.sendSourcekitdRequest(req, fileContents: snapshot.text)
+      await orLog("Opening sourcekitd document") {
+        _ = try await self.sendSourcekitdRequest(req, fileContents: snapshot.text)
+      }
       await publishDiagnosticsIfNeeded(for: notification.textDocument.uri)
     }
   }
@@ -585,7 +587,9 @@ extension SwiftLanguageService {
       await generatedInterfaceManager.close(document: data)
     case nil:
       let req = closeDocumentSourcekitdRequest(uri: notification.textDocument.uri)
-      _ = try? await self.sendSourcekitdRequest(req, fileContents: nil)
+      await orLog("Closing sourcekitd document") {
+        _ = try await self.sendSourcekitdRequest(req, fileContents: nil)
+      }
     }
   }
 

Sources/SourceKitLSP/Swift/SwiftLanguageService.swift

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import BuildSystemIntegration
+import Foundation
+import LanguageServerProtocol
+import SKLogging
+import SKUtilities
+import SwiftExtensions
+
+extension SwiftLanguageService {
+  /// Open a unique dummy document in sourcekitd that has the contents of the file on disk for `uri` but an arbitrary
+  /// URI which doesn't exist on disk. Invoke `body` with a snapshot that contains the on-disk document contents and has
+  /// that dummy URI as well as build settings that were inferred from `uri` but have that URI replaced with the dummy
+  /// URI. Close the document in sourcekit after `body` has finished.
+  func withSnapshotFromDiskOpenedInSourcekitd<Result: Sendable>(
+    uri: DocumentURI,
+    fallbackSettingsAfterTimeout: Bool,
+    body: (_ snapshot: DocumentSnapshot, _ patchedCompileCommand: SwiftCompileCommand?) async throws -> Result
+  ) async throws -> Result {
+    guard let fileURL = uri.fileURL else {
+      throw ResponseError.unknown("Cannot create snapshot with on-disk contents for non-file URI \(uri.forLogging)")
+    }
+    let snapshot = DocumentSnapshot(
+      uri: try DocumentURI(filePath: "\(UUID().uuidString)/\(fileURL.filePath)", isDirectory: false),
+      language: .swift,
+      version: 0,
+      lineTable: LineTable(try String(contentsOf: fileURL, encoding: .utf8))
+    )
+    let patchedCompileCommand: SwiftCompileCommand? =
+      if let buildSettings = await self.buildSettings(
+        for: uri,
+        fallbackAfterTimeout: fallbackSettingsAfterTimeout
+      ) {
+        SwiftCompileCommand(buildSettings.patching(newFile: snapshot.uri, originalFile: uri))
+      } else {
+        nil
+      }
+
+    _ = try await sendSourcekitdRequest(
+      self.openDocumentSourcekitdRequest(snapshot: snapshot, compileCommand: patchedCompileCommand),
+      fileContents: snapshot.text
+    )
+    let result: Swift.Result<Result, Error>
+    do {
+      result = .success(try await body(snapshot, patchedCompileCommand))
+    } catch {
+      result = .failure(error)
+    }
+    await orLog("Close helper document '\(snapshot.uri)' for cursorInfoFromDisk") {
+      _ = try await sendSourcekitdRequest(
+        self.closeDocumentSourcekitdRequest(uri: snapshot.uri),
+        fileContents: snapshot.text
+      )
+    }
+    return try result.get()
+  }
+}