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);