Use recursive descent for CharacterClass parsing, fix #4839

Character class parsing used to rely on a lookbehind to match the
closing bracket, which was inappropriate for a trailing escaped
backslash.

Instead of attempting to fix the regular expression's lookbehind
by forcing an uneven number of backslashes in the negative capture,
we now use the same pattern as descending into a group

Author: Vogel612

Rubberduck.RegexAssistant/Atoms/CharacterClass.cs

@@ -8,9 +8,6 @@ namespace Rubberduck.RegexAssistant.Atoms
 {
     internal class CharacterClass : IAtom
     {
-        public static readonly string Pattern = @"(?<!\\)\[(?<expression>.*?)(?<!\\)\]";
-        private static readonly Regex Matcher = new Regex($"^{Pattern}$", RegexOptions.Compiled);
-
         public bool InverseMatching { get; }
         public IList<string> CharacterSpecifiers { get; }
 
@@ -22,13 +19,13 @@ public CharacterClass(string specifier, Quantifier quantifier)
             }
 
             Quantifier = quantifier;
-            var m = Matcher.Match(specifier);
-            if (!m.Success)
+            if (!specifier.StartsWith("[") || !specifier.EndsWith("]"))
             {
                 throw new ArgumentException("The given specifier does not denote a character class");
             }
             Specifier = specifier;
-            var actualSpecifier = m.Groups["expression"].Value;
+            // trim leading and closing bracket
+            var actualSpecifier = specifier.Substring(1, specifier.Length - 2);
             InverseMatching = actualSpecifier.StartsWith("^");
             CharacterSpecifiers= ExtractCharacterSpecifiers(InverseMatching ? actualSpecifier.Substring(1) : actualSpecifier);
         }

Rubberduck.RegexAssistant/VBRegexParser.cs

@@ -10,7 +10,6 @@ namespace Rubberduck.RegexAssistant
     internal class VBRegexParser
     {
         private static readonly Regex LITERAL_PATTERN = new Regex("^" + Literal.Pattern);
-        private static readonly Regex CHARACTER_CLASS_PATTERN = new Regex("^" + CharacterClass.Pattern);
         private static readonly Regex QUANTIFIER_PATTERN = new Regex("^" + Quantifier.Pattern);
 
         public static IRegularExpression Parse(string specifier)
@@ -88,12 +87,7 @@ private static string DescendLiteral(string specifier)
 
         private static string DescendClass(string specifier)
         {
-            var matcher = CHARACTER_CLASS_PATTERN.Match(specifier);
-            if (matcher.Success)
-            {
-                return $"[{matcher.Groups["expression"].Value}]";
-            }
-            return "";
+            return DescendExpression(specifier, '[', ']');
         }
 
         private static string GetQuantifier(string specifier, int length)
@@ -108,18 +102,23 @@ private static string GetQuantifier(string specifier, int length)
         }
 
         private static string DescendGroup(string specifier)
+        {
+            return DescendExpression(specifier, '(', ')');
+        }
+
+        private static string DescendExpression(string specifier, char opening, char closing)
         {
             int length = 0;
             int openingCount = 0;
             bool escapeToggle = false;
-            foreach (var digit in specifier) 
+            foreach (var digit in specifier)
             {
-                if (digit == '(' && !escapeToggle)
+                if (digit == opening && !escapeToggle)
                 {
                     openingCount++;
                     escapeToggle = false;
                 }
-                if (digit == ')' && !escapeToggle)
+                if (digit == closing && !escapeToggle)
                 {
                     openingCount--;
                     escapeToggle = false;