diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningDocumentFooterAnnotation.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningDocumentFooterAnnotation.java
index 0c866c9d92d..b92b5076566 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningDocumentFooterAnnotation.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningDocumentFooterAnnotation.java
@@ -218,4 +218,10 @@ public boolean isInVisibleLines() {
public List getMinings() {
return fMinings;
}
+
+ @Override
+ public ICodeMining[] getCachedMinings() {
+ ICodeMining[] cached= fResolvedMinings;
+ return cached == null ? new ICodeMining[0] : cached.clone();
+ }
}
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineContentAnnotation.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineContentAnnotation.java
index 9759ecee4d8..9bf305f7501 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineContentAnnotation.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineContentAnnotation.java
@@ -225,4 +225,10 @@ public final boolean isAfterPosition() {
public List getMinings() {
return fMinings;
}
+
+ @Override
+ public ICodeMining[] getCachedMinings() {
+ ICodeMining[] cached= fResolvedMinings;
+ return cached == null ? new ICodeMining[0] : cached.clone();
+ }
}
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineHeaderAnnotation.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineHeaderAnnotation.java
index 0b1911cee4d..6ca3b991e8e 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineHeaderAnnotation.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineHeaderAnnotation.java
@@ -229,7 +229,7 @@ public void markDeleted(boolean deleted) {
}
static void disposeMinings(List minings) {
- minings.forEach(ICodeMining::dispose);
+ CodeMiningManager.disposeMinings(minings);
}
@Override
@@ -327,4 +327,10 @@ public boolean isInVisibleLines() {
public List getMinings() {
return fMinings;
}
+
+ @Override
+ public ICodeMining[] getCachedMinings() {
+ ICodeMining[] cached= fResolvedMinings;
+ return cached == null ? new ICodeMining[0] : cached.clone();
+ }
}
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningManager.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningManager.java
index c794c429937..5f12b11bd40 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningManager.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningManager.java
@@ -15,6 +15,7 @@
*/
package org.eclipse.jface.internal.text.codemining;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
@@ -27,12 +28,14 @@
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.function.Predicate;
import java.util.stream.Collectors;
import org.osgi.framework.Bundle;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Display;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.ILog;
@@ -66,6 +69,8 @@ public class CodeMiningManager implements Runnable {
*/
private final ISourceViewer fViewer;
+ private final Display fDisplay;
+
/**
* The inlined annotation support used to draw CodeMining in the line spacing.
*/
@@ -81,6 +86,10 @@ public class CodeMiningManager implements Runnable {
*/
private IProgressMonitor fMonitor;
+ private List> fCodeMiningFilters= List.of();
+
+ private Set fCurrentAnnotations= Collections.emptySet();
+
/**
* Constructor of codemining manager with the given arguments.
*
@@ -90,12 +99,56 @@ public class CodeMiningManager implements Runnable {
*/
public CodeMiningManager(ISourceViewer viewer, InlinedAnnotationSupport inlinedAnnotationSupport,
ICodeMiningProvider[] codeMiningProviders) {
+ this(viewer, inlinedAnnotationSupport, codeMiningProviders, List.of());
+ }
+
+ /**
+ * Creates a manager with the initial filters.
+ *
+ * @param viewer the source viewer
+ * @param inlinedAnnotationSupport the installed annotation support
+ * @param codeMiningProviders the installed providers
+ * @param filters the initial filters
+ */
+ public CodeMiningManager(ISourceViewer viewer, InlinedAnnotationSupport inlinedAnnotationSupport,
+ ICodeMiningProvider[] codeMiningProviders, List> filters) {
Assert.isNotNull(viewer);
Assert.isNotNull(inlinedAnnotationSupport);
Assert.isNotNull(codeMiningProviders);
fViewer= viewer;
+ fDisplay= viewer.getTextWidget().getDisplay();
fInlinedAnnotationSupport= inlinedAnnotationSupport;
setCodeMiningProviders(codeMiningProviders);
+ fCodeMiningFilters= List.copyOf(filters);
+ }
+
+ /**
+ * Replaces the filters and refreshes minings on the viewer's UI thread.
+ *
+ * @param filters the filters to apply
+ */
+ public void setCodeMiningFilters(List> filters) {
+ List> snapshot= List.copyOf(filters);
+ synchronized (this) {
+ cancel();
+ fCodeMiningFilters= snapshot;
+ }
+ Set retained= new HashSet<>();
+ for (AbstractInlinedAnnotation annotation : fCurrentAnnotations) {
+ try {
+ ICodeMiningAnnotation miningAnnotation= (ICodeMiningAnnotation) annotation;
+ if (miningAnnotation.getMinings().stream().allMatch(mining -> acceptsMining(mining, snapshot))
+ && Arrays.stream(miningAnnotation.getCachedMinings()).filter(Objects::nonNull)
+ .allMatch(mining -> acceptsMining(mining, snapshot))) {
+ retained.add(annotation);
+ }
+ } catch (Throwable e) {
+ logCodeMiningProviderException(e);
+ }
+ }
+ fCurrentAnnotations= retained;
+ fInlinedAnnotationSupport.updateAnnotations(retained);
+ run();
}
/**
@@ -104,21 +157,31 @@ public CodeMiningManager(ISourceViewer viewer, InlinedAnnotationSupport inlinedA
* @param codeMiningProviders the codemining providers.
*/
public void setCodeMiningProviders(ICodeMiningProvider[] codeMiningProviders) {
- cancel();
- if (fCodeMiningProviders != null) {
- fCodeMiningProviders.stream().forEach(ICodeMiningProvider::dispose);
+ List previous;
+ synchronized (this) {
+ cancel();
+ previous= fCodeMiningProviders;
+ fCodeMiningProviders= List.copyOf(Arrays.asList(codeMiningProviders));
+ }
+ if (previous != null) {
+ previous.forEach(ICodeMiningProvider::dispose);
}
- fCodeMiningProviders= Arrays.asList(codeMiningProviders);
}
/**
* Uninstalls this codemining manager.
*/
public void uninstall() {
- cancel();
+ List previous;
+ synchronized (this) {
+ cancel();
+ previous= fCodeMiningProviders;
+ fCodeMiningProviders= List.of();
+ }
+ fCurrentAnnotations= Collections.emptySet();
fInlinedAnnotationSupport.updateAnnotations(Collections.emptySet());
- if (fCodeMiningProviders != null) {
- fCodeMiningProviders.forEach(ICodeMiningProvider::dispose);
+ if (previous != null) {
+ previous.forEach(ICodeMiningProvider::dispose);
}
}
@@ -127,14 +190,9 @@ public void uninstall() {
*/
@Override
public void run() {
- if (fCodeMiningProviders == null
- || fCodeMiningProviders.isEmpty() || fViewer.getAnnotationModel() == null) {
+ if (fViewer.getAnnotationModel() == null) {
return;
}
- // Cancel the last progress monitor to cancel last resolve and render of code
- // minings
- cancel();
- // Update the code minings
updateCodeMinings();
}
@@ -142,24 +200,88 @@ public void run() {
* Update the code minings.
*/
private void updateCodeMinings() {
- // Refresh the code minings by using the new progress monitor.
- fMonitor= new CancellationExceptionMonitor();
- IProgressMonitor monitor= fMonitor;
+ IProgressMonitor monitor;
+ List providers;
+ List> filters;
+ synchronized (this) {
+ if (fCodeMiningProviders == null || fCodeMiningProviders.isEmpty()) {
+ return;
+ }
+ cancel();
+ fMonitor= new CancellationExceptionMonitor();
+ monitor= fMonitor;
+ providers= fCodeMiningProviders;
+ filters= fCodeMiningFilters;
+ }
// Collect the code minings for the viewer
- getCodeMinings(fViewer, fCodeMiningProviders, monitor).thenAccept(symbols -> {
+ getCodeMinings(fViewer, providers, monitor).thenAccept(symbols -> {
+ List accepted= new ArrayList<>();
+ List rejected= new ArrayList<>();
try {
- // check if request was canceled.
monitor.isCanceled();
- // then group code minings by lines position
- Map> groups= groupByLines(symbols, fCodeMiningProviders);
- // resolve and render code minings
- renderCodeMinings(groups, fViewer, monitor);
+ for (ICodeMining mining : symbols) {
+ if (acceptsMining(mining, filters)) {
+ accepted.add(mining);
+ } else {
+ rejected.add(mining);
+ }
+ }
} catch (Throwable e) {
+ disposeMinings(symbols);
logCodeMiningProviderException(e);
+ return;
+ }
+ disposeMinings(rejected);
+ Runnable render= () -> {
+ try {
+ monitor.isCanceled();
+ if (fViewer.getDocument() == null || fViewer.getTextWidget() == null
+ || fViewer.getTextWidget().isDisposed()) {
+ disposeMinings(accepted);
+ return;
+ }
+ } catch (CancellationException e) {
+ disposeMinings(accepted);
+ return;
+ }
+ try {
+ renderCodeMinings(groupByLines(accepted, providers), fViewer, monitor);
+ } catch (Throwable e) {
+ logCodeMiningProviderException(e);
+ }
+ };
+ if (Display.getCurrent() == fDisplay) {
+ render.run();
+ } else {
+ try {
+ fDisplay.asyncExec(render);
+ } catch (RuntimeException e) {
+ disposeMinings(accepted);
+ logCodeMiningProviderException(e);
+ }
}
});
}
+ static void disposeMinings(List extends ICodeMining> minings) {
+ for (ICodeMining mining : minings) {
+ try {
+ mining.dispose();
+ } catch (Throwable e) {
+ logCodeMiningProviderException(e);
+ }
+ }
+ }
+
+ private static boolean acceptsMining(ICodeMining mining, List> filters) {
+ for (Predicate super ICodeMining> filter : filters) {
+ if (!filter.test(mining)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
/**
* Cancel the codemining process.
*/
@@ -207,7 +329,8 @@ private static CompletableFuture> getCodeMinings(ITe
}))
.collect(Collectors.toList());
return CompletableFuture.allOf(com.toArray(new CompletableFuture[com.size()])).thenApply(
- v -> com.stream().map(CompletableFuture::join).filter(Objects::nonNull).flatMap(java.util.Collection::stream).collect(Collectors.toList()));
+ v -> com.stream().map(CompletableFuture::join).filter(Objects::nonNull)
+ .flatMap(java.util.Collection::stream).filter(Objects::nonNull).collect(Collectors.toList()));
}
/**
@@ -335,7 +458,9 @@ private void renderCodeMinings(Map> groups, ISourceV
});
// check if request was canceled.
monitor.isCanceled();
+ fCurrentAnnotations= currentAnnotations;
fInlinedAnnotationSupport.updateAnnotations(currentAnnotations);
+ monitor.isCanceled();
// redraw the existing codemining annotations since their content can change
annotationsToRedraw.stream().forEach(ICodeMiningAnnotation::redraw);
}
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/ICodeMiningAnnotation.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/ICodeMiningAnnotation.java
index 29472b5ace4..c26921f3a2a 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/ICodeMiningAnnotation.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/ICodeMiningAnnotation.java
@@ -26,6 +26,21 @@
*/
public interface ICodeMiningAnnotation {
+ /**
+ * Returns the mining instances currently owned by this annotation.
+ *
+ * @return the current minings
+ */
+ List getMinings();
+
+ /**
+ * Returns a snapshot of the cached minings used while new minings resolve.
+ * Entries may be {@code null}. Cached instances may already have been disposed.
+ *
+ * @return the cached minings
+ */
+ ICodeMining[] getCachedMinings();
+
/**
* Update code minings.
*
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/ICodeMiningProvider.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/ICodeMiningProvider.java
index ef91c0c8943..6e62ca8dc58 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/ICodeMiningProvider.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/ICodeMiningProvider.java
@@ -33,6 +33,12 @@ public interface ICodeMiningProvider {
* possible and if computing the content of {@link ICodeMining} is expensive implementors should
* only return code mining objects with the position and implement resolve
* {@link ICodeMining#resolve(ITextViewer, IProgressMonitor)}.
+ *
+ * Each invocation must return fresh mining instances. Ownership is transferred
+ * to the viewer, which may dispose them without rendering, for example when a
+ * request is canceled or a mining is rejected by a filter. Mining instances must
+ * not be shared between requests or viewers.
+ *
*
* @param viewer the viewer in which the command was invoked.
* @param monitor A progress monitor.
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/ISourceViewerExtension6.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/ISourceViewerExtension6.java
new file mode 100644
index 00000000000..8e7f4a513fc
--- /dev/null
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/ISourceViewerExtension6.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2026 SAP SE and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.jface.text.source;
+
+import java.util.function.Predicate;
+
+import org.eclipse.jface.text.codemining.ICodeMining;
+
+/**
+ * Extension interface for {@link ISourceViewer} supporting temporary, per-viewer
+ * code mining filters. Installed providers and editor preferences are not changed.
+ *
+ * @since 3.32
+ */
+public interface ISourceViewerExtension6 {
+
+ /**
+ * Adds a filter. A mining is displayed only if every registered filter accepts
+ * it. Registering the same filter instance again has no effect. Filters are
+ * retained when code mining providers are reconfigured.
+ *
+ * Filters are evaluated after providers have computed their minings and before
+ * resolution and rendering. Null entries returned by providers are ignored and
+ * are never passed to filters. Rejected minings are disposed. A filter must be
+ * thread-safe and must not access SWT widgets or modify the viewer. Its result
+ * must remain stable until it is removed. Adding a filter cancels pending
+ * updates, removes annotations containing rejected minings and requests fresh
+ * minings. Annotations containing only accepted minings remain until refreshed.
+ *
+ *
+ * Call this method on the viewer's UI thread. Clients must remove their filter
+ * when it is no longer needed; filters are released when the viewer is disposed.
+ *
+ *
+ * @param filter the filter to add, not {@code null}; {@code true} accepts a mining
+ * @throws org.eclipse.swt.SWTException if called from a thread other than the
+ * viewer's UI thread or after the viewer's text widget has been disposed
+ */
+ void addCodeMiningFilter(Predicate super ICodeMining> filter);
+
+ /**
+ * Removes the specified filter instance without affecting other filters or
+ * disposing installed providers. If registered, pending updates are canceled,
+ * current accepted mining annotations are retained and fresh minings are requested.
+ * Removing an unregistered filter has no effect.
+ *
+ * Call this method on the viewer's UI thread.
+ *
+ *
+ * @param filter the filter instance previously added, not {@code null}
+ * @throws org.eclipse.swt.SWTException if called from a thread other than the
+ * viewer's UI thread or after the viewer's text widget has been disposed
+ */
+ void removeCodeMiningFilter(Predicate super ICodeMining> filter);
+}
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/SourceViewer.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/SourceViewer.java
index 9e20b6f13ec..22e4bc04925 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/SourceViewer.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/SourceViewer.java
@@ -22,6 +22,7 @@
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
+import java.util.function.Predicate;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
@@ -69,6 +70,7 @@
import org.eclipse.jface.text.TextPresentation;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.TextViewer;
+import org.eclipse.jface.text.codemining.ICodeMining;
import org.eclipse.jface.text.codemining.ICodeMiningProvider;
import org.eclipse.jface.text.contentassist.IContentAssistant;
import org.eclipse.jface.text.contentassist.IContentAssistantExtension2;
@@ -107,7 +109,7 @@
* Clients may subclass this class but should expect some breakage by future releases.
*/
public class SourceViewer extends TextViewer
- implements ISourceViewer, ISourceViewerExtension, ISourceViewerExtension2, ISourceViewerExtension3, ISourceViewerExtension4, ISourceViewerExtension5 {
+ implements ISourceViewer, ISourceViewerExtension, ISourceViewerExtension2, ISourceViewerExtension3, ISourceViewerExtension4, ISourceViewerExtension5, ISourceViewerExtension6 {
/**
* Layout of a source viewer. Vertical ruler, text widget, and overview ruler are shown side by side.
@@ -412,6 +414,8 @@ private int[] computeScrollArrowHeights(StyledText textWidget, int bottomOffset)
*/
private CodeMiningManager fCodeMiningManager;
+ private final List> fCodeMiningFilters= new ArrayList<>();
+
private final List lifecycles;
/**
@@ -852,6 +856,7 @@ public void unconfigure() {
@Override
protected void handleDispose() {
unconfigure();
+ fCodeMiningFilters.clear();
disposeVisualAnnotationModel();
@@ -1380,7 +1385,7 @@ private void ensureCodeMiningManagerInstalled() {
fInlinedAnnotationSupport.install(this, fAnnotationPainter);
}
if (fCodeMiningManager == null) {
- fCodeMiningManager= new CodeMiningManager(this, fInlinedAnnotationSupport, fCodeMiningProviders);
+ fCodeMiningManager= new CodeMiningManager(this, fInlinedAnnotationSupport, fCodeMiningProviders, fCodeMiningFilters);
}
// now trigger an update
updateCodeMinings();
@@ -1392,6 +1397,43 @@ public boolean hasCodeMiningProviders() {
return fCodeMiningManager != null; // manager always has at least one provider
}
+ /**
+ * @since 3.32
+ */
+ @Override
+ public void addCodeMiningFilter(Predicate super ICodeMining> filter) {
+ checkCodeMiningFilterAccess();
+ Assert.isNotNull(filter);
+ if (fCodeMiningFilters.stream().noneMatch(registered -> registered == filter)) {
+ fCodeMiningFilters.add(filter);
+ if (fCodeMiningManager != null) {
+ fCodeMiningManager.setCodeMiningFilters(fCodeMiningFilters);
+ }
+ }
+ }
+
+ /**
+ * @since 3.32
+ */
+ @Override
+ public void removeCodeMiningFilter(Predicate super ICodeMining> filter) {
+ checkCodeMiningFilterAccess();
+ Assert.isNotNull(filter);
+ if (fCodeMiningFilters.removeIf(registered -> registered == filter) && fCodeMiningManager != null) {
+ fCodeMiningManager.setCodeMiningFilters(fCodeMiningFilters);
+ }
+ }
+
+ private void checkCodeMiningFilterAccess() {
+ StyledText textWidget= getTextWidget();
+ if (textWidget == null || textWidget.isDisposed()) {
+ SWT.error(SWT.ERROR_WIDGET_DISPOSED);
+ }
+ if (Display.getCurrent() != textWidget.getDisplay()) {
+ SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
+ }
+ }
+
@Override
public void updateCodeMinings() {
if (hasCodeMiningProviders()) {
diff --git a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/InlinedAnnotationSupport.java b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/InlinedAnnotationSupport.java
index 05b1a9790a0..6ad949e4492 100644
--- a/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/InlinedAnnotationSupport.java
+++ b/bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/inlined/InlinedAnnotationSupport.java
@@ -566,6 +566,7 @@ public void updateAnnotations(Set annotations) {
if (fUninstalled) {
return;
}
+ fInlinedAnnotations= annotations;
if (annotationsToAdd.isEmpty() && annotationsToRemove.isEmpty()) {
// None change, do nothing. Here the user could change position of codemining
// range
@@ -578,14 +579,19 @@ public void updateAnnotations(Set annotations) {
annotationsToRemove.toArray(new Annotation[annotationsToRemove.size()]), annotationsToAdd);
} else {
for (AbstractInlinedAnnotation ann : annotationsToRemove) {
- annotationModel.removeAnnotation(ann);
+ Set latestAnnotations= fInlinedAnnotations;
+ if (latestAnnotations == null || !latestAnnotations.contains(ann)) {
+ annotationModel.removeAnnotation(ann);
+ }
}
for (Entry mapEntry : annotationsToAdd.entrySet()) {
+ if (fInlinedAnnotations != annotations) {
+ return;
+ }
annotationModel.addAnnotation(mapEntry.getKey(), mapEntry.getValue());
}
}
}
- fInlinedAnnotations= annotations;
}
}
diff --git a/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/JFaceTextTestSuite.java b/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/JFaceTextTestSuite.java
index 3415d4764ad..0b6b7d8cef2 100644
--- a/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/JFaceTextTestSuite.java
+++ b/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/JFaceTextTestSuite.java
@@ -17,6 +17,7 @@
import org.junit.platform.suite.api.SelectClasses;
import org.eclipse.jface.text.tests.codemining.CodeMiningAnnotationReattachTest;
+import org.eclipse.jface.text.tests.codemining.CodeMiningFilterTest;
import org.eclipse.jface.text.tests.codemining.CodeMiningLineHeaderAnnotationTest;
import org.eclipse.jface.text.tests.codemining.CodeMiningProjectionViewerTest;
import org.eclipse.jface.text.tests.codemining.CodeMiningTest;
@@ -88,6 +89,7 @@
CodeMiningLineHeaderAnnotationTest.class,
CodeMiningProjectionViewerTest.class,
CodeMiningAnnotationReattachTest.class,
+ CodeMiningFilterTest.class,
TabsToSpacesConverterTest.class,
DefaultTextDoubleClickStrategyTest.class,
diff --git a/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/codemining/CodeMiningFilterTest.java b/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/codemining/CodeMiningFilterTest.java
new file mode 100644
index 00000000000..164a72367c6
--- /dev/null
+++ b/tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/codemining/CodeMiningFilterTest.java
@@ -0,0 +1,766 @@
+/*******************************************************************************
+ * Copyright (c) 2026 SAP SE and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.jface.text.tests.codemining;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Predicate;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.SWTException;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+
+import org.eclipse.core.runtime.ILogListener;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Platform;
+
+import org.eclipse.jface.internal.text.codemining.ICodeMiningAnnotation;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.codemining.AbstractCodeMining;
+import org.eclipse.jface.text.codemining.AbstractCodeMiningProvider;
+import org.eclipse.jface.text.codemining.DocumentFooterCodeMining;
+import org.eclipse.jface.text.codemining.ICodeMining;
+import org.eclipse.jface.text.codemining.ICodeMiningProvider;
+import org.eclipse.jface.text.codemining.LineContentCodeMining;
+import org.eclipse.jface.text.codemining.LineHeaderCodeMining;
+import org.eclipse.jface.text.source.Annotation;
+import org.eclipse.jface.text.source.AnnotationModel;
+import org.eclipse.jface.text.source.AnnotationPainter;
+import org.eclipse.jface.text.source.IAnnotationModel;
+import org.eclipse.jface.text.source.IAnnotationModelListener;
+import org.eclipse.jface.text.source.SourceViewer;
+import org.eclipse.jface.text.source.inlined.AbstractInlinedAnnotation;
+import org.eclipse.jface.text.source.inlined.LineHeaderAnnotation;
+
+import org.eclipse.ui.tests.harness.util.DisplayHelper;
+
+public class CodeMiningFilterTest {
+
+ private Shell shell;
+ private SourceViewer viewer;
+ private AnnotationModel model;
+
+ @BeforeEach
+ public void setUp() {
+ shell= new Shell(Display.getDefault());
+ shell.setSize(500, 200);
+ shell.setLayout(new FillLayout());
+ viewer= new SourceViewer(shell, null, SWT.NONE);
+ model= new AnnotationModel();
+ viewer.setDocument(new Document("line0\nline1\nline2\nline3"), model);
+ AnnotationPainter painter= new AnnotationPainter(viewer, null);
+ viewer.setCodeMiningAnnotationPainter(painter);
+ viewer.addPainter(painter);
+ shell.open();
+ }
+
+ @AfterEach
+ public void tearDown() {
+ shell.dispose();
+ }
+
+ @Test
+ public void testFiltersAllMiningTypesAndRestoresProviders() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ waitForAnnotations(3);
+ Predicate hide= mining -> mining.getProvider() != provider;
+ viewer.addCodeMiningFilter(hide);
+ waitForAnnotations(0);
+ assertEquals(0, provider.disposals);
+ assertMiningsDisposedExactlyOnce(provider);
+ viewer.removeCodeMiningFilter(hide);
+ waitForAnnotations(3);
+ assertEquals(0, provider.disposals);
+ assertSame(provider, provider.created.getLast().getProvider());
+ }
+
+ @Test
+ public void testBackgroundRenderingDoesNotWaitForUiThreadAfterTyping() throws Exception {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ waitForAnnotations(3);
+ viewer.getDocument().replace(0, 0, "typed");
+ provider.delayed= true;
+ viewer.updateCodeMinings();
+ List minings= provider.createMinings();
+ CompletableFuture> pending= provider.pending.getLast();
+ CompletableFuture completion= CompletableFuture.runAsync(() -> pending.complete(minings));
+ try {
+ completion.get(2, TimeUnit.SECONDS);
+ viewer.updateCodeMinings();
+ } finally {
+ DisplayHelper.sleep(shell.getDisplay(), 100);
+ }
+ assertEquals(1, provider.created.getLast().disposals);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testUiRefreshDoesNotWaitForBackgroundFilter() throws Exception {
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ CountDownLatch entered= new CountDownLatch(1);
+ CountDownLatch release= new CountDownLatch(1);
+ viewer.addCodeMiningFilter(mining -> {
+ if (Display.getCurrent() == null) {
+ entered.countDown();
+ try {
+ if (!release.await(2, TimeUnit.SECONDS)) {
+ throw new CancellationException();
+ }
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new CancellationException();
+ }
+ }
+ return mining.getProvider() == provider;
+ });
+ install(provider);
+ List minings= provider.createMinings();
+ CompletableFuture> pending= provider.pending.getLast();
+ CompletableFuture completion= CompletableFuture.runAsync(() -> pending.complete(minings));
+ try {
+ assertTrue(entered.await(2, TimeUnit.SECONDS));
+ long started= System.nanoTime();
+ viewer.updateCodeMinings();
+ assertTrue(System.nanoTime() - started < TimeUnit.SECONDS.toNanos(1),
+ "UI refresh waited for foreign code holding the manager lock");
+ } finally {
+ release.countDown();
+ DisplayHelper.sleep(shell.getDisplay(), 100);
+ }
+ completion.get(2, TimeUnit.SECONDS);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testThrowingRejectedMiningDisposalDoesNotDropAcceptedMinings() {
+ TestProvider provider= new TestProvider();
+ RuntimeException failure= new IllegalStateException("synthetic disposal failure");
+ provider.headerDisposalFailure= failure;
+ List errors= new ArrayList<>();
+ ILogListener listener= (status, plugin) -> {
+ if (status.getException() == failure) {
+ errors.add(status);
+ }
+ };
+ Platform.addLogListener(listener);
+ try {
+ viewer.addCodeMiningFilter(mining -> !(mining instanceof LineHeaderCodeMining));
+ install(provider);
+ waitForAnnotations(2);
+ assertEquals(1, provider.created.getFirst().disposals);
+ assertEquals(1, errors.size());
+ assertEquals(0, provider.otherDisposals.getFirst().get());
+ viewer.setCodeMiningProviders(null);
+ assertTrue(provider.otherDisposals.stream().allMatch(disposals -> disposals.get() == 1));
+ } finally {
+ Platform.removeLogListener(listener);
+ }
+ }
+
+ @Test
+ public void testThrowingCanceledMiningDisposalDoesNotLeakFollowingMinings() {
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ RuntimeException failure= new IllegalStateException("synthetic canceled disposal failure");
+ provider.headerDisposalFailure= failure;
+ AtomicInteger errors= new AtomicInteger();
+ ILogListener listener= (status, plugin) -> {
+ if (status.getException() == failure) {
+ errors.incrementAndGet();
+ }
+ };
+ Platform.addLogListener(listener);
+ try {
+ install(provider);
+ viewer.updateCodeMinings();
+ provider.pending.getFirst().complete(provider.createMinings());
+ assertMiningsDisposedExactlyOnce(provider);
+ assertEquals(1, errors.get());
+ } finally {
+ Platform.removeLogListener(listener);
+ }
+ }
+
+ @Test
+ public void testFiltersComposeAndRegistrationUsesIdentity() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ Predicate noHeaders= mining -> !(mining instanceof LineHeaderCodeMining);
+ Predicate noInline= mining -> !(mining instanceof LineContentCodeMining);
+ viewer.addCodeMiningFilter(noHeaders);
+ waitForAnnotations(2);
+ int requests= provider.requests;
+ viewer.addCodeMiningFilter(noHeaders);
+ assertEquals(requests, provider.requests);
+ viewer.addCodeMiningFilter(noInline);
+ waitForAnnotations(1);
+ viewer.removeCodeMiningFilter(noHeaders);
+ waitForAnnotations(2);
+ viewer.removeCodeMiningFilter(noHeaders);
+ assertEquals(requests + 2, provider.requests);
+ viewer.removeCodeMiningFilter(noInline);
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testOffThreadCallsAreRejectedBeforeProvidersAreInstalled() {
+ Predicate filter= mining -> mining instanceof LineHeaderCodeMining;
+ CompletableFuture.runAsync(() -> {
+ assertEquals(SWT.ERROR_THREAD_INVALID_ACCESS,
+ assertThrows(SWTException.class, () -> viewer.addCodeMiningFilter(filter)).code);
+ assertEquals(SWT.ERROR_THREAD_INVALID_ACCESS,
+ assertThrows(SWTException.class, () -> viewer.removeCodeMiningFilter(filter)).code);
+ }).join();
+ install(new TestProvider());
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testOffThreadCallsCannotChangeRegisteredFilters() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ Predicate headers= mining -> mining instanceof LineHeaderCodeMining;
+ Predicate inline= mining -> mining instanceof LineContentCodeMining;
+ viewer.addCodeMiningFilter(headers);
+ waitForAnnotations(1);
+ int requests= provider.requests;
+ CompletableFuture.runAsync(() -> {
+ assertEquals(SWT.ERROR_THREAD_INVALID_ACCESS,
+ assertThrows(SWTException.class, () -> viewer.addCodeMiningFilter(headers)).code);
+ assertEquals(SWT.ERROR_THREAD_INVALID_ACCESS,
+ assertThrows(SWTException.class, () -> viewer.addCodeMiningFilter(inline)).code);
+ assertEquals(SWT.ERROR_THREAD_INVALID_ACCESS,
+ assertThrows(SWTException.class, () -> viewer.removeCodeMiningFilter(headers)).code);
+ }).join();
+ assertEquals(requests, provider.requests);
+ assertEquals(1, annotationCount());
+ viewer.removeCodeMiningFilter(headers);
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testFilterCallsAfterDisposalAreRejected() {
+ Predicate filter= mining -> mining instanceof LineHeaderCodeMining;
+ shell.dispose();
+ assertEquals(SWT.ERROR_WIDGET_DISPOSED,
+ assertThrows(SWTException.class, () -> viewer.addCodeMiningFilter(filter)).code);
+ assertEquals(SWT.ERROR_WIDGET_DISPOSED,
+ assertThrows(SWTException.class, () -> viewer.removeCodeMiningFilter(filter)).code);
+ }
+
+ @Test
+ public void testRepeatedRegistrationAndRemovalDoNotRecomputeMinings() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ Predicate filter= mining -> mining instanceof LineHeaderCodeMining;
+ viewer.addCodeMiningFilter(filter);
+ int requests= provider.requests;
+ for (int attempt= 0; attempt < 1000; attempt++) {
+ viewer.addCodeMiningFilter(filter);
+ }
+ assertEquals(requests, provider.requests);
+ viewer.removeCodeMiningFilter(filter);
+ requests= provider.requests;
+ for (int attempt= 0; attempt < 1000; attempt++) {
+ viewer.removeCodeMiningFilter(filter);
+ }
+ assertEquals(requests, provider.requests);
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testNullProviderResultsAreIgnoredBeforeFiltering() {
+ TestProvider provider= new TestProvider();
+ provider.includeNullEntries= true;
+ AtomicInteger filtered= new AtomicInteger();
+ Predicate filter= mining -> {
+ filtered.incrementAndGet();
+ return mining.getProvider() == provider;
+ };
+ viewer.addCodeMiningFilter(filter);
+ viewer.setCodeMiningProviders(new ICodeMiningProvider[] {
+ new EmptyProvider(false), new EmptyProvider(true), provider });
+ waitForAnnotations(3);
+ assertEquals(3, filtered.get());
+ viewer.removeCodeMiningFilter(filter);
+ waitForAnnotations(3);
+ assertEquals(0, provider.disposals);
+ }
+
+ @Test
+ public void testNullEntriesAreIgnoredWithoutFilters() {
+ TestProvider provider= new TestProvider();
+ provider.includeNullEntries= true;
+ install(provider);
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testCanceledResultWithNullEntriesDisposesValidMinings() {
+ TestProvider provider= new TestProvider();
+ provider.includeNullEntries= true;
+ provider.delayed= true;
+ install(provider);
+ viewer.addCodeMiningFilter(mining -> mining.getProvider() != provider);
+ provider.pending.getFirst().complete(provider.createMinings());
+ assertMiningsDisposedExactlyOnce(provider);
+ provider.pending.getLast().complete(provider.createMinings());
+ assertMiningsDisposedExactlyOnce(provider);
+ assertEquals(0, annotationCount());
+ }
+
+ @Test
+ public void testFilterRetainedAcrossProviderReconfiguration() {
+ Predicate headers= mining -> mining instanceof LineHeaderCodeMining;
+ viewer.addCodeMiningFilter(headers);
+ TestProvider first= new TestProvider();
+ install(first);
+ waitForAnnotations(1);
+ viewer.setCodeMiningProviders(null);
+ assertEquals(1, first.disposals);
+ TestProvider second= new TestProvider();
+ install(second);
+ waitForAnnotations(1);
+ viewer.removeCodeMiningFilter(headers);
+ waitForAnnotations(3);
+ assertEquals(0, second.disposals);
+ }
+
+ @Test
+ public void testCanceledFutureCannotRestoreHiddenMinings() {
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ install(provider);
+ CompletableFuture> stale= provider.pending.getFirst();
+ Predicate hide= mining -> mining.getProvider() != provider;
+ viewer.addCodeMiningFilter(hide);
+ stale.complete(provider.createMinings());
+ assertMiningsDisposedExactlyOnce(provider);
+ assertEquals(0, annotationCount());
+ provider.pending.getLast().complete(provider.createMinings());
+ assertEquals(0, annotationCount());
+ assertMiningsDisposedExactlyOnce(provider);
+ viewer.removeCodeMiningFilter(hide);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ }
+
+ @Test
+ public void testDisposalCancelsPendingRequestAndDisposesItsMinings() {
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ install(provider);
+ shell.dispose();
+ provider.pending.getFirst().complete(provider.createMinings());
+ assertEquals(1, provider.disposals);
+ assertMiningsDisposedExactlyOnce(provider);
+ }
+
+ @Test
+ public void testStaleFilteredRequestCannotRemoveRestoredMinings() {
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ install(provider);
+ Predicate hide= mining -> mining.getProvider() != provider;
+ viewer.addCodeMiningFilter(hide);
+ CompletableFuture> filtered= provider.pending.getLast();
+ viewer.removeCodeMiningFilter(hide);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ CompletableFuture.runAsync(() -> filtered.complete(provider.createMinings())).join();
+ assertEquals(3, annotationCount());
+ assertEquals(1, provider.created.getLast().disposals);
+ provider.pending.getFirst().complete(provider.createMinings());
+ assertEquals(3, annotationCount());
+ assertEquals(1, provider.created.getLast().disposals);
+ }
+
+ @Test
+ public void testProviderReplacementCancelsPendingRequestWhileFiltering() {
+ TestProvider first= new TestProvider();
+ first.delayed= true;
+ Predicate headers= mining -> mining instanceof LineHeaderCodeMining;
+ viewer.addCodeMiningFilter(headers);
+ install(first);
+ TestProvider second= new TestProvider();
+ install(second);
+ waitForAnnotations(1);
+ first.pending.getFirst().complete(first.createMinings());
+ assertMiningsDisposedExactlyOnce(first);
+ assertEquals(1, first.disposals);
+ assertEquals(1, annotationCount());
+ viewer.removeCodeMiningFilter(headers);
+ waitForAnnotations(3);
+ assertEquals(0, second.disposals);
+ }
+
+ @Test
+ public void testFilteringReleasesOffscreenReservedHeight() {
+ viewer.getDocument().set("line\n".repeat(200));
+ TestProvider provider= new TestProvider();
+ provider.headerLine= 150;
+ install(provider);
+ viewer.getTextWidget().setTopIndex(150);
+ assertTrue(new DisplayHelper() {
+ @Override
+ protected boolean condition() {
+ return viewer.getTextWidget().getLineVerticalIndent(150) > 0;
+ }
+ }.waitForCondition(shell.getDisplay(), 3000));
+ viewer.getTextWidget().setTopIndex(0);
+ viewer.addCodeMiningFilter(mining -> mining.getProvider() != provider);
+ waitForAnnotations(0);
+ assertTrue(new DisplayHelper() {
+ @Override
+ protected boolean condition() {
+ return viewer.getTextWidget().getLineVerticalIndent(150) == 0;
+ }
+ }.waitForCondition(shell.getDisplay(), 3000));
+ }
+
+ @Test
+ public void testFilterChangesRetainAcceptedAnnotationsUntilRefreshCompletes() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ waitForAnnotations(3);
+ CountingHeaderMining original= provider.created.getFirst();
+ Annotation header= null;
+ for (Iterator annotations= model.getAnnotationIterator(); annotations.hasNext();) {
+ Annotation candidate= annotations.next();
+ if (candidate instanceof LineHeaderAnnotation) {
+ header= candidate;
+ }
+ }
+ assertTrue(header != null);
+ provider.delayed= true;
+ Predicate headers= mining -> mining instanceof LineHeaderCodeMining;
+ viewer.addCodeMiningFilter(headers);
+ assertEquals(1, annotationCount());
+ assertTrue(model.getPosition(header) != null, "accepted header must not be removed during refresh");
+ assertEquals(0, original.disposals);
+ viewer.removeCodeMiningFilter(headers);
+ assertEquals(1, annotationCount());
+ assertTrue(model.getPosition(header) != null);
+ assertEquals(0, original.disposals);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ assertEquals(1, original.disposals);
+ }
+
+ @Test
+ public void testFilterRejectsCachedMiningsForAllAnnotationTypes() {
+ TestProvider original= new TestProvider();
+ install(original);
+ waitForAnnotations(3);
+ TestProvider replacement= new TestProvider();
+ List replacements= replacement.createMinings();
+ int annotationsUpdated= 0;
+ for (Iterator annotations= model.getAnnotationIterator(); annotations.hasNext();) {
+ if (annotations.next() instanceof ICodeMiningAnnotation miningAnnotation) {
+ ICodeMining current= miningAnnotation.getMinings().getFirst();
+ ICodeMining next= replacements.stream()
+ .filter(mining -> mining.getPosition().equals(current.getPosition())).findFirst().orElseThrow();
+ ((AbstractCodeMining) next).setLabel(null);
+ miningAnnotation.update(List.of(next), new NullProgressMonitor());
+ assertSame(replacement, miningAnnotation.getMinings().getFirst().getProvider());
+ assertSame(original, miningAnnotation.getCachedMinings()[0].getProvider());
+ annotationsUpdated++;
+ }
+ }
+ assertEquals(3, annotationsUpdated);
+ original.delayed= true;
+ viewer.addCodeMiningFilter(mining -> mining.getProvider() == replacement);
+ assertEquals(0, annotationCount(), "annotations with rejected cached content must disappear immediately");
+ assertMiningsDisposedExactlyOnce(original);
+ assertMiningsDisposedExactlyOnce(replacement);
+ }
+
+ @Test
+ public void testFilterRegisteredFromModelCallbackSeesNewAnnotations() {
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ AtomicBoolean registered= new AtomicBoolean();
+ Predicate hide= mining -> mining.getProvider() != provider;
+ IAnnotationModelListener listener= annotationModel -> {
+ if (annotationCount() > 0 && registered.compareAndSet(false, true)) {
+ viewer.addCodeMiningFilter(hide);
+ }
+ };
+ model.addAnnotationModelListener(listener);
+ try {
+ install(provider);
+ provider.pending.getFirst().complete(provider.createMinings());
+ assertTrue(registered.get());
+ assertEquals(0, annotationCount(), "callback filter must remove the just-installed annotations");
+ assertMiningsDisposedExactlyOnce(provider);
+ provider.pending.getLast().complete(provider.createMinings());
+ assertEquals(0, annotationCount());
+ assertMiningsDisposedExactlyOnce(provider);
+ viewer.removeCodeMiningFilter(hide);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ viewer.addCodeMiningFilter(hide);
+ assertEquals(0, annotationCount(), "nested update must not leave stale support/manager state");
+ } finally {
+ model.removeAnnotationModelListener(listener);
+ }
+ }
+
+ @Test
+ public void testNonBatchCallbackDoesNotAbandonPendingRemovals() {
+ IAnnotationModel nonBatchModel= (IAnnotationModel) Proxy.newProxyInstance(
+ IAnnotationModel.class.getClassLoader(), new Class>[] { IAnnotationModel.class },
+ (proxy, method, arguments) -> {
+ try {
+ return method.invoke(model, arguments);
+ } catch (InvocationTargetException e) {
+ throw e.getCause();
+ }
+ });
+ viewer.setDocument(viewer.getDocument(), nonBatchModel);
+ TestProvider provider= new TestProvider();
+ provider.delayed= true;
+ install(provider);
+ provider.pending.getFirst().complete(provider.createMinings());
+ waitForAnnotations(3);
+ AtomicBoolean registered= new AtomicBoolean();
+ Predicate hide= mining -> mining.getProvider() != provider;
+ IAnnotationModelListener listener= annotationModel -> {
+ if (annotationCount() == 2 && registered.compareAndSet(false, true)) {
+ viewer.addCodeMiningFilter(hide);
+ }
+ };
+ model.addAnnotationModelListener(listener);
+ try {
+ viewer.updateCodeMinings();
+ provider.pending.getLast().complete(List.of());
+ assertTrue(registered.get());
+ assertEquals(0, annotationCount(), "superseded non-batch removals must still finish");
+ assertMiningsDisposedExactlyOnce(provider);
+ provider.pending.getLast().complete(List.of());
+ viewer.updateCodeMinings();
+ provider.pending.getLast().complete(List.of());
+ assertEquals(0, annotationCount(), "no orphan may survive later empty refreshes");
+ assertMiningsDisposedExactlyOnce(provider);
+ viewer.removeCodeMiningFilter(hide);
+ provider.pending.getLast().complete(provider.createMinings());
+ waitForAnnotations(3);
+ } finally {
+ model.removeAnnotationModelListener(listener);
+ }
+ }
+
+ @Test
+ public void testFilteringReleasesInlineGlyphMetrics() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ assertTrue(new DisplayHelper() {
+ @Override
+ protected boolean condition() {
+ var style= viewer.getTextWidget().getStyleRangeAtOffset(0);
+ return style != null && style.metrics != null;
+ }
+ }.waitForCondition(shell.getDisplay(), 3000));
+ viewer.addCodeMiningFilter(mining -> !(mining instanceof LineContentCodeMining));
+ waitForAnnotations(2);
+ assertTrue(new DisplayHelper() {
+ @Override
+ protected boolean condition() {
+ var style= viewer.getTextWidget().getStyleRangeAtOffset(0);
+ return style == null || style.metrics == null;
+ }
+ }.waitForCondition(shell.getDisplay(), 3000));
+ }
+
+ @Test
+ public void testFilterDoesNotAffectAnotherViewer() {
+ TestProvider provider= new TestProvider();
+ install(provider);
+ SourceViewer otherViewer= new SourceViewer(shell, null, SWT.NONE);
+ AnnotationModel otherModel= new AnnotationModel();
+ otherViewer.setDocument(new Document(viewer.getDocument().get()), otherModel);
+ AnnotationPainter painter= new AnnotationPainter(otherViewer, null);
+ otherViewer.setCodeMiningAnnotationPainter(painter);
+ otherViewer.addPainter(painter);
+ otherViewer.setCodeMiningProviders(new ICodeMiningProvider[] { new TestProvider() });
+ assertEquals(3, annotationCount(otherModel));
+ Predicate hide= mining -> mining.getProvider() != provider;
+ viewer.addCodeMiningFilter(hide);
+ waitForAnnotations(0);
+ assertEquals(3, annotationCount(otherModel));
+ viewer.removeCodeMiningFilter(hide);
+ waitForAnnotations(3);
+ assertEquals(3, annotationCount(otherModel));
+ }
+
+ private void install(TestProvider provider) {
+ viewer.setCodeMiningProviders(new ICodeMiningProvider[] { provider });
+ }
+
+ private void assertMiningsDisposedExactlyOnce(TestProvider provider) {
+ assertTrue(provider.created.stream().allMatch(mining -> mining.disposals == 1));
+ assertTrue(provider.otherDisposals.stream().allMatch(disposals -> disposals.get() == 1));
+ }
+
+ private void waitForAnnotations(int count) {
+ assertTrue(new DisplayHelper() {
+ @Override
+ protected boolean condition() {
+ return annotationCount() == count;
+ }
+ }.waitForCondition(shell.getDisplay(), 3000), "Expected " + count + " mining annotations");
+ }
+
+ private int annotationCount() {
+ return annotationCount(model);
+ }
+
+ private int annotationCount(AnnotationModel annotationModel) {
+ int count= 0;
+ for (Iterator annotations= annotationModel.getAnnotationIterator(); annotations.hasNext();) {
+ if (annotations.next() instanceof AbstractInlinedAnnotation) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+ private final class TestProvider extends AbstractCodeMiningProvider {
+ private final IDocument document= viewer.getDocument();
+ private int disposals;
+ private int requests;
+ private int headerLine= 1;
+ private boolean delayed;
+ private boolean includeNullEntries;
+ private RuntimeException headerDisposalFailure;
+ private final List created= new ArrayList<>();
+ private final List otherDisposals= new ArrayList<>();
+ private final List>> pending= new ArrayList<>();
+
+ @Override
+ public CompletableFuture> provideCodeMinings(ITextViewer textViewer, IProgressMonitor monitor) {
+ requests++;
+ if (!delayed) {
+ return CompletableFuture.completedFuture(createMinings());
+ }
+ CompletableFuture> future= new CompletableFuture<>();
+ pending.add(future);
+ return future;
+ }
+
+ private List createMinings() {
+ try {
+ CountingHeaderMining header= new CountingHeaderMining(this);
+ created.add(header);
+ AtomicInteger inlineDisposals= new AtomicInteger();
+ otherDisposals.add(inlineDisposals);
+ LineContentCodeMining inline= new LineContentCodeMining(new Position(0, 1), this) {
+ @Override
+ public void dispose() {
+ inlineDisposals.incrementAndGet();
+ super.dispose();
+ }
+ };
+ inline.setLabel("inline");
+ AtomicInteger footerDisposals= new AtomicInteger();
+ otherDisposals.add(footerDisposals);
+ DocumentFooterCodeMining footer= new DocumentFooterCodeMining(document, this, null) {
+ @Override
+ public void dispose() {
+ footerDisposals.incrementAndGet();
+ super.dispose();
+ }
+ };
+ footer.setLabel("footer");
+ List minings= new ArrayList<>(List.of(header, inline, footer));
+ if (includeNullEntries) {
+ minings.addFirst(null);
+ minings.add(2, null);
+ minings.addLast(null);
+ }
+ return minings;
+ } catch (BadLocationException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public void dispose() {
+ disposals++;
+ }
+ }
+
+ private static final class EmptyProvider extends AbstractCodeMiningProvider {
+ private final boolean nullList;
+
+ private EmptyProvider(boolean nullList) {
+ this.nullList= nullList;
+ }
+
+ @Override
+ public CompletableFuture> provideCodeMinings(ITextViewer viewer,
+ IProgressMonitor monitor) {
+ return nullList ? CompletableFuture.completedFuture(null) : null;
+ }
+ }
+
+ private final class CountingHeaderMining extends LineHeaderCodeMining {
+ private int disposals;
+ private final RuntimeException disposalFailure;
+
+ private CountingHeaderMining(TestProvider provider) throws BadLocationException {
+ super(provider.headerLine, provider.document, provider);
+ disposalFailure= provider.headerDisposalFailure;
+ setLabel("header");
+ }
+
+ @Override
+ public void dispose() {
+ disposals++;
+ super.dispose();
+ if (disposalFailure != null) {
+ throw disposalFailure;
+ }
+ }
+ }
+}