Use a separate ExecutorService in AsyncCompletionProposalPopup

This is necessary in order to effectively cancel all running futures in
the popup (when one closes the popup).

Author: fedejeanne

bundles/org.eclipse.jface.text/META-INF/MANIFEST.MF

@@ -40,4 +40,6 @@ Require-Bundle:
 Import-Package: com.ibm.icu.text
 Bundle-RequiredExecutionEnvironment: JavaSE-17
 Automatic-Module-Name: org.eclipse.jface.text
+Bundle-Activator: org.eclipse.jface.text.Activator
+Bundle-ActivationPolicy: lazy
 Require-Capability: eclipse.swt;filter:="(image.format=svg)"

bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/Activator.java

@@ -0,0 +1,68 @@
+package org.eclipse.jface.text;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+
+/**
+ * @since 3.29
+ */
+public class Activator implements BundleActivator {
+	/**
+	 * The identifier of the descriptor of this plugin in plugin.xml.
+	 */
+	public static final String ID= "org.eclipse.jface.text"; //$NON-NLS-1$
+
+	private static Activator activator;
+
+	private ExecutorService executor;
+
+	@Override
+	public void start(BundleContext context) {
+		activator= this;
+	}
+
+	@Override
+	public void stop(BundleContext context) {
+		activator= null;
+		if (executor != null) {
+			executor.shutdownNow();
+			executor= null;
+		}
+	}
+
+	public static ExecutorService getExecutor() {
+		activator.createExecutor();
+		return activator.executor;
+	}
+
+	private void createExecutor() {
+		if (activator.executor != null)
+			return;
+
+		executor= new ThreadPoolExecutor(
+				Runtime.getRuntime().availableProcessors(),
+				Runtime.getRuntime().availableProcessors(),
+				3L, TimeUnit.SECONDS,
+				new LinkedBlockingQueue<>(),
+				new ThreadFactory() {
+					AtomicInteger count= new AtomicInteger(1);
+
+					@Override
+					public Thread newThread(Runnable r) {
+						// Name the threads numerically for better debugging.
+						Thread t= new Thread(r, ID + "-worker-" + count.getAndIncrement()); //$NON-NLS-1$
+
+						// No need to keep the JVM running just because of the completion proposals
+						t.setDaemon(true);
+						return t;
+					}
+				});
+	}
+}

bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/contentassist/AsyncCompletionProposalPopup.java

@@ -23,8 +23,11 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -43,6 +46,7 @@
 
 import org.eclipse.jface.contentassist.IContentAssistSubjectControl;
 
+import org.eclipse.jface.text.Activator;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.DocumentEvent;
 import org.eclipse.jface.text.IDocument;
@@ -372,7 +376,7 @@ protected List<CompletableFuture<List<ICompletionProposal>>> buildCompletionFutu
 		}
 		List<CompletableFuture<List<ICompletionProposal>>> futures = new ArrayList<>(processors.size());
 		for (IContentAssistProcessor processor : processors) {
-			futures.add(CompletableFuture.supplyAsync(() -> {
+			futures.add(submitInterruptible(() -> {
 				AtomicReference<List<ICompletionProposal>> result= new AtomicReference<>();
 				SafeRunner.run(() -> {
 					ICompletionProposal[] proposals= processor.computeCompletionProposals(fViewer, invocationOffset);
@@ -389,11 +393,42 @@ protected List<CompletableFuture<List<ICompletionProposal>>> buildCompletionFutu
 					return Collections.emptyList();
 				}
 				return proposals;
-			}));
+			}, Activator.getExecutor()));
 		}
 		return futures;
 	}
 
+	/**
+	 * Submit a task in such a way that it actually reacts to cancellation (i.e. calls to
+	 * {@code future.cancel(true)})
+	 *
+	 * @param executor Do not use the common pool here since that one does not cancel (interrupts)
+	 *            worker threads
+	 * @return an interruptible future.
+	 */
+	private static <T> CompletableFuture<T> submitInterruptible(
+			Callable<T> task, ExecutorService executor) {
+
+		CompletableFuture<T> cf= new CompletableFuture<>();
+
+		Future<?> ft= executor.submit(() -> {
+			try {
+				cf.complete(task.call());
+			} catch (Exception e) {
+				cf.completeExceptionally(e);
+			}
+		});
+
+		// make canceling the CF also cancel the FutureTask
+		cf.whenComplete((r, t) -> {
+			if (cf.isCancelled()) {
+				ft.cancel(true); // this actually interrupts
+			}
+		});
+
+		return cf;
+	}
+
 	private String getTokenContentType(int invocationOffset) throws BadLocationException {
 		if (fContentAssistSubjectControl != null) {
 			IDocument document= fContentAssistSubjectControl.getDocument();