Merge pull request #1079 from ahoppen/ahoppen/sourcekitd-crash-status

Show an indicator in the client if sourcekitd has crashed

Author: ahoppen

Sources/SourceKitLSP/CMakeLists.txt

@@ -12,6 +12,7 @@ add_library(SourceKitLSP STATIC
   SourceKitServer+Options.swift
   TestDiscovery.swift
   ToolchainLanguageServer.swift
+  WorkDoneProgressManager.swift
   Workspace.swift
 )
 target_sources(SourceKitLSP PRIVATE

Sources/SourceKitLSP/Swift/SwiftLanguageServer.swift

@@ -127,11 +127,31 @@ public actor SwiftLanguageServer: ToolchainLanguageServer {
   nonisolated var requests: sourcekitd_api_requests { return sourcekitd.requests }
   nonisolated var values: sourcekitd_api_values { return sourcekitd.values }
 
+  /// When sourcekitd is crashed, a `WorkDoneProgressManager` that display the sourcekitd crash status in the client.
+  private var sourcekitdCrashedWorkDoneProgress: WorkDoneProgressManager?
+
   private var state: LanguageServerState {
     didSet {
       for handler in stateChangeHandlers {
         handler(oldValue, state)
       }
+
+      guard let sourceKitServer else {
+        sourcekitdCrashedWorkDoneProgress = nil
+        return
+      }
+      switch state {
+      case .connected:
+        sourcekitdCrashedWorkDoneProgress = nil
+      case .connectionInterrupted, .semanticFunctionalityDisabled:
+        if sourcekitdCrashedWorkDoneProgress == nil {
+          sourcekitdCrashedWorkDoneProgress = WorkDoneProgressManager(
+            server: sourceKitServer,
+            title: "SourceKit-LSP: Restoring functionality",
+            message: "Please run 'sourcekit-lsp diagnose' to file an issue"
+          )
+        }
+      }
     }
   }
 
@@ -149,7 +169,7 @@ public actor SwiftLanguageServer: ToolchainLanguageServer {
 
   /// Creates a language server for the given client using the sourcekitd dylib specified in `toolchain`.
   /// `reopenDocuments` is a closure that will be called if sourcekitd crashes and the `SwiftLanguageServer` asks its parent server to reopen all of its documents.
-  /// Returns `nil` if `sourcektid` couldn't be found.
+  /// Returns `nil` if `sourcekitd` couldn't be found.
   public init?(
     sourceKitServer: SourceKitServer,
     toolchain: Toolchain,
@@ -885,6 +905,12 @@ extension SwiftLanguageServer: SKDNotificationHandler {
   }
 
   private func notificationImpl(_ notification: SKDResponse) async {
+    logger.debug(
+      """
+      Received notification from sourcekitd
+      \(notification.forLogging)
+      """
+    )
     // Check if we need to update our `state` based on the contents of the notification.
     if notification.value?[self.keys.notification] == self.values.semaEnabledNotification {
       self.state = .connected
@@ -910,13 +936,6 @@ extension SwiftLanguageServer: SKDNotificationHandler {
       // Reset the document manager to reflect that.
       self.documentManager = DocumentManager()
     }
-
-    logger.debug(
-      """
-      Received notification from sourcekitd
-      \(notification.forLogging)
-      """
-    )
   }
 }
 

Sources/SourceKitLSP/WorkDoneProgressManager.swift

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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 Foundation
+import LanguageServerProtocol
+import SKSupport
+
+/// Represents a single `WorkDoneProgress` task that gets communicated with the client.
+///
+/// The work done progress is started when the object is created and ended when the object is destroyed.
+/// In between, updates can be sent to the client.
+final class WorkDoneProgressManager {
+  private let token: ProgressToken
+  private let queue = AsyncQueue<Serial>()
+  private let server: SourceKitServer
+
+  init(server: SourceKitServer, title: String, message: String? = nil) {
+    self.token = .string("WorkDoneProgress-\(UUID())")
+    self.server = server
+    queue.async { [server, token] in
+      await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
+        _ = server.client.send(CreateWorkDoneProgressRequest(token: token)) { result in
+          continuation.resume()
+        }
+      }
+      await server.sendNotificationToClient(
+        WorkDoneProgress(token: token, value: .begin(WorkDoneProgressBegin(title: title, message: message)))
+      )
+    }
+  }
+
+  func update(message: String? = nil, percentage: Int? = nil) {
+    queue.async { [server, token] in
+      await server.sendNotificationToClient(
+        WorkDoneProgress(
+          token: token,
+          value: .report(WorkDoneProgressReport(cancellable: false, message: message, percentage: percentage))
+        )
+      )
+    }
+  }
+
+  deinit {
+    queue.async { [server, token] in
+      await server.sendNotificationToClient(WorkDoneProgress(token: token, value: .end(WorkDoneProgressEnd())))
+    }
+  }
+}

Tests/SourceKitDTests/CrashRecoveryTests.swift

@@ -72,6 +72,10 @@ final class CrashRecoveryTests: XCTestCase {
       "Sanity check failed. The Hover response did not contain foo(), even before crashing sourcekitd. Received response: \(String(describing: preCrashHoverResponse))"
     )
 
+    testClient.handleNextRequest { (request: CreateWorkDoneProgressRequest) -> VoidResponse in
+      return VoidResponse()
+    }
+
     // Crash sourcekitd
 
     let sourcekitdServer =
@@ -81,33 +85,28 @@ final class CrashRecoveryTests: XCTestCase {
         in: testClient.server.workspaceForDocument(uri: uri)!
       ) as! SwiftLanguageServer
 
-    let sourcekitdCrashed = expectation(description: "sourcekitd has crashed")
-    let sourcekitdRestarted = expectation(description: "sourcekitd has been restarted (syntactic only)")
-    let semanticFunctionalityRestored = expectation(
-      description: "sourcekitd has restored semantic language functionality"
-    )
-
-    await sourcekitdServer.addStateChangeHandler { (oldState, newState) in
-      switch newState {
-      case .connectionInterrupted:
-        sourcekitdCrashed.fulfill()
-      case .semanticFunctionalityDisabled:
-        sourcekitdRestarted.fulfill()
-      case .connected:
-        semanticFunctionalityRestored.fulfill()
-      }
-    }
-
     await sourcekitdServer._crash()
 
-    try await fulfillmentOfOrThrow([sourcekitdCrashed], timeout: 5)
-    try await fulfillmentOfOrThrow([sourcekitdRestarted], timeout: 30)
+    let crashedNotification = try await testClient.nextNotification(ofType: WorkDoneProgress.self, timeout: 5)
+    XCTAssertEqual(
+      crashedNotification.value,
+      .begin(
+        WorkDoneProgressBegin(
+          title: "SourceKit-LSP: Restoring functionality",
+          message: "Please run 'sourcekit-lsp diagnose' to file an issue"
+        )
+      )
+    )
 
     // sourcekitd's semantic request timer is only started when the first semantic request comes in.
     // Send a hover request (which will fail) to trigger that timer.
     // Afterwards wait for semantic functionality to be restored.
     _ = try? await testClient.send(hoverRequest)
-    try await fulfillmentOfOrThrow([semanticFunctionalityRestored], timeout: 30)
+    let semanticFunctionalityRestoredNotification = try await testClient.nextNotification(
+      ofType: WorkDoneProgress.self,
+      timeout: 30
+    )
+    XCTAssertEqual(semanticFunctionalityRestoredNotification.value, .end(WorkDoneProgressEnd()))
 
     // Check that we get the same hover response from the restored in-memory state