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 minings) { + for (ICodeMining mining : minings) { + try { + mining.dispose(); + } catch (Throwable e) { + logCodeMiningProviderException(e); + } + } + } + + private static boolean acceptsMining(ICodeMining mining, List> filters) { + for (Predicate 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 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 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 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 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; + } + } + } +}