Add hierarchical ProjectPreferences support with tests

Co-authored-by: laeubi <[email protected]>

Author: Copilot

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ProjectNestingCache.java

@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2024 Vector Informatik GmbH 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
+ *
+ * Contributors:
+ *     Vector Informatik GmbH - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.core.internal.resources;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IPath;
+
+/**
+ * Cache for project nesting relationships. A project A is nested within a project B
+ * if B.getLocation().isPrefixOf(A.getLocation()).
+ * 
+ * This cache is invalidated when projects are created, deleted, moved, or opened/closed.
+ * 
+ * @since 3.20
+ */
+public class ProjectNestingCache {
+	/**
+	 * Cache mapping from a project to its list of ancestor projects (ordered from immediate parent to root).
+	 * The cache is cleared when projects change.
+	 */
+	private final Map<IProject, List<IProject>> nestingCache = new ConcurrentHashMap<>();
+
+	/**
+	 * Returns the list of ancestor projects for the given project, ordered from immediate parent to root.
+	 * A project B is an ancestor of project A if B.getLocation().isPrefixOf(A.getLocation()).
+	 * 
+	 * @param project the project to find ancestors for
+	 * @param workspace the workspace containing all projects
+	 * @return list of ancestor projects, or empty list if no ancestors exist
+	 */
+	public List<IProject> getAncestorProjects(IProject project, Workspace workspace) {
+		if (project == null || !project.isAccessible()) {
+			return Collections.emptyList();
+		}
+
+		// Check cache first
+		List<IProject> cached = nestingCache.get(project);
+		if (cached != null) {
+			return cached;
+		}
+
+		// Compute ancestor projects
+		List<IProject> ancestors = computeAncestorProjects(project, workspace);
+		nestingCache.put(project, ancestors);
+		return ancestors;
+	}
+
+	/**
+	 * Computes the ancestor projects for the given project.
+	 */
+	private List<IProject> computeAncestorProjects(IProject project, Workspace workspace) {
+		IPath projectLocation = project.getLocation();
+		if (projectLocation == null) {
+			return Collections.emptyList();
+		}
+
+		List<IProject> ancestors = new ArrayList<>();
+		IProject[] allProjects = workspace.getRoot().getProjects();
+
+		for (IProject potentialAncestor : allProjects) {
+			if (potentialAncestor.equals(project) || !potentialAncestor.isAccessible()) {
+				continue;
+			}
+
+			IPath ancestorLocation = potentialAncestor.getLocation();
+			if (ancestorLocation != null && ancestorLocation.isPrefixOf(projectLocation)) {
+				ancestors.add(potentialAncestor);
+			}
+		}
+
+		// Sort by path length (longer paths first = closer ancestors first)
+		ancestors.sort((p1, p2) -> {
+			IPath loc1 = p1.getLocation();
+			IPath loc2 = p2.getLocation();
+			if (loc1 == null || loc2 == null) {
+				return 0;
+			}
+			// Reverse order: longer paths (closer ancestors) come first
+			return Integer.compare(loc2.segmentCount(), loc1.segmentCount());
+		});
+
+		return Collections.unmodifiableList(ancestors);
+	}
+
+	/**
+	 * Clears the cache for the given project.
+	 * 
+	 * @param project the project whose cache entry should be cleared
+	 */
+	public void clearCache(IProject project) {
+		nestingCache.remove(project);
+	}
+
+	/**
+	 * Clears the entire cache. Should be called when projects are created, deleted, moved, or closed.
+	 */
+	public void clearCache() {
+		nestingCache.clear();
+	}
+}

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/internal/resources/ProjectPreferences.java

@@ -55,6 +55,7 @@
 import org.eclipse.core.runtime.jobs.MultiRule;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
 import org.eclipse.core.runtime.preferences.IExportedPreferences;
+import org.eclipse.core.runtime.preferences.InstanceScope;
 import org.eclipse.osgi.util.NLS;
 import org.osgi.service.prefs.BackingStoreException;
 import org.osgi.service.prefs.Preferences;
