Add RegexOptions.AnyNewLine via parser lowering

src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Parser.cs

@@ -186,7 +186,8 @@ regexPropertySymbol.SetMethod is not null ||
                 RegexOptions.Multiline |
                 RegexOptions.NonBacktracking |
                 RegexOptions.RightToLeft |
-                RegexOptions.Singleline;
+                RegexOptions.Singleline |
+                RegexOptions.AnyNewLine;
             if ((regexOptions & ~SupportedOptions) != 0)
             {
                 return new DiagnosticData(DiagnosticDescriptors.InvalidRegexArguments, GetComparableLocation(memberSyntax), "options");

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

@@ -317,6 +317,7 @@ public enum RegexOptions
         ECMAScript = 256,
         CultureInvariant = 512,
         NonBacktracking = 1024,
+        AnyNewLine = 2048,
     }
     public enum RegexParseError
     {

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

@@ -145,10 +145,10 @@ internal static void ValidatePattern(string pattern)
 
         internal static void ValidateOptions(RegexOptions options)
         {
-            const int MaxOptionShift = 11;
+            const int MaxOptionShift = 12;
             if (((((uint)options) >> MaxOptionShift) != 0) ||
                 ((options & RegexOptions.ECMAScript) != 0 && (options & ~(RegexOptions.ECMAScript | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled | RegexOptions.CultureInvariant)) != 0) ||
-                ((options & RegexOptions.NonBacktracking) != 0 && (options & (RegexOptions.ECMAScript | RegexOptions.RightToLeft)) != 0))
+                ((options & RegexOptions.NonBacktracking) != 0 && (options & (RegexOptions.ECMAScript | RegexOptions.RightToLeft | RegexOptions.AnyNewLine)) != 0))
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.options);
             }

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

@@ -102,6 +102,9 @@ internal sealed partial class RegexCharClass
         internal const string NotECMADigitClass = "\x01\x02\x00" + ECMADigitRanges;
 
         internal const string NotNewLineClass = "\x01\x02\x00\x0A\x0B";
+        internal const string NotAnyNewLineClass = "\x01\x06\x00\x0A\x0E\x85\x86\u2028\u202A";
+        /// <summary>Character class for [\n\v\f\r\u0085\u2028\u2029] — all AnyNewLine chars, used in anchor lowering.</summary>
+        internal const string AnyNewLineClass = "\x00\x06\x00\x0A\x0E\x85\x86\u2028\u202A";
 
         internal const string AnyClass = "\x00\x01\x00\x00";
         private const string EmptyClass = "\x00\x00\x00";

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

@@ -60,5 +60,12 @@ enum RegexOptions
         /// the top-level match.
         /// </remarks>
         NonBacktracking = 0x0400,
+
+        /// <summary>
+        /// Make <c>^</c>, <c>$</c>, <c>\Z</c>, and <c>.</c> recognize all common newline sequences
+        /// (<c>\r\n</c>, <c>\r</c>, <c>\n</c>, <c>\v</c> (VT), <c>\f</c> (FF), and the Unicode newlines <c>\u0085</c>, <c>\u2028</c>, <c>\u2029</c>)
+        /// instead of only <c>\n</c>.
+        /// </summary>
+        AnyNewLine = 0x0800,
     }
 }

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

@@ -391,17 +391,40 @@ private RegexNode ScanRegex()
                         break;
 
                     case '^':
-                        _unit = new RegexNode((_options & RegexOptions.Multiline) != 0 ? RegexNodeKind.Bol : RegexNodeKind.Beginning, _options);
+                        if ((_options & (RegexOptions.AnyNewLine | RegexOptions.Multiline)) == (RegexOptions.AnyNewLine | RegexOptions.Multiline))
+                        {
+                            _unit = AnyNewLineBolNode();
+                        }
+                        else
+                        {
+                            _unit = new RegexNode((_options & RegexOptions.Multiline) != 0 ? RegexNodeKind.Bol : RegexNodeKind.Beginning, _options);
+                        }
                         break;
 
                     case '$':
