public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { IParseTreeAnnotation oldAnnotation = result.Properties.Annotation; string attributeName = result.Properties.AttributeName; IReadOnlyList <string> attributeValues = result.Properties.AttributeValues; var declaration = result.Target; if (declaration.DeclarationType.HasFlag(DeclarationType.Module)) { var componentType = declaration.QualifiedModuleName.ComponentType; if (IsDefaultAttribute(componentType, attributeName, attributeValues)) { _annotationUpdater.RemoveAnnotation(rewriteSession, oldAnnotation); } else { var(newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.ModuleAttributeAnnotation(attributeName, attributeValues); _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotation, newAnnotationValues); } } else { var attributeBaseName = AttributeBaseName(attributeName, declaration); var(newAnnotation, newAnnotationValues) = _attributeAnnotationProvider.MemberAttributeAnnotation(attributeBaseName, attributeValues); _annotationUpdater.UpdateAnnotation(rewriteSession, oldAnnotation, newAnnotation, newAnnotationValues); } }
public void RemoveAnnotation(IRewriteSession rewriteSession, IParseTreeAnnotation annotation) { if (annotation == null) { _logger.Warn("Tried to remove an annotation that is null."); return; } if (rewriteSession.TargetCodeKind != CodeKind.CodePaneCode) { _logger.Warn($"Tried to remove an annotation with a rewriter not suitable for annotationss. (target code kind = {rewriteSession.TargetCodeKind})"); _logger.Trace($"Tried to remove annotation {annotation.Annotation.Name} at {annotation.QualifiedSelection.Selection} in module {annotation.QualifiedSelection.QualifiedName} using a rewriter not suitable for annotations."); return; } var annotationContext = annotation.Context; var annotationList = (VBAParser.AnnotationListContext)annotationContext.Parent; var rewriter = rewriteSession.CheckOutModuleRewriter(annotation.QualifiedSelection.QualifiedName); var annotations = annotationList.annotation(); if (annotations.Length == 1) { RemoveSingleAnnotation(rewriter, annotationContext, annotationList); } RemoveAnnotationMarker(rewriter, annotationContext); rewriter.Remove(annotationContext); }
private IInspectionResult InspectionResult(IParseTreeAnnotation pta) { return(new QualifiedContextInspectionResult( this, ResultDescription(pta), Context(pta))); }
public void UpdateAnnotation(IRewriteSession rewriteSession, IParseTreeAnnotation annotation, IAnnotation annotationInfo, IReadOnlyList <string> newValues = null) { var newAnnotationValues = newValues ?? new List <string>(); if (annotation == null) { _logger.Warn("Tried to replace an annotation that is null."); _logger.Trace($"Tried to replace an annotation that is null with an annotation {annotationInfo.Name} with values {AnnotationValuesText(newAnnotationValues)}."); return; } if (rewriteSession.TargetCodeKind != CodeKind.CodePaneCode && rewriteSession.TargetCodeKind != CodeKind.AttributesCode) { _logger.Warn($"Tried to update an annotation with a rewriter not suitable for annotationss. (target code kind = {rewriteSession.TargetCodeKind})"); _logger.Trace($"Tried to update annotation {annotation.Annotation.Name} at {annotation.QualifiedSelection.Selection} in module {annotation.QualifiedSelection.QualifiedName} with annotation {annotationInfo.Name} with values {AnnotationValuesText(newAnnotationValues)} using a rewriter not suitable for annotations."); return; } //If there are no common flags, the annotations cannot apply to the same target. if ((annotation.Annotation.Target & annotationInfo.Target) == 0) { _logger.Warn("Tried to replace an annotation with an annotation without common flags."); _logger.Trace($"Tried to replace an annotation {annotation.Annotation.Name} with values {AnnotationValuesText(newValues)} at {annotation.QualifiedSelection.Selection} in module {annotation.QualifiedSelection.QualifiedName} with an annotation {annotationInfo.Name} with values {AnnotationValuesText(newAnnotationValues)}, which does not have any common flags."); return; } var context = annotation.Context; var whitespaceAtEnd = context.whiteSpace()?.GetText() ?? string.Empty; var codeReplacement = $"{AnnotationBaseText(annotationInfo.Name, newAnnotationValues)}{whitespaceAtEnd}"; var rewriter = rewriteSession.CheckOutModuleRewriter(annotation.QualifiedSelection.QualifiedName); rewriter.Replace(annotation.Context, codeReplacement); }
private static string ResultDescription(IParseTreeAnnotation pta) { var annotationText = pta.Context.annotationName().GetText(); return(string.Format( InspectionResults.IllegalAnnotationInspection, annotationText)); }
private IInspectionResult InspectionResult(IParseTreeAnnotation pta) { var qualifiedContext = new QualifiedContext(pta.QualifiedSelection.QualifiedName, pta.Context); return(new QualifiedContextInspectionResult( this, ResultDescription(pta), qualifiedContext)); }
private void UpdateFolderAnnotation(MoveToFolderModel model, IParseTreeAnnotation oldPta, IRewriteSession rewriteSession) { var oldFolderName = oldPta.AnnotationArguments.FirstOrDefault(); if (oldFolderName == null || oldFolderName.Equals(model.TargetFolder)) { return; } var(annotation, annotationValues) = NewAnnotation(model.TargetFolder); _annotationUpdater.UpdateAnnotation(rewriteSession, oldPta, annotation, annotationValues); }
private static bool MissesCorrespondingAttribute(Declaration declaration, IParseTreeAnnotation annotationInstance) { if (!(annotationInstance.Annotation is IAttributeAnnotation annotation)) { return(false); } var attribute = annotation.Attribute(annotationInstance); if (string.IsNullOrEmpty(attribute)) { return(false); } return(declaration.DeclarationType.HasFlag(DeclarationType.Module) ? !declaration.Attributes.HasAttributeFor(annotationInstance) : !declaration.Attributes.HasAttributeFor(annotationInstance, declaration.IdentifierName)); }
public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var declaration = result.Target; IParseTreeAnnotation annotationInstance = result.Properties.Annotation; Debug.Assert(annotationInstance.Annotation is IAttributeAnnotation); IAttributeAnnotation annotation = (IAttributeAnnotation)annotationInstance.Annotation; IReadOnlyList <string> attributeValues = result.Properties.AttributeValues; var attribute = annotation.Attribute(annotationInstance); var attributeName = declaration.DeclarationType.HasFlag(DeclarationType.Module) ? attribute : $"{declaration.IdentifierName}.{attribute}"; _attributesUpdater.UpdateAttribute(rewriteSession, declaration, attributeName, annotation.AttributeValues(annotationInstance), oldValues: attributeValues); }
public override void Fix(IInspectionResult result, IRewriteSession rewriteSession) { var declaration = result.Target; IParseTreeAnnotation annotationInstance = result.Properties.Annotation; if (!(annotationInstance.Annotation is IAttributeAnnotation annotation)) { return; } var attribute = annotation.Attribute(annotationInstance); var attributeName = declaration.DeclarationType.HasFlag(DeclarationType.Module) ? attribute : $"{declaration.IdentifierName}.{attribute}"; _attributesUpdater.AddAttribute(rewriteSession, declaration, attributeName, annotation.AttributeValues(annotationInstance)); }
protected override string ResultDescription(IParseTreeAnnotation pta) { if (pta.Annotation.RequiredComponentType.HasValue) { return(string.Format(InspectionResults.InvalidAnnotationInspection_NotInRequiredComponentType, pta.Annotation.Name, // annotation... pta.QualifiedSelection.QualifiedName.ComponentType, // is used in a... pta.Annotation.RequiredComponentType)); // but is only valid in a... } else { return(string.Format(InspectionResults.InvalidAnnotationInspection_IncompatibleComponentType, pta.Annotation.Name, // annotation... pta.QualifiedSelection.QualifiedName.ComponentType)); // cannot be used in a... } }
public IEnumerable <AttributeNode> AttributeNodesFor(IParseTreeAnnotation annotationInstance, string memberName = null) { if (!(annotationInstance.Annotation is IAttributeAnnotation annotation)) { return(Enumerable.Empty <AttributeNode>()); } var attribute = annotation.Attribute(annotationInstance); var attributeName = memberName != null ? MemberAttributeName(attribute, memberName) : attribute; //VB_Ext_Key annotation depend on the defined key for identity. if (attribute.Equals("VB_Ext_Key", StringComparison.OrdinalIgnoreCase)) { return(this.Where(a => a.Name.Equals(attributeName, StringComparison.OrdinalIgnoreCase) && a.Values[0] == annotation.AttributeValues(annotationInstance)[0])); } return(this.Where(a => a.Name.Equals(attributeName, StringComparison.OrdinalIgnoreCase))); }
private static bool HasDifferingAttributeValues(Declaration declaration, IParseTreeAnnotation annotationInstance, out IReadOnlyList <string> attributeValues) { if (!(annotationInstance.Annotation is IAttributeAnnotation annotation)) { attributeValues = new List <string>(); return(false); } var attribute = annotation.Attribute(annotationInstance); var attributeNodes = declaration.DeclarationType.HasFlag(DeclarationType.Module) ? declaration.Attributes.AttributeNodesFor(annotationInstance) : declaration.Attributes.AttributeNodesFor(annotationInstance, declaration.IdentifierName); foreach (var attributeNode in attributeNodes) { var values = attributeNode.Values; if (!annotation.AttributeValues(annotationInstance).SequenceEqual(values)) { attributeValues = values; return(true); } } attributeValues = new List <string>(); return(false); }
/// <summary> /// Gets an annotation-specific description for an inspection result. /// </summary> /// <param name="pta">The invalid annotation.</param> /// <returns></returns> protected abstract string ResultDescription(IParseTreeAnnotation pta);
protected IInspectionResult InspectionResult(IParseTreeAnnotation pta) => new QualifiedContextInspectionResult(this, ResultDescription(pta), Context(pta));
protected QualifiedContext Context(IParseTreeAnnotation pta) => new QualifiedContext(pta.QualifiedSelection.QualifiedName, pta.Context);
protected override string ResultDescription(IParseTreeAnnotation pta) => string.Format(InspectionResults.InvalidAnnotationInspection, pta.Annotation.Name);
protected override string ResultDescription(IParseTreeAnnotation pta) => string.Format(InspectionResults.UnrecognizedAnnotationInspection, pta.Context.GetText());
private static bool IsResultAnnotation(IParseTreeAnnotation pta) { return(pta.Annotation.RequiredArguments > pta.AnnotationArguments.Count); }
public bool HasAttributeFor(IParseTreeAnnotation annotation, string memberName = null) { return(AttributeNodesFor(annotation, memberName).Any()); }
public static string Attribute(this IAttributeAnnotation annotation, IParseTreeAnnotation annotationInstance) { return(annotation.Attribute(annotationInstance.AnnotationArguments)); }
public static IReadOnlyList <string> AttributeValues(this IAttributeAnnotation annotation, IParseTreeAnnotation instance) { return(annotation.AnnotationToAttributeValues(instance.AnnotationArguments)); }
private static QualifiedContext Context(IParseTreeAnnotation pta) { return(new QualifiedContext(pta.QualifiedSelection.QualifiedName, pta.Context)); }
private static bool IsResultAnnotation(IParseTreeAnnotation pta) { var allowedArguments = pta.Annotation.AllowedArguments; return(allowedArguments.HasValue && allowedArguments.Value < pta.AnnotationArguments.Count); }
private static string ResultDescription(IParseTreeAnnotation pta) { return(string.Format( InspectionResults.SuperfluousAnnotationArgumentInspection, pta.Annotation.Name)); }