Merge branch 'rubberduck-vba/next' into next

Author: BZngr

Rubberduck.CodeAnalysis/Inspections/Concrete/MissingModuleAnnotationInspection.cs

@@ -17,7 +17,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// do not have a Rubberduck annotation corresponding to the hidden VB attribute.
     /// </why>
     /// <example hasResult="true">
-    /// <module name="MyModule" type="Class Module">
+    /// <module name="MyModule" type="Predeclared Class">
     /// <![CDATA[
     /// Attribute VB_PredeclaredId = True
     /// Option Explicit
@@ -26,7 +26,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// </module>
     /// </example>
     /// <example hasResult="false">
-    /// <module name="MyModule" type="Class Module">
+    /// <module name="MyModule" type="Predeclared Class">
     /// <![CDATA[
     /// Attribute VB_PredeclaredId = True
     /// '@PredeclaredId
@@ -92,4 +92,4 @@ protected override string ResultDescription(Declaration declaration, (string Att
                 string.Join(", ", properties.AttributeValues));
         }
     }
-}
+}

Rubberduck.Refactorings/Common/CodeBuilder.cs

@@ -1,4 +1,5 @@
-using Rubberduck.Parsing.Grammar;
+using Rubberduck.Common;
+using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using System;
 using System.Collections.Generic;
@@ -11,19 +12,13 @@ public interface ICodeBuilder
         /// <summary>
         /// Returns ModuleBodyElementDeclaration signature with an ImprovedArgument list
         /// </summary>
-        /// <param name="declaration"></param>
-        /// <returns></returns>
         string ImprovedFullMemberSignature(ModuleBodyElementDeclaration declaration);
 
         /// <summary>
         /// Returns a ModuleBodyElementDeclaration block
         /// with an ImprovedArgument List
         /// </summary>
-        /// <param name="declaration"></param>
         /// <param name="content">Main body content/logic of the member</param>
-        /// <param name="accessibility"></param>
-        /// <param name="newIdentifier"></param>
-        /// <returns></returns>
         string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration,
                                             string content = null,
                                             string accessibility = null,
@@ -34,19 +29,14 @@ string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration,
         /// 1. Explicitly declares Property Let\Set value parameter as ByVal
         /// 2. Ensures UserDefined Type parameters are declared either explicitly or implicitly as ByRef
         /// </summary>
-        /// <param name="declaration"></param>
-        /// <returns></returns>
         string ImprovedArgumentList(ModuleBodyElementDeclaration declaration);
 
         /// <summary>
         /// Generates a Property Get codeblock based on the prototype declaration 
         /// </summary>
         /// <param name="prototype">VariableDeclaration or UserDefinedTypeMember</param>
-        /// <param name="propertyIdentifier"></param>
-        /// <param name="accessibility"></param>
         /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