-                        _unit = new RegexNode((_options & RegexOptions.Multiline) != 0 ? RegexNodeKind.Eol : RegexNodeKind.EndZ, _options);
+                        if ((_options & RegexOptions.AnyNewLine) != 0)
+                        {
+                            _unit = (_options & RegexOptions.Multiline) != 0 ? AnyNewLineEolNode() : AnyNewLineEndZNode();
+                        }
+                        else
+                        {
+                            _unit = new RegexNode((_options & RegexOptions.Multiline) != 0 ? RegexNodeKind.Eol : RegexNodeKind.EndZ, _options);
+                        }
                         break;
 
                     case '.':
-                        _unit = (_options & RegexOptions.Singleline) != 0 ?
-                            new RegexNode(RegexNodeKind.Set, _options & ~RegexOptions.IgnoreCase, RegexCharClass.AnyClass) :
-                            new RegexNode(RegexNodeKind.Notone, _options & ~RegexOptions.IgnoreCase, '\n');
+                        if ((_options & RegexOptions.Singleline) != 0)
+                        {
+                            _unit = new RegexNode(RegexNodeKind.Set, _options & ~RegexOptions.IgnoreCase, RegexCharClass.AnyClass);
+                        }
+                        else if ((_options & RegexOptions.AnyNewLine) != 0)
+                        {
+                            _unit = new RegexNode(RegexNodeKind.Set, _options & ~RegexOptions.IgnoreCase, RegexCharClass.NotAnyNewLineClass);
+                        }
+                        else
+                        {
+                            _unit = new RegexNode(RegexNodeKind.Notone, _options & ~RegexOptions.IgnoreCase, '\n');
+                        }
                         break;
 
                     case '{':
@@ -1131,12 +1154,16 @@ private void ScanBlank()
                 case 'B':
                 case 'A':
                 case 'G':
-                case 'Z':
                 case 'z':
                     _pos++;
                     return scanOnly ? null :
                         new RegexNode(TypeFromCode(ch), _options);
 
+                case 'Z':
+                    _pos++;
+                    return scanOnly ? null :
+                        (_options & RegexOptions.AnyNewLine) != 0 ? AnyNewLineEndZNode() : new RegexNode(RegexNodeKind.EndZ, _options);
+
                 case 'w':
                     _pos++;
                     return scanOnly ? null :
@@ -1696,6 +1723,125 @@ private string ParseProperty()
             return capname;
         }
 
