From e232225ca6f85cbb7a4d933a94d699de28efd4b0 Mon Sep 17 00:00:00 2001
From: Tobias Melcher
Date: Mon, 16 Nov 2026 17:40:45 +0100
Subject: [PATCH] Add per-viewer code mining visibility filters
Allow source viewers to temporarily show only selected code minings without changing installed providers or editor preferences. Compose filters by identity and refresh minings safely across asynchronous requests and annotation updates.
---
.../CodeMiningDocumentFooterAnnotation.java | 6 +
.../CodeMiningLineContentAnnotation.java | 6 +
.../CodeMiningLineHeaderAnnotation.java | 8 +-
.../text/codemining/CodeMiningManager.java | 171 +++-
.../codemining/ICodeMiningAnnotation.java | 15 +
.../text/codemining/ICodeMiningProvider.java | 6 +
.../text/source/ISourceViewerExtension6.java | 63 ++
.../jface/text/source/SourceViewer.java | 46 +-
.../inlined/InlinedAnnotationSupport.java | 10 +-
.../jface/text/tests/JFaceTextTestSuite.java | 2 +
.../codemining/CodeMiningFilterTest.java | 766 ++++++++++++++++++
11 files changed, 1071 insertions(+), 28 deletions(-)
create mode 100644 bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/source/ISourceViewerExtension6.java
create mode 100644 tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/codemining/CodeMiningFilterTest.java
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;
+ }
+ }
+ }
+}