Refactor split of existing code vs new code ops

Moved residual new content generation/insertion out of refactoring logic
operating on existing content.

Author: BZngr

Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberModel.cs

@@ -0,0 +1,54 @@
+using Rubberduck.Parsing.Symbols;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Refactorings.CreateUDTMember
+{
+    public class CreateUDTMemberModel : IRefactoringModel
+    {
+        private Dictionary<Declaration, List<(VariableDeclaration prototype, string UDTMemberIdentifier)>> _targets { get; } = new Dictionary<Declaration, List<(VariableDeclaration, string)>>();
+
+        public CreateUDTMemberModel()
+        { }
+
+        public CreateUDTMemberModel(Declaration userDefinedType, IEnumerable<(VariableDeclaration prototype, string UserDefinedTypeMemberIdentifier)> conversionModels)
+        {
+            foreach ((VariableDeclaration prototype, string UDTMemberIdentifier) in conversionModels)
+            {
+                AssignPrototypeToUserDefinedType(userDefinedType, prototype, UDTMemberIdentifier);
+            }
+        }
+
+        public IReadOnlyCollection<Declaration> UserDefinedTypeTargets => _targets.Keys;
+
+        public IEnumerable<(VariableDeclaration prototype, string userDefinedTypeMemberIdentifier)> this[Declaration udt] 
+            => _targets[udt].Select(pr => (pr.prototype, pr.UDTMemberIdentifier));
+
+        private void AssignPrototypeToUserDefinedType(Declaration udt, VariableDeclaration prototype, string udtMemberIdentifierName = null)
+        {
+            if (!udt.DeclarationType.HasFlag(DeclarationType.UserDefinedType))
+            {
+                throw new ArgumentException();
+            }
+
+            if (!(_targets.TryGetValue(udt, out var memberPrototypes)))
+            {
+                _targets.Add(udt, new List<(VariableDeclaration, string)>());
+            }
+            else
+            {
+                var hasDuplicateMemberNames = memberPrototypes
+                    .Select(pr => pr.UDTMemberIdentifier?.ToUpperInvariant() ?? pr.prototype.IdentifierName)
+                    .GroupBy(uc => uc).Any(g => g.Count() > 1);
+
+                if (hasDuplicateMemberNames)
+                {
+                    throw new ArgumentException();
+                }
+            }
+
+            _targets[udt].Add((prototype, udtMemberIdentifierName ?? prototype.IdentifierName));
+        }
+    }
+}

Rubberduck.Refactorings/DeclareFieldsAsUDTMembers/DeclareFieldsAsUDTMembersRefactoringAction.cs renamed to Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberRefactoringAction.cs

