Restore recursive behavior of AbstractTreeViwer#internalExpandToLevel()

The method AbstractTreeViewer#internalExpandToLevel() used be a
recursively called method (by implementation and specification). As a
protected method, it is part of the API.
With a recent change, the method was changed to delegate to a different
method, removing it's recursive property. Consumers that have created
subtypes of the AbstractTreeViewer and rely the recursive behavior of
that method by overwriting it face a regression by that change.

This change restores the existing, recursive behavior of that method
while still keeping the reuse of the implementation across other use
cases.

Author: HeikoKlare

bundles/org.eclipse.jface/src/org/eclipse/jface/viewers/AbstractTreeViewer.java

@@ -28,7 +28,6 @@
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.function.Function;
 
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IStatus;
@@ -1833,23 +1832,21 @@ protected Widget internalGetWidgetToSelect(Object elementOrTreePath) {
 	}
 
 	/**
-	 * Recursively, conditionally expands the subtree rooted at the given widget to
-	 * the given level. Takes the {@code shouldChildrenExpand} predicate that
-	 * defines for a given widget if it shall be expanded.
+	 * Recursively expands the subtree rooted at the given widget to the given level
+	 * based on the {@code childExpansionFunction} function being executed for a
+	 * child to be (potentially conditionally) expanded.
 	 * <p>
 	 * Note that the default implementation of this method does not call
 	 * {@code setRedraw}.
 	 * </p>
 	 *
-	 * @param widget               the widget
-	 * @param level                non-negative level, or {@code ALL_LEVELS} to
-	 *                             expand all levels of the tree
-	 * @param shouldChildrenExpand predicate that defines for a given widget if it
-	 *                             should be expanded.
-	 * @since 3.32
+	 * @param widget                 the widget
+	 * @param level                  non-negative level, or {@code ALL_LEVELS} to
+	 *                               expand all levels of the tree
+	 * @param childExpansionFunction function to be called on a child to be expanded
 	 */
-	private void internalConditionalExpandToLevel(Widget widget, int level,
-			Function<Widget, Boolean> shouldChildrenExpand) {
+	private void internalCustomizedExpandToLevel(Widget widget, int level,
+			ExpansionFunction childExpansionFunction) {
 		if (level == ALL_LEVELS || level > 0) {
 			Object data = widget.getData();
 			if (widget instanceof Item it && data != null && !isExpandable(it, null, data)) {
@@ -1862,18 +1859,23 @@ private void internalConditionalExpandToLevel(Widget widget, int level,
 			}
 			if (level == ALL_LEVELS || level > 1) {
 				Item[] children = getChildren(widget);
-				if (children != null && shouldChildrenExpand.apply(widget).booleanValue()) {
+				if (children != null) {
 					int newLevel = (level == ALL_LEVELS ? ALL_LEVELS
 							: level - 1);
 					for (Item element : children) {
-						internalConditionalExpandToLevel(element, newLevel, shouldChildrenExpand);
+						childExpansionFunction.expand(widget, element, newLevel);
 					}
 				}
 			}
 			// XXX expanding here fails on linux
 		}
 	}
 
+	@FunctionalInterface
+	private interface ExpansionFunction {
+		void expand(Widget parent, Widget widget, int level);
+	}
+
 	/**
 	 * Recursively expands the subtree rooted at the given widget to the given
 	 * level.
@@ -1887,7 +1889,8 @@ private void internalConditionalExpandToLevel(Widget widget, int level,
 	 *               levels of the tree
 	 */
 	protected void internalExpandToLevel(Widget widget, int level) {
-		internalConditionalExpandToLevel(widget, level, w -> Boolean.TRUE);
+		internalCustomizedExpandToLevel(widget, level,
+				(parent, child, newLevel) -> internalExpandToLevel(child, newLevel));
 	}
 
 	/**
@@ -2532,14 +2535,19 @@ public void treeCollapsed(TreeExpansionEvent event) {
 			@Override
 			public void treeExpanded(TreeExpansionEvent e) {
 				Widget item = doFindItem(e.getElement());
-
-				internalConditionalExpandToLevel(item, autoExpandOnSingleChildLevels,
-						w -> Boolean.valueOf(doesWidgetHaveExactlyOneChild(w)));
+				internalCustomizedExpandToLevel(item, autoExpandOnSingleChildLevels, oneChildExpansionFunction);
 			}
 		};
 		addTreeListener(autoExpandOnSingleChildListener);
 	}
 
+	private ExpansionFunction oneChildExpansionFunction = (parent, widget, level) -> {
+		boolean hasOneChild = getChildren(parent).length == 1;
+		if (hasOneChild) {
+			internalCustomizedExpandToLevel(widget, level, this.oneChildExpansionFunction);
+		}
+	};
+
 	private void removeAutoExpandOnSingleChildListener() {
 		if (autoExpandOnSingleChildListener != null) {
 			removeTreeListener(autoExpandOnSingleChildListener);
@@ -2702,8 +2710,7 @@ public void setExpandedStateWithAutoExpandOnSingleChild(Object elementOrTreePath
 		Widget item = internalGetWidgetToSelect(elementOrTreePath);
 
 		if (autoExpandOnSingleChildLevels != NO_EXPAND && expanded) {
-			internalConditionalExpandToLevel(item, autoExpandOnSingleChildLevels,
-					w -> Boolean.valueOf(doesWidgetHaveExactlyOneChild(w)));
+			internalCustomizedExpandToLevel(item, autoExpandOnSingleChildLevels, oneChildExpansionFunction);
 		}
 	}
 
@@ -3535,8 +3542,4 @@ ISelection getUpdatedSelection(ISelection selection) {
 		return selection;
 	}
 
-	private boolean doesWidgetHaveExactlyOneChild(Widget w) {
-		return getChildren(w).length == 1;
-	}
-
 }