fix: Freeze when language server is started from the EDT

angelozerr · angelozerr · commit 915ca200f6bb · 2025-03-15T12:54:27.000+01:00
Fixes #878 Signed-off-by: azerr <azerr@redhat.com>
diff --git a/src/main/java/com/redhat/devtools/lsp4ij/DocumentContentSynchronizer.java b/src/main/java/com/redhat/devtools/lsp4ij/DocumentContentSynchronizer.java
@@ -39,27 +39,51 @@ public class DocumentContentSynchronizer implements DocumentListener {
     private final @NotNull Document document;
     private final @NotNull String fileUri;
     private final TextDocumentSyncKind syncKind;
+    private final @NotNull VirtualFile file;
+    private final @Nullable String documentText;
+    private final @Nullable String languageId;
 
     private int version = 0;
     private final List<TextDocumentContentChangeEvent> changeEvents;
-    @NotNull final CompletableFuture<Void> didOpenFuture;
+    @NotNull private CompletableFuture<Void> didOpenFuture;
 
     public DocumentContentSynchronizer(@NotNull LanguageServerWrapper languageServerWrapper,
                                        @NotNull String fileUri,
                                        @NotNull VirtualFile file,
                                        @NotNull Document document,
+                                       @Nullable String documentText,
+                                       @Nullable String languageId,
                                        @Nullable TextDocumentSyncKind syncKind) {
         this.languageServerWrapper = languageServerWrapper;
+        this.file = file;
         this.fileUri = fileUri;
         this.syncKind = syncKind != null ? syncKind : TextDocumentSyncKind.Full;
-
         this.document = document;
+        this.documentText = documentText;
+        this.languageId = languageId;
+
+        // Initialize LSP change events
+        changeEvents = new ArrayList<>();
+    }
+
+    public @NotNull CompletableFuture<Void> getDidOpenFuture() {
+        if (didOpenFuture != null) {
+            return didOpenFuture;
+        }
+        return getDidOpenFutureSync();
+    }
+
+    private synchronized @NotNull CompletableFuture<Void> getDidOpenFutureSync() {
+        if (didOpenFuture != null) {
+            return didOpenFuture;
+        }
         // add a document buffer
         TextDocumentItem textDocument = new TextDocumentItem();
         textDocument.setUri(this.fileUri);
-        textDocument.setText(document.getText());
+        textDocument.setText(documentText != null ? documentText : document.getText());
 
-        @NotNull String languageId = languageServerWrapper.getServerDefinition().getLanguageId(file, languageServerWrapper.getProject());
+        @NotNull String languageId = this.languageId != null ? this.languageId :
+                languageServerWrapper.getServerDefinition().getLanguageId(file, languageServerWrapper.getProject());
         textDocument.setLanguageId(languageId);
         textDocument.setVersion(++version);
         didOpenFuture = languageServerWrapper
@@ -81,9 +105,7 @@ public DocumentContentSynchronizer(@NotNull LanguageServerWrapper languageServer
                             }
                         })
                 );
-
-        // Initialize LSP change events
-        changeEvents = new ArrayList<>();
+        return didOpenFuture;
     }
 
     @Override
diff --git a/src/main/java/com/redhat/devtools/lsp4ij/LSPFileListener.java b/src/main/java/com/redhat/devtools/lsp4ij/LSPFileListener.java
@@ -178,7 +178,7 @@ private FileEvent fe(URI uri, FileChangeType type) {
             // 2. Send a textDocument/didOpen for the new file name
             URI newUri = languageServerWrapper.toUri(virtualNewFile);
             if (!languageServerWrapper.isConnectedTo(newUri)) {
-                languageServerWrapper.connect(virtualNewFile, null);
+                languageServerWrapper.connect(virtualNewFile, new LanguageServerWrapper.LSPFileConnectionInfo(null,null, null,true));
             }
         }
         return oldUri;
