Fix escaping behavior in DescendGroup and throw some tests at it

Author: Vogel612

Rubberduck.RegexAssistant/Rubberduck.RegexAssistant.csproj

@@ -97,6 +97,12 @@
     </None>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Rubberduck.VBEEditor\Rubberduck.VBEditor.csproj">
+      <Project>{8CE35EB3-8852-4BA1-84DD-DF3F5D2967B0}</Project>
+      <Name>Rubberduck.VBEditor</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

Rubberduck.RegexAssistant/VBRegexParser.cs

@@ -128,7 +128,7 @@ private static string DescendGroup(string specifier)
                         return openingCount == 0 ? specifier.Substring(0, length + 1) : "";
                     }
                 }
-                if (digit == '\\')
+                if (digit == '\\' || escapeToggle)
                 {
                     escapeToggle = !escapeToggle;
                 }

RubberduckTests/RegexAssistant/RegularExpressionTests.cs

@@ -286,5 +286,58 @@ public void UnbalancedGroupCorrectlyMarksTrailingParenAsError()
                 Assert.AreEqual(expected[i], subexpressions[i]);
             }
         }
+
+        [Category("RegexAssistant")]
+        [Test]
+        public void EscapedParensGroupIsParsedProperly()
+        {
+            var expected = new List<IRegularExpression>()
+            {
+                new SingleAtomExpression(new Literal("\\(", Quantifier.None)),
+                new SingleAtomExpression(new Group(new ConcatenatedExpression(new IRegularExpression[]{
+                    new SingleAtomExpression(new Literal("\\(", Quantifier.None)),
+                    new SingleAtomExpression(new Literal("\\)", Quantifier.None)),
+                }.ToList()),"(\\(\\))", Quantifier.None)),
+                new SingleAtomExpression(new Literal("\\)", Quantifier.None)),
+            };
+            var expression = VBRegexParser.Parse(@"\((\(\))\)");
+            Assert.IsInstanceOf(typeof(ConcatenatedExpression), expression);
+            var subexpressions = (expression as ConcatenatedExpression).Subexpressions;
+            Assert.AreEqual(expected.Count, subexpressions.Count);
+            for (var i = 0; i < expected.Count; i++)
+            {
+                Assert.AreEqual(expected[i], subexpressions[i]);
+            }
+        }
+
+        [Category("RegexAssistant")]
+        [Test]
+        public void IncorrectEscapeSequenceIsGroupSubExpression()
+        {
+            var expected = new List<IRegularExpression>
+            {
+                new ErrorExpression("\\"),
+                new SingleAtomExpression(new Literal("m", Quantifier.None))
+            };
+            var expression = VBRegexParser.Parse("(\\m)");
+            Assert.IsInstanceOf(typeof(SingleAtomExpression), expression);
+            var subexpressions = (((expression as SingleAtomExpression).Atom as Group)?.Subexpression as ConcatenatedExpression)?.Subexpressions ?? new List<IRegularExpression>();
+            Assert.AreEqual(expected.Count, subexpressions.Count);
+            for (var i = 0; i < expected.Count; i++)
+            {
+                Assert.AreEqual(expected[i], subexpressions[i]);
+            }
+        }
+
+        [Category("RegexAssistant")]
+        [Test]
+        public void CorrectEscapeSequenceIsGroupSubExpression()
+        {
+            var expression = VBRegexParser.Parse(@"(\\)");
+            Assert.IsInstanceOf(typeof(SingleAtomExpression), expression);
+            var inner = (((expression as SingleAtomExpression).Atom as Group)?.Subexpression as SingleAtomExpression);
+            Assert.IsNotNull(inner);
+            Assert.AreEqual(new SingleAtomExpression(new Literal("\\\\", Quantifier.None)), inner);
+        }
     }
 }