Attempting to stabilize the tests.

Author: lahodaj

java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/RunOnceFactory.java

@@ -22,13 +22,15 @@
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import org.netbeans.api.java.source.CancellableTask;
 import org.netbeans.api.java.source.CompilationInfo;
 import org.netbeans.api.java.source.JavaSource.Phase;
 import org.netbeans.api.java.source.JavaSource.Priority;
 import org.netbeans.api.java.source.JavaSourceTaskFactory;
+import org.netbeans.modules.parsing.spi.TaskIndexingMode;
 import org.openide.filesystems.FileObject;
 import org.openide.filesystems.FileUtil;
 import org.openide.util.Lookup;
@@ -49,18 +51,34 @@ public class RunOnceFactory extends JavaSourceTaskFactory {
     private CancellableTask<CompilationInfo> task;
 
     public RunOnceFactory() {
-        super(Phase.RESOLVED, Priority.BELOW_NORMAL);
+        super(Phase.RESOLVED, Priority.BELOW_NORMAL, TaskIndexingMode.ALLOWED_DURING_SCAN);
 //        INSTANCE = this;
     }
 
-    protected synchronized CancellableTask<CompilationInfo> createTask(FileObject file) {
-        final CancellableTask<CompilationInfo> task = this.task;
+    protected CancellableTask<CompilationInfo> createTask(FileObject file) {
         return new CancellableTask<CompilationInfo>() {
+            private final AtomicReference<CancellableTask<CompilationInfo>> currentTask =
+                    new AtomicReference<>();
+
             public void cancel() {
-                task.cancel();
+                CancellableTask<CompilationInfo> task = currentTask.get();
+
+                if (task != null) {
+                    task.cancel();
+                }
             }
             public void run(CompilationInfo parameter) throws Exception {
+                CancellableTask<CompilationInfo> task;
+
+                synchronized (RunOnceFactory.this) {
+                    task = RunOnceFactory.this.task;
+                }
+
+                currentTask.set(task);
+
                 task.run(parameter);
+
+                currentTask.set(null);
                 next();
             }
         };
@@ -87,25 +105,30 @@ private synchronized void addImpl(FileObject file, CancellableTask<CompilationIn
     private synchronized void next() {
         LOG.fine("next, phase 1");
 
-        if (currentFile != null) {
-            currentFile = null;
-            task = null;
-            fileObjectsChanged();
-        }
-
-        LOG.fine("next, phase 1 done");
+        if (work.isEmpty()) {
+            if (currentFile != null) {
+                LOG.fine("clearing current file");
+                currentFile = null;
+                task = null;
+                fileObjectsChanged();
+            }
 
-        if (work.isEmpty())
+            LOG.fine("work is empty");
             return ;
+        }
 
         LOG.fine("next, phase 2");
 
         Pair<FileObject, CancellableTask<CompilationInfo>> p = work.remove(0);
 
-        currentFile = p.first();
         task = p.second();
 
-        fileObjectsChanged();
+        if (currentFile == p.first()) {
+            reschedule(currentFile);
+        } else {
+            currentFile = p.first();
+            fileObjectsChanged();
+        }
 
         LOG.fine("next, phase 2 done");
     }

java/java.lsp.server/src/org/netbeans/modules/java/lsp/server/protocol/TextDocumentServiceImpl.java

@@ -1950,7 +1950,7 @@ private void runDiagnosticTasks(String uri, boolean force) {
     }
 
     private List<Diagnostic> doRunComputeDiagsOnBackground(String uri, ErrorProvider.Kind kind, long originalVersion, AtomicReference<Document> docHolder) {
-        return computeCancallablyOnBackground(uri, new CancellableTask<List<Diagnostic>>() {
+        return computeCancellablyOnBackground(uri, new CancellableTask<List<Diagnostic>>() {
             private final AtomicBoolean cancelled = new AtomicBoolean();
             private final AtomicReference<Runnable> cancelCallback = new AtomicReference<>();
             @Override
@@ -2389,7 +2389,7 @@ private static void reportNotificationDone(String s, Object parameter) {
     @Override
     public CompletableFuture<SemanticTokens> semanticTokensFull(SemanticTokensParams params) {
         String uri = params.getTextDocument().getUri();
-        return computeCancallablyOnBackground(uri, new CancellableTask<SemanticTokens>() {
+        return computeCancellablyOnBackground(uri, new CancellableTask<SemanticTokens>() {
             private final AtomicBoolean cancel = new AtomicBoolean();
             private final AtomicReference<SemanticHighlighterBase> computeTask = new AtomicReference<>();
             @Override
@@ -2684,7 +2684,8 @@ protected CallHierarchyOutgoingCall createResultItem(CallHierarchyItem item, Lis
     }
 
     private static final RequestProcessor DELAYED_RESCHEDULE = new RequestProcessor(TextDocumentServiceImpl.class.getName(), 1, false, false);
-    private <T> CompletableFuture<T> computeCancallablyOnBackground(String uri, CancellableTask<T> task, T defaultValue, int priority) {
+    private static final RequestProcessor EDITOR_BRACKGROUND = new RequestProcessor(TextDocumentServiceImpl.class.getName() + "-editor-background", 1, false, false);
+    private <T> CompletableFuture<T> computeCancellablyOnBackground(String uri, CancellableTask<T> task, T defaultValue, int priority) {
         CompletableFuture<T> result = new CompletableFuture<T>() {
             @Override
             public boolean cancel(boolean mayInterruptIfRunning) {
@@ -2722,7 +2723,7 @@ public void run(CompilationInfo parameter) throws Exception {
                     }
                 });
             } else {
-                BACKGROUND_TASKS.post(() -> {
+                EDITOR_BRACKGROUND.post(() -> {
                     result.complete(task.compute());
                 });
             }