+        /// <summary>
+        /// Creates (?!(?&lt;=\r)\n) — a negative lookahead that blocks matching
+        /// between \r and \n of a \r\n sequence. Used as a guard by all
+        /// AnyNewLine anchor lowerings to prevent anchors from firing
+        /// at the \r\n boundary.
+        /// </summary>
+        private RegexNode AnyNewLineCrLfGuardNode()
+        {
+            RegexOptions lookaheadOpts = _options & ~RegexOptions.RightToLeft;
+            RegexOptions lookbehindOpts = _options | RegexOptions.RightToLeft;
+            RegexOptions lookaheadOptsNoCase = lookaheadOpts & ~RegexOptions.IgnoreCase;
+            RegexOptions lookbehindOptsNoCase = lookbehindOpts & ~RegexOptions.IgnoreCase;
+
+            // (?<=\r)
+            var lookbehindCr = new RegexNode(RegexNodeKind.PositiveLookaround, lookbehindOpts);
+            lookbehindCr.AddChild(new RegexNode(RegexNodeKind.One, lookbehindOptsNoCase, '\r'));
+
+            // (?<=\r)\n
+            var crThenLf = new RegexNode(RegexNodeKind.Concatenate, lookaheadOpts);
+            crThenLf.AddChild(lookbehindCr);
+            crThenLf.AddChild(new RegexNode(RegexNodeKind.One, lookaheadOptsNoCase, '\n'));
+
+            // (?!(?<=\r)\n)
+            var guard = new RegexNode(RegexNodeKind.NegativeLookaround, lookaheadOpts);
+            guard.AddChild(crThenLf);
+
+            return guard;
+        }
+
+        /// <summary>
+        /// Builds a tree equivalent to $ or \Z with AnyNewLine (non-Multiline).
+        /// Matches at end of string, or before any newline at end of string,
+        /// but not between \r and \n.
+        /// Equivalent to: (?=\r\n\z|[\n\r\v\f\u0085\u2028\u2029]?\z)(?!(?&lt;=\r)\n)
+        /// </summary>
+        private RegexNode AnyNewLineEndZNode()
+        {
+            RegexOptions opts = _options;
+            RegexOptions lookaheadOpts = opts & ~RegexOptions.RightToLeft;
+            RegexOptions lookaheadOptsNoCase = lookaheadOpts & ~RegexOptions.IgnoreCase;
+
+            // \r\n\z
+            var crlfEnd = new RegexNode(RegexNodeKind.Concatenate, lookaheadOpts);
+            crlfEnd.AddChild(new RegexNode(RegexNodeKind.One, lookaheadOptsNoCase, '\r'));
+            crlfEnd.AddChild(new RegexNode(RegexNodeKind.One, lookaheadOptsNoCase, '\n'));
+            crlfEnd.AddChild(new RegexNode(RegexNodeKind.End, lookaheadOpts));
+
+            // [\n\r\v\f\u0085\u2028\u2029]?\z — optional any-newline followed by end of string
+            var anyNewLineOptEnd = new RegexNode(RegexNodeKind.Concatenate, lookaheadOpts);
+            anyNewLineOptEnd.AddChild(new RegexNode(RegexNodeKind.Set, lookaheadOptsNoCase, RegexCharClass.AnyNewLineClass).MakeQuantifier(false, 0, 1));
+            anyNewLineOptEnd.AddChild(new RegexNode(RegexNodeKind.End, lookaheadOpts));
+
+            // (?=\r\n\z|[\n\r\v\f\u0085\u2028\u2029]?\z)
+            var innerAlt = new RegexNode(RegexNodeKind.Alternate, lookaheadOpts);
+            innerAlt.AddChild(crlfEnd);
+            innerAlt.AddChild(anyNewLineOptEnd);
+            var lookahead = new RegexNode(RegexNodeKind.PositiveLookaround, lookaheadOpts);
+            lookahead.AddChild(innerAlt);
+
+            // (?=\r\n\z|[\n\r\v\f\u0085\u2028\u2029]?\z)(?!(?<=\r)\n)
+            var result = new RegexNode(RegexNodeKind.Concatenate, opts);
+            result.AddChild(lookahead);
+            result.AddChild(AnyNewLineCrLfGuardNode());
+
+            return result;
+        }
+
+        /// <summary>
+        /// Builds a tree equivalent to $ with AnyNewLine and Multiline.
+        /// Matches before any newline or at end of string, but not between \r and \n.
+        /// Equivalent to: (?=[\n\r\v\f\u0085\u2028\u2029]|\z)(?!(?&lt;=\r)\n)
+        /// </summary>
+        private RegexNode AnyNewLineEolNode()
+        {
+            RegexOptions opts = _options;
+            RegexOptions lookaheadOpts = opts & ~RegexOptions.RightToLeft;
+            RegexOptions lookaheadOptsNoCase = lookaheadOpts & ~RegexOptions.IgnoreCase;
+
+            // (?=[\n\r\v\f\u0085\u2028\u2029]|\z)
+            var innerAlt = new RegexNode(RegexNodeKind.Alternate, lookaheadOpts);
+            innerAlt.AddChild(new RegexNode(RegexNodeKind.Set, lookaheadOptsNoCase, RegexCharClass.AnyNewLineClass));
+            innerAlt.AddChild(new RegexNode(RegexNodeKind.End, lookaheadOpts));
+            var lookahead = new RegexNode(RegexNodeKind.PositiveLookaround, lookaheadOpts);
+            lookahead.AddChild(innerAlt);
+
+            // (?=[\n\r\v\f\u0085\u2028\u2029]|\z)(?!(?<=\r)\n)
+            var result = new RegexNode(RegexNodeKind.Concatenate, opts);
+            result.AddChild(lookahead);
+            result.AddChild(AnyNewLineCrLfGuardNode());
+
+            return result;
+        }
+
+        /// <summary>
+        /// Builds a tree equivalent to ^ with AnyNewLine and Multiline.
+        /// Matches after any newline or at start of string, but not between \r and \n.
+        /// Equivalent to: (?&lt;=[\n\r\v\f\u0085\u2028\u2029]|\A)(?!(?&lt;=\r)\n)
+        /// </summary>
+        private RegexNode AnyNewLineBolNode()
+        {
+            RegexOptions opts = _options;
+            RegexOptions lookbehindOpts = opts | RegexOptions.RightToLeft;
+            RegexOptions lookbehindOptsNoCase = lookbehindOpts & ~RegexOptions.IgnoreCase;
+
+            // (?<=[\n\r\v\f\u0085\u2028\u2029]|\A)
+            var innerAlt = new RegexNode(RegexNodeKind.Alternate, lookbehindOpts);
+            innerAlt.AddChild(new RegexNode(RegexNodeKind.Set, lookbehindOptsNoCase, RegexCharClass.AnyNewLineClass));
+            innerAlt.AddChild(new RegexNode(RegexNodeKind.Beginning, lookbehindOpts));
+            var lookbehind = new RegexNode(RegexNodeKind.PositiveLookaround, lookbehindOpts);
+            lookbehind.AddChild(innerAlt);
+
+            // (?<=[\n\r\v\f\u0085\u2028\u2029]|\A)(?!(?<=\r)\n)
+            var result = new RegexNode(RegexNodeKind.Concatenate, opts);
+            result.AddChild(lookbehind);
+            result.AddChild(AnyNewLineCrLfGuardNode());
+
+            return result;
+        }
+
         /// <summary>Returns the node kind for zero-length assertions with a \ code.</summary>
         private readonly RegexNodeKind TypeFromCode(char ch) =>
             ch switch

