Merge branch 'next' of https://github.com/rubberduck-vba/Rubberduck into Fix4694

bclothier · bclothier · commit e3d276f6b288 · 2019-02-13T07:07:16.000-06:00
# Conflicts:
#	Rubberduck.Main/Root/RubberduckIoCInstaller.cs
diff --git a/Rubberduck.Core/AutoComplete/AutoCompleteHandlerBase.cs b/Rubberduck.Core/AutoComplete/AutoCompleteHandlerBase.cs
@@ -5,6 +5,9 @@
 
 namespace Rubberduck.AutoComplete
 {
+    /// <summary>
+    /// A base class/interface for AC services / "handlers".
+    /// </summary>
     public abstract class AutoCompleteHandlerBase
     {
         protected AutoCompleteHandlerBase(ICodePaneHandler pane)
@@ -14,6 +17,13 @@ protected AutoCompleteHandlerBase(ICodePaneHandler pane)
 
         protected ICodePaneHandler CodePaneHandler { get; }
 
+        /// <summary>
+        /// A method that returns <c>false</c> if the input isn't handled, <c>true</c> if it is.
+        /// </summary>
+        /// <param name="e">The autocompletion event info</param>
+        /// <param name="settings">The current AC settings</param>
+        /// <param name="result">If handled, the resulting <c>CodeString</c></param>
+        /// <returns></returns>
         public abstract bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settings, out CodeString result);
     }
 }
diff --git a/Rubberduck.Core/AutoComplete/AutoCompleteService.cs b/Rubberduck.Core/AutoComplete/AutoCompleteService.cs
@@ -5,8 +5,12 @@
 using Rubberduck.Settings;
 using Rubberduck.VBEditor.Events;
 
-namespace Rubberduck.AutoComplete.Service
+namespace Rubberduck.AutoComplete
 {
+    /// <summary>
+    /// A service responsible for dispatching CodePane work to more specialized autocompletion services.
+    /// Handles changes in configuration settings.
+    /// </summary>
     public class AutoCompleteService : IDisposable
     {
         private static readonly ILogger Logger = LogManager.GetCurrentClassLogger();
@@ -151,6 +155,7 @@ private bool TryHandle(AutoCompleteEventArgs e, AutoCompleteHandlerBase handler)
                     return false;
                 }
 
+                Logger.Debug($"Keypress was handled by {handler.GetType().Name}.");
                 e.Handled = true;
                 return true;
 
@@ -169,7 +174,8 @@ public void Dispose()
         }
 
         private bool _isDisposed;
