Fixed infinite backreferenced bug in string escaping, added bracketed expression support, misc indenter fixes.

comintern · comintern · commit ccc4a72d8ca2 · 2016-12-08T00:17:44.000-06:00
diff --git a/Rubberduck.SmartIndenter/AbsoluteCodeLine.cs b/Rubberduck.SmartIndenter/AbsoluteCodeLine.cs
@@ -10,11 +10,12 @@ namespace Rubberduck.SmartIndenter
     internal class AbsoluteCodeLine
     {
         private const string StupidLineEnding = ": _";
-        private const string StringPlaceholder = "\a";
-        private static readonly Regex StringLiteralRegex = new Regex("\"(?:[^\"]+|\"\")*\"");
-        private static readonly Regex StringReplaceRegex = new Regex(StringPlaceholder);
+        private const char StringPlaceholder = '\a';
+        private const char BracketPlaceholder = '\x2';
+        private static readonly Regex StringReplaceRegex = new Regex(StringPlaceholder.ToString(CultureInfo.InvariantCulture));
+        private static readonly Regex BracketReplaceRegex = new Regex(BracketPlaceholder.ToString(CultureInfo.InvariantCulture));
         private static readonly Regex LineNumberRegex = new Regex(@"^(?<number>\d+)\s+(?<code>.*)", RegexOptions.ExplicitCapture);
-        private static readonly Regex EndOfLineCommentRegex = new Regex(@"^(?!(Rem\s)|('))(?<code>.*)(\s(?<comment>'.*))$", RegexOptions.ExplicitCapture);
+        private static readonly Regex EndOfLineCommentRegex = new Regex(@"^(?!(Rem\s)|('))(?<code>[^']*)(\s(?<comment>'.*))$", RegexOptions.ExplicitCapture);      
         private static readonly Regex ProcedureStartRegex = new Regex(@"^(Public\s|Private\s|Friend\s)?(Static\s)?(Sub|Function|Property\s(Let|Get|Set))\s");
         private static readonly Regex ProcedureStartIgnoreRegex = new Regex(@"^[LR]?Set\s|^Let\s|^(Public|Private)\sDeclare\s(Function|Sub)");
         private static readonly Regex ProcedureEndRegex = new Regex(@"^End\s(Sub|Function|Property)");
@@ -31,9 +32,10 @@ internal class AbsoluteCodeLine
         private uint _lineNumber;
         private bool _numbered;
         private string _code;
-        private bool _stupidLineEnding;
+        private readonly bool _stupidLineEnding;
         private readonly string[] _segments;
         private List<string> _strings;
+        private List<string> _brackets;
 
         public AbsoluteCodeLine(string code, IIndenterSettings settings)
         {
@@ -51,23 +53,69 @@ public AbsoluteCodeLine(string code, IIndenterSettings settings)
             
             Original = code;
 
-            ExtractStringLiterals();
+            ExtractStringLiteralsAndBrackets();
             ExtractLineNumber();
             ExtractEndOfLineComment();
-
+            _code = Regex.Replace(_code, StringPlaceholder + "+", StringPlaceholder.ToString(CultureInfo.InvariantCulture));
+            _code = Regex.Replace(_code, BracketPlaceholder + "+", BracketPlaceholder.ToString(CultureInfo.InvariantCulture)).Trim();
             _segments = _code.Split(new[] { ": " }, StringSplitOptions.None);
         }
 
-        private void ExtractStringLiterals()
+        //TODO: This should be a class.
+        private void ExtractStringLiteralsAndBrackets()
         {
             _strings = new List<string>();
-            var matches = StringLiteralRegex.Matches(_code);
-            if (matches.Count == 0) return;
-            foreach (var match in matches)
+            _brackets = new List<string>();
+
+            var chars = _code.ToCharArray();
+            var quoted = false;
+            var bracketed = false;
+            var ins = 0;
+            var strpos = 0;
+            var brkpos = 0;
+            for (var c = 0; c < chars.Length; c++)
             {
-                _strings.Add(match.ToString());
+                if (chars[c] == '"' && !bracketed)
+                {
+                    if (!quoted)
+                    {
+                        strpos = c;
+                        quoted = true;
+                        continue;
+                    }
+                    if (c + 1 < chars.Length && chars[c] == '"')
+                    {
+                        c++;
+                    }
+                    quoted = false;
+                    _strings.Add(new string(chars.Skip(strpos).Take(c - strpos).ToArray()));
+                    for (var e = strpos; e < c; e++)
+                    {
+                        chars[e] = StringPlaceholder;
+                    }
+                }
+                else if (!quoted && !bracketed && chars[c] == '[')
+                {
+                    bracketed = true;
+                    brkpos = c;
+                    ins++;
+                }
+                else if (!quoted && bracketed && chars[c] == ']')
+                {
+                    ins--;
+                    if (ins != 0)
+                    {
+                        continue;
+                    }
+                    bracketed = false;
+                    _brackets.Add(new string(chars.Skip(brkpos).Take(c - brkpos).ToArray()));
+                    for (var e = brkpos; e < c; e++)
+                    {
+                        chars[e] = BracketPlaceholder;
+                    }
+                }
             }
-            _code = StringLiteralRegex.Replace(_code, StringPlaceholder);
+            _code = new string(chars);            
         }
 
         private void ExtractLineNumber()
@@ -77,12 +125,9 @@ private void ExtractLineNumber()
             {
                 _numbered = true;
                 _lineNumber = Convert.ToUInt32(match.Groups["number"].Value);
-                _code = match.Groups["code"].Value.Trim();
-            }
-            else
-            {
-                _code = _code.Trim();
+                _code = match.Groups["code"].Value;
             }
+            _code = _code.Trim();
         }
 
         private void ExtractEndOfLineComment()
