Merge pull request #3368 from bclothier/next

No user-visible functionality change. Improved extracting `Selection` out of a `ParserRuleContext`; added `Selection`-involving extension methods.

Author: retailcoder

Rubberduck.Parsing/ParserRuleContextExtensions.cs

@@ -13,14 +13,15 @@ public static Selection GetSelection(this ParserRuleContext context)
             // if we have an empty module, `Stop` is null
             if (context?.Stop == null) { return Selection.Home; }
 
-            // ANTLR indexes are 0-based, but VBE's are 1-based.
+            // ANTLR indexes for columns are 0-based, but VBE's are 1-based.
+            // ANTLR lines and VBE's lines are both 1-based
             // 1 is the default value that will select all lines. Replace zeroes with ones.
             // See also: https://msdn.microsoft.com/en-us/library/aa443952(v=vs.60).aspx
 
             return new Selection(context.Start.Line == 0 ? 1 : context.Start.Line,
                                  context.Start.Column + 1,
-                                 context.Stop.Line == 0 ? 1 : context.Stop.Line,
-                                 context.Stop.Column + context.Stop.Text.Length + 1);
+                                 context.Stop.Line == 0 ? 1 : context.Stop.EndLine(),
+                                 context.Stop.EndColumn() + 1);
         }
 
         //This set of overloads returns the selection for the entire procedure statement body, i.e. Public Function Foo(bar As String) As String

Rubberduck.Parsing/Rubberduck.Parsing.csproj

@@ -202,6 +202,7 @@
     <Compile Include="ComReflection\ComProject.cs" />
     <Compile Include="Rewriter\IModuleRewriter.cs" />
     <Compile Include="PreProcessing\VBAPreprocessorVisitor.cs" />
+    <Compile Include="SelectionExtensions.cs" />
     <Compile Include="SymbolList.cs" />
     <Compile Include="Symbols\AliasDeclaration.cs" />
     <Compile Include="Symbols\DeclarationFinderFactory.cs" />
@@ -348,6 +349,7 @@
     <Compile Include="Symbols\ConstantDeclaration.cs" />
     <Compile Include="ComReflection\XmlPersistableDeclarations.cs" />
     <Compile Include="Symbols\UnboundMemberDeclaration.cs" />
+    <Compile Include="TokenExtensions.cs" />
     <Compile Include="VBA\AttributeListener.cs" />
     <Compile Include="VBA\AttributeParser.cs" />
     <Compile Include="VBA\Attributes.cs" />

Rubberduck.Parsing/SelectionExtensions.cs

@@ -0,0 +1,55 @@
+using Antlr4.Runtime;
+using Rubberduck.VBEditor;
+using System;
+
+namespace Rubberduck.Parsing
+{
+    /// <summary>
+    /// Provide extensions on selections & contexts/tokens
+    /// to assist in validating whether a selection contains
+    /// a given context or a token. 
+    /// </summary>
+    public static class SelectionExtensions
+    {
+        /// <summary>
+        /// Validates whether a token is contained within a given Selection
+        /// </summary>
+        /// <param name="selection">One-based selection, usually from CodePane.Selection</param>
+        /// <param name="token">An individual token within a module's parse tree</param>
+        /// <returns>Boolean with true indicating that token is within the selection</returns>
+        public static bool Contains(this Selection selection, IToken token)
+        {
+            return
+                (((selection.StartLine == token.Line) && (selection.StartColumn - 1) <= token.Column) 
+                    || (selection.StartLine < token.Line))
+             && (((selection.EndLine == token.EndLine()) && (selection.EndColumn - 1) >= (token.EndColumn())) 
+                    || (selection.EndLine > token.EndLine()));
+        }
+
+        /// <summary>
+        /// Validates whether a context is contained within a given Selection
+        /// </summary>
+        /// <param name="selection">One-based selection, usually from CodePane.Selection</param>
+        /// <param name="context">A context which contains several tokens within a module's parse tree</param>
+        /// <returns>Boolean with true indicating that context is within the selection</returns>
+        public static bool Contains(this Selection selection, ParserRuleContext context)
+        {
+            return
+               (((selection.StartLine == context.Start.Line) && (selection.StartColumn - 1) <= context.Start.Column) 
+                    || (selection.StartLine < context.Start.Line))
+            && (((selection.EndLine == context.Stop.EndLine()) && (selection.EndColumn - 1) >= (context.Stop.EndColumn())) 
+                    || (selection.EndLine > context.Stop.EndLine()));
+        }
+
+        /// <summary>
+        /// Convenience method for validating that a selection is inside a specified parser rule context.
+        /// </summary>
+        /// <param name="selection">The selection that should be contained within the ParserRuleContext</param>
+        /// <param name="context">The containing ParserRuleContext</param>
+        /// <returns>Boolean with true indicating that the selection is inside the given context</returns>
+        public static bool IsContainedIn(this Selection selection, ParserRuleContext context)
+        {
+            return context.GetSelection().Contains(selection);
+        }
+    }
+}

Rubberduck.Parsing/TokenExtensions.cs

@@ -0,0 +1,50 @@
+using System;
+using Antlr4.Runtime;
+
+namespace Rubberduck.Parsing
+{
+    public static class TokenExtensions
+    {
+        /// <summary>
+        /// Obtain the actual last column the token occupies. Because a token can be spread 
+        /// across multiple lines with line continuations it is necessary to do some work 
+        /// to determine the token's actual ending column.
+        /// Whitespace and newline should be preserved within the token.
+        /// </summary>
+        /// <param name="token">The last token within a given context to test</param>
+        /// <returns>Zero-based column position</returns>
+        public static int EndColumn(this IToken token)
+        {
+            if (token.Text.Contains(Environment.NewLine))
+            {
+                var splitStrings = token.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
+                var lastOccupiedLine = splitStrings[splitStrings.Length - 1];
+
+                return lastOccupiedLine.Length;
+            }
+            else
+            {
+                return token.Column + token.Text.Length;
+            }
+        }
+
+        /// <summary>
+        /// Obtain the actual last line token occupies. Typically it is same as token.Line but 
+        /// when it contains line continuation and is spread across lines, extra newlines are
+        /// counted and added.
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns>One-based line position</returns>
+        public static int EndLine(this IToken token)
+        {
+            if (token.Text.Contains(Environment.NewLine))
+            {
+                var splitStrings = token.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
+
+                return token.Line + (splitStrings.Length - 1);
+            }
+
+            return token.Line;
+        }
+    }
+}