diff --git a/src/main/java/com/redhat/devtools/lsp4ij/LanguageServerWrapper.java b/src/main/java/com/redhat/devtools/lsp4ij/LanguageServerWrapper.java
@@ -67,6 +67,8 @@ public class LanguageServerWrapper implements Disposable {
 
     private static final int MAX_NUMBER_OF_RESTART_ATTEMPTS = 20; // TODO move this max value in settings
 
+    record LSPFileConnectionInfo(@Nullable Document document, @Nullable String documentText, @Nullable String languageId, boolean waitForDidOpen) {}
+
     private MessageBusConnection messageBusConnection;
 
     @NotNull
@@ -370,7 +372,7 @@ public synchronized void start() throws LanguageServerException {
                     }).thenRun(() -> this.languageServer.initialized(new InitializedParams())).thenRun(() -> {
                         initializeFuture.thenRunAsync(() -> {
                             for (VirtualFile fileToReconnect : filesToReconnect) {
-                                connect(fileToReconnect, null);
+                                connect(fileToReconnect, new LSPFileConnectionInfo(null, null, null,true));
                             }
                         });
 
@@ -680,12 +682,12 @@ public boolean canOperate(Project project) {
      * </p>
      *
      * @param file             the file to connect to the language server
-     * @param optionalDocument the document of the file and null otherwise. In the null case, the document will be retrieved from the file
+     * @param fileConnectionInfo the document of the file and null otherwise. In the null case, the document will be retrieved from the file
      *                         by using a blocking read action.
      * @return the completable future with the language server instance or null.
      */
     CompletableFuture<@Nullable LanguageServer> connect(@NotNull VirtualFile file,
-                                                        @Nullable Document optionalDocument) {
+                                                        @NotNull LanguageServerWrapper.LSPFileConnectionInfo fileConnectionInfo) {
         removeStopTimer(false);
 
         URI fileUri = toUri(file);
@@ -694,7 +696,8 @@ public boolean canOperate(Project project) {
             return CompletableFuture.completedFuture(null);
         }
 
-        var ls = getLanguageServerWhenDidOpen(fileUri);
+        boolean waitForDidOpen = fileConnectionInfo.waitForDidOpen();
+        var ls = getLanguageServerWhenDidOpen(fileUri, waitForDidOpen);
         if (ls != null) {
             return ls;
         }
@@ -711,42 +714,49 @@ public boolean canOperate(Project project) {
             // Here, the "initialize" future is initialized
 
             // Check if file is already opened (without synchronized block)
-            var ls2 = getLanguageServerWhenDidOpen(fileUri);
+            var ls2 = getLanguageServerWhenDidOpen(fileUri, waitForDidOpen);
             if (ls2 != null) {
                 return ls2;
             }
 
             // Here the file is not already connected
             // To connect the file, we need the document instance to add LSP document listener to manage didOpen, didChange, etc.
+            Document optionalDocument = fileConnectionInfo.document();
             Document document = optionalDocument != null ? optionalDocument : LSPIJUtils.getDocument(file);
 
             synchronized (connectedDocuments) {
                 // Check again if file is already opened (within synchronized block)
-                ls2 = getLanguageServerWhenDidOpen(fileUri);
+                ls2 = getLanguageServerWhenDidOpen(fileUri, waitForDidOpen);
                 if (ls2 != null) {
                     return ls2;
                 }
 
-                DocumentContentSynchronizer synchronizer = createDocumentContentSynchronizer(fileUri.toASCIIString(), file, document);
+                DocumentContentSynchronizer synchronizer = createDocumentContentSynchronizer(fileUri.toASCIIString(), file, document, fileConnectionInfo.documentText(), fileConnectionInfo.languageId());
                 document.addDocumentListener(synchronizer);
                 LSPVirtualFileData data = new LSPVirtualFileData(new LanguageServerItem(languageServer, this), file, synchronizer);
                 LanguageServerWrapper.this.connectedDocuments.put(fileUri, data);
 
-                return getLanguageServerWhenDidOpen(synchronizer.didOpenFuture);
+                if (waitForDidOpen) {
+                    return getLanguageServerWhenDidOpen(synchronizer.getDidOpenFuture());
+                }
+                return CompletableFuture.completedFuture(languageServer);
             }
         });
     }
 
     @Nullable
-    private CompletableFuture<LanguageServer> getLanguageServerWhenDidOpen(@Nullable URI fileUri) {
+    private CompletableFuture<LanguageServer> getLanguageServerWhenDidOpen(@Nullable URI fileUri, boolean waitForDidOpen) {
         if (fileUri == null) {
             return null;
         }
         var existingData = connectedDocuments.get(fileUri);
         if (existingData != null) {
+            if (!waitForDidOpen) {
+                return CompletableFuture.completedFuture(languageServer);
+            }
             // The file is already connected.
             // returns the language server instance when didOpen happened
-            var didOpenFuture = existingData.getSynchronizer().didOpenFuture;
+            var didOpenFuture = existingData.getSynchronizer().getDidOpenFuture();
             return getLanguageServerWhenDidOpen(didOpenFuture);
         }
         return null;
@@ -767,7 +777,9 @@ private CompletableFuture<LanguageServer> getLanguageServerWhenDidOpen(Completab
     @NotNull
     private DocumentContentSynchronizer createDocumentContentSynchronizer(@NotNull String fileUri,
                                                                           @NotNull VirtualFile file,
-                                                                          @NotNull Document document) {
+                                                                          @NotNull Document document,
+                                                                          @Nullable String documentText,
+                                                                          @Nullable String languageId) {
         Either<TextDocumentSyncKind, TextDocumentSyncOptions> syncOptions = initializeFuture == null ? null
                 : this.serverCapabilities.getTextDocumentSync();
         TextDocumentSyncKind syncKind = null;
@@ -778,7 +790,7 @@ private DocumentContentSynchronizer createDocumentContentSynchronizer(@NotNull S
                 syncKind = syncOptions.getLeft();
             }
         }
-        return new DocumentContentSynchronizer(this, fileUri, file, document, syncKind);
+        return new DocumentContentSynchronizer(this, fileUri, file, document, documentText, languageId, syncKind);
     }
 
     void disconnect(@NotNull VirtualFile file, boolean stopIfNoOpenedFiles) {
diff --git a/src/main/java/com/redhat/devtools/lsp4ij/LanguageServiceAccessor.java b/src/main/java/com/redhat/devtools/lsp4ij/LanguageServiceAccessor.java
@@ -256,16 +256,33 @@ public boolean hasAny(@NotNull VirtualFile file,
                                                                             @Nullable LanguageServerDefinition matchServerDefinition) {
         // Collect started (or not) language servers which matches the given file.
         CompletableFuture<Collection<LanguageServerWrapper>> matchedServers = getMatchedLanguageServersWrappers(file, matchServerDefinition, beforeStartingServerFilter);
-        if (matchedServers.isDone() && matchedServers.getNow(Collections.emptyList()).isEmpty()) {
+        var matchedServersNow= matchedServers.getNow(Collections.emptyList());
+        if (matchedServers.isDone() && matchedServersNow.isEmpty()) {
             // None language servers matches the given file
             return CompletableFuture.completedFuture(Collections.emptyList());
         }
 
+
         // getLanguageServers is generally called with Read Access.
         // We get the Document instance now, to avoid creating a new Read Action thread to get it from the file.
         // The document instance is only used when the file is opened, to add
         // LSP document listener to manage didOpen, didChange, etc.
-        Document document = ApplicationManager.getApplication().isReadAccessAllowed() ? LSPIJUtils.getDocument(file) : null;
+        boolean writeAccessAllowed = !ApplicationManager.getApplication().isWriteAccessAllowed();
+        boolean readAccessAllowed = !ApplicationManager.getApplication().isWriteAccessAllowed();
+        Document document = readAccessAllowed || (!writeAccessAllowed) ? LSPIJUtils.getDocument(file) : null;
+
+        Map<LanguageServerWrapper, LanguageServerWrapper.LSPFileConnectionInfo> connectFileData = new HashMap<>();
+        for (var ls : matchedServersNow) {
+            var uri = ls.toUri(file);
+            if (uri != null && !ls.isConnectedTo(uri)) {
+                if(document != null) {
+                    String text = document.getText();
+                    String languageId = ls.getServerDefinition().getLanguageId(file, project);
+                    var data = new LanguageServerWrapper.LSPFileConnectionInfo(document, text, languageId, true);
+                    connectFileData.put(ls, data);
+                }
+            }
+        }
 
         // Returns the language servers which match the given file, start them and connect the file to each matched language server
         final List<LanguageServerItem> servers = Collections.synchronizedList(new ArrayList<>());
@@ -281,7 +298,11 @@ public boolean hasAny(@NotNull VirtualFile file,
                                                 .thenComposeAsync(server -> {
                                                     if (server != null &&
                                                             (afterStartingServerFilter == null || afterStartingServerFilter.test(clientFeatures))) {
-                                                        return wrapper.connect(file, document);
+                                                        var data = connectFileData.get(wrapper);
+                                                        if (data == null) {
+                                                            data = new LanguageServerWrapper.LSPFileConnectionInfo(document, null, null, !writeAccessAllowed);
+                                                        }
+                                                        return wrapper.connect(file, data);
                                                     }
                                                     return CompletableFuture.completedFuture(null);
                                                 }).thenAccept(server -> {
diff --git a/src/main/java/com/redhat/devtools/lsp4ij/internal/CompletableFutures.java b/src/main/java/com/redhat/devtools/lsp4ij/internal/CompletableFutures.java
@@ -13,6 +13,7 @@
  *******************************************************************************/
 package com.redhat.devtools.lsp4ij.internal;
 
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.ProgressManager;
@@ -146,7 +147,8 @@ public static void waitUntilDone(@Nullable CompletableFuture<?> future,
                 if (timeout != null  && time > timeout) {
                     throw ignore;
                 }
-                if (file != null && !future.isDone() && System.currentTimeMillis() - start > 5000 && ProjectIndexingManager.isIndexingAll()) {
+                if (file != null && !future.isDone() && System.currentTimeMillis() - start > 5000 &&
+                        (ProjectIndexingManager.isIndexingAll() || ApplicationManager.getApplication().isDispatchThread())) {
                     // When some projects are being indexed,
                     // the language server startup can take a long time
                     // and the LSP feature (ex: codeLens)

Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ private FileEvent fe(URI uri, FileChangeType type) {`
`178`	`178`	`// 2. Send a textDocument/didOpen for the new file name`
`179`	`179`	`URI newUri = languageServerWrapper.toUri(virtualNewFile);`
`180`	`180`	`if (!languageServerWrapper.isConnectedTo(newUri)) {`
`181`		`- languageServerWrapper.connect(virtualNewFile, null);`
	`181`	`+ languageServerWrapper.connect(virtualNewFile, new LanguageServerWrapper.LSPFileConnectionInfo(null,null, null,true));`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`	`return oldUri;`