src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.Ctor.Tests.cs

@@ -100,8 +100,8 @@ public static void Ctor_Invalid()
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", (RegexOptions)(-1)));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", (RegexOptions)(-1), new TimeSpan()));
 
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", (RegexOptions)0x800));
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", (RegexOptions)0x800, new TimeSpan()));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", (RegexOptions)0x1000));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", (RegexOptions)0x1000, new TimeSpan()));
             if (PlatformDetection.IsNetFramework)
             {
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexHelpers.RegexOptionNonBacktracking));
@@ -113,7 +113,9 @@ public static void Ctor_Invalid()
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexOptions.ECMAScript | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.Singleline));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexOptions.ECMAScript | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexOptions.ECMAScript | RegexHelpers.RegexOptionNonBacktracking));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexOptions.ECMAScript | RegexHelpers.RegexOptionAnyNewLine));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexOptions.RightToLeft | RegexHelpers.RegexOptionNonBacktracking));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => new Regex("foo", RegexHelpers.RegexOptionAnyNewLine | RegexHelpers.RegexOptionNonBacktracking));
 
             // MatchTimeout is invalid
             AssertExtensions.Throws<ArgumentOutOfRangeException>("matchTimeout", () => new Regex("foo", RegexOptions.None, new TimeSpan(-1)));

src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.EnumerateMatches.Tests.cs

@@ -33,9 +33,9 @@ public void EnumerateMatches_Ctor_Invalid()
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.EnumerateMatches("input", "pattern", (RegexOptions)(-1)));
             AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.EnumerateMatches("input", "pattern", (RegexOptions)(-1), TimeSpan.FromSeconds(1)));
 
-            // 0x400 is new NonBacktracking mode that is now valid, 0x800 is still invalid
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.EnumerateMatches("input", "pattern", (RegexOptions)0x800));
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.EnumerateMatches("input", "pattern", (RegexOptions)0x800, TimeSpan.FromSeconds(1)));
+            // 0x800 is new AnyNewLine mode that is now valid, 0x1000 is still invalid
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.EnumerateMatches("input", "pattern", (RegexOptions)0x1000));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("options", () => Regex.EnumerateMatches("input", "pattern", (RegexOptions)0x1000, TimeSpan.FromSeconds(1)));
 
             // MatchTimeout is invalid
             AssertExtensions.Throws<ArgumentOutOfRangeException>("matchTimeout", () => Regex.EnumerateMatches("input", "pattern", RegexOptions.None, TimeSpan.Zero));