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