@@ -74,6 +75,12 @@ public class ProjectPreferences extends EclipsePreferences {
 	 * Cache which nodes have been loaded from disk
 	 */
 	private static final Set<String> loadedNodes = ConcurrentHashMap.newKeySet();
+	
+	/**
+	 * Cache for project nesting relationships
+	 */
+	private static final ProjectNestingCache nestingCache = new ProjectNestingCache();
+	
 	private IFile file;
 	private volatile boolean initialized;
 	/**
@@ -145,6 +152,8 @@ static void deleted(IFolder folder) throws CoreException {
 		boolean hasResourcesSettings = getFile(folder, PREFS_REGULAR_QUALIFIER).exists() || getFile(folder, PREFS_DERIVED_QUALIFIER).exists();
 		// remove the preferences
 		removeNode(projectNode);
+		// Clear nesting cache as project structure changed
+		nestingCache.clearCache();
 		// notifies the CharsetManager
 		if (hasResourcesSettings) {
 			preferencesChanged(folder.getProject());
@@ -165,6 +174,8 @@ static void deleted(IProject project) throws CoreException {
 		boolean hasResourcesSettings = getFile(project, PREFS_REGULAR_QUALIFIER).exists() || getFile(project, PREFS_DERIVED_QUALIFIER).exists();
 		// remove the preferences
 		removeNode(projectNode);
+		// Clear nesting cache as project was deleted
+		nestingCache.clearCache();
 		// notifies the CharsetManager
 		if (hasResourcesSettings) {
 			preferencesChanged(project);
@@ -613,11 +624,97 @@ protected void load() throws BackingStoreException {
 	}
 
 	private void load(boolean reportProblems) throws BackingStoreException {
+		// Load hierarchical preferences if enabled
+		if (isHierarchicalPreferencesEnabled()) {
+			loadHierarchical(reportProblems);
+		} else {
+			loadSingle(reportProblems);
+		}
+	}
+
+	/**
+	 * Checks if hierarchical project preferences are enabled.
+	 */
+	private boolean isHierarchicalPreferencesEnabled() {
+		if (project == null || qualifier == null) {
+			return false;
+		}
+		Preferences node = Platform.getPreferencesService().getRootNode()
+				.node(InstanceScope.SCOPE)
+				.node(ResourcesPlugin.PI_RESOURCES);
+		return node.getBoolean(ResourcesPlugin.PREF_ENABLE_HIERARCHICAL_PROJECT_PREFERENCES,
+				ResourcesPlugin.DEFAULT_PREF_ENABLE_HIERARCHICAL_PROJECT_PREFERENCES);
+	}
+
+	/**
+	 * Loads preferences hierarchically from ancestor projects.
+	 */
+	private void loadHierarchical(boolean reportProblems) throws BackingStoreException {
+		List<IProject> ancestors = nestingCache.getAncestorProjects(project, getWorkspace());
+		
+		// Load from ancestors first (root to immediate parent)
+		for (int i = ancestors.size() - 1; i >= 0; i--) {
+			IProject ancestor = ancestors.get(i);
+			IFile ancestorFile = getFile(ancestor, qualifier);
+			if (ancestorFile != null && ancestorFile.exists()) {
+				loadPropertiesFromFile(ancestorFile, reportProblems);
+			}
+		}
+		
+		// Finally, load from the project itself (which will override ancestor values)
+		loadSingle(reportProblems);
+		// Mark as loaded even if the local file doesn't exist (we may have inherited values)
+		loadedNodes.add(absolutePath());
+	}
+
+	/**
+	 * Loads properties from a single file into this node.
+	 */
+	private void loadPropertiesFromFile(IFile file, boolean reportProblems) throws BackingStoreException {
+		if (file == null || !file.exists()) {
+			return;
+		}
+		if (Policy.DEBUG_PREFERENCES) {
+			Policy.debug("Loading hierarchical preferences from file: " + file.getFullPath()); //$NON-NLS-1$
+		}
+		Properties fromDisk = new Properties();
+		try (InputStream input = file.getContents(true)) {
+			fromDisk.load(input);
+			convertFromProperties(this, fromDisk, true);
+		} catch (CoreException e) {
+			if (e.getStatus().getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
+				if (Policy.DEBUG_PREFERENCES) {
+					Policy.debug("Hierarchical preference file does not exist: " + file.getFullPath()); //$NON-NLS-1$
+				}
+				return;
+			}
+			if (reportProblems) {
+				String message = NLS.bind(Messages.preferences_loadException, file.getFullPath());
+				log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, message, e));
+				throw new BackingStoreException(message);
+			}
+		} catch (IOException e) {
+			if (reportProblems) {
+				String message = NLS.bind(Messages.preferences_loadException, file.getFullPath());
+				log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, message, e));
+				throw new BackingStoreException(message);
+			}
+		}
+	}
+
+	/**
+	 * Loads preferences from a single file (non-hierarchical).
+	 */
+	private void loadSingle(boolean reportProblems) throws BackingStoreException {
 		IFile localFile = getFile();
 		if (localFile == null || !localFile.exists()) {
 			if (Policy.DEBUG_PREFERENCES) {
 				Policy.debug("Unable to determine preference file or file does not exist for node: " + absolutePath()); //$NON-NLS-1$
 			}
+			// Mark as loaded even if file doesn't exist when in non-hierarchical mode
+			if (!isHierarchicalPreferencesEnabled()) {
+				loadedNodes.add(absolutePath());
+			}
 			return;
 		}
 		if (Policy.DEBUG_PREFERENCES) {
@@ -627,7 +724,10 @@ private void load(boolean reportProblems) throws BackingStoreException {
 		try (InputStream input = localFile.getContents(true)) {
 			fromDisk.load(input);
 			convertFromProperties(this, fromDisk, true);
-			loadedNodes.add(absolutePath());
+			// Mark as loaded only in non-hierarchical mode (hierarchical mode marks at the end)
+			if (!isHierarchicalPreferencesEnabled()) {
+				loadedNodes.add(absolutePath());
+			}
 		} catch (CoreException e) {
 			if (e.getStatus().getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
 				if (Policy.DEBUG_PREFERENCES) {

resources/bundles/org.eclipse.core.resources/src/org/eclipse/core/resources/ResourcesPlugin.java

@@ -368,6 +368,23 @@ public final class ResourcesPlugin extends Plugin {
 	 */
 	public static final boolean DEFAULT_PREF_SEPARATE_DERIVED_ENCODINGS = false;
 
+	/**
+	 * Name of a preference for enabling hierarchical project preferences.
+	 * When enabled, project preferences are searched up in the chain of nested projects,
+	 * where a project A is nested within a project B if B.getLocation().isPrefixOf(A.getLocation()).
+	 * Values of deeper nested projects overwrite values in lower level projects.
+	 *
+	 * @since 3.20
+	 */
+	public static final String PREF_ENABLE_HIERARCHICAL_PROJECT_PREFERENCES = "enableHierarchicalProjectPreferences"; //$NON-NLS-1$
+
+	/**
+	 * Default setting for {@value #PREF_ENABLE_HIERARCHICAL_PROJECT_PREFERENCES}.
+	 *
+	 * @since 3.20
+	 */
+	public static final boolean DEFAULT_PREF_ENABLE_HIERARCHICAL_PROJECT_PREFERENCES = true;
+
 	/**
 	 * Name of a preference for configuring the marker severity in case project
 	 * description references an unknown nature.