-        protected virtual void Dispose(bool disposing)
+
+        private void Dispose(bool disposing)
         {
             if (_isDisposed || !disposing)
             {
diff --git a/Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPair.cs b/Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPair.cs
@@ -1,7 +1,7 @@
-﻿using Rubberduck.VBEditor;
-using System;
+﻿using System;
+using Rubberduck.VBEditor;
 
-namespace Rubberduck.AutoComplete.Service
+namespace Rubberduck.AutoComplete.SelfClosingPairs
 {
     public class SelfClosingPair : IEquatable<SelfClosingPair>
     {
diff --git a/Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPairCompletionService.cs b/Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPairCompletionService.cs
@@ -8,7 +8,7 @@
 using Rubberduck.Parsing.VBA.Parsing;
 using Rubberduck.VBEditor;
 
-namespace Rubberduck.AutoComplete.Service
+namespace Rubberduck.AutoComplete.SelfClosingPairs
 {
     public class SelfClosingPairCompletionService
     {
diff --git a/Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPairHandler.cs b/Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPairHandler.cs
@@ -1,13 +1,16 @@
-﻿using System.Collections.Generic;
-using System.Diagnostics;
+﻿using System;
+using System.Collections.Generic;
 using System.Linq;
 using Rubberduck.Settings;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.Events;
 using Rubberduck.VBEditor.SourceCodeHandling;
 
-namespace Rubberduck.AutoComplete.Service
+namespace Rubberduck.AutoComplete.SelfClosingPairs
 {
+    /// <summary>
+    /// An AC handler that automatically closes certain specific "pairs" of characters, e.g. double quotes, or parentheses.
+    /// </summary>
     public class SelfClosingPairHandler : AutoCompleteHandlerBase
     {
         private const int MaximumLines = 25;
@@ -39,6 +42,7 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin
             result = null;
             if (!_scpInputLookup.TryGetValue(e.Character, out var pair) && e.Character != '\b')
             {
+                // not an interesting keypress.
                 return false;
             }
 
@@ -50,15 +54,25 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin
                 return false;
             }
 
+            if (!original.CaretPosition.IsSingleCharacter)
+            {
+                // here would be an opportunity to "wrap selection" with a SCP.
+                // todo: WrapSelectionWith(pair)?
+                result = null;
+                return false;
+            }
+
             if (pair != null)
             {
+                // found a SCP for the input key; see if we should handle it:
                 if (!HandleInternal(e, original, pair, out result))
                 {
                     return false;
                 }
             }
             else if (e.Character == '\b')
             {
+                // backspace - see if SCP logic needs to intervene:
                 foreach (var scp in _selfClosingPairs)
                 {
                     if (HandleInternal(e, original, scp, out result))
@@ -70,9 +84,11 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin
 
             if (result == null)
             {
+                // no meaningful output; let the input be handled by another handler, maybe.
                 return false;
             }
 
+            // 1-based selection span in the code pane starts at column 1 but really encompasses the entire line.
             var snippetPosition = new Selection(result.SnippetPosition.StartLine, 1, result.SnippetPosition.EndLine, 1);
             result = new CodeString(result.Code, result.CaretPosition, snippetPosition);
 
@@ -82,13 +98,6 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin
 
         private bool HandleInternal(AutoCompleteEventArgs e, CodeString original, SelfClosingPair pair, out CodeString result)
         {
-            if (!original.CaretPosition.IsSingleCharacter)
-            {
-                // todo: WrapSelectionWith(pair)?
-                result = null;
-                return false;
-            }
-
             // if executing the SCP against the original code yields no result, we need to bail out.
             if (!_scpService.Execute(pair, original, e.Character, out result))
             {
@@ -115,21 +124,34 @@ private bool HandleInternal(AutoCompleteEventArgs e, CodeString original, SelfCl
                 );
             }
 
+            if (original.CaretLine.EndsWith(" ") && 
+                string.Equals(original.CaretLine, prettified.CaretLine + " ", StringComparison.InvariantCultureIgnoreCase))
+            {
+                prettified = original;
+            }
+
             // if executing the SCP against the prettified code yields no result, we need to bail out.
             if (!_scpService.Execute(pair, prettified, e.Character, out result))
             {
                 return false;
             }
 
             var reprettified = CodePaneHandler.Prettify(e.Module, result);
-            if (pair.OpeningChar == '(' && e.Character == pair.OpeningChar && !reprettified.Equals(result))
+            if (pair.OpeningChar == '(' && e.Character == pair.OpeningChar)
             {
+                if (string.Equals(reprettified.Code, result.Code, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    e.Handled = true;
+                    result = reprettified;
+                    return true;
+                }
+
                 // VBE eats it. bail out but don't swallow the keypress.
                 e.Handled = false;
                 result = null;
                 return false;
             }
-            
+
             var currentLine = reprettified.Lines[reprettified.CaretPosition.StartLine];
             if (!string.IsNullOrWhiteSpace(currentLine) &&
                 currentLine.EndsWith(" ") &&
diff --git a/Rubberduck.Core/AutoComplete/ShowIntelliSenseCommand.cs b/Rubberduck.Core/AutoComplete/ShowIntelliSenseCommand.cs
@@ -3,7 +3,7 @@
 using Rubberduck.UI.Command;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
-namespace Rubberduck.AutoComplete.Service
+namespace Rubberduck.AutoComplete
 {
     public interface IShowIntelliSenseCommand
     {
diff --git a/Rubberduck.Core/AutoComplete/SmartConcat/SmartConcatenationHandler.cs b/Rubberduck.Core/AutoComplete/SmartConcat/SmartConcatenationHandler.cs
@@ -4,7 +4,7 @@
 using Rubberduck.VBEditor.Events;
 using Rubberduck.VBEditor.SourceCodeHandling;
 
-namespace Rubberduck.AutoComplete.Service
+namespace Rubberduck.AutoComplete.SmartConcat
 {
     /// <summary>
     /// Adds a line continuation when {ENTER} is pressed when inside a string literal.
diff --git a/Rubberduck.Core/Common/RubberduckHooks.cs b/Rubberduck.Core/Common/RubberduckHooks.cs
@@ -8,7 +8,6 @@
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.WindowsApi;
 using Rubberduck.AutoComplete;
-using Rubberduck.AutoComplete.Service;
 
 namespace Rubberduck.Common
 {
diff --git a/Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml b/Rubberduck.Core/UI/Settings/AutoCompleteSettings.xaml
@@ -130,6 +130,7 @@
                                        MaxNumber="{Binding Path=DataContext.ConcatMaxLinesMaxValue, RelativeSource={RelativeSource Self}}">
                     
                 </controls:NumberPicker>-->
+                <!--
                 <Label Margin="10" 
                        Content="{Resx ResxName=Rubberduck.Resources.Settings.AutoCompletesPage, Key=BlockCompletion}"
                        FontWeight="Bold" />
@@ -145,6 +146,7 @@
                           IsEnabled="{Binding EnableBlockCompletion}"
                           IsChecked="{Binding CompleteBlockOnTab}" 
                           Content="{Resx ResxName=Rubberduck.Resources.Settings.AutoCompletesPage, Key=CompleteBlockOnTab}" />
+                -->
             </StackPanel>
         </ScrollViewer>
     </Grid>
diff --git a/Rubberduck.Main/Root/RubberduckIoCInstaller.cs b/Rubberduck.Main/Root/RubberduckIoCInstaller.cs
@@ -11,7 +11,6 @@
 using Castle.MicroKernel.SubSystems.Configuration;
 using Castle.Windsor;
 using Rubberduck.AutoComplete;
-using Rubberduck.AutoComplete.Service;
 using Rubberduck.CodeAnalysis.CodeMetrics;
 using Rubberduck.ComClientLibrary.UnitTesting;
 using Rubberduck.Common;
diff --git a/Rubberduck.Parsing/Grammar/VBAParser.g4 b/Rubberduck.Parsing/Grammar/VBAParser.g4
@@ -579,7 +579,15 @@ subscript : (expression whiteSpace TO whiteSpace)? expression;
 
 unrestrictedIdentifier : identifier | statementKeyword | markerKeyword;
 legalLabelIdentifier : { !(new[]{DOEVENTS,END,CLOSE,ELSE,LOOP,NEXT,RANDOMIZE,REM,RESUME,RETURN,STOP,WEND}).Contains(_input.La(1))}? identifier | markerKeyword;
-identifier : typedIdentifier | untypedIdentifier;
+//The predicate in the following rule has been introduced to lessen the problem that VBA uses the same characters used as type hints in other syntactical constructs, 
+//e.g. in the bang notation (see withDictionaryAccessExpr). Generally, it is not legal to have an identifier or opening bracket follow immediately after a type hint.
+//The first part of the predicate tries to exclude these two situations. Unfortunately, predicates have to be at the start of a rule. So, an assumption about the number 
+//of tokens in the identifier is made. All untypedIdentifers not a foreignNames consist of exactly one token and a typedIdentifier is an untyped one followed by a typeHint,
+//again a single token. So, in the majority of situations, the third token is the token following the potential type hint. 
+//For foreignNames, no assumption can be made because they consist of a pair of brackets containing arbitrarily many tokens. 
+//That is why the second part of the predicate looks at the first character in order to determine whether the identifier is a foreignName. 
+identifier : {_input.La(3) != IDENTIFIER && _input.La(3) != L_SQUARE_BRACKET || _input.La(1) == L_SQUARE_BRACKET}? typedIdentifier 
+             | untypedIdentifier;
 untypedIdentifier : identifierValue;
 typedIdentifier : untypedIdentifier typeHint;
 identifierValue : IDENTIFIER | keyword | foreignName;
diff --git a/Rubberduck.Resources/RubberduckUI.Designer.cs b/Rubberduck.Resources/RubberduckUI.Designer.cs
diff --git a/Rubberduck.VBEEditor/SourceCodeHandling/ISourceCodeHandler.cs b/Rubberduck.VBEEditor/SourceCodeHandling/ISourceCodeHandler.cs
@@ -2,6 +2,9 @@
 
 namespace Rubberduck.VBEditor.SourceCodeHandling
 {
+    /// <summary>
+    /// An object that can rewrite a module's contents.
+    /// </summary>
     public interface ISourceCodeHandler : ISourceCodeProvider
     {
         /// <summary>
@@ -10,6 +13,9 @@ public interface ISourceCodeHandler : ISourceCodeProvider
         void SubstituteCode(QualifiedModuleName module, string newCode);
     }
 
+    /// <summary>
+    /// An object that can manipulate the code in a CodePane.
+    /// </summary>
     public interface ICodePaneHandler : ISourceCodeHandler
     {
         /// <summary>
diff --git a/RubberduckTests/AutoComplete/SelfClosingPairCompletionServiceTests.cs b/RubberduckTests/AutoComplete/SelfClosingPairCompletionServiceTests.cs
@@ -1,6 +1,6 @@
 ﻿using NUnit.Framework;
 using System.Windows.Forms;
-using Rubberduck.AutoComplete.Service;
+using Rubberduck.AutoComplete.SelfClosingPairs;
 using Rubberduck.VBEditor;
 
 namespace RubberduckTests.AutoComplete
diff --git a/RubberduckTests/AutoComplete/SelfClosingPairHandlerTests.cs b/RubberduckTests/AutoComplete/SelfClosingPairHandlerTests.cs
diff --git a/RubberduckTests/AutoComplete/SelfClosingPairTestInfo.cs b/RubberduckTests/AutoComplete/SelfClosingPairTestInfo.cs
diff --git a/RubberduckTests/AutoComplete/SmartConcatCompletionTests.cs b/RubberduckTests/AutoComplete/SmartConcatCompletionTests.cs
diff --git a/RubberduckTests/Grammar/VBAParserTests.cs b/RubberduckTests/Grammar/VBAParserTests.cs

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,9 @@`
`5`	`5`
`6`	`6`	`namespace Rubberduck.AutoComplete`
`7`	`7`	`{`
	`8`	`+ /// <summary>`
	`9`	`+ /// A base class/interface for AC services / "handlers".`
	`10`	`+ /// </summary>`
`8`	`11`	`public abstract class AutoCompleteHandlerBase`
`9`	`12`	`{`
`10`	`13`	`protected AutoCompleteHandlerBase(ICodePaneHandler pane)`
`@@ -14,6 +17,13 @@ protected AutoCompleteHandlerBase(ICodePaneHandler pane)`
`14`	`17`
`15`	`18`	`protected ICodePaneHandler CodePaneHandler { get; }`
`16`	`19`
	`20`	`+ /// <summary>`
	`21`	`+ /// A method that returns <c>false</c> if the input isn't handled, <c>true</c> if it is.`
	`22`	`+ /// </summary>`
	`23`	`+ /// <param name="e">The autocompletion event info</param>`
	`24`	`+ /// <param name="settings">The current AC settings</param>`
	`25`	`+ /// <param name="result">If handled, the resulting <c>CodeString</c></param>`
	`26`	`+ /// <returns></returns>`
`17`	`27`	`public abstract bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settings, out CodeString result);`
`18`	`28`	`}`
`19`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,12 @@`
`5`	`5`	`using Rubberduck.Settings;`
`6`	`6`	`using Rubberduck.VBEditor.Events;`
`7`	`7`
`8`		`-namespace Rubberduck.AutoComplete.Service`
	`8`	`+namespace Rubberduck.AutoComplete`
`9`	`9`	`{`
	`10`	`+ /// <summary>`
	`11`	`+ /// A service responsible for dispatching CodePane work to more specialized autocompletion services.`
	`12`	`+ /// Handles changes in configuration settings.`
	`13`	`+ /// </summary>`
`10`	`14`	`public class AutoCompleteService : IDisposable`
`11`	`15`	`{`
`12`	`16`	`private static readonly ILogger Logger = LogManager.GetCurrentClassLogger();`
`@@ -151,6 +155,7 @@ private bool TryHandle(AutoCompleteEventArgs e, AutoCompleteHandlerBase handler)`
`151`	`155`	`return false;`
`152`	`156`	`}`
`153`	`157`
	`158`	`+ Logger.Debug($"Keypress was handled by {handler.GetType().Name}.");`
`154`	`159`	`e.Handled = true;`
`155`	`160`	`return true;`
`156`	`161`
`@@ -169,7 +174,8 @@ public void Dispose()`
`169`	`174`	`}`
`170`	`175`
`171`	`176`	`private bool _isDisposed;`
`172`		`- protected virtual void Dispose(bool disposing)`
	`177`	`+`
	`178`	`+ private void Dispose(bool disposing)`
`173`	`179`	`{`
`174`	`180`	`if (_isDisposed \|\| !disposing)`
`175`	`181`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`		`-using Rubberduck.VBEditor;`
`2`		`-using System;`
	`1`	`+using System;`
	`2`	`+using Rubberduck.VBEditor;`
`3`	`3`
`4`		`-namespace Rubberduck.AutoComplete.Service`
	`4`	`+namespace Rubberduck.AutoComplete.SelfClosingPairs`
`5`	`5`	`{`
`6`	`6`	`public class SelfClosingPair : IEquatable<SelfClosingPair>`
`7`	`7`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`using Rubberduck.Parsing.VBA.Parsing;`
`9`	`9`	`using Rubberduck.VBEditor;`
`10`	`10`
`11`		`-namespace Rubberduck.AutoComplete.Service`
	`11`	`+namespace Rubberduck.AutoComplete.SelfClosingPairs`
`12`	`12`	`{`
`13`	`13`	`public class SelfClosingPairCompletionService`
`14`	`14`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,16 @@`
`1`		`-using System.Collections.Generic;`
`2`		`-using System.Diagnostics;`
	`1`	`+using System;`
	`2`	`+using System.Collections.Generic;`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using Rubberduck.Settings;`
`5`	`5`	`using Rubberduck.VBEditor;`
`6`	`6`	`using Rubberduck.VBEditor.Events;`
`7`	`7`	`using Rubberduck.VBEditor.SourceCodeHandling;`
`8`	`8`
`9`		`-namespace Rubberduck.AutoComplete.Service`
	`9`	`+namespace Rubberduck.AutoComplete.SelfClosingPairs`
`10`	`10`	`{`
	`11`	`+ /// <summary>`
	`12`	`+ /// An AC handler that automatically closes certain specific "pairs" of characters, e.g. double quotes, or parentheses.`
	`13`	`+ /// </summary>`
`11`	`14`	`public class SelfClosingPairHandler : AutoCompleteHandlerBase`
`12`	`15`	`{`
`13`	`16`	`private const int MaximumLines = 25;`
`@@ -39,6 +42,7 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin`
`39`	`42`	`result = null;`
`40`	`43`	`if (!_scpInputLookup.TryGetValue(e.Character, out var pair) && e.Character != '\b')`
`41`	`44`	`{`
	`45`	`+ // not an interesting keypress.`
`42`	`46`	`return false;`
`43`	`47`	`}`
`44`	`48`
`@@ -50,15 +54,25 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin`
`50`	`54`	`return false;`
`51`	`55`	`}`
`52`	`56`
	`57`	`+ if (!original.CaretPosition.IsSingleCharacter)`
	`58`	`+ {`
	`59`	`+ // here would be an opportunity to "wrap selection" with a SCP.`
	`60`	`+ // todo: WrapSelectionWith(pair)?`
	`61`	`+ result = null;`
	`62`	`+ return false;`
	`63`	`+ }`
	`64`	`+`
`53`	`65`	`if (pair != null)`
`54`	`66`	`{`
	`67`	`+ // found a SCP for the input key; see if we should handle it:`
`55`	`68`	`if (!HandleInternal(e, original, pair, out result))`
`56`	`69`	`{`
`57`	`70`	`return false;`
`58`	`71`	`}`
`59`	`72`	`}`
`60`	`73`	`else if (e.Character == '\b')`
`61`	`74`	`{`
	`75`	`+ // backspace - see if SCP logic needs to intervene:`
`62`	`76`	`foreach (var scp in _selfClosingPairs)`
`63`	`77`	`{`
`64`	`78`	`if (HandleInternal(e, original, scp, out result))`
`@@ -70,9 +84,11 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin`
`70`	`84`
`71`	`85`	`if (result == null)`
`72`	`86`	`{`
	`87`	`+ // no meaningful output; let the input be handled by another handler, maybe.`
`73`	`88`	`return false;`
`74`	`89`	`}`
`75`	`90`
	`91`	`+ // 1-based selection span in the code pane starts at column 1 but really encompasses the entire line.`
`76`	`92`	`var snippetPosition = new Selection(result.SnippetPosition.StartLine, 1, result.SnippetPosition.EndLine, 1);`
`77`	`93`	`result = new CodeString(result.Code, result.CaretPosition, snippetPosition);`
`78`	`94`
`@@ -82,13 +98,6 @@ public override bool Handle(AutoCompleteEventArgs e, AutoCompleteSettings settin`
`82`	`98`
`83`	`99`	`private bool HandleInternal(AutoCompleteEventArgs e, CodeString original, SelfClosingPair pair, out CodeString result)`
`84`	`100`	`{`
`85`		`- if (!original.CaretPosition.IsSingleCharacter)`
`86`		`- {`
`87`		`- // todo: WrapSelectionWith(pair)?`
`88`		`- result = null;`
`89`		`- return false;`
`90`		`- }`
`91`		`-`
`92`	`101`	`// if executing the SCP against the original code yields no result, we need to bail out.`
`93`	`102`	`if (!_scpService.Execute(pair, original, e.Character, out result))`
`94`	`103`	`{`
`@@ -115,21 +124,34 @@ private bool HandleInternal(AutoCompleteEventArgs e, CodeString original, SelfCl`
`115`	`124`	`);`
`116`	`125`	`}`
`117`	`126`
	`127`	`+ if (original.CaretLine.EndsWith(" ") &&`
	`128`	`+ string.Equals(original.CaretLine, prettified.CaretLine + " ", StringComparison.InvariantCultureIgnoreCase))`
	`129`	`+ {`
	`130`	`+ prettified = original;`
	`131`	`+ }`
	`132`	`+`
`118`	`133`	`// if executing the SCP against the prettified code yields no result, we need to bail out.`
`119`	`134`	`if (!_scpService.Execute(pair, prettified, e.Character, out result))`
`120`	`135`	`{`
`121`	`136`	`return false;`
`122`	`137`	`}`
`123`	`138`
`124`	`139`	`var reprettified = CodePaneHandler.Prettify(e.Module, result);`
`125`		`- if (pair.OpeningChar == '(' && e.Character == pair.OpeningChar && !reprettified.Equals(result))`
	`140`	`+ if (pair.OpeningChar == '(' && e.Character == pair.OpeningChar)`
`126`	`141`	`{`
	`142`	`+ if (string.Equals(reprettified.Code, result.Code, StringComparison.InvariantCultureIgnoreCase))`
	`143`	`+ {`
	`144`	`+ e.Handled = true;`
	`145`	`+ result = reprettified;`
	`146`	`+ return true;`
	`147`	`+ }`
	`148`	`+`
`127`	`149`	`// VBE eats it. bail out but don't swallow the keypress.`
`128`	`150`	`e.Handled = false;`
`129`	`151`	`result = null;`
`130`	`152`	`return false;`
`131`	`153`	`}`
`132`		`-`
	`154`	`+`
`133`	`155`	`var currentLine = reprettified.Lines[reprettified.CaretPosition.StartLine];`
`134`	`156`	`if (!string.IsNullOrWhiteSpace(currentLine) &&`
`135`	`157`	`currentLine.EndsWith(" ") &&`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`using Rubberduck.UI.Command;`
`4`	`4`	`using Rubberduck.VBEditor.SafeComWrappers.Abstract;`
`5`	`5`
`6`		`-namespace Rubberduck.AutoComplete.Service`
	`6`	`+namespace Rubberduck.AutoComplete`
`7`	`7`	`{`
`8`	`8`	`public interface IShowIntelliSenseCommand`
`9`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`using Rubberduck.VBEditor.Events;`
`5`	`5`	`using Rubberduck.VBEditor.SourceCodeHandling;`
`6`	`6`
`7`		`-namespace Rubberduck.AutoComplete.Service`
	`7`	`+namespace Rubberduck.AutoComplete.SmartConcat`
`8`	`8`	`{`
`9`	`9`	`/// <summary>`
`10`	`10`	`/// Adds a line continuation when {ENTER} is pressed when inside a string literal.`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@`
`8`	`8`	`using Rubberduck.VBEditor.SafeComWrappers.Abstract;`
`9`	`9`	`using Rubberduck.VBEditor.WindowsApi;`
`10`	`10`	`using Rubberduck.AutoComplete;`
`11`		`-using Rubberduck.AutoComplete.Service;`
`12`	`11`
`13`	`12`	`namespace Rubberduck.Common`
`14`	`13`	`{`