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/src/org/eclipse/jface/text/contentassist/AsyncCompletionProposalPopup.java

@@ -23,8 +23,15 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -60,6 +67,22 @@ class AsyncCompletionProposalPopup extends CompletionProposalPopup {
 
 	private static final int MAX_WAIT_IN_MS= 50; // TODO make it a preference
 
+	private static final ExecutorService 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) {
+					Thread t= new Thread(r, AsyncCompletionProposalPopup.class.getSimpleName() + "-worker-" + count.getAndIncrement()); //$NON-NLS-1$
+					t.setDaemon(true); // No need to keep the JVM running just because of the completion proposals
+					return t;
+				}
+			});
+
 	/**
 	 * This is only used and set when populating the dialog is async (ie computation takes more than
 	 * MAX_WAIT_IN_MS
@@ -372,7 +395,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 +412,46 @@ protected List<CompletableFuture<List<ICompletionProposal>>> buildCompletionFutu
 					return Collections.emptyList();
 				}
 				return proposals;
-			}));
+			}, EXECUTOR));
 		}
 		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<>();
+		FutureTask<T> ft= new FutureTask<>(task);
+
+		executor.submit(() -> {
+			try {
+				ft.run(); // executes in this thread
+				cf.complete(ft.get());
+			} catch (CancellationException e) {
+				cf.cancel(true);
+			} 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();