@@ -6,21 +6,21 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-namespace Rubberduck.Refactorings.DeclareFieldsAsUDTMembers
+namespace Rubberduck.Refactorings.CreateUDTMember
 {
-    public class DeclareFieldsAsUDTMembersRefactoringAction : CodeOnlyRefactoringActionBase<DeclareFieldsAsUDTMembersModel>
+    public class CreateUDTMemberRefactoringAction : CodeOnlyRefactoringActionBase<CreateUDTMemberModel>
     {
         private readonly IDeclarationFinderProvider _declarationFinderProvider;
         private readonly ICodeBuilder _codeBuilder;
 
-        public DeclareFieldsAsUDTMembersRefactoringAction(IDeclarationFinderProvider declarationFinderProvider,IRewritingManager rewritingManager, ICodeBuilder codeBuilder)
+        public CreateUDTMemberRefactoringAction(IDeclarationFinderProvider declarationFinderProvider,IRewritingManager rewritingManager, ICodeBuilder codeBuilder)
             : base(rewritingManager)
         {
             _declarationFinderProvider = declarationFinderProvider;
             _codeBuilder = codeBuilder;
         }
 
-        public override void Refactor(DeclareFieldsAsUDTMembersModel model, IRewriteSession rewriteSession)
+        public override void Refactor(CreateUDTMemberModel model, IRewriteSession rewriteSession)
         {
             if (model.UserDefinedTypeTargets.Any( udt => !(udt.Context is VBAParser.UdtDeclarationContext)))
             {

Rubberduck.Refactorings/DeclareFieldsAsUDTMembers/DeclareFieldsAsUDTMembersModel.cs

@@ -19,18 +19,15 @@ public class EncapsulateFieldModelFactory : IEncapsulateFieldModelFactory
         private readonly IEncapsulateFieldUseBackingUDTMemberModelFactory _useBackingUDTMemberModelFactory;
         private readonly IEncapsulateFieldUseBackingFieldModelFactory _useBackingFieldModelFactory;
         private readonly IEncapsulateFieldCandidateCollectionFactory _fieldCandidateCollectionFactory;
-        private readonly IEncapsulateFieldRequestFactory _requestFactory;
 
         public EncapsulateFieldModelFactory(
             IEncapsulateFieldUseBackingUDTMemberModelFactory encapsulateFieldUseBackingUDTMemberModelFactory,
             IEncapsulateFieldUseBackingFieldModelFactory encapsulateFieldUseBackingFieldModelFactory,
-            IEncapsulateFieldCandidateCollectionFactory encapsulateFieldCandidateCollectionFactory,
-            IEncapsulateFieldRequestFactory encapsulateFieldRequestFactory)
+            IEncapsulateFieldCandidateCollectionFactory encapsulateFieldCandidateCollectionFactory)
         {
             _useBackingUDTMemberModelFactory = encapsulateFieldUseBackingUDTMemberModelFactory as IEncapsulateFieldUseBackingUDTMemberModelFactory;
             _useBackingFieldModelFactory = encapsulateFieldUseBackingFieldModelFactory;
             _fieldCandidateCollectionFactory = encapsulateFieldCandidateCollectionFactory;
-            _requestFactory = encapsulateFieldRequestFactory;
         }
 
         public EncapsulateFieldModel Create(Declaration target)
@@ -42,12 +39,11 @@ public EncapsulateFieldModel Create(Declaration target)
 
             var fieldCandidates = _fieldCandidateCollectionFactory.Create(targetField.QualifiedModuleName);
 
-            var encapsulationRequest = _requestFactory.Create(targetField);
-            var requests = new List<EncapsulateFieldRequest>() { encapsulationRequest };
+            var fieldEncapsulationModels = new List<FieldEncapsulationModel>() { new FieldEncapsulationModel(targetField) };
 
-            var useBackingFieldModel = _useBackingFieldModelFactory.Create(fieldCandidates, requests);
+            var useBackingFieldModel = _useBackingFieldModelFactory.Create(fieldCandidates, fieldEncapsulationModels);
 
-            var useBackingUDTMemberModel = _useBackingUDTMemberModelFactory.Create(fieldCandidates, requests);
+            var useBackingUDTMemberModel = _useBackingUDTMemberModelFactory.Create(fieldCandidates, fieldEncapsulationModels);
 
             var initialStrategy = useBackingUDTMemberModel.ObjectStateUDTField.IsExistingDeclaration
                 ? EncapsulateFieldStrategy.ConvertFieldsToUDTMembers

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldModelFactory.cs

@@ -8,13 +8,16 @@ public class EncapsulateFieldRefactoringAction : IRefactoringAction<EncapsulateF
     {
         private readonly EncapsulateFieldUseBackingFieldRefactoringAction _useBackingField;
         private readonly EncapsulateFieldUseBackingUDTMemberRefactoringAction _useBackingUDTMember;
+        private readonly INewContentAggregatorFactory _newContentAggregatorFactory;
 
         public EncapsulateFieldRefactoringAction(
             EncapsulateFieldUseBackingFieldRefactoringAction encapsulateFieldUseBackingField,
-            EncapsulateFieldUseBackingUDTMemberRefactoringAction encapsulateFieldUseUDTMember)
+            EncapsulateFieldUseBackingUDTMemberRefactoringAction encapsulateFieldUseUDTMember,
+            INewContentAggregatorFactory newContentAggregatorFactory)
         {
             _useBackingField = encapsulateFieldUseBackingField;
             _useBackingUDTMember = encapsulateFieldUseUDTMember;
+            _newContentAggregatorFactory = newContentAggregatorFactory;
         }
 
         public void Refactor(EncapsulateFieldModel model)
@@ -26,10 +29,12 @@ public void Refactor(EncapsulateFieldModel model)
 
             if (model.EncapsulateFieldStrategy == EncapsulateFieldStrategy.ConvertFieldsToUDTMembers)
             {
+                model.EncapsulateFieldUseBackingUDTMemberModel.NewContentAggregator = _newContentAggregatorFactory.Create();
                 _useBackingUDTMember.Refactor(model.EncapsulateFieldUseBackingUDTMemberModel);
                 return;
             }
 
+            model.EncapsulateFieldUseBackingFieldModel.NewContentAggregator = _newContentAggregatorFactory.Create();
             _useBackingField.Refactor(model.EncapsulateFieldUseBackingFieldModel);
         }
     }

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoringAction.cs

@@ -1,4 +1,4 @@
-using Rubberduck.Refactorings.DeclareFieldsAsUDTMembers;
+using Rubberduck.Refactorings.CreateUDTMember;
 using Rubberduck.Refactorings.ReplaceDeclarationIdentifier;
 using Rubberduck.Refactorings.ReplaceReferences;
 using Rubberduck.Refactorings.ReplacePrivateUDTMemberReferences;
@@ -11,7 +11,7 @@ public interface IEncapsulateFieldRefactoringActionsProvider
         ICodeOnlyRefactoringAction<ReplaceReferencesModel> ReplaceReferences { get; }
         ICodeOnlyRefactoringAction<ReplacePrivateUDTMemberReferencesModel> ReplaceUDTMemberReferences { get; }
         ICodeOnlyRefactoringAction<ReplaceDeclarationIdentifierModel> ReplaceDeclarationIdentifiers { get; }
-        ICodeOnlyRefactoringAction<DeclareFieldsAsUDTMembersModel> DeclareFieldsAsUDTMembers { get; }
+        ICodeOnlyRefactoringAction<CreateUDTMemberModel> CreateUDTMember { get; }
         ICodeOnlyRefactoringAction<EncapsulateFieldInsertNewCodeModel> EncapsulateFieldInsertNewCode { get; }
     }
 
