Fix escaped pattern display in GeneratedRegex XML documentation (#120098)

* Initial plan

* Fix escaped pattern in GeneratedRegex summary - remove double escaping

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

* Update test expectations to match fixed single-escaped pattern behavior

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

* Fix XML parsing errors by properly escaping invalid XML characters in pattern documentation

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

* Consolidate XML escaping logic into existing EscapeXmlComment method

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

* Fix C1 control character escaping to resolve all test failures

Co-authored-by: danmoseley <6385855+danmoseley@users.noreply.github.com>

* Simplify EscapeXmlComment

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>
Co-authored-by: danmoseley <6385855+danmoseley@users.noreply.github.com>
Co-authored-by: Stephen Toub <stoub@microsoft.com>

Author: 3 people

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

@@ -13,6 +13,7 @@
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Threading;
+using System.Text;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 
@@ -26,9 +27,34 @@ namespace System.Text.RegularExpressions.Generator
 {
     public partial class RegexGenerator
     {
-        /// <summary>Escapes '&amp;', '&lt;' and '&gt;' characters. We aren't using HtmlEncode as that would also escape single and double quotes.</summary>
-        private static string EscapeXmlComment(string text) =>
-            text.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
+        /// <summary>Escapes characters that are invalid in XML comments.</summary>
+        private static string EscapeXmlComment(string text)
+        {
+            if (!string.IsNullOrEmpty(text))
+            {
+                StringBuilder sb = new(text.Length);
+                foreach (char c in text)
+                {
+                    switch ((int)c)
+                    {
+                        // Escape XML entities.
+                        case '&': sb.Append("&amp;"); break;
+                        case '<': sb.Append("&lt;"); break;
+                        case '>': sb.Append("&gt;"); break;
+
+                        // Propagate all other valid XML characters as-is. Control chars are considered invalid.
+                        case (>= 0x20 and <= 0x7F) or (>= 0xA0 and <= 0xD7FF) or (>= 0xE000 and <= 0xFFFD): sb.Append(c); break;
+
+                        // Use Unicode escape sequences for everything else.
+                        default: sb.Append($"\\u{(int)c:X4}"); break;
+                    }
+                }
+
+                text = sb.ToString();
+            }
+
+            return text;
+        }
 
         /// <summary>Emits the definition of the partial method. This method just delegates to the property cache on the generated Regex-derived type.</summary>
         private static void EmitRegexPartialMethod(RegexMethod regexMethod, IndentedTextWriter writer)
@@ -59,7 +85,7 @@ private static void EmitRegexPartialMethod(RegexMethod regexMethod, IndentedText
             // Emit the partial method definition.
             writer.WriteLine($"/// <remarks>");
             writer.WriteLine($"/// Pattern:<br/>");
-            writer.WriteLine($"/// <code>{EscapeXmlComment(Literal(regexMethod.Pattern, quote: false))}</code><br/>");
+            writer.WriteLine($"/// <code>{EscapeXmlComment(regexMethod.Pattern)}</code><br/>");
             if (regexMethod.Options != RegexOptions.None)
             {
                 writer.WriteLine($"/// Options:<br/>");

src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/RegexGeneratorOutputTests.cs

@@ -80,7 +80,7 @@ partial class C
                 {
                     /// <remarks>
                     /// Pattern:<br/>
-                    /// <code>^(?&lt;proto&gt;\\w+)://[^/]+?(?&lt;port&gt;:\\d+)?/</code><br/>
+                    /// <code>^(?&lt;proto&gt;\w+)://[^/]+?(?&lt;port&gt;:\d+)?/</code><br/>
                     /// Explanation:<br/>
                     /// <code>
                     /// ○ Match if at the beginning of the string.<br/>
@@ -482,7 +482,7 @@ partial class C
                 {
                     /// <remarks>
                     /// Pattern:<br/>
-                    /// <code>href\\s*=\\s*(?:["'](?&lt;1&gt;[^"']*)["']|(?&lt;1&gt;[^&gt;\\s]+))</code><br/>
+                    /// <code>href\s*=\s*(?:["'](?&lt;1&gt;[^"']*)["']|(?&lt;1&gt;[^&gt;\s]+))</code><br/>
                     /// Explanation:<br/>
                     /// <code>
                     /// ○ Match the string "href".<br/>
@@ -1132,5 +1132,66 @@ file static class Utilities
                 """
             };
         }
+
+        [Fact]
+        public async Task Pattern_Should_Not_Be_Double_Escaped_In_Documentation()
+        {
+            string program = """
+                using System.Text.RegularExpressions;
+                partial class C
+                {
+                    [GeneratedRegex(@"\.")]
+                    public static partial Regex DotPattern();
+                }
+                """;
+
+            string actual = await RegexGeneratorHelper.GenerateSourceText(program, allowUnsafe: true, checkOverflow: false);
+            
+            // The pattern should show \. (single backslash) not \\. (double backslash) in the documentation
+            Assert.Contains("/// <code>\\.</code><br/>", actual);
+            Assert.DoesNotContain("/// <code>\\\\.</code><br/>", actual);
+        }
+
+        [Fact]
+        public async Task Pattern_With_Control_Characters_Should_Be_Escaped_For_XML()
+        {
+            string program = """
+                using System.Text.RegularExpressions;
+                partial class C
+                {
+                    [GeneratedRegex("a\0b")]
+                    public static partial Regex NullCharPattern();
+                }
+                """;
+
+            string actual = await RegexGeneratorHelper.GenerateSourceText(program, allowUnsafe: true, checkOverflow: false);
+            
+            // The pattern should escape null characters as Unicode escape sequences for XML safety in the documentation
+            Assert.Contains("/// <code>a\\u0000b</code><br/>", actual);
+            
+            // The actual pattern string (base.pattern assignment) should properly escape the null character for C#
+            Assert.Contains("base.pattern = \"a\\0b\";", actual);
+        }
+
+        [Fact]
+        public async Task Pattern_With_Newline_Should_Be_Escaped_For_XML()
+        {
+            string program = """
+                using System.Text.RegularExpressions;
+                partial class C
+                {
+                    [GeneratedRegex("\n")]
+                    public static partial Regex NewlinePattern();
+                }
+                """;
+
+            string actual = await RegexGeneratorHelper.GenerateSourceText(program, allowUnsafe: true, checkOverflow: false);
+            
+            // The pattern should escape newline as Unicode escape sequence to avoid breaking XML comments
+            Assert.Contains("/// <code>\\u000A</code><br/>", actual);
+            
+            // The actual pattern string should properly escape the newline for C#
+            Assert.Contains("base.pattern = \"\\n\";", actual);
+        }
     }
 }