@@ -98,7 +143,24 @@ private void ExtractEndOfLineComment()
         }
 
         public string Original { get; private set; }
-        
+
+        public string Escaped
+        {
+            get
+            {
+                var output = Original;
+                foreach (var item in _strings)
+                {
+                    output = output.Replace(item, new string(StringPlaceholder, item.Length));
+                }
+                foreach (var item in _brackets)
+                {
+                    output = output.Replace(item, new string(BracketPlaceholder, item.Length));
+                }
+                return output;
+            }
+        }
+
         public string EndOfLineComment { get; private set; }
 
         public IEnumerable<string> Segments
@@ -146,7 +208,7 @@ public bool HasContinuation
 
         public bool IsPrecompilerDirective
         {
-            get { return Original.TrimStart().StartsWith("#"); }
+            get { return _code.TrimStart().StartsWith("#"); }
         }
 
         public bool IsBareDebugStatement
@@ -248,6 +310,10 @@ public string Indent(int indents, bool atProcStart, bool absolute = false)
             {
                 code = _strings.Aggregate(code, (current, literal) => StringReplaceRegex.Replace(current, literal, 1));
             }
+            if (_brackets.Any())
+            {
+                code = _brackets.Aggregate(code, (current, expr) => BracketReplaceRegex.Replace(current, expr, 1));
+            }
 
             code = string.Join(string.Empty, number, new string(' ', gap), code);
             if (string.IsNullOrEmpty(EndOfLineComment))
@@ -283,10 +349,20 @@ public override string ToString()
         }
 
         private void AlignDims(int postition)
-        {            
+        {
+            if (_segments[0].Trim().StartsWith("As "))
+            {
+                _segments[0] = string.Format("{0}{1}", new String(' ', _settings.AlignDimColumn - postition - 1), _segments[0].Trim());
+                return;
+            }
             var alignTokens = _segments[0].Split(new[] { " As " }, StringSplitOptions.None);
+            if (alignTokens.Length <= 1)
+            {
+                return;
+            }
             var gap = Math.Max(_settings.AlignDimColumn - postition - alignTokens[0].Length - 2, 0);
-            _segments[0] = string.Format("{0}{1} As {2}", alignTokens[0].Trim(), new string(' ', gap), string.Join(" As ", alignTokens.Skip(1)));
+            _segments[0] = string.Format("{0}{1} As {2}", alignTokens[0].Trim(), new string(' ', gap),
+                                         string.Join(" As ", alignTokens.Skip(1)));
         }
     }
 }
