Rename ReReduceTree to FinalReduce

Better name that pairs with FinalOptimize which calls it.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: danmoseley

src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexNode.cs

@@ -394,11 +394,11 @@ internal RegexNode FinalOptimize()
                 // FinalOptimize can create patterns like Atomic(Alternate(X, Empty)) that ReduceAtomic
                 // would simplify to Loop?(X), or Concatenate(X, Empty) that ReduceConcatenation would
                 // simplify to X. A single re-reduce pass catches all such cases.
-                rootNode.ReReduceTree();
+                rootNode.FinalReduce();
 
                 // Optimization: unnecessary re-processing of starting loops.
-                // This runs after ReReduceTree so it operates on the final tree structure, since
-                // ReReduceTree may restructure alternations into concatenations with a leading loop.
+                // This runs after FinalReduce so it operates on the final tree structure, since
+                // FinalReduce may restructure alternations into concatenations with a leading loop.
                 // If an expression is guaranteed to begin with a single-character unbounded loop that isn't part of an alternation (in which case it
                 // wouldn't be guaranteed to be at the beginning) or a capture (in which case a back reference could be influenced by its length), then we
                 // can update the tree with a temporary node to indicate that the implementation should use that node's ending position in the input text
@@ -456,7 +456,7 @@ internal RegexNode FinalOptimize()
         /// created by the <see cref="FinalOptimize"/> passes, e.g. Concatenate(X, Empty)
         /// or Atomic wrappers that became redundant.
         /// </summary>
-        private void ReReduceTree()
+        private void FinalReduce()
         {
             if (!StackHelper.TryEnsureSufficientExecutionStack())
             {
@@ -465,7 +465,7 @@ private void ReReduceTree()
 
             for (int i = 0, childCount = ChildCount(); i < childCount; i++)
             {
-                Child(i).ReReduceTree();
+                Child(i).FinalReduce();
                 ReplaceChild(i, Child(i)); // ReplaceChild reduces the node in place
             }
         }

src/libraries/System.Text.RegularExpressions/tests/UnitTests/RegexReductionTests.cs

@@ -475,14 +475,14 @@ public class RegexReductionTests
         [InlineData("(?:http|https)://foo", "http(?>s?)://foo")]
         [InlineData("(?:ab|abc)d", "ab(?>c?)d")]
         [InlineData("(?:abc|abcd|abce|abcfg)h", "abc(?:|[de]|fg)h")]
-        // ReReduceTree: post-FinalOptimize cleanup. Each case shows the equivalent tree without re-reduce.
-        [InlineData("a|ab", "a")]                                          // Without re-reduce: a(?:)  — prefix extraction leaves Concat(a, Empty); re-reduce strips Empty
-        [InlineData(@"\n|\n\r|\r\n", @"(?>\n|\r\n)")]                      // Without re-reduce: (?>\n(?:)|\r\n)  — shared prefix \n leaves Concat(\n, Empty) in branch; re-reduce collapses it
-        [InlineData(@"[ab]+c[ab]+|[ab]+", @"(?>(?>[ab]+)(?:c(?>[ab]+))?)")]  // Without re-reduce: (?>[ab]+c[ab]+|[ab]+)  — quantified set prefix [ab]+ not extracted until re-reduce
-        [InlineData("ab|a|ac", "ab?")]                                     // Without re-reduce: a(?>b?)  — prefix extraction + Atomic context creates redundant Atomic(Oneloopatomic); re-reduce strips Atomic
-        [InlineData("ab|a|ac|d", "(?>ab?|d)")]                             // Without re-reduce: (?>a(?>b?)|d)  — same redundant Atomic removal, within a larger Alternate
-        [InlineData("a?b|a??b", "(?>a?(?>b))")]                            // Without re-reduce: (?>a?(?>[b]))  — greedy/lazy branches merge after atomic promotion; re-reduce converts single-char [b] to b
-        [InlineData("[ab]?c|[ab]??c", "(?>[ab]?(?>c))")]                   // Without re-reduce: (?>[ab]?(?>[c]))  — same single-char class simplification with set loop prefix
+        // FinalReduce: post-FinalOptimize re-reduction. Each case shows the equivalent tree without this pass.
+        [InlineData("a|ab", "a")]                                          // Without FinalReduce: a(?:)  — prefix extraction leaves Concat(a, Empty); FinalReduce strips Empty
+        [InlineData(@"\n|\n\r|\r\n", @"(?>\n|\r\n)")]                      // Without FinalReduce: (?>\n(?:)|\r\n)  — shared prefix \n leaves Concat(\n, Empty) in branch; FinalReduce collapses it
+        [InlineData(@"[ab]+c[ab]+|[ab]+", @"(?>(?>[ab]+)(?:c(?>[ab]+))?)")]  // Without FinalReduce: (?>[ab]+c[ab]+|[ab]+)  — quantified set prefix [ab]+ not extracted until FinalReduce
+        [InlineData("ab|a|ac", "ab?")]                                     // Without FinalReduce: a(?>b?)  — prefix extraction + Atomic context creates redundant Atomic(Oneloopatomic); FinalReduce strips Atomic
+        [InlineData("ab|a|ac|d", "(?>ab?|d)")]                             // Without FinalReduce: (?>a(?>b?)|d)  — same redundant Atomic removal, within a larger Alternate
+        [InlineData("a?b|a??b", "(?>a?(?>b))")]                            // Without FinalReduce: (?>a?(?>[b]))  — greedy/lazy branches merge after atomic promotion; FinalReduce converts single-char [b] to b
+        [InlineData("[ab]?c|[ab]??c", "(?>[ab]?(?>c))")]                   // Without FinalReduce: (?>[ab]?(?>[c]))  — same single-char class simplification with set loop prefix
         public void PatternsReduceIdentically(string actual, string expected)
         {
             // NOTE: RegexNode.ToString is only compiled into debug builds, so DEBUG is currently set on the unit tests project.