public static AttributeSyntax RenameNameEquals(this AttributeSyntax node, string nameEquals, string renameTo)
{
var candidate = FindByNameEquals(node.ArgumentList, nameEquals);
if (candidate != null)
{
return(node.ReplaceNode(candidate, candidate.WithNameEquals(SyntaxFactory.NameEquals(renameTo))));
}
return(node);
}
public override SyntaxNode VisitAttribute(AttributeSyntax node)
{
var kindWhitelist = new List <SyntaxKind>
{
SyntaxKind.AttributeArgument,
SyntaxKind.Attribute,
SyntaxKind.AttributeList,
SyntaxKind.AttributeArgumentList,
SyntaxKind.Parameter
};
SyntaxNode parent = node;
while (parent.Kind() != SyntaxKind.Parameter)
{
parent = parent.Parent;
if (!kindWhitelist.Contains(parent.Kind()))
{
return(base.VisitAttribute(node));
}
}
if (node.Name.ToFullString() != "FromHeader")
{
return(base.VisitAttribute(node));
}
if (!(parent is ParameterSyntax))
{
return(base.VisitAttribute(node));
}
var parameterName = (parent as ParameterSyntax).Identifier.ToFullString();
var name = SyntaxFactory.ParseName("MyAttribute");
var arguments = SyntaxFactory.ParseAttributeArgumentList($"(Name = \"{parameterName}\")");
var attribute = SyntaxFactory.Attribute(name, arguments);
//var attributeList = new SeparatedSyntaxList<AttributeSyntax>();
//attributeList = attributeList.Add(attribute);
//var list = AttributeList(attributeList);
node = node.ReplaceNode(node, attribute);
return(base.VisitAttribute(node));
}
private static AttributeListSyntax CreateAttribute(string @namespace, AttributeSyntax attribute)
{
var list = attribute.FirstAncestorOrSelf <AttributeListSyntax>();
if (list?.Attributes.Count != 1)
{
return(null);
}
if (!Attribute.TryFindArgument(attribute, 1, KnownSymbol.XmlnsDefinitionAttribute.ClrNamespaceArgumentName, out AttributeArgumentSyntax oldArgument))
{
return(null);
}
var newArgument = oldArgument.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(@namespace)));
return(list.WithAttributes(SyntaxFactory.SingletonSeparatedList(attribute.ReplaceNode(oldArgument, newArgument))).WithAdditionalAnnotations(Formatter.Annotation));
}
public override SyntaxNode VisitAttribute(AttributeSyntax attribute)
{
if (attribute.Name.GetText().ToString() == "InternalsVisibleTo")
{
var value = attribute.ArgumentList.Arguments.Select(argument => argument.Expression).OfType <LiteralExpressionSyntax>()
.Select(a => a.Token.ValueText).FirstOrDefault();
var newArgumentList = SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList(new[]
{
SyntaxFactory.AttributeArgument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal($"{value},myupdated value"))
)
}));
return(attribute.ReplaceNode(attribute.ArgumentList, newArgumentList));
}
return(attribute);
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
foreach (var diagnostic in context.Diagnostics)
{
if (!string.Equals(diagnostic.Id, JsonObjectOptInAnalyzer.DiagnosticId, StringComparison.Ordinal))
{
continue;
}
var documentRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
AttributeSyntax syntax = documentRoot.FindNode(diagnostic.Location.SourceSpan) as AttributeSyntax;
if (syntax == null)
{
continue;
}
ExpressionSyntax expression =
SyntaxFactory.ParseExpression("global::Newtonsoft.Json.MemberSerialization.OptIn")
.WithAdditionalAnnotations(Simplifier.Annotation);
AttributeSyntax newAttribute = null;
AttributeArgumentListSyntax argumentList = syntax.ArgumentList;
if (argumentList != null)
{
AttributeArgumentSyntax existingArgument = null;
foreach (var attributeArgument in argumentList.Arguments)
{
if (string.Equals("MemberSerialization", attributeArgument.NameEquals?.Name?.Identifier.ValueText, StringComparison.Ordinal))
{
existingArgument = attributeArgument;
break;
}
}
if (existingArgument == null)
{
SemanticModel semanticModel = null;
foreach (var attributeArgument in argumentList.Arguments)
{
// this time only interested in arguments (no NameEquals clause)
if (attributeArgument.NameEquals != null)
{
continue;
}
if (string.Equals("memberSerialization", attributeArgument.NameColon?.Name?.Identifier.ValueText, StringComparison.Ordinal))
{
existingArgument = attributeArgument;
break;
}
if (attributeArgument.NameColon != null)
{
continue;
}
if (semanticModel == null)
{
semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
}
if (IsMemberSerializationArgument(semanticModel, attributeArgument.Expression, context.CancellationToken))
{
existingArgument = attributeArgument;
break;
}
}
}
if (existingArgument != null)
{
var newArgument =
existingArgument
.WithExpression(expression)
.WithTriviaFrom(existingArgument)
.WithoutFormatting();
newAttribute = syntax.ReplaceNode(existingArgument, newArgument);
}
}
if (newAttribute == null)
{
if (argumentList == null)
{
argumentList = SyntaxFactory.AttributeArgumentList();
}
NameEqualsSyntax nameEquals;
if (argumentList.Arguments.Any(argument => argument.NameEquals == null))
{
nameEquals = SyntaxFactory.NameEquals("MemberSerialization");
}
else
{
nameEquals = null;
}
AttributeArgumentSyntax defaultValueArgument = SyntaxFactory.AttributeArgument(nameEquals, null, expression);
argumentList = argumentList.AddArguments(defaultValueArgument);
newAttribute = syntax.WithArgumentList(argumentList);
}
SyntaxNode newRoot = documentRoot.ReplaceNode(syntax, newAttribute);
Document newDocument = context.Document.WithSyntaxRoot(newRoot);
context.RegisterCodeFix(CodeAction.Create("Add MemberSerialization.OptIn", _ => Task.FromResult(newDocument)), diagnostic);
}
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
foreach (var diagnostic in context.Diagnostics)
{
if (!string.Equals(diagnostic.Id, JsonPropertyDefaultValueHandlingAnalyzer.DiagnosticId, StringComparison.Ordinal))
{
continue;
}
var documentRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
AttributeSyntax syntax = documentRoot.FindNode(diagnostic.Location.SourceSpan) as AttributeSyntax;
if (syntax == null)
{
continue;
}
ExpressionSyntax expression =
SyntaxFactory.ParseExpression("global::Newtonsoft.Json.DefaultValueHandling.Ignore")
.WithAdditionalAnnotations(Simplifier.Annotation);
AttributeSyntax newAttribute = null;
AttributeArgumentListSyntax argumentList = syntax.ArgumentList;
if (argumentList != null)
{
AttributeArgumentSyntax existingArgument = null;
foreach (var attributeArgument in argumentList.Arguments)
{
if (string.Equals("DefaultValueHandling", attributeArgument.NameEquals?.Name?.Identifier.ValueText, StringComparison.Ordinal))
{
existingArgument = attributeArgument;
break;
}
}
if (existingArgument != null)
{
var newArgument =
existingArgument
.WithExpression(expression)
.WithTriviaFrom(existingArgument)
.WithoutFormatting();
newAttribute = syntax.ReplaceNode(existingArgument, newArgument);
}
}
if (newAttribute == null)
{
NameEqualsSyntax nameEquals = SyntaxFactory.NameEquals("DefaultValueHandling");
AttributeArgumentSyntax defaultValueArgument = SyntaxFactory.AttributeArgument(nameEquals, null, expression);
if (argumentList == null)
{
argumentList = SyntaxFactory.AttributeArgumentList();
}
argumentList = argumentList.AddArguments(defaultValueArgument);
newAttribute = syntax.WithArgumentList(argumentList);
}
SyntaxNode newRoot = documentRoot.ReplaceNode(syntax, newAttribute);
Document newDocument = context.Document.WithSyntaxRoot(newRoot);
context.RegisterCodeFix(CodeAction.Create("Add DefaultValueHandling.Ignore", _ => Task.FromResult(newDocument)), diagnostic);
}
}
