Implement pull-model documentDiagnostics

Author: tristanlabelle

Sources/LanguageServerProtocol/SupportTypes/RegistrationOptions.swift

@@ -171,12 +171,7 @@ public struct DiagnosticRegistrationOptions: RegistrationOptions, TextDocumentRe
 
   public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
     textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
-
-    dict["interFileDependencies"] = .bool(diagnosticOptions.interFileDependencies)
-    dict["workspaceDiagnostics"] = .bool(diagnosticOptions.workspaceDiagnostics)
-    if let workDoneProgress = diagnosticOptions.workDoneProgress {
-      dict["workDoneProgress"] = .bool(workDoneProgress)
-    }
+    diagnosticOptions.encodeIntoLSPAny(dict: &dict)
   }
 }
 

Sources/LanguageServerProtocol/SupportTypes/ServerCapabilities.swift

@@ -868,9 +868,6 @@ public struct DiagnosticOptions: WorkDoneProgressOptions, Codable, Hashable {
   /// The server provides support for workspace diagnostics as well.
   public var workspaceDiagnostics: Bool
 
-  /// A document selector to identify the scope of the registration. If set to null the document selector provided on the client side will be used.
-  public var documentSelector: DocumentSelector?
-
   /// The id used to register the request. The id can be used to deregister the request again. See also Registration#id
   public var id: String?
 
@@ -880,17 +877,29 @@ public struct DiagnosticOptions: WorkDoneProgressOptions, Codable, Hashable {
     identifier: String? = nil,
     interFileDependencies: Bool,
     workspaceDiagnostics: Bool,
-    documentSelector: DocumentSelector? = nil,
     id: String? = nil,
     workDoneProgress: Bool? = nil
   ) {
     self.identifier = identifier
     self.interFileDependencies = interFileDependencies
     self.workspaceDiagnostics = workspaceDiagnostics
-    self.documentSelector = documentSelector
     self.id = id
     self.workDoneProgress = workDoneProgress
   }
+
+  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
+    if let identifier = identifier {
+      dict["identifier"] = .string(identifier)
+    }
+    dict["interFileDependencies"] = .bool(interFileDependencies)
+    dict["workspaceDiagnostics"] = .bool(workspaceDiagnostics)
+    if let id = id {
+      dict["id"] = .string(id)
+    }
+    if let workDoneProgress = workDoneProgress {
+      dict["workDoneProgress"] = .bool(workDoneProgress)
+    }
+  }
 }
 
 public struct WorkspaceServerCapabilities: Codable, Hashable {

Sources/SourceKitD/sourcekitd_uids.swift

@@ -177,6 +177,7 @@ public struct sourcekitd_requests {
   public let codecomplete_update: sourcekitd_uid_t
   public let codecomplete_close: sourcekitd_uid_t
   public let cursorinfo: sourcekitd_uid_t
+  public let diagnostics: sourcekitd_uid_t
   public let expression_type: sourcekitd_uid_t
   public let find_usr: sourcekitd_uid_t
   public let variable_type: sourcekitd_uid_t
@@ -194,6 +195,7 @@ public struct sourcekitd_requests {
     codecomplete_update = api.uid_get_from_cstr("source.request.codecomplete.update")!
     codecomplete_close = api.uid_get_from_cstr("source.request.codecomplete.close")!
     cursorinfo = api.uid_get_from_cstr("source.request.cursorinfo")!
+    diagnostics = api.uid_get_from_cstr("source.request.diagnostics")!
     expression_type = api.uid_get_from_cstr("source.request.expression.type")!
     find_usr = api.uid_get_from_cstr("source.request.editor.find_usr")!
     variable_type = api.uid_get_from_cstr("source.request.variable.type")!

Sources/SourceKitLSP/CapabilityRegistry.swift

@@ -62,8 +62,7 @@ public final class CapabilityRegistry {
   public var clientHasDynamicInlayHintRegistration: Bool {
     clientCapabilities.textDocument?.inlayHint?.dynamicRegistration == true
   }
-
-  public var clientHasDocumentDiagnosticsRegistration: Bool {
+  public var clientHasDynamicDocumentDiagnosticsRegistration: Bool {
     clientCapabilities.textDocument?.diagnostic?.dynamicRegistration == true
   }
 
@@ -75,6 +74,14 @@ public final class CapabilityRegistry {
     clientCapabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration == true
   }
 
+  public var clientHasSemanticTokenRefreshSupport: Bool {
+    clientCapabilities.workspace?.semanticTokens?.refreshSupport == true
+  }
+
+  public var clientHasDiagnosticsCodeDescriptionSupport: Bool {
+    clientCapabilities.textDocument?.publishDiagnostics?.codeDescriptionSupport == true
+  }
+
   /// Dynamically register completion capabilities if the client supports it and
   /// we haven't yet registered any completion capabilities for the given
   /// languages.
@@ -216,7 +223,7 @@ public final class CapabilityRegistry {
     for languages: [Language],
     registerOnClient: ClientRegistrationHandler
   ) {
-    guard clientHasDocumentDiagnosticsRegistration else { return }
+    guard clientHasDynamicDocumentDiagnosticsRegistration else { return }
     if let registration = registration(for: languages, in: pullDiagnostics) {
       if options != registration.diagnosticOptions {
         log("Unable to register new pull diagnostics options \(options) for " +
@@ -266,13 +273,26 @@ public final class CapabilityRegistry {
     if registration.method == CompletionRequest.method {
       completion.removeValue(forKey: registration)
     }
+    if registration.method == FoldingRangeRequest.method {
+      foldingRange.removeValue(forKey: registration)
+    }
     if registration.method == SemanticTokensRegistrationOptions.method {
       semanticTokens.removeValue(forKey: registration)
     }
+    if registration.method == InlayHintRequest.method {
+      inlayHint.removeValue(forKey: registration)
+    }
+    if registration.method == DocumentDiagnosticsRequest.method {
+      pullDiagnostics.removeValue(forKey: registration)
+    }
+  }
+
+  public func pullDiagnosticsRegistration(for language: Language) -> DiagnosticRegistrationOptions? {
+    registration(for: [language], in: pullDiagnostics)
   }
 
-  private func documentSelector(for langauges: [Language]) -> DocumentSelector {
-    return DocumentSelector(langauges.map { DocumentFilter(language: $0.rawValue) })
+  private func documentSelector(for languages: [Language]) -> DocumentSelector {
+    return DocumentSelector(languages.map { DocumentFilter(language: $0.rawValue) })
   }
 
   private func encode<T: RegistrationOptions>(_ options: T) -> LSPAny {

Sources/SourceKitLSP/Clang/ClangLanguageServer.swift

@@ -103,7 +103,6 @@ final class ClangLanguageServerShim: LanguageServer, ToolchainLanguageServer {
   public init?(
     client: LocalConnection,
     toolchain: Toolchain,
-    clientCapabilities: ClientCapabilities?,
     options: SourceKitServer.Options,
     workspace: Workspace,
     reopenDocuments: @escaping (ToolchainLanguageServer) -> Void

Sources/SourceKitLSP/SourceKitServer.swift

@@ -1766,7 +1766,6 @@ func languageService(
   let server = try languageServerType.serverType.init(
     client: connectionToClient,
     toolchain: toolchain,
-    clientCapabilities: workspace.capabilityRegistry.clientCapabilities,
     options: options,
     workspace: workspace,
     reopenDocuments: reopenDocuments

Sources/SourceKitLSP/Swift/CodeCompletion.swift

@@ -139,8 +139,8 @@ extension SwiftLanguageServer {
       let typeName: String? = value[self.keys.typename]
       let docBrief: String? = value[self.keys.doc_brief]
 
-      let clientCompletionCapabilities = self.clientCapabilities.textDocument?.completion
-      let clientSupportsSnippets = clientCompletionCapabilities?.completionItem?.snippetSupport == true
+      let completionCapabilities = self.capabilityRegistry.clientCapabilities.textDocument?.completion
+      let clientSupportsSnippets = completionCapabilities?.completionItem?.snippetSupport == true
       let text = insertText.map {
         rewriteSourceKitPlaceholders(inString: $0, clientSupportsSnippets: clientSupportsSnippets)
       }

Sources/SourceKitLSP/Swift/SwiftLanguageServer.swift

@@ -103,7 +103,7 @@ public final class SwiftLanguageServer: ToolchainLanguageServer {
 
   let sourcekitd: SourceKitD
 
-  let clientCapabilities: ClientCapabilities
+  let capabilityRegistry: CapabilityRegistry
 
   let serverOptions: SourceKitServer.Options
 
@@ -122,6 +122,14 @@ public final class SwiftLanguageServer: ToolchainLanguageServer {
   var keys: sourcekitd_keys { return sourcekitd.keys }
   var requests: sourcekitd_requests { return sourcekitd.requests }
   var values: sourcekitd_values { return sourcekitd.values }
+
+  var enablePublishDiagnostics: Bool {
+    // Since LSP 3.17.0, diagnostics can be reported through pull-based requests,
+    // in addition to the existing push-based publish notifications.
+    // If the client supports pull diagnostics, we report the capability
+    // and we should disable the publish notifications to avoid double-reporting.
+    return capabilityRegistry.pullDiagnosticsRegistration(for: .swift) == nil
+  }
 
   private var state: LanguageServerState {
     didSet {
@@ -144,15 +152,14 @@ public final class SwiftLanguageServer: ToolchainLanguageServer {
   public init?(
     client: LocalConnection,
     toolchain: Toolchain,
-    clientCapabilities: ClientCapabilities?,
     options: SourceKitServer.Options,
     workspace: Workspace,
     reopenDocuments: @escaping (ToolchainLanguageServer) -> Void
   ) throws {
     guard let sourcekitd = toolchain.sourcekitd else { return nil }
     self.client = client
     self.sourcekitd = try SourceKitDImpl.getOrCreate(dylibPath: sourcekitd)
-    self.clientCapabilities = clientCapabilities ?? ClientCapabilities(workspace: nil, textDocument: nil)
+    self.capabilityRegistry = workspace.capabilityRegistry
     self.serverOptions = options
     self.documentManager = DocumentManager()
     self.state = .connected
@@ -242,7 +249,7 @@ public final class SwiftLanguageServer: ToolchainLanguageServer {
 
   /// Inform the client about changes to the syntax highlighting tokens.
   private func requestTokensRefresh() {
-    if clientCapabilities.workspace?.semanticTokens?.refreshSupport ?? false {
+    if capabilityRegistry.clientHasSemanticTokenRefreshSupport {
       _ = client.send(WorkspaceSemanticTokensRefreshRequest(), queue: queue) { result in
         if let error = result.failure {
           log("refreshing tokens failed: \(error)", level: .warning)
@@ -285,8 +292,7 @@ public final class SwiftLanguageServer: ToolchainLanguageServer {
     let stageUID: sourcekitd_uid_t? = response[sourcekitd.keys.diagnostic_stage]
     let stage = stageUID.flatMap { DiagnosticStage($0, sourcekitd: sourcekitd) } ?? .sema
 
-    let supportsCodeDescription =
-           (clientCapabilities.textDocument?.publishDiagnostics?.codeDescriptionSupport == true)
+    let supportsCodeDescription = capabilityRegistry.clientHasDiagnosticsCodeDescriptionSupport
 
     // Note: we make the notification even if there are no diagnostics to clear the current state.
     var newDiags: [CachedDiagnostic] = []
@@ -326,7 +332,10 @@ public final class SwiftLanguageServer: ToolchainLanguageServer {
     req[keys.sourcetext] = ""
 
     if let dict = try? self.sourcekitd.sendSync(req) {
-      publishDiagnostics(response: dict, for: snapshot, compileCommand: compileCommand)
+      if (enablePublishDiagnostics) {
+        publishDiagnostics(response: dict, for: snapshot, compileCommand: compileCommand)
+      }
+
       if dict[keys.diagnostic_stage] as sourcekitd_uid_t? == sourcekitd.values.diag_stage_sema {
         // Only update semantic tokens if the 0,0 replacetext request returned semantic information.
         updateSemanticTokens(response: dict, for: snapshot)
@@ -370,7 +379,10 @@ extension SwiftLanguageServer {
         range: .bool(true),
         full: .bool(true)),
       inlayHintProvider: .value(InlayHintOptions(
-        resolveProvider: false))
+        resolveProvider: false)),
+      diagnosticProvider: DiagnosticOptions(
+        interFileDependencies: true,
+        workspaceDiagnostics: false)
     ))
   }
 
@@ -964,6 +976,7 @@ extension SwiftLanguageServer {
   }
 
   public func foldingRange(_ req: Request<FoldingRangeRequest>) {
+    let foldingRangeCapabilities = capabilityRegistry.clientCapabilities.textDocument?.foldingRange
     queue.async {
       guard let snapshot = self.documentManager.latestSnapshot(req.params.textDocument.uri) else {
         log("failed to find snapshot for url \(req.params.textDocument.uri)")
@@ -1142,17 +1155,16 @@ extension SwiftLanguageServer {
         }
       }
 
-      let capabilities = self.clientCapabilities.textDocument?.foldingRange
       // If the limit is less than one, do nothing.
-      if let limit = capabilities?.rangeLimit, limit <= 0 {
+      if let limit = foldingRangeCapabilities?.rangeLimit, limit <= 0 {
         req.reply([])
         return
       }
 
       let rangeFinder = FoldingRangeFinder(
         snapshot: snapshot,
-        rangeLimit: capabilities?.rangeLimit,
-        lineFoldingOnly: capabilities?.lineFoldingOnly ?? false)
+        rangeLimit: foldingRangeCapabilities?.rangeLimit,
+        lineFoldingOnly: foldingRangeCapabilities?.lineFoldingOnly ?? false)
       rangeFinder.walk(sourceFile)
       let ranges = rangeFinder.finalize()
 
@@ -1167,12 +1179,12 @@ extension SwiftLanguageServer {
     ]
     let wantedActionKinds = req.params.context.only
     let providers = providersAndKinds.filter { wantedActionKinds?.contains($0.1) != false }
+    let codeActionCapabilities = capabilityRegistry.clientCapabilities.textDocument?.codeAction
     retrieveCodeActions(req, providers: providers.map { $0.provider }) { result in
       switch result {
       case .success(let codeActions):
-        let capabilities = self.clientCapabilities.textDocument?.codeAction
         let response = CodeActionRequestResponse(codeActions: codeActions,
-                                                 clientCapabilities: capabilities)
+                                                 clientCapabilities: codeActionCapabilities)
         req.reply(response)
       case .failure(let error):
         req.reply(.failure(error))
@@ -1332,6 +1344,76 @@ extension SwiftLanguageServer {
     req.reply(.failure(.unknown("Pull-model diagnostics not implemented yet.")))
   }
 
+  // Must be called on self.queue
+  public func _documentDiagnostic(
+    _ uri: DocumentURI,
+    _ completion: @escaping (Result<[Diagnostic], ResponseError>) -> Void
+  ) {
+    dispatchPrecondition(condition: .onQueue(queue))
+
+    guard let snapshot = documentManager.latestSnapshot(uri) else {
+      let msg = "failed to find snapshot for url \(uri)"
+      log(msg)
+      return completion(.failure(.unknown(msg)))
+    }
+
+    let keys = self.keys
+
+    let skreq = SKDRequestDictionary(sourcekitd: self.sourcekitd)
+    skreq[keys.request] = requests.diagnostics
+    skreq[keys.sourcefile] = snapshot.document.uri.pseudoPath
+
+    // FIXME: SourceKit should probably cache this for us.
+    if let compileCommand = self.commandsByFile[uri] {
+      skreq[keys.compilerargs] = compileCommand.compilerArgs
+    }
+
+    let supportsCodeDescription = capabilityRegistry.clientHasDiagnosticsCodeDescriptionSupport
+
+    let handle = self.sourcekitd.send(skreq, self.queue) { response in
+      guard let dict = response.success else {
+        return completion(.failure(ResponseError(response.failure!)))
+      }
+
+      var diagnostics: [Diagnostic] = []
+      dict[keys.diagnostics]?.forEach { _, diag in
+        if let diagnostic = Diagnostic(diag, in: snapshot, useEducationalNoteAsCode: supportsCodeDescription) {
+          diagnostics.append(diagnostic)
+        }
+        return true
+      }
+
+      completion(.success(diagnostics))
+    }
+
+    // FIXME: cancellation
+    _ = handle
+  }
+  
+  public func documentDiagnostic(
+    _ uri: DocumentURI,
+    _ completion: @escaping (Result<[Diagnostic], ResponseError>) -> Void
+  ) {
+    self.queue.async {
+      self._documentDiagnostic(uri, completion)
+    }
+  }
+
+  public func documentDiagnostic(_ req: Request<DocumentDiagnosticsRequest>) {
+    let uri = req.params.textDocument.uri
+    documentDiagnostic(req.params.textDocument.uri) { result in
+      switch result {
+        case .success(let diagnostics):
+          req.reply(.full(.init(items: diagnostics)))
+
+        case .failure(let error):
+          let message = "document diagnostic failed \(uri): \(error)"
+          log(message, level: .warning)
+          return req.reply(.failure(.unknown(message)))
+      }
+    }
+  }
+
   public func executeCommand(_ req: Request<ExecuteCommandRequest>) {
     let params = req.params
     //TODO: If there's support for several types of commands, we might need to structure this similarly to the code actions request.

Sources/SourceKitLSP/ToolchainLanguageServer.swift

@@ -32,7 +32,6 @@ public protocol ToolchainLanguageServer: AnyObject {
   init?(
     client: LocalConnection,
     toolchain: Toolchain,
-    clientCapabilities: ClientCapabilities?,
     options: SourceKitServer.Options,
     workspace: Workspace,
     reopenDocuments: @escaping (ToolchainLanguageServer) -> Void

Tests/SourceKitLSPTests/DiagnosticsTests.swift renamed to Tests/SourceKitLSPTests/PublishDiagnosticsTests.swift

@@ -15,7 +15,7 @@ import LSPTestSupport
 import SKTestSupport
 import XCTest
 
-final class DiagnosticsTests: XCTestCase {
+final class PublishDiagnosticsTests: XCTestCase {
   /// Connection and lifetime management for the service.
   var connection: TestSourceKitServer! = nil
 
@@ -28,7 +28,7 @@ final class DiagnosticsTests: XCTestCase {
 
   override func setUp() {
     version = 0
-    uri = DocumentURI(URL(fileURLWithPath: "/DiagnosticsTests/\(UUID()).swift"))
+    uri = DocumentURI(URL(fileURLWithPath: "/PublishDiagnosticsTests/\(UUID()).swift"))
     connection = TestSourceKitServer()
     sk = connection.client
     let documentCapabilities = TextDocumentClientCapabilities()