protected virtual IEncapsulateFieldCandidate AssignNoConflictIdentifier(IEncapsulateFieldCandidate candidate, DeclarationType declarationType)
{
Debug.Assert(declarationType.HasFlag(DeclarationType.Property) ||
declarationType.HasFlag(DeclarationType.Variable));
var isConflictingIdentifier = HasConflictingIdentifierIgnoreEncapsulationFlag(candidate, declarationType, out _);
var guard = 0;
while (guard++ < 10 && isConflictingIdentifier)
{
var identifier = IdentifierToCompare(candidate, declarationType);
if (declarationType.HasFlag(DeclarationType.Property))
{
candidate.PropertyIdentifier = identifier.IncrementEncapsulationIdentifier();
}
else
{
candidate.BackingIdentifier = identifier.IncrementEncapsulationIdentifier();
}
isConflictingIdentifier = HasConflictingIdentifierIgnoreEncapsulationFlag(candidate, declarationType, out _);
}
return(candidate);
}
protected virtual bool InternalHasConflictingIdentifier(IEncapsulateFieldCandidate field, DeclarationType declarationType, bool ignoreEncapsulationFlags, out string errorMessage)
{
errorMessage = string.Empty;
var potentialDeclarationIdentifierConflicts = new List <string>();
potentialDeclarationIdentifierConflicts.AddRange(PotentialConflictIdentifiers(field, declarationType));
if (ignoreEncapsulationFlags)
{
potentialDeclarationIdentifierConflicts.AddRange(_fieldCandidates.Where(fc => fc.TargetID != field.TargetID).Select(fc => fc.PropertyIdentifier));
}
else
{
potentialDeclarationIdentifierConflicts.AddRange(FlaggedCandidates.Where(fc => fc.TargetID != field.TargetID).Select(fc => fc.PropertyIdentifier));
}
potentialDeclarationIdentifierConflicts.AddRange(_udtMemberCandidates.Where(udtm => udtm.TargetID != field.TargetID && udtm.EncapsulateFlag).Select(udtm => udtm.PropertyIdentifier));
var identifierToCompare = IdentifierToCompare(field, declarationType);
if (potentialDeclarationIdentifierConflicts.Any(m => m.IsEquivalentVBAIdentifierTo(identifierToCompare)))
{
errorMessage = RubberduckUI.EncapsulateField_NameConflictDetected;
return(true);
}
return(false);
}
public ConvertToUDTMember(IEncapsulateFieldCandidate candidate, IObjectStateUDT objStateUDT)
{
_wrapped = candidate;
PropertyIdentifier = _wrapped.PropertyIdentifier;
ObjectStateUDT = objStateUDT;
_uniqueID = BuildUniqueID(candidate, objStateUDT);
_hashCode = _uniqueID.GetHashCode();
}
public MasterDetailSelectionManager(IEncapsulateFieldCandidate selected)
: this(selected?.TargetID)
{
if (selected != null)
{
DetailField = new ViewableEncapsulatedField(selected);
}
}
public UserDefinedTypeMemberCandidate(IEncapsulateFieldCandidate candidate, IUserDefinedTypeCandidate udtField)
{
WrappedCandidate = candidate;
UDTField = udtField;
PropertyIdentifier = IdentifierName;
BackingIdentifier = IdentifierName;
_hashCode = TargetID.GetHashCode();
}
public virtual IEncapsulateFieldCandidate AssignNoConflictIdentifiers(IEncapsulateFieldCandidate candidate)
{
candidate = AssignNoConflictIdentifier(candidate, DeclarationType.Property);
if (!(candidate is UserDefinedTypeMemberCandidate))
{
candidate = AssignNoConflictIdentifier(candidate, DeclarationType.Variable);
}
return(candidate);
}
protected override IEnumerable <Declaration> FindRelevantMembers(IEncapsulateFieldCandidate candidate)
{
var members = _declarationFinderProvider.DeclarationFinder.Members(candidate.QualifiedModuleName)
.Where(d => d != candidate.Declaration);
var membersToRemove = _fieldCandidates.Where(fc => fc.EncapsulateFlag && fc.Declaration.DeclarationType.HasFlag(DeclarationType.Variable))
.Select(fc => fc.Declaration);
return(members.Except(membersToRemove));
}
public UserDefinedTypeMemberCandidate(IEncapsulateFieldCandidate candidate, IUserDefinedTypeCandidate udtField)
{
_wrappedCandidate = candidate;
_rhsParameterIdentifierName = Resources.Refactorings.Refactorings.CodeBuilder_DefaultPropertyRHSParam;
UDTField = udtField;
PropertyIdentifier = IdentifierName;
BackingIdentifier = IdentifierName;
_uniqueID = BuildUniqueID(candidate, UDTField);
_hashCode = _uniqueID.GetHashCode();
}
private void InitializeModel(ReplacePrivateUDTMemberReferencesModel model, IEncapsulateFieldCandidate udtfield)
{
foreach (var udtMember in model.UDTMembers)
{
var udtExpressions = new PrivateUDTMemberReferenceReplacementExpressions($"{udtfield.IdentifierName}.{udtMember.IdentifierName}")
{
LocalReferenceExpression = udtMember.IdentifierName,
};
model.AssignUDTMemberReferenceExpressions(udtfield.Declaration as VariableDeclaration, udtMember, udtExpressions);
}
}
protected override IEncapsulateFieldCandidate AssignNoConflictIdentifier(IEncapsulateFieldCandidate candidate, DeclarationType declarationType)
{
candidate = base.AssignNoConflictIdentifier(candidate, declarationType);
var objectStateUDT = _objectStateUDTs.SingleOrDefault(os => os.IsSelected);
var guard = 0;
while (guard++ < 10 && ConflictsWithExistingUDTMembers(objectStateUDT, candidate.BackingIdentifier))
{
candidate.BackingIdentifier = candidate.BackingIdentifier.IncrementEncapsulationIdentifier();
}
return(candidate);
}
private void InitializeModel(ReplaceReferencesModel model, IEncapsulateFieldCandidate field)
{
foreach (var idRef in field.Declaration.References)
{
var replacementExpression = field.PropertyIdentifier;
if (idRef.QualifiedModuleName == field.QualifiedModuleName && field.Declaration.IsArray)
{
replacementExpression = field.BackingIdentifier;
}
model.AssignReferenceReplacementExpression(idRef, replacementExpression);
}
}
private PropertyAttributeSet CreatePropertyAttributeSet(IEncapsulateFieldCandidate candidate)
{
return(new PropertyAttributeSet()
{
PropertyName = candidate.PropertyIdentifier,
BackingField = candidate.BackingIdentifier,
AsTypeName = candidate.PropertyAsTypeName,
RHSParameterIdentifier = Resources.Refactorings.Refactorings.CodeBuilder_DefaultPropertyRHSParam,
GeneratePropertyLet = !candidate.IsReadOnly && !candidate.Declaration.IsObject && !candidate.Declaration.IsArray,
GeneratePropertySet = !candidate.IsReadOnly && !candidate.Declaration.IsArray && (candidate.Declaration.IsObject || candidate.Declaration.AsTypeName == Tokens.Variant),
UsesSetAssignment = candidate.Declaration.IsObject,
Declaration = candidate.Declaration
});
}
private IEnumerable <PropertyAttributeSet> CreatePropertyAttributeSets(IEncapsulateFieldCandidate candidate)
{
switch (candidate)
{
case IUserDefinedTypeCandidate udtCandidate:
return(CreatePropertyAttributeSets(udtCandidate));
case IUserDefinedTypeMemberCandidate udtMemberCandidate:
return(CreatePropertyAttributeSets(udtMemberCandidate));
default:
return(new List <PropertyAttributeSet>()
{
CreatePropertyAttributeSet(candidate)
});
}
}
public override bool TryValidateEncapsulationAttributes(IEncapsulateFieldCandidate field, out string errorMessage)
{
errorMessage = string.Empty;
if (!field.EncapsulateFlag)
{
return(true);
}
if (!base.TryValidateEncapsulationAttributes(field, out errorMessage))
{
return(false);
}
//Compare to existing members...they cannot change
var objectStateUDT = _objectStateUDTs.SingleOrDefault(os => os.IsSelected);
return(!ConflictsWithExistingUDTMembers(objectStateUDT, field.BackingIdentifier));
}
public virtual bool TryValidateEncapsulationAttributes(IEncapsulateFieldCandidate field, out string errorMessage)
{
errorMessage = string.Empty;
if (!field.EncapsulateFlag)
{
return(true);
}
if (!field.NameValidator.IsValidVBAIdentifier(field.PropertyIdentifier, out errorMessage))
{
return(false);
}
if (HasConflictingIdentifier(field, DeclarationType.Property, out errorMessage))
{
return(false);
}
return(true);
}
private List <string> PotentialConflictIdentifiers(IEncapsulateFieldCandidate candidate, DeclarationType declarationType)
{
var members = FindRelevantMembers(candidate);
var nameConflictCandidates = members
.Where(d => !IsAlwaysIgnoreNameConflictType(d, declarationType)).ToList();
var localReferences = candidate.Declaration.References.Where(rf => rf.QualifiedModuleName == candidate.QualifiedModuleName);
if (localReferences.Any())
{
foreach (var idRef in localReferences)
{
var locals = members.Except(nameConflictCandidates)
.Where(localDec => localDec.ParentScopeDeclaration.Equals(idRef.ParentScoping));
nameConflictCandidates.AddRange(locals);
}
}
return(nameConflictCandidates.Select(c => c.IdentifierName).ToList());
}
protected override void LoadFieldReferenceContextReplacements(IEncapsulateFieldCandidate field)
{
Debug.Assert(field is IConvertToUDTMember);
var converted = field as IConvertToUDTMember;
if (converted.WrappedCandidate is IUserDefinedTypeCandidate udt && udt.TypeDeclarationIsPrivate)
{
foreach (var member in udt.Members)
{
foreach (var idRef in member.FieldContextReferences)
{
var replacementText = member.IdentifierForReference(idRef);
if (IsExternalReferenceRequiringModuleQualification(idRef))
{
replacementText = $"{udt.QualifiedModuleName.ComponentName}.{replacementText}";
}
SetUDTMemberReferenceRewriteContent(idRef, replacementText);
}
}
}
private static string BackingUDTMember_BackingFieldQualifier(IEncapsulateFieldCandidate candidate, string backingField)
=> $"{candidate.PropertyIdentifier}.{backingField}";
private static string BackingField_BackingFieldQualifier(IEncapsulateFieldCandidate candidate, string backingField)
=> $"{candidate.BackingIdentifier}.{backingField}";
public ViewableEncapsulatedField(IEncapsulateFieldCandidate efd)
{
_efd = efd;
_hashCode = efd.TargetID.GetHashCode();
}
public IReadOnlyCollection <PropertyAttributeSet> GeneratePropertyAttributeSets(IEncapsulateFieldCandidate candidate)
{
if (!(candidate is IEncapsulateFieldAsUDTMemberCandidate asUDTCandidate))
{
_backingFieldQualifierFunc = BackingField_BackingFieldQualifier;
return(CreatePropertyAttributeSets(candidate).ToList());
}
return(GeneratePropertyAttributeSets(asUDTCandidate));
}
public EncapsulateFieldAsUDTMemberCandidate(IEncapsulateFieldCandidate candidate, IObjectStateUDT objStateUDT)
{
_wrapped = candidate;
ObjectStateUDT = objStateUDT;
_hashCode = $"{candidate.QualifiedModuleName.Name}.{candidate.IdentifierName}".GetHashCode();
}
public IEncapsulateFieldAsUDTMemberCandidate CreateUDTMemberCandidate(IEncapsulateFieldCandidate fieldCandidate, IObjectStateUDT defaultObjectStateField) => new EncapsulateFieldAsUDTMemberCandidate(fieldCandidate, defaultObjectStateField);
protected override IEnumerable <Declaration> FindRelevantMembers(IEncapsulateFieldCandidate candidate) => _declarationFinderProvider.DeclarationFinder.Members(candidate.QualifiedModuleName) .Where(d => d != candidate.Declaration);
public bool IsConflictingProposedIdentifier(string fieldName, IEncapsulateFieldCandidate candidate, DeclarationType declarationType) => PotentialConflictIdentifiers(candidate, declarationType) .Any(m => m.IsEquivalentVBAIdentifierTo(fieldName));
protected abstract IEnumerable <Declaration> FindRelevantMembers(IEncapsulateFieldCandidate candidate);
protected string IdentifierToCompare(IEncapsulateFieldCandidate field, DeclarationType declarationType)
{
return(declarationType.HasFlag(DeclarationType.Property)
? field.PropertyIdentifier
: field.BackingIdentifier);
}
public bool HasConflictingIdentifier(IEncapsulateFieldCandidate field, DeclarationType declarationType, out string errorMessage) => InternalHasConflictingIdentifier(field, declarationType, false, out errorMessage);
protected bool HasConflictingIdentifierIgnoreEncapsulationFlag(IEncapsulateFieldCandidate field, DeclarationType declarationType, out string errorMessage) => InternalHasConflictingIdentifier(field, declarationType, true, out errorMessage);