diff --git a/Rubberduck.SmartIndenter/LogicalCodeLine.cs b/Rubberduck.SmartIndenter/LogicalCodeLine.cs
@@ -132,7 +132,7 @@ public string Indented()
             var current = _lines.First().Indent(IndentationLevel, AtProcedureStart);
             var commentPos = string.IsNullOrEmpty(_lines.First().EndOfLineComment) ? 0 : current.Length - _lines.First().EndOfLineComment.Length;
             output.Add(current);
-            var alignment = FunctionAlign(current, _lines[1].Original.Trim().StartsWith(":="));
+            var alignment = FunctionAlign(current, _lines[1].Escaped.Trim().StartsWith(":="));
 
             //foreach (var line in _lines.Skip(1))
             for (var i = 1; i < _lines.Count; i++)
@@ -156,7 +156,7 @@ public string Indented()
                 var operatorAdjust = _settings.IgnoreOperatorsInContinuations && OperatorIgnoreRegex.IsMatch(line.Original) ? 2 : 0;              
                 current = line.Indent(Math.Max(alignment - operatorAdjust, 0), AtProcedureStart, true);
                 output.Add(current);
-                alignment = FunctionAlign(current, i + 1 < _lines.Count && _lines[i + 1].Original.Trim().StartsWith(":="));
+                alignment = FunctionAlign(current, i + 1 < _lines.Count && _lines[i + 1].Escaped.Trim().StartsWith(":="));
                 commentPos = string.IsNullOrEmpty(line.EndOfLineComment) ? 0 : current.Length - line.EndOfLineComment.Length;
             }
 
@@ -181,9 +181,11 @@ private int FunctionAlign(string line, bool splitNamed)
                 var character = line.Substring(index - 1, 1);
                 switch (character)
                 {
-                    case "\"":
-                        //A String => jump to the end of it
-                        while (!line.Substring(index++, 1).Equals("\"")) { }
+                    case "\a":
+                        while (!line.Substring(index++, 1).Equals("\a")) { }
+                        break;
+                    case "\x2":
+                        while (!line.Substring(index++, 1).Equals("\x2")) { }
                         break;
                     case "(":
                         //Start of another function => remember this position
diff --git a/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs b/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs
@@ -953,6 +953,7 @@ Sub Foo(ByRef _
             Assert.AreEqual(expectedCode, module.Content());
         }
 
+        //https://github.com/rubberduck-vba/Rubberduck/issues/2408
         [TestMethod]
         [TestCategory("Inspections")]
         public void ParameterCanBeByVal_QuickFixWithOptionalWorks()
@@ -986,6 +987,7 @@ Debug.Print foo
             Assert.AreEqual(expectedCode, module.Content());
         }
 
+        //https://github.com/rubberduck-vba/Rubberduck/issues/2408
         [TestMethod]
         [TestCategory("Inspections")]
         public void ParameterCanBeByVal_QuickFixWithOptionalByRefWorks()
@@ -1019,6 +1021,51 @@ Debug.Print foo
             Assert.AreEqual(expectedCode, module.Content());
         }
 
