Log contextual requests that affect sourcekitd’s global state

This way we can log them when a sourcekitd request crashes and we can thus replay these contextual requests when diagnosing the crash.

Author: ahoppen

Package.swift

@@ -429,6 +429,7 @@ var targets: [Target] = [
     dependencies: [
       "BuildSystemIntegration",
       "CSKTestSupport",
+      "Csourcekitd",
       "InProcessClient",
       "LanguageServerProtocol",
       "LanguageServerProtocolExtensions",

Sources/SKTestSupport/SkipUnless.swift

@@ -259,11 +259,11 @@ package actor SkipUnless {
       )
       do {
         let response = try await sourcekitd.send(
+          \.codeCompleteSetPopularAPI,
           sourcekitd.dictionary([
-            sourcekitd.keys.request: sourcekitd.requests.codeCompleteSetPopularAPI,
             sourcekitd.keys.codeCompleteOptions: [
               sourcekitd.keys.useNewAPI: 1
-            ],
+            ]
           ]),
           timeout: defaultTimeoutDuration
         )

Sources/SKTestSupport/SourceKitD+send.swift

@@ -10,19 +10,23 @@
 //
 //===----------------------------------------------------------------------===//
 
+package import Csourcekitd
 package import SourceKitD
 
 extension SourceKitD {
   /// Convenience overload of the `send` function for testing that doesn't restart sourcekitd if it does not respond
   /// and doesn't pass any file contents.
   package func send(
+    _ requestUid: KeyPath<sourcekitd_api_requests, sourcekitd_api_uid_t>,
     _ request: SKDRequestDictionary,
-    timeout: Duration
+    timeout: Duration = defaultTimeoutDuration
   ) async throws -> SKDResponseDictionary {
     return try await self.send(
+      requestUid,
       request,
       timeout: timeout,
       restartTimeout: .seconds(60 * 60 * 24),
+      documentUrl: nil,
       fileContents: nil
     )
   }

Sources/SourceKitD/SourceKitD.swift

@@ -315,18 +315,60 @@ package actor SourceKitD {
     }
   }
 
+  private struct ContextualRequest {
+    enum Kind {
+      case editorOpen
+      case codeCompleteOpen
+    }
+    let kind: Kind
+    let request: SKDRequestDictionary
+  }
+
+  private var contextualRequests: [URL: [ContextualRequest]] = [:]
+
+  private func recordContextualRequest(
+    requestUid: sourcekitd_api_uid_t,
+    request: SKDRequestDictionary,
+    documentUrl: URL?
+  ) {
+    guard let documentUrl else {
+      return
+    }
+    switch requestUid {
+    case requests.editorOpen:
+      contextualRequests[documentUrl] = [ContextualRequest(kind: .editorOpen, request: request)]
+    case requests.editorClose:
+      contextualRequests[documentUrl] = nil
+    case requests.codeCompleteOpen:
+      contextualRequests[documentUrl, default: []].removeAll(where: { $0.kind == .codeCompleteOpen })
+      contextualRequests[documentUrl, default: []].append(ContextualRequest(kind: .codeCompleteOpen, request: request))
+    case requests.codeCompleteClose:
+      contextualRequests[documentUrl, default: []].removeAll(where: { $0.kind == .codeCompleteOpen })
+      if contextualRequests[documentUrl]?.isEmpty ?? false {
+        contextualRequests[documentUrl] = nil
+      }
+    default:
+      break
+    }
+  }
+
   /// - Parameters:
   ///   - request: The request to send to sourcekitd.
   ///   - timeout: The maximum duration how long to wait for a response. If no response is returned within this time,
   ///     declare the request as having timed out.
   ///   - fileContents: The contents of the file that the request operates on. If sourcekitd crashes, the file contents
   ///     will be logged.
   package func send(
+    _ requestUid: KeyPath<sourcekitd_api_requests, sourcekitd_api_uid_t>,
     _ request: SKDRequestDictionary,
     timeout: Duration,
     restartTimeout: Duration,
+    documentUrl: URL?,
     fileContents: String?
   ) async throws -> SKDResponseDictionary {
+    request.set(keys.request, to: requests[keyPath: requestUid])
+    recordContextualRequest(requestUid: requests[keyPath: requestUid], request: request, documentUrl: documentUrl)
+
     let sourcekitdResponse = try await withTimeout(timeout) {
       let restartTimeoutHandle = TimeoutHandle()
       do {
@@ -387,13 +429,24 @@ package actor SourceKitD {
 
     guard let dict = sourcekitdResponse.value else {
       if sourcekitdResponse.error == .connectionInterrupted {
-        let log = """
+        var log = """
           Request:
           \(request.description)
 
           File contents:
           \(fileContents ?? "<nil>")
           """
+
+        if let documentUrl {
+          let contextualRequests = (contextualRequests[documentUrl] ?? []).filter { $0.request !== request }
+          for (index, contextualRequest) in contextualRequests.enumerated() {
+            log += """
+
+              Contextual request \(index + 1) / \(contextualRequests.count):
+              \(contextualRequest.request.description)
+              """
+          }
+        }
         let chunks = splitLongMultilineMessage(message: log)
         for (index, chunk) in chunks.enumerated() {
           logger.fault(
@@ -414,10 +467,14 @@ package actor SourceKitD {
   }
 
   package func crash() async {
-    let req = dictionary([
-      keys.request: requests.crashWithExit
-    ])
-    _ = try? await send(req, timeout: .seconds(60), restartTimeout: .seconds(24 * 60 * 60), fileContents: nil)
+    _ = try? await send(
+      \.crashWithExit,
+      dictionary([:]),
+      timeout: .seconds(60),
+      restartTimeout: .seconds(24 * 60 * 60),
+      documentUrl: nil,
+      fileContents: nil
+    )
   }
 }
 

Sources/SourceKitLSP/Rename.swift

@@ -353,7 +353,6 @@ extension SwiftLanguageService {
     }
 
     let req = sourcekitd.dictionary([
-      keys.request: sourcekitd.requests.nameTranslation,
       keys.sourceFile: snapshot.uri.pseudoPath,
       keys.compilerArgs: await self.compileCommand(for: snapshot.uri, fallbackAfterTimeout: false)?.compilerArgs
         as [SKDRequestValue]?,
@@ -363,7 +362,7 @@ extension SwiftLanguageService {
       keys.argNames: sourcekitd.array(name.parameters.map { $0.stringOrWildcard }),
     ])
 
-    let response = try await sendSourcekitdRequest(req, fileContents: snapshot.text)
+    let response = try await send(sourcekitdRequest: \.nameTranslation, req, snapshot: snapshot)
 
     guard let isZeroArgSelector: Int = response[keys.isZeroArgSelector],
       let selectorPieces: SKDResponseArray = response[keys.selectorPieces]
@@ -405,7 +404,6 @@ extension SwiftLanguageService {
     name: String
   ) async throws -> String {
     let req = sourcekitd.dictionary([
-      keys.request: sourcekitd.requests.nameTranslation,
       keys.sourceFile: snapshot.uri.pseudoPath,
       keys.compilerArgs: await self.compileCommand(for: snapshot.uri, fallbackAfterTimeout: false)?.compilerArgs
         as [SKDRequestValue]?,
@@ -421,7 +419,7 @@ extension SwiftLanguageService {
       req.set(keys.baseName, to: name)
     }
 
-    let response = try await sendSourcekitdRequest(req, fileContents: snapshot.text)
+    let response = try await send(sourcekitdRequest: \.nameTranslation, req, snapshot: snapshot)
 
     guard let baseName: String = response[keys.baseName] else {
       throw NameTranslationError.malformedClangToSwiftTranslateNameResponse(response)
@@ -886,15 +884,14 @@ extension SwiftLanguageService {
     )
 
     let skreq = sourcekitd.dictionary([
-      keys.request: requests.findRenameRanges,
       keys.sourceFile: snapshot.uri.pseudoPath,
       // find-syntactic-rename-ranges is a syntactic sourcekitd request that doesn't use the in-memory file snapshot.
       // We need to send the source text again.
       keys.sourceText: snapshot.text,
       keys.renameLocations: locations,
     ])
 
-    let syntacticRenameRangesResponse = try await sendSourcekitdRequest(skreq, fileContents: snapshot.text)
+    let syntacticRenameRangesResponse = try await send(sourcekitdRequest: \.findRenameRanges, skreq, snapshot: snapshot)
     guard let categorizedRanges: SKDResponseArray = syntacticRenameRangesResponse[keys.categorizedRanges] else {
       throw ResponseError.internalError("sourcekitd did not return categorized ranges")
     }

Sources/SourceKitLSP/Swift/CodeCompletionSession.swift

@@ -264,7 +264,6 @@ class CodeCompletionSession {
     self.clientSupportsDocumentationResolve =
       clientCapabilities.textDocument?.completion?.completionItem?.resolveSupport?.properties.contains("documentation")
       ?? false
-
   }
 
   private func open(
@@ -279,7 +278,6 @@ class CodeCompletionSession {
 
     let sourcekitdPosition = snapshot.sourcekitdPosition(of: self.position)
     let req = sourcekitd.dictionary([
-      keys.request: sourcekitd.requests.codeCompleteOpen,
       keys.line: sourcekitdPosition.line,
       keys.column: sourcekitdPosition.utf8Column,
       keys.name: uri.pseudoPath,
@@ -288,7 +286,7 @@ class CodeCompletionSession {
       keys.codeCompleteOptions: optionsDictionary(filterText: filterText),
     ])
 
-    let dict = try await sendSourceKitdRequest(req, snapshot: snapshot)
+    let dict = try await send(sourceKitDRequest: \.codeCompleteOpen, req, snapshot: snapshot)
     self.state = .open
 
     guard let completions: SKDResponseArray = dict[keys.results] else {
@@ -314,15 +312,14 @@ class CodeCompletionSession {
     logger.info("Updating code completion session: \(self.description) filter=\(filterText)")
     let sourcekitdPosition = snapshot.sourcekitdPosition(of: self.position)
     let req = sourcekitd.dictionary([
-      keys.request: sourcekitd.requests.codeCompleteUpdate,
       keys.line: sourcekitdPosition.line,
       keys.column: sourcekitdPosition.utf8Column,
       keys.name: uri.pseudoPath,
       keys.sourceFile: uri.pseudoPath,
       keys.codeCompleteOptions: optionsDictionary(filterText: filterText),
     ])
 
-    let dict = try await sendSourceKitdRequest(req, snapshot: snapshot)
+    let dict = try await send(sourceKitDRequest: \.codeCompleteUpdate, req, snapshot: snapshot)
     guard let completions: SKDResponseArray = dict[keys.results] else {
       return CompletionList(isIncomplete: false, items: [])
     }
@@ -363,29 +360,31 @@ class CodeCompletionSession {
     case .open:
       let sourcekitdPosition = snapshot.sourcekitdPosition(of: self.position)
       let req = sourcekitd.dictionary([
-        keys.request: sourcekitd.requests.codeCompleteClose,
         keys.line: sourcekitdPosition.line,
         keys.column: sourcekitdPosition.utf8Column,
         keys.sourceFile: snapshot.uri.pseudoPath,
         keys.name: snapshot.uri.pseudoPath,
         keys.codeCompleteOptions: [keys.useNewAPI: 1],
       ])
       logger.info("Closing code completion session: \(self.description)")
-      _ = try? await sendSourceKitdRequest(req, snapshot: nil)
+      _ = try? await send(sourceKitDRequest: \.codeCompleteClose, req, snapshot: nil)
       self.state = .closed
     }
   }
 
   // MARK: - Helpers
 
-  private func sendSourceKitdRequest(
+  private func send(
+    sourceKitDRequest requestUid: KeyPath<sourcekitd_api_requests, sourcekitd_api_uid_t> & Sendable,
     _ request: SKDRequestDictionary,
     snapshot: DocumentSnapshot?
   ) async throws -> SKDResponseDictionary {
     try await sourcekitd.send(
+      requestUid,
       request,
       timeout: options.sourcekitdRequestTimeoutOrDefault,
       restartTimeout: options.semanticServiceRestartTimeoutOrDefault,
+      documentUrl: snapshot?.uri.arbitrarySchemeURL,
       fileContents: snapshot?.text
     )
   }
@@ -560,11 +559,17 @@ class CodeCompletionSession {
     var item = item
     if let itemId = CompletionItemData(fromLSPAny: item.data)?.itemId {
       let req = sourcekitd.dictionary([
-        sourcekitd.keys.request: sourcekitd.requests.codeCompleteDocumentation,
-        sourcekitd.keys.identifier: itemId,
+        sourcekitd.keys.identifier: itemId
       ])
       let documentationResponse = await orLog("Retrieving documentation for completion item") {
-        try await sourcekitd.send(req, timeout: timeout, restartTimeout: restartTimeout, fileContents: nil)
+        try await sourcekitd.send(
+          \.codeCompleteDocumentation,
+          req,
+          timeout: timeout,
+          restartTimeout: restartTimeout,
+          documentUrl: nil,
+          fileContents: nil
+        )
       }
       if let docString: String = documentationResponse?[sourcekitd.keys.docBrief] {
         item.documentation = .markupContent(MarkupContent(kind: .markdown, value: docString))

Sources/SourceKitLSP/Swift/CursorInfo.swift

@@ -158,7 +158,6 @@ extension SwiftLanguageService {
     let keys = self.keys
 
     let skreq = sourcekitd.dictionary([
-      keys.request: requests.cursorInfo,
       keys.cancelOnSubsequentRequest: 0,
       keys.offset: offsetRange.lowerBound,
       keys.length: offsetRange.upperBound != offsetRange.lowerBound ? offsetRange.count : nil,
@@ -170,7 +169,7 @@ extension SwiftLanguageService {
 
     appendAdditionalParameters?(skreq)
 
-    let dict = try await sendSourcekitdRequest(skreq, fileContents: snapshot.text)
+    let dict = try await send(sourcekitdRequest: \.cursorInfo, skreq, snapshot: snapshot)
 
     var cursorInfoResults: [CursorInfo] = []
     if let cursorInfo = CursorInfo(dict, snapshot: snapshot, documentManager: documentManager, sourcekitd: sourcekitd) {

Sources/SourceKitLSP/Swift/DiagnosticReportManager.swift

@@ -107,7 +107,6 @@ actor DiagnosticReportManager {
     let keys = self.keys
 
     let skreq = sourcekitd.dictionary([
-      keys.request: requests.diagnostics,
       keys.sourceFile: snapshot.uri.sourcekitdSourceFile,
       keys.primaryFile: snapshot.uri.primaryFile?.pseudoPath,
       keys.compilerArgs: compilerArgs as [SKDRequestValue],
@@ -116,9 +115,11 @@ actor DiagnosticReportManager {
     let dict: SKDResponseDictionary
     do {
       dict = try await self.sourcekitd.send(
+        \.diagnostics,
         skreq,
         timeout: options.sourcekitdRequestTimeoutOrDefault,
         restartTimeout: options.semanticServiceRestartTimeoutOrDefault,
+        documentUrl: snapshot.uri.arbitrarySchemeURL,
         fileContents: snapshot.text
       )
     } catch SKDError.requestFailed(let sourcekitdError) {