Reorganize - add folders and move files

BZngr · BZngr · commit a0e2e31ef1f0 · 2020-09-07T16:37:53.000-07:00
diff --git a/Rubberduck.Refactorings/EncapsulateField/ConflictDetection/EncapsulateFieldUseBackingFieldsConflictFinder.cs b/Rubberduck.Refactorings/EncapsulateField/ConflictDetection/EncapsulateFieldUseBackingFieldsConflictFinder.cs
@@ -5,10 +5,11 @@
 
 namespace Rubberduck.Refactorings.EncapsulateField
 {
-    public class UseBackingFieldsStrategyConflictFinder : EncapsulateFieldConflictFinderBase, IEncapsulateFieldConflictFinder
+    public class EncapsulateFieldUseBackingFieldsConflictFinder : EncapsulateFieldConflictFinderBase, IEncapsulateFieldConflictFinder
     {
-        public UseBackingFieldsStrategyConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates, IEnumerable<IUserDefinedTypeMemberCandidate> udtCandidates)
-            : base(declarationFinderProvider, candidates, udtCandidates) { }
+        public EncapsulateFieldUseBackingFieldsConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates)
+            : base(declarationFinderProvider, candidates)
+        { }
 
         protected override IEnumerable<Declaration> FindRelevantMembers(IEncapsulateFieldCandidate candidate)
             => _declarationFinderProvider.DeclarationFinder.Members(candidate.QualifiedModuleName)
