Merge pull request #4498 from retailcoder/scp

self-closing pair completion bugfix

Author: retailcoder

Rubberduck.Core/AutoComplete/AutoCompleteHandlerBase.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Linq;
-using Rubberduck.Parsing.VBA.Extensions;
-using Rubberduck.Settings;
+using Rubberduck.Settings;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.Events;
 using Rubberduck.VBEditor.SourceCodeHandling;
@@ -17,6 +14,6 @@ protected AutoCompleteHandlerBase(ICodePaneHandler pane)
 
         protected ICodePaneHandler CodePaneHandler { get; }
 
-        public abstract CodeString Handle(AutoCompleteEventArgs e, AutoCompleteSettings settings);
+        public abstract bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settings, out CodeString result);
     }
 }

Rubberduck.Core/AutoComplete/Service/AutoCompleteService.cs

@@ -135,11 +135,13 @@ private void HandleKeyDown(object sender, AutoCompleteEventArgs e)
 
             foreach (var handler in _handlers)
             {
-                var result = handler.Handle(e, _settings);
-                if (result != null && e.Handled)
+                if (!handler.Handle(e, _settings, out _))
                 {
-                    return;
+                    continue;
                 }
+
+                e.Handled = true;
+                return;
             }
         }
 

Rubberduck.Core/AutoComplete/Service/SelfClosingPair.cs

@@ -1,7 +1,18 @@
-namespace Rubberduck.AutoComplete.Service
+using Rubberduck.VBEditor;
+using System;
+
+namespace Rubberduck.AutoComplete.Service
 {
-    public class SelfClosingPair
+    public class SelfClosingPair : IEquatable<SelfClosingPair>
     {
+        [Flags]
+        public enum MatchType
+        {
+            NoMatch = 0,
+            OpeningCharacterMatch = 1,
+            ClosingCharacterMatch = 2,
+        }
+
         public SelfClosingPair(char opening, char closing)
         {
             OpeningChar = opening;
@@ -15,5 +26,15 @@ public SelfClosingPair(char opening, char closing)
         /// True if <see cref="OpeningChar"/> is the same as <see cref="ClosingChar"/>.
         /// </summary>
         public bool IsSymetric => OpeningChar == ClosingChar;
+
+        public bool Equals(SelfClosingPair other) => other?.OpeningChar == OpeningChar &&
+                                                     other.ClosingChar == ClosingChar;
+
+        public override bool Equals(object obj)
+        {
+            return obj is SelfClosingPair scp && Equals(scp);
+        }
+
+        public override int GetHashCode() => HashCode.Compute(OpeningChar, ClosingChar);
     }
 }

Rubberduck.Core/AutoComplete/Service/SelfClosingPairCompletionService.cs

@@ -12,18 +12,25 @@ namespace Rubberduck.AutoComplete.Service
 {
     public class SelfClosingPairCompletionService
     {
+        /*
+         // note: this works... but the VBE makes an annoying DING! when the command isn't available.
+         // todo: implement our own intellisense, then uncomment this code.
         private readonly IShowIntelliSenseCommand _showIntelliSense;
 
         public SelfClosingPairCompletionService(IShowIntelliSenseCommand showIntelliSense)
         {
             _showIntelliSense = showIntelliSense;
         }
+        */
 
-        public CodeString Execute(SelfClosingPair pair, CodeString original, char input)
+        public bool Execute(SelfClosingPair pair, CodeString original, char input, out CodeString result)
         {
+            result = null;
+
             var previousCharIsClosingChar =
                 original.CaretPosition.StartColumn > 0 &&
                 original.CaretLine[original.CaretPosition.StartColumn - 1] == pair.ClosingChar;
+
             var nextCharIsClosingChar =
                 original.CaretPosition.StartColumn < original.CaretLine.Length &&
                 original.CaretLine[original.CaretPosition.StartColumn] == pair.ClosingChar;
@@ -33,49 +40,45 @@ public CodeString Execute(SelfClosingPair pair, CodeString original, char input)
                 previousCharIsClosingChar && !nextCharIsClosingChar
                 || original.IsComment || (original.IsInsideStringLiteral && !nextCharIsClosingChar))
             {
-                return null;
+                return false;
             }
 
             if (input == pair.OpeningChar)
             {
-                var result = HandleOpeningChar(pair, original);
-                return result;
+                return HandleOpeningChar(pair, original, out result);
             }
-
+            
             if (input == pair.ClosingChar)
             {
-                return HandleClosingChar(pair, original);
+                return HandleClosingChar(pair, original, out result);
             }
 
             if (input == '\b')
             {
-                return Execute(pair, original, Keys.Back);
+                return Execute(pair, original, Keys.Back, out result);
             }
 
-            return null;
+            return false;
         }
 
-        public CodeString Execute(SelfClosingPair pair, CodeString original, Keys input)
+        public bool Execute(SelfClosingPair pair, CodeString original, Keys input, out CodeString result)
         {
+            result = null;
             if (original.IsComment)
             {
-                return null;
+                // not handling backspace in comments
+                return false;
             }
 
-            if (input == Keys.Back)
-            {
-                return HandleBackspace(pair, original);
-            }
-
-            return null;
+            return input == Keys.Back && HandleBackspace(pair, original, out result);
         }
 
-        private CodeString HandleOpeningChar(SelfClosingPair pair, CodeString original)
+        private bool HandleOpeningChar(SelfClosingPair pair, CodeString original, out CodeString result)
         {
             var nextPosition = original.CaretPosition.ShiftRight();
             var autoCode = new string(new[] { pair.OpeningChar, pair.ClosingChar });
             var lines = original.Lines;
-            var line = lines[original.CaretPosition.StartLine];
+            var line = original.CaretLine;
 
             string newCode;
             if (string.IsNullOrEmpty(line))
@@ -94,14 +97,17 @@ private CodeString HandleOpeningChar(SelfClosingPair pair, CodeString original)
             }
             lines[original.CaretPosition.StartLine] = newCode;
 
-            return new CodeString(string.Join("\r\n", lines), nextPosition, new Selection(original.SnippetPosition.StartLine, 1, original.SnippetPosition.EndLine, 1));
+            result = new CodeString(string.Join("\r\n", lines), nextPosition, new Selection(original.SnippetPosition.StartLine, 1, original.SnippetPosition.EndLine, 1));
+            return true;
         }
 
-        private CodeString HandleClosingChar(SelfClosingPair pair, CodeString original)
+        private bool HandleClosingChar(SelfClosingPair pair, CodeString original, out CodeString result)
         {
+            result = null;
             if (pair.IsSymetric)
             {
-                return null;
+                // a symetric pair would have already been handled with the opening character.
+                return false;
             }
 
             var nextIsClosingChar = original.CaretLine.Length > original.CaretCharIndex &&  
@@ -111,26 +117,24 @@ private CodeString HandleClosingChar(SelfClosingPair pair, CodeString original)
                 var nextPosition = original.CaretPosition.ShiftRight();
                 var newCode = original.Code;
 
-                return new CodeString(newCode, nextPosition, new Selection(original.SnippetPosition.StartLine, 1, original.SnippetPosition.EndLine, 1));
+                result = new CodeString(newCode, nextPosition, new Selection(original.SnippetPosition.StartLine, 1, original.SnippetPosition.EndLine, 1));
+                return true;
             }
-            return null;
-        }
 