-        /// <param name="parameterIdentifier">Defaults to 'value' unless otherwise specified</param>
-        /// <returns></returns>
+        /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertyGetCodeBlock(Declaration prototype,
                                             string propertyIdentifier,
                                             out string codeBlock,
@@ -57,11 +47,8 @@ bool TryBuildPropertyGetCodeBlock(Declaration prototype,
         /// Generates a Property Let codeblock based on the prototype declaration 
         /// </summary>
         /// <param name="prototype">VariableDeclaration or UserDefinedTypeMember</param>
-        /// <param name="propertyIdentifier"></param>
-        /// <param name="accessibility"></param>
-        /// <param name="content">Membmer body content.  Formatting is the responsibility of the caller</param>
-        /// <param name="parameterIdentifier">Defaults to 'value' unless otherwise specified</param>
-        /// <returns></returns>
+        /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
+        /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertyLetCodeBlock(Declaration prototype,
                                             string propertyIdentifier,
                                             out string codeBlock,
@@ -73,21 +60,26 @@ bool TryBuildPropertyLetCodeBlock(Declaration prototype,
         /// Generates a Property Set codeblock based on the prototype declaration 
         /// </summary>
         /// <param name="prototype">VariableDeclaration or UserDefinedTypeMember</param>
-        /// <param name="propertyIdentifier"></param>
-        /// <param name="accessibility"></param>
-        /// <param name="content">Membmer body content.  Formatting is the responsibility of the caller</param>
-        /// <param name="parameterIdentifier">Defaults to 'value' unless otherwise specified</param>
-        /// <returns></returns>
+        /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
+        /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertySetCodeBlock(Declaration prototype,
                                             string propertyIdentifier,
                                             out string codeBlock,
                                             string accessibility = null,
                                             string content = null,
                                             string parameterIdentifier = null);
+        /// <summary>
+        /// Generates a default RHS property parameter IdentifierName
+        /// </summary>
+        /// <param name="propertyIdentifier">Let/Set Property IdentifierName</param>
+        string BuildPropertyRhsParameterName(string propertyIdentifier);
     }
 
     public class CodeBuilder : ICodeBuilder
     {
+        public string BuildPropertyRhsParameterName(string propertyIdentifier)
+            => string.Format(Resources.Refactorings.Refactorings.CodeBuilder_DefaultPropertyRHSParamFormat, propertyIdentifier.ToLowerCaseFirstLetter());
+
         public string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration, 
                                         string content = null, 
                                         string accessibility = null, 
@@ -127,7 +119,7 @@ private bool TryBuildPropertyBlockFromTarget<T>(T prototype, DeclarationType let
                 return false;
             }
 
-            var propertyValueParam = parameterIdentifier ?? Resources.RubberduckUI.EncapsulateField_DefaultPropertyParameter;
+            var propertyValueParam = parameterIdentifier ?? BuildPropertyRhsParameterName(propertyIdentifier);
 
             var asType = prototype.IsArray
                 ? $"{Tokens.Variant}"

Rubberduck.Refactorings/Common/IModuleRewriterExtensions.cs

@@ -0,0 +1,108 @@
+using Antlr4.Runtime;
+using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Refactorings.Common
+{
+    public static class IModuleRewriterExtensions
+    {
+        /// <summary>
+        /// Removes variable declaration and subsequent <c>VBAParser.EndOfStatementContext</c>
+        /// depending on the <paramref name="removeEndOfStmtContext"/> flag.
+        /// This function is intended to be called only once per rewriter within a given <c>ModuleRewriteSession</c>.  
+        /// </summary>
+        /// <remarks>
+        /// Calling this function with <paramref name="removeEndOfStmtContext"/> defaulted to <c>true</c>
+        /// avoids leaving residual newlines between the deleted declaration and the next declaration. 
+        /// The one-time call constraint is required for scenarios where variables to delete are declared in a list.  Specifically,
+        /// the use case where all the variables in the list are to be removed.
+        /// If the variables to remove are not declared in a list, then this function can be called multiple times.
+        /// </remarks>
+        public static void RemoveVariables(this IModuleRewriter rewriter, IEnumerable<VariableDeclaration> toRemove, bool removeEndOfStmtContext = true)
+        {
+            if (!toRemove.Any())
+            {
+                return;
+            }
+
+            var fieldsToDeleteByListContext = toRemove.Distinct()
+                .ToLookup(f => f.Context.GetAncestor<VBAParser.VariableListStmtContext>());
+
+            foreach (var fieldsToDelete in fieldsToDeleteByListContext)
+            {
+                var variableList = fieldsToDelete.Key.children.OfType<VBAParser.VariableSubStmtContext>();
+
+                if (variableList.Count() == fieldsToDelete.Count())
+                {
+                    if (fieldsToDelete.First().ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Module))
+                    {
+                        rewriter.RemoveDeclarationContext<VBAParser.ModuleDeclarationsElementContext>(fieldsToDelete.First(), removeEndOfStmtContext);
+                    }
+                    else
+                    {
+                        rewriter.RemoveDeclarationContext<VBAParser.BlockStmtContext>(fieldsToDelete.First(), removeEndOfStmtContext);
+                    }
+                    continue;
+                }
+
+                foreach (var target in fieldsToDelete)
+                {
+                    rewriter.Remove(target);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Removes a member declaration and subsequent <c>VBAParser.EndOfStatementContext</c>
+        /// depending on the <paramref name="removeEndOfStmtContext"/> flag.
+        /// </summary>
+        /// <remarks>
+        /// Calling this function with <paramref name="removeEndOfStmtContext"/> defaulted to <c>true</c>
+        /// avoids leaving residual newlines between the deleted declaration and the next declaration. 
+        /// </remarks>
+        public static void RemoveMember(this IModuleRewriter rewriter, ModuleBodyElementDeclaration target, bool removeEndOfStmtContext = true)
+        {
+            RemoveMembers(rewriter, new ModuleBodyElementDeclaration[] { target }, removeEndOfStmtContext);
+        }
+
+        /// <summary>
+        /// Removes member declarations and subsequent <c>VBAParser.EndOfStatementContext</c>
+        /// depending on the <paramref name="removeEndOfStmtContext"/> flag.
+        /// </summary>
+        /// <remarks>
+        /// Calling this function with <paramref name="removeEndOfStmtContext"/> defaulted to <c>true</c>
+        /// avoids leaving residual newlines between the deleted declaration and the next declaration. 
+        /// </remarks>
+        public static void RemoveMembers(this IModuleRewriter rewriter, IEnumerable<ModuleBodyElementDeclaration> toRemove, bool removeEndOfStmtContext = true)
+        {
+            if (!toRemove.Any())
+            {
+                return;
+            }
+
+            foreach (var member in toRemove)
+            {
+                rewriter.RemoveDeclarationContext<VBAParser.ModuleBodyElementContext>(member, removeEndOfStmtContext);
+            }
+        }
+
+        private static void RemoveDeclarationContext<T>(this IModuleRewriter rewriter, Declaration declaration, bool removeEndOfStmtContext = true) where T : ParserRuleContext
+        {
+            if (!declaration.Context.TryGetAncestor<T>(out var elementContext))
+            {
+                throw new ArgumentException();
+            }
+
+            rewriter.Remove(elementContext);
+            if (removeEndOfStmtContext && elementContext.TryGetFollowingContext<VBAParser.EndOfStatementContext>(out var nextContext))
+            {
+                rewriter.Remove(nextContext);
+            }
+        }
+    }
+}

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs

@@ -2,7 +2,6 @@
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.Common;
-using Rubberduck.Refactorings.EncapsulateField.Extensions;
 using Rubberduck.VBEditor;
 using System;
 using System.Collections.Generic;
@@ -16,12 +15,14 @@ public class EncapsulateFieldElementsBuilder
         private readonly IDeclarationFinderProvider _declarationFinderProvider;
         private QualifiedModuleName _targetQMN;
         private string _defaultObjectStateUDTTypeName;
+        private ICodeBuilder _codeBuilder;
 
         public EncapsulateFieldElementsBuilder(IDeclarationFinderProvider declarationFinderProvider, QualifiedModuleName targetQMN)
         {
             _declarationFinderProvider = declarationFinderProvider;
             _targetQMN = targetQMN;
             _defaultObjectStateUDTTypeName = $"T{_targetQMN.ComponentName}";
+            _codeBuilder = new CodeBuilder();
             CreateRefactoringElements();
         }
 
@@ -110,7 +111,7 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate
             if (target.IsUserDefinedType())
             {
                 var udtValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedType);
-                var udtField = new UserDefinedTypeCandidate(target, udtValidator) as IUserDefinedTypeCandidate;
+                var udtField = new UserDefinedTypeCandidate(target, udtValidator, _codeBuilder.BuildPropertyRhsParameterName) as IUserDefinedTypeCandidate;
 
                 (Declaration udtDeclaration, IEnumerable<Declaration> udtMembers) = GetUDTAndMembersForField(udtField);
 
@@ -125,7 +126,7 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate
                     {
                         udtMemberValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMemberArray);
                     }
-                    var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField) as IUserDefinedTypeMemberCandidate;
+                    var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField, _codeBuilder.BuildPropertyRhsParameterName) as IUserDefinedTypeMemberCandidate;
 
                     udtField.AddMember(candidateUDTMember);
                 }
@@ -141,10 +142,10 @@ private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidate
             }
             else if (target.IsArray)
             {
-                return new ArrayCandidate(target, validator);
+                return new ArrayCandidate(target, validator, _codeBuilder.BuildPropertyRhsParameterName);
             }
 
-            var candidate = new EncapsulateFieldCandidate(target, validator);
+            var candidate = new EncapsulateFieldCandidate(target, validator, _codeBuilder.BuildPropertyRhsParameterName);
             return candidate;
         }
 

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoring.cs