+        //https://github.com/rubberduck-vba/Rubberduck/issues/2408
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void ParameterCanBeByVal_QuickFixWithOptional_LineContinuationsWorks()
+        {
+            Assert.Inconclusive("Pending more comprehensive fix.");
+            const string inputCode =
+@"Sub foo(Optional _
+  ByRef _
+  foo _
+  As _
+  Byte _
+  )
+  Debug.Print foo
+End Sub";
+
+            const string expectedCode =
+@"Sub foo(Optional _
+  ByVal _
+  foo _
+  As _
+  Byte _
+  )
+  Debug.Print foo
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            IVBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var project = vbe.Object.VBProjects[0];
+            var module = project.VBComponents[0].CodeModule;
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new ParameterCanBeByValInspection(parser.State);
+            inspection.GetInspectionResults().First().QuickFixes.Single(s => s is PassParameterByValueQuickFix).Fix();
+
+            Assert.AreEqual(expectedCode, module.Content());
+        }
+
         [TestMethod]
         [TestCategory("Inspections")]
         public void InspectionType()
diff --git a/RubberduckTests/SmartIndenter/LineContinuationTests.cs b/RubberduckTests/SmartIndenter/LineContinuationTests.cs
@@ -542,7 +542,90 @@ public void ContinuationsInProcedureDeclarationsWorks()
             Assert.IsTrue(expected.SequenceEqual(actual));
         }
 
+        //https://github.com/rubberduck-vba/Rubberduck/issues/2407
+        [TestMethod] 
+        [TestCategory("Indenter")]
+        public void ContinuationsInProcedureDeclarationsWithAlignWorks()
+        {
+            var code = new[]
+            {
+                "Sub MySub()",
+                "Dim x1 As Integer, x2 _",
+                "As Integer",
+                "End Sub"
+            };
+
+            var expected = new[]
+            {
+                "Sub MySub()",
+                "    Dim x1    As Integer, x2 _",
+                "              As Integer",
+                "End Sub"
+            };
+
+            var indenter = new Indenter(null, () =>
+            {
+                var s = IndenterSettingsTests.GetMockIndenterSettings();
+                s.IndentFirstDeclarationBlock = true;
+                s.AlignDims = true;
+                s.AlignDimColumn = 15;
+                return s;
+            });
+            var actual = indenter.Indent(code, string.Empty);
+            Assert.IsTrue(expected.SequenceEqual(actual));
+        }
+
+        //https://github.com/rubberduck-vba/Rubberduck/issues/2407
+        [TestMethod] 
+        [TestCategory("Indenter")]
+        public void ContinuationsInProcedureDeclarationsWithAlignWorksBareType()
+        {
+            var code = new[]
+            {
+                "Sub MySub()",
+                "Dim x1 As Integer",
+                "Dim x2 As _",
+                "Integer",
+                "Dim x3 As Integer: _",
+                "Dim x4 As _",
+                "Integer",
+                "Dim x5 As Integer _",
+                "'Comment _",
+                "as _",
+                "integer",
+                "End Sub"
+            };
+
+            var expected = new[]
+            {
+                "Sub MySub()",
+                "    Dim x1    As Integer",
+                "    Dim x2    As _",
+                "    Integer",
+                "    Dim x3    As Integer: _",
+                "    Dim x4    As _",
+                "    Integer",
+                "    Dim x5    As Integer _",
+                "        'Comment _",
+                "        as _",
+                "        integer",
+                "End Sub"
+            };
+
+            var indenter = new Indenter(null, () =>
+            {
+                var s = IndenterSettingsTests.GetMockIndenterSettings();
+                s.IndentFirstDeclarationBlock = true;
+                s.AlignDims = true;
+                s.AlignDimColumn = 15;
+                return s;
+            });
+            var actual = indenter.Indent(code, string.Empty);
+            Assert.IsTrue(expected.SequenceEqual(actual));
+        }
+
         [TestMethod]
+        [TestCategory("Indenter")]
         public void ContinuationWithOnlyCommentWorks()
         {
             var code = new[]
diff --git a/RubberduckTests/SmartIndenter/MiscAndCornerCaseTests.cs b/RubberduckTests/SmartIndenter/MiscAndCornerCaseTests.cs
diff --git a/RubberduckTests/SmartIndenter/SpecificSettingTests.cs b/RubberduckTests/SmartIndenter/SpecificSettingTests.cs
