Add ModifyUserDefinedTypeRefactoringAction

Replaces CreateUDTMemberRefactoringAction.  Leverages ICodeBuilder and
IIndenter to rewrite  the entire UDT declaration after adding (or
removing) UDT Members.

Author: BZngr

Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberModel.cs

@@ -1,8 +1,8 @@
-using Rubberduck.Refactorings.CreateUDTMember;
-using Rubberduck.Refactorings.ReplaceDeclarationIdentifier;
+using Rubberduck.Refactorings.ReplaceDeclarationIdentifier;
 using Rubberduck.Refactorings.ReplaceReferences;
 using Rubberduck.Refactorings.ReplacePrivateUDTMemberReferences;
 using Rubberduck.Refactorings.EncapsulateFieldInsertNewCode;
+using Rubberduck.Refactorings.ModifyUserDefinedType;
 
 namespace Rubberduck.Refactorings.EncapsulateField
 {
@@ -11,33 +11,33 @@ public interface IEncapsulateFieldRefactoringActionsProvider
         ICodeOnlyRefactoringAction<ReplaceReferencesModel> ReplaceReferences { get; }
         ICodeOnlyRefactoringAction<ReplacePrivateUDTMemberReferencesModel> ReplaceUDTMemberReferences { get; }
         ICodeOnlyRefactoringAction<ReplaceDeclarationIdentifierModel> ReplaceDeclarationIdentifiers { get; }
-        ICodeOnlyRefactoringAction<CreateUDTMemberModel> CreateUDTMember { get; }
+        ICodeOnlyRefactoringAction<ModifyUserDefinedTypeModel> ModifyUserDefinedType { get; }
         ICodeOnlyRefactoringAction<EncapsulateFieldInsertNewCodeModel> EncapsulateFieldInsertNewCode { get; }
     }
 
     /// <summary>
     /// EncapsulateFieldRefactoringActionsProvider reduces the number of EncapsulateField refactoring action 