diff --git a/Rubberduck.Refactorings/EncapsulateField/ConflictDetection/EncapsulateFieldUseBackingUDTMemberConflictFinder.cs b/Rubberduck.Refactorings/EncapsulateField/ConflictDetection/EncapsulateFieldUseBackingUDTMemberConflictFinder.cs
@@ -6,12 +6,12 @@
 
 namespace Rubberduck.Refactorings.EncapsulateField
 {
-    public interface IConvertFieldsToUDTMembersStrategyConflictFinder : IEncapsulateFieldConflictFinder
+    public interface IEncapsulateFieldUseBackingUDTMemberConflictFinder : IEncapsulateFieldConflictFinder
     {
         IObjectStateUDT AssignNoConflictIdentifiers(IObjectStateUDT stateUDT, IDeclarationFinderProvider declarationFinderProvider);
     }
 
-    public class ConvertFieldsToUDTMembersStrategyConflictFinder : EncapsulateFieldConflictFinderBase, IConvertFieldsToUDTMembersStrategyConflictFinder
+    public class EncapsulateFieldUseBackingUDTMemberConflictFinder : EncapsulateFieldConflictFinderBase, IEncapsulateFieldUseBackingUDTMemberConflictFinder
     {
         private static DeclarationType[] _udtTypeIdentifierNonConflictTypes = new DeclarationType[]
         {
@@ -27,17 +27,20 @@ public class ConvertFieldsToUDTMembersStrategyConflictFinder : EncapsulateFieldC
             DeclarationType.Parameter
         };
 
-        private IEnumerable<IObjectStateUDT> _objectStateUDTs;
-        public ConvertFieldsToUDTMembersStrategyConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates, IEnumerable<IUserDefinedTypeMemberCandidate> udtCandidates, IEnumerable<IObjectStateUDT> objectStateUDTs)
-            : base(declarationFinderProvider, candidates, udtCandidates)
+        private List<IObjectStateUDT> _objectStateUDTs;
+        public EncapsulateFieldUseBackingUDTMemberConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates, IEnumerable<IObjectStateUDT> objectStateUDTs)
+            : base(declarationFinderProvider, candidates)
         {
-            _objectStateUDTs = objectStateUDTs;
+            _objectStateUDTs = objectStateUDTs.ToList();
         }
 
         public override bool TryValidateEncapsulationAttributes(IEncapsulateFieldCandidate field, out string errorMessage)
         {
             errorMessage = string.Empty;
-            if (!field.EncapsulateFlag) { return true; }
+            if (!field.EncapsulateFlag)
+            {
+                return true;
+            }
 
             if (!base.TryValidateEncapsulationAttributes(field, out errorMessage))
             {
@@ -97,7 +100,10 @@ protected override IEncapsulateFieldCandidate AssignNoConflictIdentifier(IEncaps
 
         private bool ConflictsWithExistingUDTMembers(IObjectStateUDT objectStateUDT, string identifier)
         {
-            if (objectStateUDT is null) { return false; }
+            if (objectStateUDT is null)
+            {
+                return false;
+            }
 
             return objectStateUDT.ExistingMembers.Any(nm => nm.IdentifierName.IsEquivalentVBAIdentifierTo(identifier));
         }
diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldAsUDTMemberCandidate.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldAsUDTMemberCandidate.cs
@@ -7,19 +7,18 @@
 namespace Rubberduck.Refactorings.EncapsulateField
 {
 
-    public interface IConvertToUDTMember : IEncapsulateFieldCandidate
+    public interface IEncapsulateFieldAsUDTMemberCandidate : IEncapsulateFieldCandidate
     {
         string UDTMemberDeclaration { get; }
-        IEncapsulateFieldCandidate WrappedCandidate { get; }
         IObjectStateUDT ObjectStateUDT { set; get; }
     }
 
-    public class ConvertToUDTMember : IConvertToUDTMember
+    public class EncapsulateFieldAsUDTMemberCandidate : IEncapsulateFieldAsUDTMemberCandidate
     {
         private int _hashCode;
         private readonly string _uniqueID;
-        private readonly IEncapsulateFieldCandidate _wrapped;
-        public ConvertToUDTMember(IEncapsulateFieldCandidate candidate, IObjectStateUDT objStateUDT)
+        private IEncapsulateFieldCandidate _wrapped;
+        public EncapsulateFieldAsUDTMemberCandidate(IEncapsulateFieldCandidate candidate, IObjectStateUDT objStateUDT)
         {
             _wrapped = candidate;
             PropertyIdentifier = _wrapped.PropertyIdentifier;
@@ -40,8 +39,6 @@ public virtual string UDTMemberDeclaration
             }
         }
 
-        public IEncapsulateFieldCandidate WrappedCandidate => _wrapped;
-
         public IObjectStateUDT ObjectStateUDT { set; get; }
 
         public string TargetID => _wrapped.TargetID;
@@ -123,7 +120,10 @@ public string IdentifierForReference(IdentifierReference idRef)
         public bool TryValidateEncapsulationAttributes(out string errorMessage)
         {
             errorMessage = string.Empty;
-            if (!_wrapped.EncapsulateFlag) { return true; }
+            if (!_wrapped.EncapsulateFlag)
+            {
+                return true;
+            }
 
             if (_wrapped is IArrayCandidate ac)
             {
@@ -159,7 +159,7 @@ public IEnumerable<PropertyAttributeSet> PropertyAttributeSets
         public override bool Equals(object obj)
         {
             return obj != null
-                && obj is ConvertToUDTMember convertWrapper
+                && obj is EncapsulateFieldAsUDTMemberCandidate convertWrapper
                 && BuildUniqueID(convertWrapper, convertWrapper.ObjectStateUDT) == _uniqueID;
         }
 
diff --git a/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidateFactory.cs b/Rubberduck.Refactorings/EncapsulateField/FieldCandidates/EncapsulateFieldCandidateFactory.cs
@@ -2,7 +2,6 @@
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.Common;
 using Rubberduck.Refactorings.EncapsulateField;
-using System.Collections.Generic;
 using System.Linq;
 
 namespace Rubberduck.Refactorings
@@ -11,6 +10,7 @@ public interface IEncapsulateFieldCandidateFactory
     {
         IEncapsulateFieldCandidate Create(Declaration target);
     }
+
     public class EncapsulateFieldCandidateFactory : IEncapsulateFieldCandidateFactory
     {
         private readonly IDeclarationFinderProvider _declarationFinderProvider;
@@ -28,7 +28,9 @@ public IEncapsulateFieldCandidate Create(Declaration target)
             {
                 var udtField = new UserDefinedTypeCandidate(target, _codeBuilder.BuildPropertyRhsParameterName) as IUserDefinedTypeCandidate;
 
-                (Declaration udtDeclaration, IEnumerable<Declaration> udtMembers) = GetUDTAndMembersForField(udtField);
+                var udtMembers = _declarationFinderProvider.DeclarationFinder
+                    .UserDeclarations(DeclarationType.UserDefinedTypeMember)
+                    .Where(utm => udtField.Declaration.AsTypeDeclaration == utm.ParentDeclaration);
 
                 foreach (var udtMemberDeclaration in udtMembers)
                 {
@@ -38,9 +40,9 @@ public IEncapsulateFieldCandidate Create(Declaration target)
                 }
 
                 var udtVariablesOfSameType = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
-                    .Where(v => v.AsTypeDeclaration == udtDeclaration);
+                    .Where(v => v.AsTypeDeclaration == udtField.Declaration.AsTypeDeclaration);
 
-                udtField.CanBeObjectStateUDT = udtField.TypeDeclarationIsPrivate
+                udtField.IsObjectStateUDTCandidate = udtField.TypeDeclarationIsPrivate
                     && udtField.Declaration.HasPrivateAccessibility()
                     && udtVariablesOfSameType.Count() == 1;
 
@@ -52,19 +54,7 @@ public IEncapsulateFieldCandidate Create(Declaration target)
                 return arrayCandidate;
             }
 
-            var candidate = new EncapsulateFieldCandidate(target, _codeBuilder.BuildPropertyRhsParameterName);
-            return candidate;
-        }
-
-        private (Declaration TypeDeclaration, IEnumerable<Declaration> Members) GetUDTAndMembersForField(IUserDefinedTypeCandidate udtField)
-        {
-            var userDefinedTypeDeclaration = udtField.Declaration.AsTypeDeclaration;
-
-            var udtMembers = _declarationFinderProvider.DeclarationFinder
-               .UserDeclarations(DeclarationType.UserDefinedTypeMember)
-               .Where(utm => userDefinedTypeDeclaration == utm.ParentDeclaration);
-
-            return (userDefinedTypeDeclaration, udtMembers);
+            return new EncapsulateFieldCandidate(target, _codeBuilder.BuildPropertyRhsParameterName);
         }
     }
 }
diff --git a/Rubberduck.Refactorings/EncapsulateField/ObjectStateUDT/ObjectStateUDT.cs b/Rubberduck.Refactorings/EncapsulateField/ObjectStateUDT/ObjectStateUDT.cs
@@ -11,13 +11,14 @@ namespace Rubberduck.Refactorings.EncapsulateField
 {
     public interface IObjectStateUDT : IEncapsulateFieldRefactoringElement
     {
+        Declaration Declaration { get; }
         string TypeIdentifier { set; get; }
         string FieldDeclarationBlock { get; }
         string FieldIdentifier { set; get; }
         bool IsExistingDeclaration { get; }
         Declaration AsTypeDeclaration { get; }
         bool IsSelected { set; get; }
-        IEnumerable<IUserDefinedTypeMemberCandidate> ExistingMembers { get; }
+        IReadOnlyCollection<IUserDefinedTypeMemberCandidate> ExistingMembers { get; }
     }
 
     /// <summary>
@@ -31,82 +32,72 @@ public interface IObjectStateUDT : IEncapsulateFieldRefactoringElement
     public class ObjectStateUDT : IObjectStateUDT
     {
         private static string _defaultNewFieldName = RubberduckUI.EncapsulateField_DefaultObjectStateUDTFieldName;
-        private List<IConvertToUDTMember> _convertedMembers;
+        private readonly IUserDefinedTypeCandidate _wrappedUDTField;
+        private readonly int _hashCode;
 
-        private readonly IUserDefinedTypeCandidate _wrappedUDT;
-        private readonly ICodeBuilder _codeBuilder;
-        private int _hashCode;
-
-        public ObjectStateUDT(IUserDefinedTypeCandidate udt)
-            : this(udt.Declaration.AsTypeName)
+        public ObjectStateUDT(IUserDefinedTypeCandidate udtField)
+            : this(udtField.Declaration.AsTypeName)
         {
-            if (!udt.TypeDeclarationIsPrivate)
+            if (!udtField.TypeDeclarationIsPrivate)
             {
                 throw new ArgumentException();
             }
 
-            FieldIdentifier = udt.IdentifierName;
-            _wrappedUDT = udt;
-            _hashCode = ($"{_qmn.Name}.{_wrappedUDT.IdentifierName}").GetHashCode();
+            QualifiedModuleName = udtField.QualifiedModuleName;
+            FieldIdentifier = udtField.IdentifierName;
+            _wrappedUDTField = udtField;
+            _hashCode = ($"{QualifiedModuleName.Name}.{_wrappedUDTField.IdentifierName}").GetHashCode();
         }
 
-        public ObjectStateUDT(QualifiedModuleName qmn)
-            :this($"T{qmn.ComponentName.CapitalizeFirstLetter()}")
+        public ObjectStateUDT(QualifiedModuleName qualifiedModuleName)
+            :this($"T{qualifiedModuleName.ComponentName.CapitalizeFirstLetter()}")
         {
-            QualifiedModuleName = qmn;
+            QualifiedModuleName = qualifiedModuleName;
         }
 
         private ObjectStateUDT(string typeIdentifier)
         {
             FieldIdentifier = _defaultNewFieldName;
             TypeIdentifier = typeIdentifier;
-            _convertedMembers = new List<IConvertToUDTMember>();
-            _codeBuilder = new CodeBuilder();
-            _convertedMembers = new List<IConvertToUDTMember>();
         }
 
         public string FieldDeclarationBlock
             => $"{Accessibility.Private} {IdentifierName} {Tokens.As} {AsTypeName}";
 
-        public string IdentifierName => _wrappedUDT?.IdentifierName ?? FieldIdentifier;
+        public string IdentifierName => _wrappedUDTField?.IdentifierName ?? FieldIdentifier;
+
+        public Declaration Declaration => _wrappedUDTField?.Declaration;
 
-        public string AsTypeName => _wrappedUDT?.AsTypeName ?? TypeIdentifier;
+        public string AsTypeName => _wrappedUDTField?.AsTypeName ?? TypeIdentifier;
 
         private bool _isSelected;
         public bool IsSelected
         {
             set
             {
                 _isSelected = value;
-                if (_wrappedUDT != null)
+                if (_wrappedUDTField != null)
                 {
-                    _wrappedUDT.IsSelectedObjectStateUDT = value;
+                    _wrappedUDTField.IsSelectedObjectStateUDT = value;
                     if (_isSelected && IsExistingDeclaration)
                     {
-                        _wrappedUDT.EncapsulateFlag = false;
+                        _wrappedUDTField.EncapsulateFlag = false;
                     }
                 }
             }
             get => _isSelected;
         }
 
-        public IEnumerable<IUserDefinedTypeMemberCandidate> ExistingMembers 
-            => IsExistingDeclaration
-                ? _wrappedUDT.Members
-                : Enumerable.Empty<IUserDefinedTypeMemberCandidate>();
+        public IReadOnlyCollection<IUserDefinedTypeMemberCandidate> ExistingMembers 
+            => _wrappedUDTField?.Members.ToList() ?? new List<IUserDefinedTypeMemberCandidate>();
 
-        private QualifiedModuleName _qmn;
-        public QualifiedModuleName QualifiedModuleName
-        {
-            set => _qmn = value;
-            get => _wrappedUDT?.QualifiedModuleName ?? _qmn;
-        }
+        public QualifiedModuleName QualifiedModuleName { get; }
 
         public string TypeIdentifier { set; get; }
 
-        public bool IsExistingDeclaration => _wrappedUDT != null;
+        public bool IsExistingDeclaration => _wrappedUDTField != null;
 
-        public Declaration AsTypeDeclaration => _wrappedUDT?.Declaration.AsTypeDeclaration;
+        public Declaration AsTypeDeclaration => _wrappedUDTField?.Declaration.AsTypeDeclaration;
 
         public string FieldIdentifier { set; get; }
 
@@ -116,13 +107,15 @@ public override bool Equals(object obj)
             {
                 return true;
             }
+
             if (obj is IEncapsulateFieldRefactoringElement fd && fd.IdentifierName == IdentifierName)
             {
                 return true;
             }
+
             return false;
         }
 
-       public override int GetHashCode() => _hashCode;
+        public override int GetHashCode() => _hashCode;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,11 @@`
`5`	`5`
`6`	`6`	`namespace Rubberduck.Refactorings.EncapsulateField`
`7`	`7`	`{`
`8`		`- public class UseBackingFieldsStrategyConflictFinder : EncapsulateFieldConflictFinderBase, IEncapsulateFieldConflictFinder`
	`8`	`+ public class EncapsulateFieldUseBackingFieldsConflictFinder : EncapsulateFieldConflictFinderBase, IEncapsulateFieldConflictFinder`
`9`	`9`	`{`
`10`		`- public UseBackingFieldsStrategyConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates, IEnumerable<IUserDefinedTypeMemberCandidate> udtCandidates)`
`11`		`- : base(declarationFinderProvider, candidates, udtCandidates) { }`
	`10`	`+ public EncapsulateFieldUseBackingFieldsConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates)`
	`11`	`+ : base(declarationFinderProvider, candidates)`
	`12`	`+ { }`
`12`	`13`
`13`	`14`	`protected override IEnumerable<Declaration> FindRelevantMembers(IEncapsulateFieldCandidate candidate)`
`14`	`15`	`=> _declarationFinderProvider.DeclarationFinder.Members(candidate.QualifiedModuleName)`
Original file line number	Diff line number	Diff line change
`@@ -6,12 +6,12 @@`
`6`	`6`
`7`	`7`	`namespace Rubberduck.Refactorings.EncapsulateField`
`8`	`8`	`{`
`9`		`- public interface IConvertFieldsToUDTMembersStrategyConflictFinder : IEncapsulateFieldConflictFinder`
	`9`	`+ public interface IEncapsulateFieldUseBackingUDTMemberConflictFinder : IEncapsulateFieldConflictFinder`
`10`	`10`	`{`
`11`	`11`	`IObjectStateUDT AssignNoConflictIdentifiers(IObjectStateUDT stateUDT, IDeclarationFinderProvider declarationFinderProvider);`
`12`	`12`	`}`
`13`	`13`
`14`		`- public class ConvertFieldsToUDTMembersStrategyConflictFinder : EncapsulateFieldConflictFinderBase, IConvertFieldsToUDTMembersStrategyConflictFinder`
	`14`	`+ public class EncapsulateFieldUseBackingUDTMemberConflictFinder : EncapsulateFieldConflictFinderBase, IEncapsulateFieldUseBackingUDTMemberConflictFinder`
`15`	`15`	`{`
`16`	`16`	`private static DeclarationType[] _udtTypeIdentifierNonConflictTypes = new DeclarationType[]`
`17`	`17`	`{`
`@@ -27,17 +27,20 @@ public class ConvertFieldsToUDTMembersStrategyConflictFinder : EncapsulateFieldC`
`27`	`27`	`DeclarationType.Parameter`
`28`	`28`	`};`
`29`	`29`
`30`		`- private IEnumerable<IObjectStateUDT> _objectStateUDTs;`
`31`		`- public ConvertFieldsToUDTMembersStrategyConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates, IEnumerable<IUserDefinedTypeMemberCandidate> udtCandidates, IEnumerable<IObjectStateUDT> objectStateUDTs)`
`32`		`- : base(declarationFinderProvider, candidates, udtCandidates)`
	`30`	`+ private List<IObjectStateUDT> _objectStateUDTs;`
	`31`	`+ public EncapsulateFieldUseBackingUDTMemberConflictFinder(IDeclarationFinderProvider declarationFinderProvider, IEnumerable<IEncapsulateFieldCandidate> candidates, IEnumerable<IObjectStateUDT> objectStateUDTs)`
	`32`	`+ : base(declarationFinderProvider, candidates)`
`33`	`33`	`{`
`34`		`- _objectStateUDTs = objectStateUDTs;`
	`34`	`+ _objectStateUDTs = objectStateUDTs.ToList();`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public override bool TryValidateEncapsulationAttributes(IEncapsulateFieldCandidate field, out string errorMessage)`
`38`	`38`	`{`
`39`	`39`	`errorMessage = string.Empty;`
`40`		`- if (!field.EncapsulateFlag) { return true; }`
	`40`	`+ if (!field.EncapsulateFlag)`
	`41`	`+ {`
	`42`	`+ return true;`
	`43`	`+ }`
`41`	`44`
`42`	`45`	`if (!base.TryValidateEncapsulationAttributes(field, out errorMessage))`
`43`	`46`	`{`
`@@ -97,7 +100,10 @@ protected override IEncapsulateFieldCandidate AssignNoConflictIdentifier(IEncaps`
`97`	`100`
`98`	`101`	`private bool ConflictsWithExistingUDTMembers(IObjectStateUDT objectStateUDT, string identifier)`
`99`	`102`	`{`
`100`		`- if (objectStateUDT is null) { return false; }`
	`103`	`+ if (objectStateUDT is null)`
	`104`	`+ {`
	`105`	`+ return false;`
	`106`	`+ }`
`101`	`107`
`102`	`108`	`return objectStateUDT.ExistingMembers.Any(nm => nm.IdentifierName.IsEquivalentVBAIdentifierTo(identifier));`
`103`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,19 +7,18 @@`
`7`	`7`	`namespace Rubberduck.Refactorings.EncapsulateField`
`8`	`8`	`{`
`9`	`9`
`10`		`- public interface IConvertToUDTMember : IEncapsulateFieldCandidate`
	`10`	`+ public interface IEncapsulateFieldAsUDTMemberCandidate : IEncapsulateFieldCandidate`
`11`	`11`	`{`
`12`	`12`	`string UDTMemberDeclaration { get; }`
`13`		`- IEncapsulateFieldCandidate WrappedCandidate { get; }`
`14`	`13`	`IObjectStateUDT ObjectStateUDT { set; get; }`
`15`	`14`	`}`
`16`	`15`
`17`		`- public class ConvertToUDTMember : IConvertToUDTMember`
	`16`	`+ public class EncapsulateFieldAsUDTMemberCandidate : IEncapsulateFieldAsUDTMemberCandidate`
`18`	`17`	`{`
`19`	`18`	`private int _hashCode;`
`20`	`19`	`private readonly string _uniqueID;`
`21`		`- private readonly IEncapsulateFieldCandidate _wrapped;`
`22`		`- public ConvertToUDTMember(IEncapsulateFieldCandidate candidate, IObjectStateUDT objStateUDT)`
	`20`	`+ private IEncapsulateFieldCandidate _wrapped;`
	`21`	`+ public EncapsulateFieldAsUDTMemberCandidate(IEncapsulateFieldCandidate candidate, IObjectStateUDT objStateUDT)`
`23`	`22`	`{`
`24`	`23`	`_wrapped = candidate;`
`25`	`24`	`PropertyIdentifier = _wrapped.PropertyIdentifier;`
`@@ -40,8 +39,6 @@ public virtual string UDTMemberDeclaration`
`40`	`39`	`}`
`41`	`40`	`}`
`42`	`41`
`43`		`- public IEncapsulateFieldCandidate WrappedCandidate => _wrapped;`
`44`		`-`
`45`	`42`	`public IObjectStateUDT ObjectStateUDT { set; get; }`
`46`	`43`
`47`	`44`	`public string TargetID => _wrapped.TargetID;`
`@@ -123,7 +120,10 @@ public string IdentifierForReference(IdentifierReference idRef)`
`123`	`120`	`public bool TryValidateEncapsulationAttributes(out string errorMessage)`
`124`	`121`	`{`
`125`	`122`	`errorMessage = string.Empty;`
`126`		`- if (!_wrapped.EncapsulateFlag) { return true; }`
	`123`	`+ if (!_wrapped.EncapsulateFlag)`
	`124`	`+ {`
	`125`	`+ return true;`
	`126`	`+ }`
`127`	`127`
`128`	`128`	`if (_wrapped is IArrayCandidate ac)`
`129`	`129`	`{`
`@@ -159,7 +159,7 @@ public IEnumerable<PropertyAttributeSet> PropertyAttributeSets`
`159`	`159`	`public override bool Equals(object obj)`
`160`	`160`	`{`
`161`	`161`	`return obj != null`
`162`		`- && obj is ConvertToUDTMember convertWrapper`
	`162`	`+ && obj is EncapsulateFieldAsUDTMemberCandidate convertWrapper`
`163`	`163`	`&& BuildUniqueID(convertWrapper, convertWrapper.ObjectStateUDT) == _uniqueID;`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`using Rubberduck.Parsing.VBA;`
`3`	`3`	`using Rubberduck.Refactorings.Common;`
`4`	`4`	`using Rubberduck.Refactorings.EncapsulateField;`
`5`		`-using System.Collections.Generic;`
`6`	`5`	`using System.Linq;`
`7`	`6`
`8`	`7`	`namespace Rubberduck.Refactorings`
`@@ -11,6 +10,7 @@ public interface IEncapsulateFieldCandidateFactory`
`11`	`10`	`{`
`12`	`11`	`IEncapsulateFieldCandidate Create(Declaration target);`
`13`	`12`	`}`
	`13`	`+`
`14`	`14`	`public class EncapsulateFieldCandidateFactory : IEncapsulateFieldCandidateFactory`
`15`	`15`	`{`
`16`	`16`	`private readonly IDeclarationFinderProvider _declarationFinderProvider;`
`@@ -28,7 +28,9 @@ public IEncapsulateFieldCandidate Create(Declaration target)`
`28`	`28`	`{`
`29`	`29`	`var udtField = new UserDefinedTypeCandidate(target, _codeBuilder.BuildPropertyRhsParameterName) as IUserDefinedTypeCandidate;`
`30`	`30`
`31`		`- (Declaration udtDeclaration, IEnumerable<Declaration> udtMembers) = GetUDTAndMembersForField(udtField);`
	`31`	`+ var udtMembers = _declarationFinderProvider.DeclarationFinder`
	`32`	`+ .UserDeclarations(DeclarationType.UserDefinedTypeMember)`
	`33`	`+ .Where(utm => udtField.Declaration.AsTypeDeclaration == utm.ParentDeclaration);`
`32`	`34`
`33`	`35`	`foreach (var udtMemberDeclaration in udtMembers)`
`34`	`36`	`{`
`@@ -38,9 +40,9 @@ public IEncapsulateFieldCandidate Create(Declaration target)`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`var udtVariablesOfSameType = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Variable)`
`41`		`- .Where(v => v.AsTypeDeclaration == udtDeclaration);`
	`43`	`+ .Where(v => v.AsTypeDeclaration == udtField.Declaration.AsTypeDeclaration);`
`42`	`44`
`43`		`- udtField.CanBeObjectStateUDT = udtField.TypeDeclarationIsPrivate`
	`45`	`+ udtField.IsObjectStateUDTCandidate = udtField.TypeDeclarationIsPrivate`
`44`	`46`	`&& udtField.Declaration.HasPrivateAccessibility()`
`45`	`47`	`&& udtVariablesOfSameType.Count() == 1;`
`46`	`48`
`@@ -52,19 +54,7 @@ public IEncapsulateFieldCandidate Create(Declaration target)`
`52`	`54`	`return arrayCandidate;`
`53`	`55`	`}`
`54`	`56`
`55`		`- var candidate = new EncapsulateFieldCandidate(target, _codeBuilder.BuildPropertyRhsParameterName);`
`56`		`- return candidate;`
`57`		`- }`
`58`		`-`
`59`		`- private (Declaration TypeDeclaration, IEnumerable<Declaration> Members) GetUDTAndMembersForField(IUserDefinedTypeCandidate udtField)`
`60`		`- {`
`61`		`- var userDefinedTypeDeclaration = udtField.Declaration.AsTypeDeclaration;`
`62`		`-`
`63`		`- var udtMembers = _declarationFinderProvider.DeclarationFinder`
`64`		`- .UserDeclarations(DeclarationType.UserDefinedTypeMember)`
`65`		`- .Where(utm => userDefinedTypeDeclaration == utm.ParentDeclaration);`
`66`		`-`
`67`		`- return (userDefinedTypeDeclaration, udtMembers);`
	`57`	`+ return new EncapsulateFieldCandidate(target, _codeBuilder.BuildPropertyRhsParameterName);`
`68`	`58`	`}`
`69`	`59`	`}`
`70`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,13 +11,14 @@ namespace Rubberduck.Refactorings.EncapsulateField`
`11`	`11`	`{`
`12`	`12`	`public interface IObjectStateUDT : IEncapsulateFieldRefactoringElement`
`13`	`13`	`{`
	`14`	`+ Declaration Declaration { get; }`
`14`	`15`	`string TypeIdentifier { set; get; }`
`15`	`16`	`string FieldDeclarationBlock { get; }`
`16`	`17`	`string FieldIdentifier { set; get; }`
`17`	`18`	`bool IsExistingDeclaration { get; }`
`18`	`19`	`Declaration AsTypeDeclaration { get; }`
`19`	`20`	`bool IsSelected { set; get; }`
`20`		`- IEnumerable<IUserDefinedTypeMemberCandidate> ExistingMembers { get; }`
	`21`	`+ IReadOnlyCollection<IUserDefinedTypeMemberCandidate> ExistingMembers { get; }`
`21`	`22`	`}`
`22`	`23`
`23`	`24`	`/// <summary>`
`@@ -31,82 +32,72 @@ public interface IObjectStateUDT : IEncapsulateFieldRefactoringElement`
`31`	`32`	`public class ObjectStateUDT : IObjectStateUDT`
`32`	`33`	`{`
`33`	`34`	`private static string _defaultNewFieldName = RubberduckUI.EncapsulateField_DefaultObjectStateUDTFieldName;`
`34`		`- private List<IConvertToUDTMember> _convertedMembers;`
	`35`	`+ private readonly IUserDefinedTypeCandidate _wrappedUDTField;`
	`36`	`+ private readonly int _hashCode;`
`35`	`37`
`36`		`- private readonly IUserDefinedTypeCandidate _wrappedUDT;`
`37`		`- private readonly ICodeBuilder _codeBuilder;`
`38`		`- private int _hashCode;`
`39`		`-`
`40`		`- public ObjectStateUDT(IUserDefinedTypeCandidate udt)`
`41`		`- : this(udt.Declaration.AsTypeName)`
	`38`	`+ public ObjectStateUDT(IUserDefinedTypeCandidate udtField)`
	`39`	`+ : this(udtField.Declaration.AsTypeName)`
`42`	`40`	`{`
`43`		`- if (!udt.TypeDeclarationIsPrivate)`
	`41`	`+ if (!udtField.TypeDeclarationIsPrivate)`
`44`	`42`	`{`
`45`	`43`	`throw new ArgumentException();`
`46`	`44`	`}`
`47`	`45`
`48`		`- FieldIdentifier = udt.IdentifierName;`
`49`		`- _wrappedUDT = udt;`
`50`		`- _hashCode = ($"{_qmn.Name}.{_wrappedUDT.IdentifierName}").GetHashCode();`
	`46`	`+ QualifiedModuleName = udtField.QualifiedModuleName;`
	`47`	`+ FieldIdentifier = udtField.IdentifierName;`
	`48`	`+ _wrappedUDTField = udtField;`
	`49`	`+ _hashCode = ($"{QualifiedModuleName.Name}.{_wrappedUDTField.IdentifierName}").GetHashCode();`
`51`	`50`	`}`
`52`	`51`
`53`		`- public ObjectStateUDT(QualifiedModuleName qmn)`
`54`		`- :this($"T{qmn.ComponentName.CapitalizeFirstLetter()}")`
	`52`	`+ public ObjectStateUDT(QualifiedModuleName qualifiedModuleName)`
	`53`	`+ :this($"T{qualifiedModuleName.ComponentName.CapitalizeFirstLetter()}")`
`55`	`54`	`{`
`56`		`- QualifiedModuleName = qmn;`
	`55`	`+ QualifiedModuleName = qualifiedModuleName;`
`57`	`56`	`}`
`58`	`57`
`59`	`58`	`private ObjectStateUDT(string typeIdentifier)`
`60`	`59`	`{`
`61`	`60`	`FieldIdentifier = _defaultNewFieldName;`
`62`	`61`	`TypeIdentifier = typeIdentifier;`
`63`		`- _convertedMembers = new List<IConvertToUDTMember>();`
`64`		`- _codeBuilder = new CodeBuilder();`
`65`		`- _convertedMembers = new List<IConvertToUDTMember>();`
`66`	`62`	`}`
`67`	`63`
`68`	`64`	`public string FieldDeclarationBlock`
`69`	`65`	`=> $"{Accessibility.Private} {IdentifierName} {Tokens.As} {AsTypeName}";`
`70`	`66`
`71`		`- public string IdentifierName => _wrappedUDT?.IdentifierName ?? FieldIdentifier;`
	`67`	`+ public string IdentifierName => _wrappedUDTField?.IdentifierName ?? FieldIdentifier;`
	`68`	`+`
	`69`	`+ public Declaration Declaration => _wrappedUDTField?.Declaration;`
`72`	`70`
`73`		`- public string AsTypeName => _wrappedUDT?.AsTypeName ?? TypeIdentifier;`
	`71`	`+ public string AsTypeName => _wrappedUDTField?.AsTypeName ?? TypeIdentifier;`
`74`	`72`
`75`	`73`	`private bool _isSelected;`
`76`	`74`	`public bool IsSelected`
`77`	`75`	`{`
`78`	`76`	`set`
`79`	`77`	`{`
`80`	`78`	`_isSelected = value;`
`81`		`- if (_wrappedUDT != null)`
	`79`	`+ if (_wrappedUDTField != null)`
`82`	`80`	`{`
`83`		`- _wrappedUDT.IsSelectedObjectStateUDT = value;`
	`81`	`+ _wrappedUDTField.IsSelectedObjectStateUDT = value;`
`84`	`82`	`if (_isSelected && IsExistingDeclaration)`
`85`	`83`	`{`
`86`		`- _wrappedUDT.EncapsulateFlag = false;`
	`84`	`+ _wrappedUDTField.EncapsulateFlag = false;`
`87`	`85`	`}`
`88`	`86`	`}`
`89`	`87`	`}`
`90`	`88`	`get => _isSelected;`
`91`	`89`	`}`
`92`	`90`
`93`		`- public IEnumerable<IUserDefinedTypeMemberCandidate> ExistingMembers`
`94`		`- => IsExistingDeclaration`
`95`		`- ? _wrappedUDT.Members`
`96`		`- : Enumerable.Empty<IUserDefinedTypeMemberCandidate>();`
	`91`	`+ public IReadOnlyCollection<IUserDefinedTypeMemberCandidate> ExistingMembers`
	`92`	`+ => _wrappedUDTField?.Members.ToList() ?? new List<IUserDefinedTypeMemberCandidate>();`
`97`	`93`
`98`		`- private QualifiedModuleName _qmn;`
`99`		`- public QualifiedModuleName QualifiedModuleName`
`100`		`- {`
`101`		`- set => _qmn = value;`
`102`		`- get => _wrappedUDT?.QualifiedModuleName ?? _qmn;`
`103`		`- }`
	`94`	`+ public QualifiedModuleName QualifiedModuleName { get; }`
`104`	`95`
`105`	`96`	`public string TypeIdentifier { set; get; }`
`106`	`97`
`107`		`- public bool IsExistingDeclaration => _wrappedUDT != null;`
	`98`	`+ public bool IsExistingDeclaration => _wrappedUDTField != null;`
`108`	`99`
`109`		`- public Declaration AsTypeDeclaration => _wrappedUDT?.Declaration.AsTypeDeclaration;`
	`100`	`+ public Declaration AsTypeDeclaration => _wrappedUDTField?.Declaration.AsTypeDeclaration;`
`110`	`101`
`111`	`102`	`public string FieldIdentifier { set; get; }`
`112`	`103`
`@@ -116,13 +107,15 @@ public override bool Equals(object obj)`
`116`	`107`	`{`
`117`	`108`	`return true;`
`118`	`109`	`}`
	`110`	`+`
`119`	`111`	`if (obj is IEncapsulateFieldRefactoringElement fd && fd.IdentifierName == IdentifierName)`
`120`	`112`	`{`
`121`	`113`	`return true;`
`122`	`114`	`}`
	`115`	`+`
`123`	`116`	`return false;`
`124`	`117`	`}`
`125`	`118`
`126`		`- public override int GetHashCode() => _hashCode;`
	`119`	`+ public override int GetHashCode() => _hashCode;`
`127`	`120`	`}`
`128`	`121`	`}`