Reset evaluators immediately after use, not only on reuse

That frees up the cache directly in the typical `el.select("parent child")` flow.

The streaming use of evaluators still only reset on reuse, because the control flow of the stream returns to the caller before complete execution. But we also now hold the cache as a WeakHashMap, so it can be GCed when the DOM goes unreachable.

Also changed to the reset to call `remove` so that the ThreadLocalMap entry is removed (vs just clearing the held map).

Fixes #2411

Author: jhy

CHANGES.md

@@ -24,7 +24,7 @@
 * A ValidationException could be thrown in the adoption agency algorithm with particularly broken input. Now logged as a parse error. [#2393](https://github.com/jhy/jsoup/issues/2393)
 * Null characters in the HTML body were not consistently removed; and in foreign content were not correctly replaced. [#2395](https://github.com/jhy/jsoup/issues/2395)
 * An IndexOutOfBoundsException could be thrown when parsing a body fragment with crafted input. Now logged as a parse error. [#2397](https://github.com/jhy/jsoup/issues/2397), [#2406](https://github.com/jhy/jsoup/issues/2406)
-
+* When using StructuralEvaluators (e.g., a `parent child` selector) across many retained threads, their memoized results could also be retained, increasing memory use. These results are now cleared immediately after use, reducing overall memory consumption. [#2411](https://github.com/jhy/jsoup/issues/2411)
 
 ## 1.21.2 (2025-Aug-25)
 

src/main/java/org/jsoup/select/Collector.java

@@ -31,8 +31,9 @@ public static Elements collect(Evaluator eval, Element root) {
         Stream<Element> stream = eval.wantsNodes() ?
             streamNodes(eval, root, Element.class) :
             stream(eval, root);
-
-        return stream.collect(toCollection(Elements::new));
+        Elements els = stream.collect(toCollection(Elements::new));
+        eval.reset(); // drops any held memos
+        return els;
     }
 
     /**

src/main/java/org/jsoup/select/StructuralEvaluator.java

@@ -1,6 +1,5 @@
 package org.jsoup.select;
 
-import org.jsoup.internal.Functions;
 import org.jsoup.internal.SoftPool;
 import org.jsoup.internal.StringUtil;
 import org.jsoup.nodes.Element;
@@ -10,8 +9,8 @@
 import org.jsoup.nodes.TextNode;
 
 import java.util.ArrayList;
-import java.util.IdentityHashMap;
 import java.util.Map;
+import java.util.WeakHashMap;
 
 /**
  * Base structural evaluator.
@@ -32,17 +31,16 @@ boolean wantsNodes() {
 
     // Memoize inner matches, to save repeated re-evaluations of parent, sibling etc.
     // root + element: Boolean matches. ThreadLocal in case the Evaluator is compiled then reused across multi threads
-    final ThreadLocal<IdentityHashMap<Node, IdentityHashMap<Node, Boolean>>>
-        threadMemo = ThreadLocal.withInitial(IdentityHashMap::new);
+    final ThreadLocal<Map<Node, Map<Node, Boolean>>> threadMemo = ThreadLocal.withInitial(WeakHashMap::new);
 
     boolean memoMatches(final Element root, final Node node) {
-        Map<Node, IdentityHashMap<Node, Boolean>> rootMemo = threadMemo.get();
-        Map<Node, Boolean> memo = rootMemo.computeIfAbsent(root, Functions.identityMapFunction());
-        return memo.computeIfAbsent(node, key -> evaluator.matches(root, key));
+        Map<Node, Map<Node, Boolean>> rootMemo = threadMemo.get();
+        Map<Node, Boolean> memo = rootMemo.computeIfAbsent(root, r -> new WeakHashMap<>());
+        return memo.computeIfAbsent(node, test -> evaluator.matches(root, test));
     }
 
     @Override protected void reset() {
-        threadMemo.get().clear();
+        threadMemo.remove();
         evaluator.reset();
         super.reset();
     }

src/test/java/org/jsoup/select/SelectorTest.java

@@ -11,9 +11,9 @@
 import org.jsoup.parser.Parser;
 import org.junit.jupiter.api.Test;
 
-import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 import static org.jsoup.select.EvaluatorDebug.sexpr;
@@ -1192,7 +1192,7 @@ public void wildcardNamespaceMatchesNoNamespace() {
         Evaluator eval = QueryParser.parse("p ~ p");
         CombiningEvaluator.And andEval = (CombiningEvaluator.And) eval;
         StructuralEvaluator.PreviousSibling prevEval = (StructuralEvaluator.PreviousSibling) andEval.evaluators.get(0);
-        IdentityHashMap<Node, IdentityHashMap<Node, Boolean>> map = prevEval.threadMemo.get();
+        Map<Node, Map<Node, Boolean>> map = prevEval.threadMemo.get();
         assertEquals(0, map.size()); // no memo yet
 
         Document doc1 = Jsoup.parse("<p>One<p>Two<p>Three");
@@ -1205,7 +1205,7 @@ public void wildcardNamespaceMatchesNoNamespace() {
         assertEquals(2, s2.size());
         assertEquals("Two2", s2.first().text());
 
-        assertEquals(1, map.size()); // root of doc 2
+        assertEquals(0, map.size()); // reset after collect
     }
 
     @Test public void blankTextNodesAreConsideredEmpty() {

src/test/java/org/jsoup/select/StructuralEvaluatorTest.java

@@ -42,7 +42,8 @@ void selectorMemoIsClearedOnReset(String selector, boolean expectMemos) {
         List<StructuralEvaluator> structuralEvals = new ArrayList<>();
         collectEvals(evaluator, structuralEvals);
 
-        Selector.select(evaluator, doc); // populate memos
+        // use Collector.stream vs Selector.select(), as the later is able to reset after executing
+        Collector.stream(evaluator, doc).count(); // consume stream to populate memos
         assertFalse(structuralEvals.isEmpty());
 
         boolean hadMemos = false;