Support Notones in alternation reductions that merge sets (#118109)

Today, given an alternation like `a|b|[cd]|efg`, that gets reduced to `[abcd]|efg`, supporting One and Set nodes. But it doesn't support Notone nodes. That means the semi-common idiom `.|\n` that folks use to express any character when not using Singleline doesn't get reduced and remains an alternation. This extends the existing reduction pass to also recognize Notones, just by treating them as one or two ranges.

Author: stephentoub

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

@@ -366,6 +366,23 @@ public bool Negate
 
         public void AddChar(char c) => AddRange(c, c);
 
+        public void AddNotChar(char c)
+        {
+            if (c == 0)
+            {
+                AddRange((char)1, LastChar);
+            }
+            else if (c == LastChar)
+            {
+                AddRange((char)0, (char)(LastChar - 1));
+            }
+            else
+            {
+                AddRange((char)0, (char)(c - 1));
+                AddRange((char)(c + 1), LastChar);
+            }
+        }
+
         /// <summary>
         /// Adds a regex char class
         /// </summary>

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

@@ -1072,7 +1072,7 @@ void ReduceSingleLetterAndNestedAlternations()
                             }
                             j--;
                         }
-                        else if (at.Kind is RegexNodeKind.Set or RegexNodeKind.One)
+                        else if (at.Kind is RegexNodeKind.Set or RegexNodeKind.One or RegexNodeKind.Notone)
                         {
                             // Cannot merge sets if L or I options differ, or if either are negated.
                             optionsAt = at.Options & (RegexOptions.RightToLeft | RegexOptions.IgnoreCase);
@@ -1095,7 +1095,7 @@ void ReduceSingleLetterAndNestedAlternations()
                                 break;
                             }
 
-                            // The last node was a Set or a One, we're a Set or One and our options are the same.
+                            // The last node was a Set/One/Notone, we're a Set/One/Notone, and our options are the same.
                             // Merge the two nodes.
                             j--;
                             prev = children[j];
@@ -1106,6 +1106,11 @@ void ReduceSingleLetterAndNestedAlternations()
                                 prevCharClass = new RegexCharClass();
                                 prevCharClass.AddChar(prev.Ch);
                             }
+                            else if (prev.Kind == RegexNodeKind.Notone)
+                            {
+                                prevCharClass = new RegexCharClass();
+                                prevCharClass.AddNotChar(prev.Ch);
+                            }
                             else
                             {
                                 prevCharClass = RegexCharClass.Parse(prev.Str!);
@@ -1115,6 +1120,10 @@ void ReduceSingleLetterAndNestedAlternations()
                             {
                                 prevCharClass.AddChar(at.Ch);
                             }
+                            else if (at.Kind == RegexNodeKind.Notone)
+                            {
+                                prevCharClass.AddNotChar(at.Ch);
+                            }
                             else
                             {
                                 RegexCharClass atCharClass = RegexCharClass.Parse(at.Str!);

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

@@ -283,6 +283,10 @@ public class RegexReductionTests
         [InlineData("a|b", "[ab]")]
         [InlineData("a|b|c|d|e|g|h|z", "[a-eghz]")]
         [InlineData("a|b|c|def|g|h", "(?>[a-c]|def|[gh])")]
+        [InlineData("a|[^a]", @"[\s\S]")]
+        [InlineData(".|\n", @"[\s\S]")]
+        [InlineData(".|\n|a", @"[\s\S]")]
+        [InlineData("abc|.|\n|def", @"abc|[\s\S]|def")]
         [InlineData("this|that|there|then|those", "th(?>is|at|ere|en|ose)")]
         [InlineData("^this|^that|^there|^then|^those", "^th(?>is|at|ere|en|ose)")]
         [InlineData("\bthis|\bthat|\bthere|\bthen|\bthose", "\bth(?>is|at|ere|en|ose)")]