Refactoring of Validations and conflict detection

Conflict detectors need to align with the two versions of refactoring
strategies as well.

Author: BZngr

Rubberduck.Core/UI/Refactorings/EncapsulateField/EncapsulateFieldViewModel.cs

@@ -17,7 +17,7 @@ private class MasterDetailSelectionManager
             private const string _neverATargetID = "_Never_a_TargetID_";
             private bool _detailFieldIsFlagged;
 
-            public MasterDetailSelectionManager(IEncapsulatableField selected)
+            public MasterDetailSelectionManager(IEncapsulateFieldCandidate selected)
                 : this(selected?.TargetID)
             {
                 if (selected != null)
@@ -101,12 +101,12 @@ public ObservableCollection<IEncapsulatedFieldViewData> EncapsulationFields
             {
                 var viewableFields = new ObservableCollection<IEncapsulatedFieldViewData>();
 
-                //var orderedFields = Model.EncapsulationCandidates.Where(ec => !(_selectedObjectStateUDT?.IsEncapsulateFieldCandidate(ec) ?? false))
-                //                            .OrderBy(efd => efd.Declaration.Selection).ToList();
-
-                var orderedFields = Model.EncapsulationCandidates.Where(ec => !(_selectedObjectStateUDT?.IsExistingDeclaration ?? false))
-                                            .OrderBy(efd => efd.Declaration.Selection).ToList();
-
+                var orderedFields = Model.EncapsulationCandidates.OrderBy(efd => efd.Declaration.Selection).ToList();
+                if (_selectedObjectStateUDT != null && _selectedObjectStateUDT.IsExistingDeclaration)
+                {
+                    orderedFields = Model.EncapsulationCandidates.Where(ec => !_selectedObjectStateUDT.FieldIdentifier.Equals(ec.IdentifierName))
+                                                .OrderBy(efd => efd.Declaration.Selection).ToList();
+                }
                 foreach (var efd in orderedFields)
                 {
                     viewableFields.Add(new ViewableEncapsulatedField(efd));

Rubberduck.Core/UI/Refactorings/EncapsulateField/ViewableEncapsulatedField.cs

@@ -19,9 +19,9 @@ public interface IEncapsulatedFieldViewData
 
     public class ViewableEncapsulatedField : IEncapsulatedFieldViewData
     {
-        private IEncapsulatableField _efd;
+        private IEncapsulateFieldCandidate _efd;
         private readonly int _hashCode;
-        public ViewableEncapsulatedField(IEncapsulatableField efd)
+        public ViewableEncapsulatedField(IEncapsulateFieldCandidate efd)
         {
             _efd = efd;
             _hashCode = efd.TargetID.GetHashCode();

Rubberduck.Refactorings/EncapsulateField/EncapsulateFIeldResources.cs

@@ -18,7 +18,7 @@ public static string PreviewMarker
 
         public static string DefaultStateUDTFieldName => "this";
 
-        public static string GroupBoxHeaderSuffix = "Property Name:";
+        public static string GroupBoxHeaderSuffix = "Property Name";
 
         public static string Caption
             => RubberduckUI.EncapsulateField_Caption;

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldElementsBuilder.cs

@@ -23,66 +23,93 @@ public EncapsulateFieldElementsBuilder(IDeclarationFinderProvider declarationFin
             CreateRefactoringElements();
         }
 
+        public IObjectStateUDT DefaultObjectStateUDT { private set; get; }
+
         public IObjectStateUDT ObjectStateUDT { private set; get; }
 
         public IEncapsulateFieldValidationsProvider ValidationsProvider { private set; get; }
 
-        public IEnumerable<IEncapsulatableField> Candidates { private set; get; }
+        public IEnumerable<IEncapsulateFieldCandidate> Candidates { private set; get; }
+
+        public IEnumerable<IObjectStateUDT> ObjectStateUDTCandidates { private set; get; } = new List<IObjectStateUDT>();
 
         private void CreateRefactoringElements()
         {
             var fieldDeclarations = _declarationFinderProvider.DeclarationFinder
                 .Members(_targetQMN)
                 .Where(v => v.IsMemberVariable() && !v.IsWithEvents);
 
-            ValidationsProvider = new EncapsulateFieldValidationsProvider();
-
-            var nameValidator = ValidationsProvider.NameOnlyValidator(NameValidators.Default);
+            var defaultNamesValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.Default);
 
-            var candidates = new List<IEncapsulatableField>();
+            var candidates = new List<IEncapsulateFieldCandidate>();
             foreach (var fieldDeclaration in fieldDeclarations)
             {
                 Debug.Assert(!fieldDeclaration.DeclarationType.Equals(DeclarationType.UserDefinedTypeMember));
 
-                var fieldEncapsulationCandidate = CreateCandidate(fieldDeclaration, nameValidator);
-
+                var fieldEncapsulationCandidate = CreateCandidate(fieldDeclaration, defaultNamesValidator);
 
                 candidates.Add(fieldEncapsulationCandidate);
             }
 
-            ValidationsProvider.RegisterCandidates(candidates);
+            Candidates = candidates;
+
+            ObjectStateUDTCandidates = BuildObjectStateUDTCandidates(candidates).ToList();
+
+            var objectStateUDTIdentifier = $"T{_targetQMN.ComponentName}";
+            ObjectStateUDT = ObjectStateUDTCandidates.FirstOrDefault(os => os.AsTypeDeclaration.IdentifierName.StartsWith(objectStateUDTIdentifier, StringComparison.InvariantCultureIgnoreCase));
+
+            DefaultObjectStateUDT = CreateStateUDTField();
+            DefaultObjectStateUDT.IsSelected = true;
+            if (ObjectStateUDT != null)
+            {
+                ObjectStateUDT.IsSelected = true;
+                DefaultObjectStateUDT.IsSelected = false;
+            }
+
+            ObjectStateUDTCandidates = ObjectStateUDTCandidates.Concat(new IObjectStateUDT[] { DefaultObjectStateUDT });
 
-            var conflictsValidator = ValidationsProvider.ConflictDetector(EncapsulateFieldStrategy.UseBackingFields, _declarationFinderProvider);
+            ValidationsProvider = new EncapsulateFieldValidationsProvider(Candidates, ObjectStateUDTCandidates);
 
-            ObjectStateUDT = CreateStateUDTField(conflictsValidator);
+            var conflictsFinder = ValidationsProvider.ConflictDetector(EncapsulateFieldStrategy.UseBackingFields, _declarationFinderProvider);
             foreach (var candidate in candidates)
             {
-                candidate.ConflictFinder = conflictsValidator;
-                conflictsValidator.AssignNoConflictIdentifier(candidate, DeclarationType.Property);
-                conflictsValidator.AssignNoConflictIdentifier(candidate, DeclarationType.Variable);
+                candidate.ConflictFinder = conflictsFinder;
             }
+        }
 
-            Candidates = candidates;
+        private IEnumerable<IObjectStateUDT> BuildObjectStateUDTCandidates(IEnumerable<IEncapsulateFieldCandidate> candidates) //, IObjectStateUDT defaultObjectStateUDT)
+        {
+            var udtCandidates = candidates.Where(c => c is IUserDefinedTypeCandidate udt
+                        && udt.CanBeObjectStateUDT);
+
+            var objectStateUDTs = new List<IObjectStateUDT>();
+            foreach (var udt in udtCandidates)
+            {
+                objectStateUDTs.Add(new ObjectStateUDT(udt as IUserDefinedTypeCandidate));
+            }
+
+            var objectStateUDTIdentifier = $"T{_targetQMN.ComponentName}";
+            var objectStateUDT = objectStateUDTs.FirstOrDefault(os => os.AsTypeDeclaration.IdentifierName.StartsWith(objectStateUDTIdentifier, StringComparison.InvariantCultureIgnoreCase));
+
+            return objectStateUDTs;
         }
 
-        private IObjectStateUDT CreateStateUDTField(IEncapsulateFieldConflictFinder validator)
+        private IObjectStateUDT CreateStateUDTField()
         {
             var stateUDT = new ObjectStateUDT(_targetQMN) as IObjectStateUDT;
 
-            stateUDT.FieldIdentifier = validator.CreateNonConflictIdentifierForProposedType(stateUDT.FieldIdentifier, _targetQMN, DeclarationType.Variable);
-
-            stateUDT.TypeIdentifier = validator.CreateNonConflictIdentifierForProposedType(stateUDT.TypeIdentifier, _targetQMN, DeclarationType.UserDefinedType);
+            EncapsulateFieldValidationsProvider.AssignNoConflictIdentifiers(stateUDT, _declarationFinderProvider);
 
             stateUDT.IsSelected = true;
 
             return stateUDT;
         }
 
-        private IEncapsulatableField CreateCandidate(Declaration target, IValidateVBAIdentifiers validator)// Predicate<string> nameValidator)
+        private IEncapsulateFieldCandidate CreateCandidate(Declaration target, IValidateVBAIdentifiers validator)// Predicate<string> nameValidator)
         {
             if (target.IsUserDefinedTypeField())
             {
-                var udtValidator = ValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedType);
+                var udtValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedType);
                 var udtField = new UserDefinedTypeCandidate(target, udtValidator) as IUserDefinedTypeCandidate;
 
                 (Declaration udtDeclaration, IEnumerable<Declaration> udtMembers) = GetUDTAndMembersForField(udtField);
@@ -93,10 +120,10 @@ private IEncapsulatableField CreateCandidate(Declaration target, IValidateVBAIde
 
                 foreach (var udtMemberDeclaration in udtMembers)
                 {
-                    var udtMemberValidator = ValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMember);
+                    var udtMemberValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMember);
                     if (udtMemberDeclaration.IsArray)
                     {
-                        udtMemberValidator = ValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMemberArray);
+                        udtMemberValidator = EncapsulateFieldValidationsProvider.NameOnlyValidator(NameValidators.UserDefinedTypeMemberArray);
                     }
                     var candidateUDTMember = new UserDefinedTypeMemberCandidate(CreateCandidate(udtMemberDeclaration, udtMemberValidator), udtField) as IUserDefinedTypeMemberCandidate;
 
@@ -106,7 +133,9 @@ private IEncapsulatableField CreateCandidate(Declaration target, IValidateVBAIde
                 var udtVariablesOfSameType = _declarationFinderProvider.DeclarationFinder.UserDeclarations(DeclarationType.Variable)
                     .Where(v => v.AsTypeDeclaration == udtDeclaration);
 
-                udtField.CanBeObjectStateUDT = udtField.TypeDeclarationIsPrivate && udtVariablesOfSameType.Count() == 1;
+                udtField.CanBeObjectStateUDT = udtField.TypeDeclarationIsPrivate 
+                    && udtField.Declaration.HasPrivateAccessibility()
+                    && udtVariablesOfSameType.Count() == 1;
 
                 return udtField;
             }