@@ -20,20 +20,20 @@ public class EncapsulateFieldRefactoringActionsProvider : IEncapsulateFieldRefac
         private readonly ReplaceReferencesRefactoringAction _replaceReferences;
         private readonly ReplaceDeclarationIdentifierRefactoringAction _replaceDeclarationIdentifiers;
         private readonly ReplacePrivateUDTMemberReferencesRefactoringAction _replaceUDTMemberReferencesRefactoringAction;
-        private readonly DeclareFieldsAsUDTMembersRefactoringAction _declareFieldsAsUDTMembersRefactoringAction;
+        private readonly CreateUDTMemberRefactoringAction _createUDTMemberRefactoringAction;
         private readonly EncapsulateFieldInsertNewCodeRefactoringAction _encapsulateFieldInsertNewCodeRefactoringAction;
 
         public EncapsulateFieldRefactoringActionsProvider(
             ReplaceReferencesRefactoringAction replaceReferencesRefactoringAction,
             ReplacePrivateUDTMemberReferencesRefactoringAction replaceUDTMemberReferencesRefactoringAction,
             ReplaceDeclarationIdentifierRefactoringAction replaceDeclarationIdentifierRefactoringAction,
-            DeclareFieldsAsUDTMembersRefactoringAction declareFieldsAsUDTMembersRefactoringAction,
+            CreateUDTMemberRefactoringAction createUDTMemberRefactoringActionRefactoringAction,
             EncapsulateFieldInsertNewCodeRefactoringAction encapsulateFieldInsertNewCodeRefactoringAction)
         {
             _replaceReferences = replaceReferencesRefactoringAction;
             _replaceUDTMemberReferencesRefactoringAction = replaceUDTMemberReferencesRefactoringAction;
             _replaceDeclarationIdentifiers = replaceDeclarationIdentifierRefactoringAction;
-            _declareFieldsAsUDTMembersRefactoringAction = declareFieldsAsUDTMembersRefactoringAction;
+            _createUDTMemberRefactoringAction = createUDTMemberRefactoringActionRefactoringAction;
             _encapsulateFieldInsertNewCodeRefactoringAction = encapsulateFieldInsertNewCodeRefactoringAction;
         }
 
@@ -46,8 +46,8 @@ public ICodeOnlyRefactoringAction<ReplaceDeclarationIdentifierModel> ReplaceDecl
         public ICodeOnlyRefactoringAction<ReplacePrivateUDTMemberReferencesModel> ReplaceUDTMemberReferences
             => _replaceUDTMemberReferencesRefactoringAction;
 
