Remove regex from the compiler (#12063)

Fixes #12062

Nerd sniped myself reading this issue this morning. Seemed straight
forward enough, ~but I decided to tweak the behaviour slightly because
there seemed no point for the extra complexity of trying to keep track
of how long it had been since a lowercase letter.~ I was overthinking
the algorithm.

~| Method | Mean        | Error     | StdDev    | Gen0   | Allocated |
|------- |------------:|----------:|----------:|-------:|----------:|
| Regex  | 1,133.09 ns | 21.888 ns | 24.328 ns | 0.0191 |     112 B |
| Loop   |    98.81 ns |  2.070 ns |  2.301 ns | 0.0097 |      56 B |~

Author: davidwengier

src/Compiler/Microsoft.AspNetCore.Razor.Language/test/HtmlConventionsTest.cs

@@ -3,13 +3,15 @@
 
 #nullable disable
 
+using System;
+using System.Text.RegularExpressions;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Razor.Language;
 
 public class HtmlConventionsTest
 {
-    public static TheoryData HtmlConversionData
+    public static TheoryData<string, string> HtmlConversionData
     {
         get
         {
@@ -22,11 +24,21 @@ public static TheoryData HtmlConversionData
                     { "ALLCAPS", "allcaps" },
                     { "One1Two2Three3", "one1-two2-three3" },
                     { "ONE1TWO2THREE3", "one1two2three3" },
-                    { "First_Second_ThirdHi", "first_second_third-hi" }
+                    { "First_Second_ThirdHi", "first_second_third-hi" },
+                    { "ONE1Two", "one1-two" },
+                    { "One123Two234Three345", "one123-two234-three345" },
+                    { "ONE123TWO234THREE345", "one123two234three345" },
+                    { "1TWO2THREE3", "1two2three3" },
+                    { "alllowercase", "alllowercase" },
                 };
         }
     }
 
+    private static readonly Regex OldHtmlCaseRegex = new Regex(
+        "(?<!^)((?<=[a-zA-Z0-9])[A-Z][a-z])|((?<=[a-z])[A-Z])",
+        RegexOptions.None,
+        TimeSpan.FromMilliseconds(500));
+
     [Theory]
     [MemberData(nameof(HtmlConversionData))]
     public void ToHtmlCase_ReturnsExpectedConversions(string input, string expectedOutput)
@@ -35,6 +47,10 @@ public void ToHtmlCase_ReturnsExpectedConversions(string input, string expectedO
         var output = HtmlConventions.ToHtmlCase(input);
 
         // Assert
-        Assert.Equal(output, expectedOutput);
+        Assert.Equal(expectedOutput, output);
+
+        // Assure backwards compatibility with regex
+        var regexResult = OldHtmlCaseRegex.Replace(input, "-$1$2").ToLowerInvariant();
+        Assert.Equal(regexResult, output);
     }
 }

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/HtmlConventions.cs

@@ -1,29 +1,17 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System;
-using System.Text.RegularExpressions;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.AspNetCore.Razor.PooledObjects;
 
 namespace Microsoft.AspNetCore.Razor.Language;
 
 public static class HtmlConventions
 {
-    private const string HtmlCaseRegexReplacement = "-$1$2";
     private static readonly char[] InvalidNonWhitespaceHtmlCharacters =
-        new[] { '@', '!', '<', '/', '?', '[', '>', ']', '=', '"', '\'', '*' };
-
-    // This matches the following AFTER the start of the input string (MATCH).
-    // Any letter/number followed by an uppercase letter then lowercase letter: 1(Aa), a(Aa), A(Aa)
-    // Any lowercase letter followed by an uppercase letter: a(A)
-    // Each match is then prefixed by a "-" via the ToHtmlCase method.
-    private static readonly Regex HtmlCaseRegex =
-        new Regex(
-            "(?<!^)((?<=[a-zA-Z0-9])[A-Z][a-z])|((?<=[a-z])[A-Z])",
-            RegexOptions.None,
-            TimeSpan.FromMilliseconds(500));
-
+        ['@', '!', '<', '/', '?', '[', '>', ']', '=', '"', '\'', '*'];
 
     internal static bool IsInvalidNonWhitespaceHtmlCharacters(char testChar)
     {
@@ -50,8 +38,81 @@ internal static bool IsInvalidNonWhitespaceHtmlCharacters(char testChar)
     /// ONE1TWO2THREE3 => one1two2three3
     /// First_Second_ThirdHi => first_second_third-hi
     /// </example>
-    public static string ToHtmlCase(string name)
+    public static string ToHtmlCase(string input)
+    {
+        if (string.IsNullOrEmpty(input))
+        {
+            return input;
+        }
+
+        return TryGetKebabCaseString(input, out var result)
+            ? result
+            : input;
+    }
+
+    private static bool TryGetKebabCaseString(ReadOnlySpan<char> input, [NotNullWhen(true)] out string? result)
     {
-        return HtmlCaseRegex.Replace(name, HtmlCaseRegexReplacement).ToLowerInvariant();
+        using var _ = StringBuilderPool.GetPooledObject(out var builder);
+
+        var allLower = true;
+        var i = 0;
+        foreach (var c in input)
+        {
+            if (char.IsUpper(c))
+            {
+                allLower = false;
+
+                if (ShouldInsertHyphenBeforeUppercase(input, i))
+                {
+                    builder.Append('-');
+                }
+
+                builder.Append(char.ToLowerInvariant(c));
+            }
+            else
+            {
+                builder.Append(c);
+            }
+
+            i++;
+        }
+
+        if (allLower)
+        {
+            // If the input is all lowercase, we don't need to realize the builder,
+            // it will just be cleared when the pooled object is disposed.
+            result = null;
+            return false;
+        }
+
+        result = builder.ToString();
+        return true;
+    }
+
+    private static bool ShouldInsertHyphenBeforeUppercase(ReadOnlySpan<char> input, int i)
+    {
+        Debug.Assert(char.IsUpper(input[i]));
+
+        if (i == 0)
+        {
+            // First character is uppercase, no hyphen needed (e.g. This → this)
+            return false;
+        }
+
+        var prev = input[i - 1];
+        if (char.IsLower(prev))
+        {
+            // Lowercase followed by uppercase (e.g. someThing → some-thing)
+            return true;
+        }
+
+        if ((char.IsUpper(prev) || char.IsDigit(prev)) &&
+            (i + 1 < input.Length) && char.IsLower(input[i + 1]))
+        {
+            // Uppercase or digit followed by uppercase, followed by lowercase (e.g. CAPSOn → caps-on or ONE1Two → ONE1-Two)
+            return true;
+        }
+
+        return false;
     }
 }