Fix CloseUnrelatedProjectsAction enablement after closing all unrelated projects

After PR #3871, updateSelection() only checked whether the user selection
contained an open project, so the action stayed enabled even when no
unrelated projects were left to close. PR #3871 was needed because the
prior check was triggering buildConnectedComponents() on every selection
change, which calls IProject#getReferencedProjects() across the workspace
and can resolve classpath containers, blocking the IDE.

Cache the workspace project graph and invalidate it from resourceChanged()
when project open state or description changes. The expensive graph build
now runs at most once per project-state change rather than once per
selection event, while updateSelection() can again ask whether any open
unrelated project actually exists. Selection-time work is reduced to a
non-mutating scan of the cached graph.

Add CloseUnrelatedProjectsActionEnablementTest covering the regression
scenario reported on PR #3871: A and B linked, C unrelated; after closing
C, selecting B must disable the action.

Author: vogella

bundles/org.eclipse.ui.ide/extensions/org/eclipse/ui/actions/CloseUnrelatedProjectsAction.java

@@ -19,7 +19,9 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
@@ -67,6 +69,10 @@ public class CloseUnrelatedProjectsAction extends CloseResourceAction {
 
 	private List<? extends IResource> oldSelection = Collections.emptyList();
 
+	// Cached workspace project graph. Built lazily, reused across selection
+	// changes, invalidated when project open state or description changes.
+	private DisjointSet<IProject> projectGraph;
+
 
 	/**
 	 * Builds the connected component set for the input projects.
@@ -131,18 +137,23 @@ public CloseUnrelatedProjectsAction(IShellProvider provider){
 		initAction();
 	}
 
-	/**
-	 * Overrides to avoid calling the expensive
-	 * {@code computeRelated(List)} during selection changes. Uses only
-	 * the raw selection to determine enablement.
-	 */
 	@Override
 	protected boolean updateSelection(IStructuredSelection s) {
 		selectionDirty = true;
 		if (!selectionIsOfType(IResource.PROJECT)) {
 			return false;
 		}
+		boolean hasOpenSelectedProject = false;
 		for (IResource resource : super.getSelectedResources()) {
+			if (resource instanceof IProject project && project.isOpen()) {
+				hasOpenSelectedProject = true;
+				break;
+			}
+		}
+		if (!hasOpenSelectedProject) {
+			return false;
+		}
+		for (IResource resource : getSelectedResources()) {
 			if (resource instanceof IProject project && project.isOpen()) {
 				return true;
 			}
@@ -217,27 +228,50 @@ protected void clearCache() {
 	}
 
 	/**
-	 * Computes the related projects of the selection.
+	 * Computes the projects unrelated to the given selection.
 	 */
 	private List<IResource> computeRelated(List<? extends IResource> selection) {
 		if (selection.contains(ResourcesPlugin.getWorkspace().getRoot())) {
 			return new ArrayList<>();
 		}
-		//build the connected component set for all projects in the workspace
-		DisjointSet<IProject> set = buildConnectedComponents(ResourcesPlugin.getWorkspace().getRoot().getProjects());
-		//remove the connected components that the selected projects are in
+		DisjointSet<IProject> set = getProjectGraph();
+		Set<IProject> excludedRoots = new HashSet<>();
 		for (IResource resource : selection) {
 			IProject project = resource.getProject();
 			if (project != null) {
-				set.removeSet(project);
+				IProject root = set.findSet(project);
+				if (root != null) {
+					excludedRoots.add(root);
+				}
 			}
 		}
-		//the remainder of the projects in the disjoint set are unrelated to the selection
+		List<IProject> all = new ArrayList<>();
+		set.toList(all);
 		List<IResource> projects = new ArrayList<>();
-		set.toList(projects);
+		for (IProject project : all) {
+			IProject root = set.findSet(project);
+			if (root != null && !excludedRoots.contains(root)) {
+				projects.add(project);
+			}
+		}
 		return projects;
 	}
 
+	private DisjointSet<IProject> getProjectGraph() {
+		DisjointSet<IProject> graph = projectGraph;
+		if (graph == null) {
+			graph = buildConnectedComponents(ResourcesPlugin.getWorkspace().getRoot().getProjects());
+			projectGraph = graph;
+		}
+		return graph;
+	}
+
+	private void invalidateProjectGraph() {
+		projectGraph = null;
+		oldSelection = Collections.emptyList();
+		selectionDirty = true;
+	}
+
 	@Override
 	protected List<? extends IResource> getSelectedResources() {
 		if (selectionDirty) {
@@ -268,6 +302,7 @@ public void resourceChanged(IResourceChangeEvent event) {
 				for (IResourceDelta projDelta : projDeltas) {
 					//changing either the description or the open state can affect enablement
 					if ((projDelta.getFlags() & (IResourceDelta.OPEN | IResourceDelta.DESCRIPTION)) != 0) {
+						invalidateProjectGraph();
 						selectionChanged(getStructuredSelection());
 						return;
 					}

tests/org.eclipse.ui.tests.navigator/src/org/eclipse/ui/tests/navigator/NavigatorTestSuite.java

@@ -21,6 +21,7 @@
 
 import org.eclipse.ui.tests.navigator.cdt.CdtTest;
 import org.eclipse.ui.tests.navigator.jst.JstPipelineTest;
+import org.eclipse.ui.tests.navigator.resources.CloseUnrelatedProjectsActionEnablementTest;
 import org.eclipse.ui.tests.navigator.resources.FoldersAsProjectsContributionTest;
 import org.eclipse.ui.tests.navigator.resources.NestedResourcesTests;
 import org.eclipse.ui.tests.navigator.resources.PathComparatorTest;
@@ -36,6 +37,7 @@
 		LabelProviderTest.class, SorterTest.class, ViewerTest.class, CdtTest.class, M12Tests.class,
 		FirstClassM1Tests.class, LinkHelperTest.class, ShowInTest.class, ResourceTransferTest.class,
 		EvaluationCacheTest.class, ResourceMgmtActionProviderTests.class,
+		CloseUnrelatedProjectsActionEnablementTest.class,
 		NestedResourcesTests.class, PathComparatorTest.class, FoldersAsProjectsContributionTest.class,
 		GoBackForwardsTest.class, CopyPasteActionTest.class
 		// DnDTest.class, // DnDTest.testSetDragOperation() fails

tests/org.eclipse.ui.tests.navigator/src/org/eclipse/ui/tests/navigator/resources/CloseUnrelatedProjectsActionEnablementTest.java

@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2026 Lars Vogel 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.ui.tests.navigator.resources;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.IWorkspace;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.actions.CloseUnrelatedProjectsAction;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class CloseUnrelatedProjectsActionEnablementTest {
+
+	private IProject a;
+	private IProject b;
+	private IProject c;
+	private Shell shell;
+
+	@BeforeEach
+	public void setUp() throws CoreException {
+		IWorkspace ws = ResourcesPlugin.getWorkspace();
+		long suffix = System.nanoTime();
+		a = ws.getRoot().getProject("CUPA_A_" + suffix);
+		b = ws.getRoot().getProject("CUPA_B_" + suffix);
+		c = ws.getRoot().getProject("CUPA_C_" + suffix);
+		a.create(null);
+		a.open(null);
+		b.create(null);
+		b.open(null);
+		c.create(null);
+		c.open(null);
+
+		IProjectDescription aDesc = a.getDescription();
+		aDesc.setReferencedProjects(new IProject[] { b });
+		a.setDescription(aDesc, null);
+
+		shell = new Shell(Display.getDefault());
+	}
+
+	@AfterEach
+	public void tearDown() throws CoreException {
+		if (shell != null && !shell.isDisposed()) {
+			shell.dispose();
+		}
+		for (IProject p : new IProject[] { a, b, c }) {
+			if (p != null && p.exists()) {
+				p.delete(true, true, null);
+			}
+		}
+	}
+
+	@Test
+	public void testDisabledAfterAllUnrelatedProjectsClosed() throws CoreException {
+		CloseUnrelatedProjectsAction action = new CloseUnrelatedProjectsAction(() -> shell);
+
+		action.selectionChanged(new StructuredSelection(a));
+		assertTrue(action.isEnabled(),
+				"action must be enabled while unrelated open project C exists");
+
+		c.close(null);
+
+		action.selectionChanged(new StructuredSelection(b));
+		assertFalse(action.isEnabled(),
+				"action must be disabled when no unrelated open project remains");
+	}
+
+	@Test
+	public void testEnabledWhenUnrelatedOpenProjectExists() {
+		CloseUnrelatedProjectsAction action = new CloseUnrelatedProjectsAction(() -> shell);
+
+		action.selectionChanged(new StructuredSelection(a));
+		assertTrue(action.isEnabled(), "expected enabled when unrelated open project C exists");
+
+		action.selectionChanged(new StructuredSelection(b));
+		assertTrue(action.isEnabled(),
+				"expected enabled when unrelated open project C exists (selection B)");
+	}
+
+	@Test
+	public void testDisabledWhenSelectionCoversAllOpenProjects() throws CoreException {
+		c.close(null);
+		CloseUnrelatedProjectsAction action = new CloseUnrelatedProjectsAction(() -> shell);
+		action.selectionChanged(new StructuredSelection(new Object[] { a, b }));
+		assertFalse(action.isEnabled(),
+				"action must be disabled when selection plus its references covers all open projects");
+	}
+}