-    /// constructor parameters providing refactoring actions common to the aggregated EncapsulateFieldRefactoringActions
+    /// constructor parameters.  It provides Refactoring Actions common to the EncapsulateFieldRefactoringActions
     /// </summary>
     public class EncapsulateFieldRefactoringActionsProvider : IEncapsulateFieldRefactoringActionsProvider
     {
         private readonly ReplaceReferencesRefactoringAction _replaceReferences;
         private readonly ReplaceDeclarationIdentifierRefactoringAction _replaceDeclarationIdentifiers;
         private readonly ReplacePrivateUDTMemberReferencesRefactoringAction _replaceUDTMemberReferencesRefactoringAction;
-        private readonly CreateUDTMemberRefactoringAction _createUDTMemberRefactoringAction;
+        private readonly ModifyUserDefinedTypeRefactoringAction _modifyUDTRefactoringAction;
         private readonly EncapsulateFieldInsertNewCodeRefactoringAction _encapsulateFieldInsertNewCodeRefactoringAction;
 
         public EncapsulateFieldRefactoringActionsProvider(
             ReplaceReferencesRefactoringAction replaceReferencesRefactoringAction,
             ReplacePrivateUDTMemberReferencesRefactoringAction replaceUDTMemberReferencesRefactoringAction,
             ReplaceDeclarationIdentifierRefactoringAction replaceDeclarationIdentifierRefactoringAction,
-            CreateUDTMemberRefactoringAction createUDTMemberRefactoringActionRefactoringAction,
+            ModifyUserDefinedTypeRefactoringAction modifyUserDefinedTypeRefactoringAction,
             EncapsulateFieldInsertNewCodeRefactoringAction encapsulateFieldInsertNewCodeRefactoringAction)
         {
             _replaceReferences = replaceReferencesRefactoringAction;
             _replaceUDTMemberReferencesRefactoringAction = replaceUDTMemberReferencesRefactoringAction;
             _replaceDeclarationIdentifiers = replaceDeclarationIdentifierRefactoringAction;
-            _createUDTMemberRefactoringAction = createUDTMemberRefactoringActionRefactoringAction;
+            _modifyUDTRefactoringAction = modifyUserDefinedTypeRefactoringAction;
             _encapsulateFieldInsertNewCodeRefactoringAction = encapsulateFieldInsertNewCodeRefactoringAction;
         }
 
@@ -50,8 +50,8 @@ public ICodeOnlyRefactoringAction<ReplaceDeclarationIdentifierModel> ReplaceDecl
         public ICodeOnlyRefactoringAction<ReplacePrivateUDTMemberReferencesModel> ReplaceUDTMemberReferences
             => _replaceUDTMemberReferencesRefactoringAction;
 
-        public ICodeOnlyRefactoringAction<CreateUDTMemberModel> CreateUDTMember
-            => _createUDTMemberRefactoringAction;
+        public ICodeOnlyRefactoringAction<ModifyUserDefinedTypeModel> ModifyUserDefinedType
+            => _modifyUDTRefactoringAction;
 
         public ICodeOnlyRefactoringAction<EncapsulateFieldInsertNewCodeModel> EncapsulateFieldInsertNewCode
             => _encapsulateFieldInsertNewCodeRefactoringAction;

Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberRefactoringAction.cs

@@ -1,19 +1,19 @@
 using Rubberduck.Parsing.Rewriter;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Refactorings.Common;
-using Rubberduck.Refactorings.CreateUDTMember;
 using Rubberduck.Refactorings.ReplaceReferences;
 using Rubberduck.Refactorings.ReplacePrivateUDTMemberReferences;
 using System.Linq;
 using Rubberduck.Refactorings.EncapsulateField;
 using Rubberduck.Refactorings.EncapsulateFieldInsertNewCode;
 using System.Collections.Generic;
+using Rubberduck.Refactorings.ModifyUserDefinedType;
 
 namespace Rubberduck.Refactorings.EncapsulateFieldUseBackingUDTMember
 {
     public class EncapsulateFieldUseBackingUDTMemberRefactoringAction : CodeOnlyRefactoringActionBase<EncapsulateFieldUseBackingUDTMemberModel>
     {
-        private readonly ICodeOnlyRefactoringAction<CreateUDTMemberModel> _createUDTMemberRefactoringAction;
+        private readonly ICodeOnlyRefactoringAction<ModifyUserDefinedTypeModel> _modifyUDTRefactoringAction;
         private readonly ICodeOnlyRefactoringAction<ReplacePrivateUDTMemberReferencesModel> _replacePrivateUDTMemberReferencesRefactoringAction;
         private readonly ICodeOnlyRefactoringAction<ReplaceReferencesModel> _replaceReferencesRefactoringAction;
         private readonly ICodeOnlyRefactoringAction<EncapsulateFieldInsertNewCodeModel> _encapsulateFieldInsertNewCodeRefactoringAction;
@@ -29,7 +29,7 @@ public EncapsulateFieldUseBackingUDTMemberRefactoringAction(
             IEncapsulateFieldCodeBuilderFactory encapsulateFieldCodeBuilderFactory)
                 : base(rewritingManager)
         {
-            _createUDTMemberRefactoringAction = refactoringActionsProvider.CreateUDTMember;
+            _modifyUDTRefactoringAction = refactoringActionsProvider.ModifyUserDefinedType;
             _replacePrivateUDTMemberReferencesRefactoringAction = refactoringActionsProvider.ReplaceUDTMemberReferences;
             _replaceReferencesRefactoringAction = refactoringActionsProvider.ReplaceReferences;
             _encapsulateFieldInsertNewCodeRefactoringAction = refactoringActionsProvider.EncapsulateFieldInsertNewCode;
@@ -58,11 +58,14 @@ private void ModifyFields(EncapsulateFieldUseBackingUDTMemberModel encapsulateFi
 
             if (encapsulateFieldModel.ObjectStateUDTField.IsExistingDeclaration)
             {
-                var conversionPairs = encapsulateFieldModel.SelectedFieldCandidates
-                    .Select(c => (c.Declaration, c.BackingIdentifier));
+                var model = new ModifyUserDefinedTypeModel(encapsulateFieldModel.ObjectStateUDTField.AsTypeDeclaration);
 
-                var model = new CreateUDTMemberModel(encapsulateFieldModel.ObjectStateUDTField.AsTypeDeclaration, conversionPairs);
-                _createUDTMemberRefactoringAction.Refactor(model, rewriteSession);
+                foreach (var candidate in encapsulateFieldModel.SelectedFieldCandidates)
+                {
+                    model.AddNewMemberPrototype(candidate.Declaration, candidate.BackingIdentifier);
+                }
+
+                _modifyUDTRefactoringAction.Refactor(model,rewriteSession);
             }
 
             rewriter.RemoveVariables(encapsulateFieldModel.SelectedFieldCandidates.Select(f => f.Declaration)

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoringActionsProvider.cs

@@ -0,0 +1,60 @@
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Symbols;
+using System;
+using System.Collections.Generic;
+
+namespace Rubberduck.Refactorings.ModifyUserDefinedType
+{
+    public class ModifyUserDefinedTypeModel : IRefactoringModel
+    {
+        private List<(Declaration, string)> _newMembers;
+        private List<Declaration> _membersToRemove;
+
+        public ModifyUserDefinedTypeModel(Declaration target)
+        {
+            if (!target.DeclarationType.HasFlag(DeclarationType.UserDefinedType))
+            {
+                throw new ArgumentException();
+            }
+
+            Target = target;
+            _newMembers = new List<(Declaration, string)>();
+            _membersToRemove = new List<Declaration>();
+            InsertionIndex = (Target.Context as VBAParser.UdtDeclarationContext).END_TYPE().Symbol.TokenIndex - 1;
+        }
+
+        public Declaration Target { get; }
+
+        public int InsertionIndex { get; }
+
+        public void AddNewMemberPrototype(Declaration prototype, string memberIdentifier)
+        {
+            if (!IsValidPrototypeDeclarationType(prototype.DeclarationType))
+            {
+                throw new ArgumentException("Invalid prototype DeclarationType");
+            }
+            _newMembers.Add((prototype, memberIdentifier));
+        }
+
+        public void RemoveMember(Declaration member)
+        {
+            if (!member.DeclarationType.HasFlag(DeclarationType.UserDefinedTypeMember))
+            {
+                throw new ArgumentException();
+            }
+            _membersToRemove.Add(member);
+        }
+
+        public IEnumerable<(Declaration, string)> MembersToAdd => _newMembers;
+
+        public IEnumerable<Declaration> MembersToRemove => _membersToRemove;
+
+        private static bool IsValidPrototypeDeclarationType(DeclarationType declarationType)
+        {
+            return declarationType.HasFlag(DeclarationType.Variable)
+                || declarationType.HasFlag(DeclarationType.UserDefinedTypeMember)
+                || declarationType.HasFlag(DeclarationType.Constant)
+                || declarationType.HasFlag(DeclarationType.Function);
+        }
+    }
+}

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldUseBackingUDTMember/EncapsulateFieldUseBackingUDTMemberRefactoringAction.cs

@@ -0,0 +1,62 @@
+using Rubberduck.Parsing;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.SmartIndenter;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Refactorings.ModifyUserDefinedType
+{
+    public class ModifyUserDefinedTypeRefactoringAction : CodeOnlyRefactoringActionBase<ModifyUserDefinedTypeModel>
+    {
+        private readonly IDeclarationFinderProvider _declarationFinderProvider;
+        private readonly IRewritingManager _rewritingManager;
+        private readonly ICodeBuilder _codeBuilder;
+
+        /// <summary>
+        /// Removes or adds UserDefinedTypeMember declarations to an existing UserDefinedType. 
+        /// Adding a UDTMember is based on a Declaration prototype (typically a variable declaration but can a UserDefinedTypeMember, Constant, or Function).
+        /// </summary>
+        /// <remarks>
+        /// The refactoring actions does not modify the prototype declaration or its references.
+        /// The refactoring actions does not modify references for removed UDTMembers.
+        /// The refactoring action does not provide any identifier validation or conflictAnalysis
+        /// </remarks>
+        public ModifyUserDefinedTypeRefactoringAction(IDeclarationFinderProvider declarationFinderProvider, IRewritingManager rewritingManager, ICodeBuilder codeBuilder)
+            :base(rewritingManager)
+        {
+            _declarationFinderProvider = declarationFinderProvider;
+            _rewritingManager = rewritingManager;
+            _codeBuilder = codeBuilder;
+        }
+
+        public override void Refactor(ModifyUserDefinedTypeModel model, IRewriteSession rewriteSession)
+        {
+            var newMembers = new List<string>();
+            foreach ((Declaration Prototype, string Identifier) in model.MembersToAdd)
+            {
+                _codeBuilder.TryBuildUDTMemberDeclaration(Prototype, Identifier, out var udtMemberDeclaration);
+                newMembers.Add(udtMemberDeclaration);
+            }
+
+            var scratchPad = _rewritingManager.CheckOutCodePaneSession().CheckOutModuleRewriter(model.Target.QualifiedModuleName);
+            scratchPad.InsertBefore(model.InsertionIndex, $"{Environment.NewLine}{string.Join(Environment.NewLine, newMembers)}");
+
+            foreach (var member in model.MembersToRemove)
+            {
+                scratchPad.Remove(member);
+            }
+
+            var udtDeclarationContext = model.Target.Context as VBAParser.UdtDeclarationContext;
+            var newBlock = scratchPad.GetText(udtDeclarationContext.Start.TokenIndex, udtDeclarationContext.Stop.TokenIndex);
+            var udtLines = newBlock.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)
+                .Where(ul => !string.IsNullOrEmpty(ul.Trim()));
+
+            var rewriter = rewriteSession.CheckOutModuleRewriter(model.Target.QualifiedModuleName);
+            rewriter.Replace(udtDeclarationContext, string.Join(Environment.NewLine, _codeBuilder.Indenter.Indent(udtLines)));
+        }
+    }
+}