Don’t send messages to clangd after it has crashed but before it has restarted

Author: ahoppen

Sources/SourceKitLSP/Clang/ClangLanguageServer.swift

@@ -50,8 +50,31 @@ actor ClangLanguageServerShim: ToolchainLanguageServer, MessageHandler {
   /// to the editor.
   public let client: Connection
 
-  /// The connection to the clangd LSP. `nil` until `startClangdProcesss` has been called.
-  var clangd: Connection!
+  /// The connection to the clangd LSP. 
+  ///
+  /// `nil` until `startClangdProcesss` has been called.
+  ///
+  /// - Important: Access `clangd` to ensure all documents have been reopened
+  ///   after clangd crashes.
+  var unsafeClangd: Connection!
+
+  /// The connection to `clangd`.
+  ///
+  /// After `clangd` crashes, this property doesn't return until `clangd` has
+  /// been relaunched, documents have been reopened in `clangd` and `clangd`
+  /// is ready to receive requests again.
+  var clangd: Connection {
+    get async {
+      // If clangd has crashed, wait for it to restart before sending any
+      // messages to it.
+      _ = await clangdRestartTask?.value
+      return unsafeClangd
+    }
+  }
+
+  /// If `clangd` is restared, the task to relaunch it and reopen all the
+  /// documents within.
+  var clangdRestartTask: Task<Void, Never>?
 
   /// Capabilities of the clangd LSP, if received.
   var capabilities: ServerCapabilities? = nil
@@ -179,7 +202,7 @@ actor ClangLanguageServerShim: ToolchainLanguageServer, MessageHandler {
       inFD: clangdToUs.fileHandleForReading,
       outFD: usToClangd.fileHandleForWriting
     )
-    self.clangd = connectionToClangd
+    self.unsafeClangd = connectionToClangd
 
     connectionToClangd.start(receiveHandler: self) {
       // FIXME: keep the pipes alive until we close the connection. This
@@ -235,8 +258,8 @@ actor ClangLanguageServerShim: ToolchainLanguageServer, MessageHandler {
     }
     self.lastClangdRestart = Date()
 
-    Task {
-      try await Task.sleep(nanoseconds: UInt64(restartDelay) * 1_000_000_000)
+    clangdRestartTask = Task {
+      try? await Task.sleep(nanoseconds: UInt64(restartDelay) * 1_000_000_000)
       self.clangRestartScheduled = false
       do {
         try self.startClangdProcesss()
@@ -250,7 +273,8 @@ actor ClangLanguageServerShim: ToolchainLanguageServer, MessageHandler {
       } catch {
         log("Failed to restart clangd after a crash.", level: .error)
       }
-      }
+      clangdRestartTask = nil
+    }
   }
 
   /// Handler for notifications received **from** clangd, ie. **clangd** is
@@ -260,7 +284,7 @@ actor ClangLanguageServerShim: ToolchainLanguageServer, MessageHandler {
   func handle(_ params: some NotificationType, from clientID: ObjectIdentifier) async {
     if let publishDiags = params as? PublishDiagnosticsNotification {
       await self.publishDiagnostics(Notification(publishDiags, clientID: clientID))
-    } else if clientID == ObjectIdentifier(self.clangd) {
+    } else if clientID == ObjectIdentifier(self.unsafeClangd) {
       self.client.send(params)
     }
   }
@@ -279,7 +303,7 @@ actor ClangLanguageServerShim: ToolchainLanguageServer, MessageHandler {
       reply(result)
     })
 
-    if request.clientID == ObjectIdentifier(self.clangd) {
+    if request.clientID == ObjectIdentifier(self.unsafeClangd) {
       self.forwardRequest(request, to: self.client)
     } else {
       request.reply(.failure(ResponseError.methodNotFound(R.method)))
@@ -373,16 +397,23 @@ extension ClangLanguageServerShim {
     // Store the initialize request so we can replay it in case clangd crashes
     self.initializeRequest = initialize
 
-    let result = try clangd.sendSync(initialize)
+    // This must not access `clangd` because it is called from the
+    // `clangdRestartTask` and accessing `clangd` is blocked until that task
+    // completes.
+    let result = try unsafeClangd.sendSync(initialize)
     self.capabilities = result.capabilities
     return result
   }
 
   public func clientInitialized(_ initialized: InitializedNotification) {
-    clangd.send(initialized)
+    // This must not access `clangd` because it is called from the
+    // `clangdRestartTask` and accessing `clangd` is blocked until that task
+    // completes.
+    unsafeClangd.send(initialized)
   }
 
   public func shutdown() async {
+    let clangd = await clangd
     await withCheckedContinuation { continuation in
       _ = clangd.send(ShutdownRequest(), queue: self.clangdCommunicationQueue) { [weak self] _ in
         guard let self else { return }
@@ -405,24 +436,24 @@ extension ClangLanguageServerShim {
     // sending the open notification, so that the initial diagnostics already
     // have build settings.
     await documentUpdatedBuildSettings(note.textDocument.uri, change: .removedOrUnavailable)
-    clangd.send(note)
+    await clangd.send(note)
   }
 
-  public func closeDocument(_ note: DidCloseTextDocumentNotification) {
+  public func closeDocument(_ note: DidCloseTextDocumentNotification) async {
     openDocuments[note.textDocument.uri] = nil
-    clangd.send(note)
+    await clangd.send(note)
   }
 
-  public func changeDocument(_ note: DidChangeTextDocumentNotification) {
-    clangd.send(note)
+  public func changeDocument(_ note: DidChangeTextDocumentNotification) async {
+    await clangd.send(note)
   }
 
   public func willSaveDocument(_ note: WillSaveTextDocumentNotification) {
 
   }
 
-  public func didSaveDocument(_ note: DidSaveTextDocumentNotification) {
-    clangd.send(note)
+  public func didSaveDocument(_ note: DidSaveTextDocumentNotification) async {
+    await clangd.send(note)
   }
 
   // MARK: - Build System Integration
@@ -448,101 +479,101 @@ extension ClangLanguageServerShim {
       let note = DidChangeConfigurationNotification(settings: .clangd(
         ClangWorkspaceSettings(
           compilationDatabaseChanges: [pathString: compileCommand])))
-      clangd.send(note)
+      await clangd.send(note)
     }
   }
 
-  public func documentDependenciesUpdated(_ uri: DocumentURI) {
+  public func documentDependenciesUpdated(_ uri: DocumentURI) async {
     // In order to tell clangd to reload an AST, we send it an empty `didChangeTextDocument`
     // with `forceRebuild` set in case any missing header files have been added.
     // This works well for us as the moment since clangd ignores the document version.
     let note = DidChangeTextDocumentNotification(
       textDocument: VersionedTextDocumentIdentifier(uri, version: 0),
       contentChanges: [],
       forceRebuild: true)
-    clangd.send(note)
+    await clangd.send(note)
   }
 
   // MARK: - Text Document
 
 
   /// Returns true if the `ToolchainLanguageServer` will take ownership of the request.
-  public func definition(_ req: Request<DefinitionRequest>) -> Bool {
+  public func definition(_ req: Request<DefinitionRequest>) async -> Bool {
     // We handle it to provide jump-to-header support for #import/#include.
-    self.forwardRequest(req, to: self.clangd)
+    self.forwardRequest(req, to: await self.clangd)
     return true
   }
 
   /// Returns true if the `ToolchainLanguageServer` will take ownership of the request.
-  public func declaration(_ req: Request<DeclarationRequest>) -> Bool {
+  public func declaration(_ req: Request<DeclarationRequest>) async -> Bool {
     // We handle it to provide jump-to-header support for #import/#include.
-    forwardRequest(req, to: clangd)
+    forwardRequest(req, to: await clangd)
     return true
   }
 
-  func completion(_ req: Request<CompletionRequest>) {
-    forwardRequest(req, to: clangd)
+  func completion(_ req: Request<CompletionRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func hover(_ req: Request<HoverRequest>) {
-    forwardRequest(req, to: clangd)
+  func hover(_ req: Request<HoverRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func symbolInfo(_ req: Request<SymbolInfoRequest>) {
-    forwardRequest(req, to: clangd)
+  func symbolInfo(_ req: Request<SymbolInfoRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func documentSymbolHighlight(_ req: Request<DocumentHighlightRequest>) {
-    forwardRequest(req, to: clangd)
+  func documentSymbolHighlight(_ req: Request<DocumentHighlightRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func documentSymbol(_ req: Request<DocumentSymbolRequest>) {
-    forwardRequest(req, to: clangd)
+  func documentSymbol(_ req: Request<DocumentSymbolRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func documentColor(_ req: Request<DocumentColorRequest>) {
+  func documentColor(_ req: Request<DocumentColorRequest>) async {
     if self.capabilities?.colorProvider?.isSupported == true {
-      forwardRequest(req, to: clangd)
+      forwardRequest(req, to: await clangd)
     } else {
       req.reply(.success([]))
     }
   }
 
-  func documentSemanticTokens(_ req: Request<DocumentSemanticTokensRequest>) {
-    forwardRequest(req, to: clangd)
+  func documentSemanticTokens(_ req: Request<DocumentSemanticTokensRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func documentSemanticTokensDelta(_ req: Request<DocumentSemanticTokensDeltaRequest>) {
-    forwardRequest(req, to: clangd)
+  func documentSemanticTokensDelta(_ req: Request<DocumentSemanticTokensDeltaRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func documentSemanticTokensRange(_ req: Request<DocumentSemanticTokensRangeRequest>) {
-    forwardRequest(req, to: clangd)
+  func documentSemanticTokensRange(_ req: Request<DocumentSemanticTokensRangeRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func colorPresentation(_ req: Request<ColorPresentationRequest>) {
+  func colorPresentation(_ req: Request<ColorPresentationRequest>) async {
     if self.capabilities?.colorProvider?.isSupported == true {
-      forwardRequest(req, to: clangd)
+      forwardRequest(req, to: await clangd)
     } else {
       req.reply(.success([]))
     }
   }
 
-  func codeAction(_ req: Request<CodeActionRequest>) {
-    forwardRequest(req, to: clangd)
+  func codeAction(_ req: Request<CodeActionRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func inlayHint(_ req: Request<InlayHintRequest>) {
-    forwardRequest(req, to: clangd)
+  func inlayHint(_ req: Request<InlayHintRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func documentDiagnostic(_ req: Request<DocumentDiagnosticsRequest>) {
-    forwardRequest(req, to: clangd)
+  func documentDiagnostic(_ req: Request<DocumentDiagnosticsRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 
-  func foldingRange(_ req: Request<FoldingRangeRequest>) {
+  func foldingRange(_ req: Request<FoldingRangeRequest>) async {
     if self.capabilities?.foldingRangeProvider?.isSupported == true {
-      forwardRequest(req, to: clangd)
+      forwardRequest(req, to: await clangd)
     } else {
       req.reply(.success(nil))
     }
@@ -554,8 +585,8 @@ extension ClangLanguageServerShim {
 
   // MARK: - Other
 
-  func executeCommand(_ req: Request<ExecuteCommandRequest>) {
-    forwardRequest(req, to: clangd)
+  func executeCommand(_ req: Request<ExecuteCommandRequest>) async {
+    forwardRequest(req, to: await clangd)
   }
 }