@@ -6,7 +6,6 @@
 using Rubberduck.VBEditor;
 using Rubberduck.SmartIndenter;
 using Rubberduck.VBEditor.Utility;
-using System;
 
 namespace Rubberduck.Refactorings.EncapsulateField
 {
@@ -91,26 +90,25 @@ protected override EncapsulateFieldModel InitializeModel(Declaration target)
 
         protected override void RefactorImpl(EncapsulateFieldModel model)
         {
-            var refactorRewriteSession = new EncapsulateFieldRewriteSession(_rewritingManager.CheckOutCodePaneSession()) as IEncapsulateFieldRewriteSession;
+            var executableRewriteSession = _rewritingManager.CheckOutCodePaneSession();
 
-            refactorRewriteSession = RefactorRewrite(model, refactorRewriteSession);
+            RefactorRewrite(model, executableRewriteSession);
 
-            if (!refactorRewriteSession.TryRewrite())
+            if (!executableRewriteSession.TryRewrite())
             {
-                throw new RewriteFailedException(refactorRewriteSession.RewriteSession);
+                throw new RewriteFailedException(executableRewriteSession);
             }
         }
 
         private string PreviewRewrite(EncapsulateFieldModel model)
         {
-            var previewSession = new EncapsulateFieldRewriteSession(_rewritingManager.CheckOutCodePaneSession()) as IEncapsulateFieldRewriteSession; ;
+            var previewSession = RefactorRewrite(model, _rewritingManager.CheckOutCodePaneSession(), true);
 
-            previewSession = RefactorRewrite(model, previewSession, true);
-
-            return previewSession.CreatePreview(model.QualifiedModuleName);
+            return previewSession.CheckOutModuleRewriter(model.QualifiedModuleName)
+                .GetText();
         }
 
-        private IEncapsulateFieldRewriteSession RefactorRewrite(EncapsulateFieldModel model, IEncapsulateFieldRewriteSession refactorRewriteSession, bool asPreview = false)
+        private IRewriteSession RefactorRewrite(EncapsulateFieldModel model, IRewriteSession refactorRewriteSession, bool asPreview = false)
         {
             if (!model.SelectedFieldCandidates.Any()) { return refactorRewriteSession; }