-        public ICodeOnlyRefactoringAction<DeclareFieldsAsUDTMembersModel> DeclareFieldsAsUDTMembers
-            => _declareFieldsAsUDTMembersRefactoringAction;
+        public ICodeOnlyRefactoringAction<CreateUDTMemberModel> CreateUDTMember
+            => _createUDTMemberRefactoringAction;
 
         public ICodeOnlyRefactoringAction<EncapsulateFieldInsertNewCodeModel> EncapsulateFieldInsertNewCode
             => _encapsulateFieldInsertNewCodeRefactoringAction;

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRefactoringActionsProvider.cs

@@ -11,14 +11,14 @@ public interface IEncapsulateFieldUseBackingFieldModelFactory
         /// Creates an <c>EncapsulateFieldUseBackingFieldModel</c> used by the <c>EncapsulateFieldUseBackingFieldRefactoringAction</c>.
         /// </summary>
         /// <param name="clientTarget">Optional: <c>UserDefinedType</c> Field to include the Encapsulated Field(s)</param>
-        EncapsulateFieldUseBackingFieldModel Create(IEnumerable<EncapsulateFieldRequest> requests);
+        EncapsulateFieldUseBackingFieldModel Create(IEnumerable<FieldEncapsulationModel> requests);
 
         /// <summary>
         /// Creates an <c>EncapsulateFieldUseBackingFieldModel</c> based upon collection of
         /// <c>IEncapsulateFieldCandidate</c> instances created by <c>EncapsulateFieldCandidateCollectionFactory</c>.  
         /// This function is intended for exclusive use by <c>EncapsulateFieldModelFactory</c>
         /// </summary>
-        EncapsulateFieldUseBackingFieldModel Create(IReadOnlyCollection<IEncapsulateFieldCandidate> candidates, IEnumerable<EncapsulateFieldRequest> requests);
+        EncapsulateFieldUseBackingFieldModel Create(IReadOnlyCollection<IEncapsulateFieldCandidate> candidates, IEnumerable<FieldEncapsulationModel> requests);
     }
 
     public class EncapsulateFieldUseBackingFieldModelFactory : IEncapsulateFieldUseBackingFieldModelFactory
@@ -34,7 +34,7 @@ public EncapsulateFieldUseBackingFieldModelFactory(
             _conflictFinderFactory = encapsulateFieldConflictFinderFactory;
         }
 
-        public EncapsulateFieldUseBackingFieldModel Create(IEnumerable<EncapsulateFieldRequest> requests)
+        public EncapsulateFieldUseBackingFieldModel Create(IEnumerable<FieldEncapsulationModel> requests)
         {
             if (!requests.Any())
             {
@@ -45,14 +45,19 @@ public EncapsulateFieldUseBackingFieldModel Create(IEnumerable<EncapsulateFieldR
             return Create(fieldCandidates, requests);
         }
 
-        public EncapsulateFieldUseBackingFieldModel Create(IReadOnlyCollection<IEncapsulateFieldCandidate> candidates, IEnumerable<EncapsulateFieldRequest> requests)
+        public EncapsulateFieldUseBackingFieldModel Create(IReadOnlyCollection<IEncapsulateFieldCandidate> candidates, IEnumerable<FieldEncapsulationModel> requests)
         {
             var fieldCandidates = candidates.ToList();
 
             foreach (var request in requests)
             {
                 var candidate = fieldCandidates.Single(c => c.Declaration.Equals(request.Declaration));
-                request.ApplyRequest(candidate);
+                candidate.EncapsulateFlag = true;
+                candidate.IsReadOnly = request.IsReadOnly;
+                if (request.PropertyIdentifier != null)
+                {
+                    candidate.PropertyIdentifier = request.PropertyIdentifier;
+                }
             }
 
             var conflictsFinder = _conflictFinderFactory.CreateEncapsulateFieldUseBackingFieldConflictFinder(fieldCandidates);

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldRequest/EncapsulateFieldRequest.cs

@@ -128,7 +128,7 @@ private void ReplaceEncapsulatedFieldReferences(IEnumerable<IEncapsulateFieldCan
                         ? field.Declaration.IsArray ? field.BackingIdentifier : field.PropertyIdentifier
                         : field.PropertyIdentifier;
 
-                    model.AssignFieldReferenceReplacementExpression(idRef, replacementExpression);
+                    model.AssignReferenceReplacementExpression(idRef, replacementExpression);
                 }
             }