Rework EncapsulateFieldRefactoring factories

Let CW supply factories where possible.   Resulted in removal of several
explicitly defined factory class files...which led to a lot of renames,
refactoring, and some file structure changes.

Author: BZngr

Rubberduck.Main/Root/RubberduckIoCInstaller.cs

@@ -411,18 +411,8 @@ private void RegisterEncapsulateFieldRefactoringFactories(IWindsorContainer cont
             container.Register(Component.For<IEncapsulateFieldModelFactory>()
                 .ImplementedBy<EncapsulateFieldModelFactory>()
                 .LifestyleSingleton());
-            container.Register(Component.For<IEncapsulateFieldCollectionsProviderFactory>()
-                .ImplementedBy<EncapsulateFieldCollectionsProviderFactory>()
-                .LifestyleSingleton());
-            container.Register(Component.For<IObjectStateUserDefinedTypeFactory>()
-                .ImplementedBy<ObjectStateUserDefinedTypeFactory>()
-                .LifestyleSingleton());
-            container.Register(Component.For<IEncapsulateFieldConflictFinderFactory>()
-                .ImplementedBy<EncapsulateFieldConflictFinderFactory>()
-                .LifestyleSingleton());
         }
 
-
         private void RegisterQuickFixes(IWindsorContainer container, Assembly[] assembliesToRegister)
         {
             foreach (var assembly in assembliesToRegister)

Rubberduck.Refactorings/EncapsulateField/ConflictDetection/EncapsulateFieldConflictFinder.cs

@@ -11,6 +11,13 @@
 
 namespace Rubberduck.Refactorings.EncapsulateField
 {
+    public interface IEncapsulateFieldConflictFinderFactory
+    {
+        IEncapsulateFieldConflictFinder Create(IDeclarationFinderProvider declarationFinderProvider,
+            IEnumerable<IEncapsulateFieldCandidate> candidates,
+            IEnumerable<IObjectStateUDT> objectStateUDTs);
+    }
+
     public interface IEncapsulateFieldConflictFinder 
     {
         bool IsConflictingIdentifier(IEncapsulateFieldCandidate field, string identifierToCompare, out string errorMessage);

Rubberduck.Refactorings/EncapsulateField/ConflictDetection/EncapsulateFieldConflictFinderFactory.cs

@@ -0,0 +1,65 @@
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.VBEditor;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Refactorings.EncapsulateField
+{
+    public interface IEncapsulateFieldCandidateSetsProviderFactory
+    {
+        IEncapsulateFieldCandidateSetsProvider Create(IDeclarationFinderProvider declarationFinderProvider,
+            IEncapsulateFieldCandidateFactory encapsulateFieldCandidateFactory,
+            QualifiedModuleName qualifiedModuleName);
+    }
+
+    public interface IEncapsulateFieldCandidateSetsProvider
+    {
+        IReadOnlyCollection<IEncapsulateFieldCandidate> EncapsulateFieldUseBackingFieldCandidates { get; }
+        IReadOnlyCollection<IEncapsulateFieldAsUDTMemberCandidate> EncapsulateFieldUseBackingUDTMemberCandidates { get; }
+        IReadOnlyCollection<IObjectStateUDT> ObjectStateFieldCandidates { get; }
+    }
+
+    /// <summary>
+    /// EncapsulateFieldCandidateSetsProvider provides access to a sets of 
+    /// EncapsulateField candidate instances to be shared among EncapsulateFieldRefactoringActions.
+    /// </summary>
+    public class EncapsulateFieldCandidateSetsProvider : IEncapsulateFieldCandidateSetsProvider
+    {
+        public EncapsulateFieldCandidateSetsProvider(IDeclarationFinderProvider declarationFinderProvider,
+            IEncapsulateFieldCandidateFactory encapsulateFieldCandidateFactory,
+            QualifiedModuleName qualifiedModuleName)
+        {
+            EncapsulateFieldUseBackingFieldCandidates = declarationFinderProvider.DeclarationFinder.Members(qualifiedModuleName, DeclarationType.Variable)
+                .Where(v => v.ParentDeclaration is ModuleDeclaration
+                    && !v.IsWithEvents)
+                .Select(f => encapsulateFieldCandidateFactory.CreateFieldCandidate(f))
+                .ToList();
+
+            var objectStateUDTCandidates = EncapsulateFieldUseBackingFieldCandidates
+                .OfType<IUserDefinedTypeCandidate>()
+                .Where(fc => fc.Declaration.Accessibility == Accessibility.Private
+                    && fc.Declaration.AsTypeDeclaration.Accessibility == Accessibility.Private)
+                .Select(udtc => encapsulateFieldCandidateFactory.CreateObjectStateField(udtc))
+                //If multiple fields of the same UserDefinedType exist, they are all disqualified as candidates to host a module's state.
+                .ToLookup(objectStateUDTCandidate => objectStateUDTCandidate.Declaration.AsTypeDeclaration.IdentifierName)
+                .Where(osc => osc.Count() == 1)
+                .SelectMany(osc => osc)
+                .ToList();
+
+            var defaultObjectStateUDT = encapsulateFieldCandidateFactory.CreateDefaultObjectStateField(qualifiedModuleName);
+            objectStateUDTCandidates.Add(defaultObjectStateUDT);
+            ObjectStateFieldCandidates = objectStateUDTCandidates;
+
+            EncapsulateFieldUseBackingUDTMemberCandidates = EncapsulateFieldUseBackingFieldCandidates
+                .Select(fc => encapsulateFieldCandidateFactory.CreateUDTMemberCandidate(fc, defaultObjectStateUDT))
+                .ToList();
+        }
+
+        public IReadOnlyCollection<IEncapsulateFieldCandidate> EncapsulateFieldUseBackingFieldCandidates { get; }
+
+        public IReadOnlyCollection<IEncapsulateFieldAsUDTMemberCandidate> EncapsulateFieldUseBackingUDTMemberCandidates { get; }
+
+        public IReadOnlyCollection<IObjectStateUDT> ObjectStateFieldCandidates { get; }
+    }
+}

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldCandidateSetsProvider.cs

@@ -25,12 +25,12 @@ public EncapsulateFieldInsertNewCodeRefactoringAction(
             IDeclarationFinderProvider declarationFinderProvider, 
             IRewritingManager rewritingManager,
             IPropertyAttributeSetsGenerator propertyAttributeSetsGenerator,
-            IEncapsulateFieldCodeBuilderFactory encapsulateFieldCodeBuilderFactory)
+            IEncapsulateFieldCodeBuilder encapsulateFieldCodeBuilder)
                 : base(rewritingManager)
         {
             _declarationFinderProvider = declarationFinderProvider;
             _propertyAttributeSetsGenerator = propertyAttributeSetsGenerator;
-            _encapsulateFieldCodeBuilder = encapsulateFieldCodeBuilderFactory.Create();
+            _encapsulateFieldCodeBuilder = encapsulateFieldCodeBuilder;
         }
 
         public override void Refactor(EncapsulateFieldInsertNewCodeModel model, IRewriteSession rewriteSession)

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldCollectionsProvider.cs

@@ -11,6 +11,11 @@ public enum NewContentType
         CodeSectionBlock,
     }
 
+    public interface INewContentAggregatorFactory
+    {
+        INewContentAggregator Create();
+    }
+
     public interface INewContentAggregator
     {
         /// <summary>

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldCollectionsProviderFactory.cs

@@ -35,7 +35,7 @@ public EncapsulateFieldModel(EncapsulateFieldUseBackingFieldModel backingFieldMo
 
         public Action<EncapsulateFieldModel> StrategyChangedAction { set; get; } = (m) => { };
 
-        public Action<EncapsulateFieldModel> ObjectStateUDTChangedAction { set; get; } = (m) => { };
+        public Action<EncapsulateFieldModel> ObjectStateFieldChangedAction { set; get; } = (m) => { };
 
         public IReadOnlyCollection<IObjectStateUDT> ObjectStateUDTCandidates { private set; get; }
 
@@ -48,7 +48,7 @@ public IObjectStateUDT ObjectStateUDTField
                 if (EncapsulateFieldUseBackingUDTMemberModel.ObjectStateUDTField != value)
                 {
                     EncapsulateFieldUseBackingUDTMemberModel.ObjectStateUDTField = value;
-                    ObjectStateUDTChangedAction(this);
+                    ObjectStateFieldChangedAction(this);
                 }
             }
             get => EncapsulateFieldStrategy == EncapsulateFieldStrategy.ConvertFieldsToUDTMembers