Remove slow regex from threading analyzers

Author: AArnott

src/Microsoft.VisualStudio.Threading.Analyzers/CommonInterest.cs

@@ -69,12 +69,6 @@ public static class CommonInterest
 
     private const string GetAwaiterMethodName = "GetAwaiter";
 
-    private static readonly TimeSpan RegexMatchTimeout = TimeSpan.FromSeconds(5);  // Prevent expensive CPU hang in Regex.Match if backtracking occurs due to pathological input (see #485).
-
-    private static readonly Regex NegatableTypeOrMemberReferenceRegex = new Regex(@"^(?<negated>!)?\[(?<typeName>[^\[\]\:]+)+\](?:\:\:(?<memberName>\S+))?\s*$", RegexOptions.Singleline | RegexOptions.CultureInvariant, RegexMatchTimeout);
-
-    private static readonly Regex MemberReferenceRegex = new Regex(@"^\[(?<typeName>[^\[\]\:]+)+\]::(?<memberName>\S+)\s*$", RegexOptions.Singleline | RegexOptions.CultureInvariant, RegexMatchTimeout);
-
     /// <summary>
     /// An array with '.' as its only element.
     /// </summary>
@@ -92,28 +86,17 @@ public static IEnumerable<TypeMatchSpec> ReadTypesAndMembers(AnalyzerOptions ana
     {
         foreach (string line in ReadAdditionalFiles(analyzerOptions, fileNamePattern, cancellationToken))
         {
-            Match? match = null;
-            try
-            {
-                match = NegatableTypeOrMemberReferenceRegex.Match(line);
-            }
-            catch (RegexMatchTimeoutException)
-            {
-                throw new InvalidOperationException($"Regex.Match timeout when parsing line: {line}");
-            }
-
-            if (!match.Success)
+            if (!TryParseNegatableTypeOrMemberReference(line, out bool negated, out string? typeNameValue, out string? memberNameValue))
             {
                 throw new InvalidOperationException($"Parsing error on line: {line}");
             }
 
-            bool inverted = match.Groups["negated"].Success;
-            string[] typeNameElements = match.Groups["typeName"].Value.Split(QualifiedIdentifierSeparators);
+            string[] typeNameElements = typeNameValue!.Split(QualifiedIdentifierSeparators);
             string typeName = typeNameElements[typeNameElements.Length - 1];
             var containingNamespace = typeNameElements.Take(typeNameElements.Length - 1).ToImmutableArray();
             var type = new QualifiedType(containingNamespace, typeName);
-            QualifiedMember member = match.Groups["memberName"].Success ? new QualifiedMember(type, match.Groups["memberName"].Value) : default(QualifiedMember);
-            yield return new TypeMatchSpec(type, member, inverted);
+            QualifiedMember member = memberNameValue is not null ? new QualifiedMember(type, memberNameValue) : default(QualifiedMember);
+            yield return new TypeMatchSpec(type, member, negated);
         }
     }
 
@@ -345,26 +328,171 @@ public static IEnumerable<string> ReadLinesFromAdditionalFile(SourceText text)
 
     public static QualifiedMember ParseAdditionalFileMethodLine(string line)
     {
-        Match? match = null;
-        try
+        if (!TryParseMemberReference(line, out string? typeNameValue, out string? memberName))
         {
-            match = MemberReferenceRegex.Match(line);
+            throw new InvalidOperationException($"Parsing error on line: {line}");
         }
-        catch (RegexMatchTimeoutException)
+
+        string[] typeNameElements = typeNameValue!.Split(QualifiedIdentifierSeparators);
+        string typeName = typeNameElements[typeNameElements.Length - 1];
+        var containingType = new QualifiedType(typeNameElements.Take(typeNameElements.Length - 1).ToImmutableArray(), typeName);
+        return new QualifiedMember(containingType, memberName!);
+    }
+
+    /// <summary>
+    /// Parses a line of the form <c>!?[TypeName](::MemberName)?</c> without using regex.
+    /// </summary>
+    /// <param name="line">The line to parse.</param>
+    /// <param name="negated"><see langword="true" /> if the line begins with '!'.</param>
+    /// <param name="typeName">The type name parsed from the brackets.</param>
+    /// <param name="memberName">The member name after '::', or <see langword="null" /> if not present.</param>
+    /// <returns><see langword="true" /> if parsing succeeded.</returns>
+    private static bool TryParseNegatableTypeOrMemberReference(string line, out bool negated, out string? typeName, out string? memberName)
+    {
+        negated = false;
+        typeName = null;
+        memberName = null;
+
+        int pos = 0;
+
+        // Optional negation prefix.
+        if (pos < line.Length && line[pos] == '!')
         {
-            throw new InvalidOperationException($"Regex.Match timeout when parsing line: {line}");
+            negated = true;
+            pos++;
         }
 
-        if (!match.Success)
+        // Required opening bracket.
+        if (pos >= line.Length || line[pos] != '[')
         {
-            throw new InvalidOperationException($"Parsing error on line: {line}");
+            return false;
         }
 
-        string methodName = match.Groups["memberName"].Value;
-        string[] typeNameElements = match.Groups["typeName"].Value.Split(QualifiedIdentifierSeparators);
-        string typeName = typeNameElements[typeNameElements.Length - 1];
-        var containingType = new QualifiedType(typeNameElements.Take(typeNameElements.Length - 1).ToImmutableArray(), typeName);
-        return new QualifiedMember(containingType, methodName);
+        pos++;
+
+        // Type name: one or more chars that are not '[', ']', or ':'.
+        int typeNameStart = pos;
+        while (pos < line.Length && line[pos] != '[' && line[pos] != ']' && line[pos] != ':')
+        {
+            pos++;
+        }
+
+        if (pos == typeNameStart)
+        {
+            return false;
+        }
+
+        typeName = line.Substring(typeNameStart, pos - typeNameStart);
+
+        // Required closing bracket.
+        if (pos >= line.Length || line[pos] != ']')
+        {
+            return false;
+        }
+
+        pos++;
+
+        // Optional '::memberName'.
+        if (pos + 1 < line.Length && line[pos] == ':' && line[pos + 1] == ':')
+        {
+            pos += 2;
+            int memberNameStart = pos;
+            while (pos < line.Length && !char.IsWhiteSpace(line[pos]))
+            {
+                pos++;
+            }
+
+            if (pos == memberNameStart)
+            {
+                // '::' present but no member name follows.
+                return false;
+            }
+
+            memberName = line.Substring(memberNameStart, pos - memberNameStart);
+        }
+
+        // Allow only trailing whitespace.
+        while (pos < line.Length && char.IsWhiteSpace(line[pos]))
+        {
+            pos++;
+        }
+
+        return pos == line.Length;
+    }
+
+    /// <summary>
+    /// Parses a line of the form <c>[TypeName]::MemberName</c> without using regex.
+    /// </summary>
+    /// <param name="line">The line to parse.</param>
+    /// <param name="typeName">The type name parsed from the brackets.</param>
+    /// <param name="memberName">The member name after '::'.</param>
+    /// <returns><see langword="true" /> if parsing succeeded.</returns>
+    private static bool TryParseMemberReference(string line, out string? typeName, out string? memberName)
+    {
+        typeName = null;
+        memberName = null;
+
+        int pos = 0;
+
+        // Required opening bracket.
+        if (pos >= line.Length || line[pos] != '[')
+        {
+            return false;
+        }
+
+        pos++;
+
+        // Type name: one or more chars that are not '[', ']', or ':'.
+        int typeNameStart = pos;
+        while (pos < line.Length && line[pos] != '[' && line[pos] != ']' && line[pos] != ':')
+        {
+            pos++;
+        }
+
+        if (pos == typeNameStart)
+        {
+            return false;
+        }
+
+        typeName = line.Substring(typeNameStart, pos - typeNameStart);
+
+        // Required closing bracket.
+        if (pos >= line.Length || line[pos] != ']')
+        {
+            return false;
+        }
+
+        pos++;
+
+        // Required '::'.
+        if (pos + 1 >= line.Length || line[pos] != ':' || line[pos + 1] != ':')
+        {
+            return false;
+        }
+
+        pos += 2;
+
+        // Member name: one or more non-whitespace chars.
+        int memberNameStart = pos;
+        while (pos < line.Length && !char.IsWhiteSpace(line[pos]))
+        {
+            pos++;
+        }
+
+        if (pos == memberNameStart)
+        {
+            return false;
+        }
+
+        memberName = line.Substring(memberNameStart, pos - memberNameStart);
+
+        // Allow only trailing whitespace.
+        while (pos < line.Length && char.IsWhiteSpace(line[pos]))
+        {
+            pos++;
+        }
+
+        return pos == line.Length;
     }
 
     private static bool TestGetAwaiterMethod(IMethodSymbol getAwaiterMethod)