-        private CodeString HandleBackspace(SelfClosingPair pair, CodeString original)
-        {
-            return DeleteMatchingTokens(pair, original);
+            return false;
         }
 
-        private CodeString DeleteMatchingTokens(SelfClosingPair pair, CodeString original)
+        private bool HandleBackspace(SelfClosingPair pair, CodeString original, out CodeString result)
         {
+            result = null;
             var position = original.CaretPosition;
             var lines = original.Lines;
 
             var line = lines[original.CaretPosition.StartLine];
             if (line.Length == 0)
             {
                 // nothing to delete at caret position... bail out.
-                return null;
+                return false;
             }
 
             var previous = Math.Max(0, position.StartColumn - 1);
@@ -146,24 +150,25 @@ private CodeString DeleteMatchingTokens(SelfClosingPair pair, CodeString origina
                 if (line.Length == 2)
                 {
                     // entire line consists in the self-closing pair itself.
-                    return new CodeString(string.Empty, default, Selection.Empty.ShiftRight());
+                    result = new CodeString(string.Empty, default, Selection.Empty.ShiftRight());
                 }
 
                 // simple case; caret is between the opening and closing chars - remove both.
                 lines[original.CaretPosition.StartLine] = line.Remove(previous, 2);
-                return new CodeString(string.Join("\r\n", lines), original.CaretPosition.ShiftLeft(), original.SnippetPosition);
+                result = new CodeString(string.Join("\r\n", lines), original.CaretPosition.ShiftLeft(), original.SnippetPosition);
             }
 
             if (previous < line.Length - 1 && previousChar == pair.OpeningChar)
             {
-                return DeleteMatchingTokensMultiline(pair, original);
+                return DeleteMatchingTokensMultiline(pair, original, out result);
             }
 
-            return null;
+            return result != null;
         }
 
-        private CodeString DeleteMatchingTokensMultiline(SelfClosingPair pair, CodeString original)
+        private bool DeleteMatchingTokensMultiline(SelfClosingPair pair, CodeString original, out CodeString result)
         {
+            result = null;
             var position = original.CaretPosition;
             var lines = original.Lines;
             var line = lines[original.CaretPosition.StartLine];
@@ -177,7 +182,7 @@ private CodeString DeleteMatchingTokensMultiline(SelfClosingPair pair, CodeStrin
             if (closingTokenPosition == default)
             {
                 // could not locate the closing token... bail out.
-                return null;
+                return false;
             }
 
             var closingLine = lines[closingTokenPosition.EndLine].Remove(closingTokenPosition.StartColumn, 1);
@@ -243,8 +248,9 @@ private CodeString DeleteMatchingTokensMultiline(SelfClosingPair pair, CodeStrin
             // remove any dangling empty lines...
             lines = lines.Where((x, i) => i <= position.StartLine || !string.IsNullOrWhiteSpace(x)).ToArray();
 
-            return new CodeString(string.Join("\r\n", lines), finalCaretPosition,
+            result = new CodeString(string.Join("\r\n", lines), finalCaretPosition,
                 new Selection(original.SnippetPosition.StartLine, 1, original.SnippetPosition.EndLine, 1));
+            return true;
         }
 
         private static Selection HandleBackspaceContinuations(string[] nonEmptyLines, Selection finalCaretPosition)