public static FieldDeclarationSyntax AddObsoleteAttribute(this FieldDeclarationSyntax fieldDeclaration, string message = "", bool error = false)
{
return(fieldDeclaration.AddAttributeLists(
AttributeList(
Attribute(
IdentifierName("Obsolete"),
AttributeArgumentList(
AttributeArgument(StringLiteralExpression(message)),
AttributeArgument(NameColon("error"), BooleanLiteralExpression(error)))))));
}
public MemberSyntax(FieldDeclarationSyntax field)
{
this.AttributeLists = field.AttributeLists;
this.GetLeadingTrivia = () => field.GetLeadingTrivia();
this.ReplaceNode = (x, y) => field.ReplaceNode(x, y);
this.WithoutLeadingTrivia = () => new MemberSyntax(field.WithoutLeadingTrivia());
this.WithLeadingTrivia = x => new MemberSyntax(field.WithLeadingTrivia(x));
this.AddAttributeLists = xs => new MemberSyntax(field.AddAttributeLists(xs));
this.Self = field;
}
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
{
string fullName = SyntaxUtils.GetFullName(node);
this.GetRemapInfo(fullName, out var listAttributes, node.Declaration.Type.ToString(), out string newType, out string newName);
// ClangSharp mistakenly emits string[] for WCHAR[] Foo = "Bar".
// Change it to string
if (newType == null && node.Declaration.Type.ToString() == "string[]")
{
newType = "string";
}
// Turn public static readonly Guids into string constants with an attribute
// to signal language projections to turn them into Guid constants. Guid constants
// aren't allowed in metadata, requiring us to surface them this way
if (node.Modifiers.ToString() == "public static readonly" && node.Declaration.Type.ToString() == "Guid")
{
Guid guidVal = Guid.Empty;
var varInitializer = node.Declaration.Variables.First().Initializer;
if (varInitializer.Value is ObjectCreationExpressionSyntax objCreationSyntax)
{
var args = objCreationSyntax.ArgumentList.Arguments;
if (args.Count == 11)
{
uint p0 = EncodeHelpers.ParseHex(args[0].ToString());
ushort p1 = (ushort)EncodeHelpers.ParseHex(args[1].ToString());
ushort p2 = (ushort)EncodeHelpers.ParseHex(args[2].ToString());
byte p3 = (byte)EncodeHelpers.ParseHex(args[3].ToString());
byte p4 = (byte)EncodeHelpers.ParseHex(args[4].ToString());
byte p5 = (byte)EncodeHelpers.ParseHex(args[5].ToString());
byte p6 = (byte)EncodeHelpers.ParseHex(args[6].ToString());
byte p7 = (byte)EncodeHelpers.ParseHex(args[7].ToString());
byte p8 = (byte)EncodeHelpers.ParseHex(args[8].ToString());
byte p9 = (byte)EncodeHelpers.ParseHex(args[9].ToString());
byte p10 = (byte)EncodeHelpers.ParseHex(args[10].ToString());
guidVal = new Guid(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
}
else if (objCreationSyntax.ArgumentList.Arguments.Count == 1)
{
// If this is an invalid format, remove the node
if (!Guid.TryParse(objCreationSyntax.ArgumentList.Arguments[0].ToString(), out guidVal))
{
return(null);
}
}
}
if (guidVal == Guid.Empty)
{
return(node);
}
node = node.RemoveNode(varInitializer, SyntaxRemoveOptions.KeepExteriorTrivia | SyntaxRemoveOptions.KeepEndOfLine);
node = node.AddAttributeLists(EncodeHelpers.ConvertGuidToAttributeList(guidVal).WithLeadingTrivia(node.GetLeadingTrivia()));
return(node);
}
node = (FieldDeclarationSyntax)base.VisitFieldDeclaration(node);
if (listAttributes != null)
{
foreach (var attrNode in listAttributes)
{
var attrListNode =
SyntaxFactory.AttributeList(
SyntaxFactory.SingletonSeparatedList <AttributeSyntax>(attrNode));
node = node.WithAttributeLists(node.AttributeLists.Add(attrListNode));
}
}
var firstVar = node.Declaration.Variables.First();
if (newName != null)
{
var newVar = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(newName));
node = node.ReplaceNode(firstVar, newVar);
}
if (newType != null)
{
node = node.WithDeclaration(node.Declaration.WithType(SyntaxFactory.ParseTypeName(newType).WithTrailingTrivia(SyntaxFactory.Space)));
}
return(node);
}
public static FieldDeclarationSyntax AddAttributes(this FieldDeclarationSyntax field, params string[] attributeNames)
{
return(field.AddAttributeLists(MakeAttributes(attributeNames)));
}
private static Task <Document> ApplyNonSerializedFixAsync(CodeFixContext context, SyntaxNode syntaxRoot, FieldDeclarationSyntax field)
{
var updated = field.AddAttributeLists(NonSerialized);
return(Task.FromResult(context.Document.WithSyntaxRoot(syntaxRoot.ReplaceNode(field, updated))));
}
public override SyntaxNode VisitFieldDeclaration(FieldDeclarationSyntax node)
{
if (node.Parent is not CompilationUnitSyntax)
{
return(node);
}
var variableDeclarator = node.GetSingleDeclarator();
var invocationExpression = variableDeclarator.Initializer?.Value as InvocationExpressionSyntax;
if (invocationExpression?.GetIdentifierName() != "Argument")
{
return(node);
}
var originalNode = node;
var resolutionName = invocationExpression.GetArgumentAt <LiteralExpressionSyntax>(0).GetConstantValue <string>();
var defaultValue = invocationExpression.GetArgumentAt <ExpressionSyntax>(1);
var nonDefaultValue = defaultValue is LiteralExpressionSyntax literalExpression
? literalExpression.GetNonDefaultValue()
: defaultValue;
AttributeListSyntax CreateAttributeListWith(string name, string argument = null)
{
var attribute = Attribute(IdentifierName(name));
if (argument != null)
{
attribute = attribute.WithArgumentList(AttributeArgumentList(
SeparatedList(new[] { AttributeArgument(argument.ToLiteralExpression()) })));
}
return(AttributeList(SeparatedList(new[] { attribute })));
}
node = node.WithoutTrivia();
node = node.AddAttributeLists(
CreateAttributeListWith(
"Parameter",
!resolutionName.Replace("_", string.Empty).Replace("-", string.Empty)
.EqualsOrdinalIgnoreCase(variableDeclarator.Identifier.Text)
? resolutionName
: null));
node = node.WithDeclaration(
node.Declaration.WithType(
variableDeclarator.Identifier.Text.ContainsAnyOrdinalIgnoreCase("path", "dir", "file")
? ParseTypeName(nameof(AbsolutePath))
: invocationExpression.GetSingleGenericArgumentOrNull() ?? defaultValue.GetExpressionType()));
node = node.WithDeclaration(
node.Declaration
.WithVariables(
SeparatedList(node.Declaration.Variables
.Select(x => x.WithInitializer(nonDefaultValue != null
? EqualsValueClause(nonDefaultValue)
: null)))));
node = node.WithModifiers(TokenList(Token(SyntaxKind.ReadOnlyKeyword)));
if (variableDeclarator.Identifier.Text.ContainsAnyOrdinalIgnoreCase("password", "key", "token", "secret", "credentials"))
{
node = node.AddAttributeLists(CreateAttributeListWith("Secret"));
}
return(node.WithTriviaFrom(originalNode));
}
public static FieldDeclarationSyntax WithAttributes(this FieldDeclarationSyntax node, params AttributeSyntax[] attributes)
{
return(node.AddAttributeLists(AttributeList(SeparatedList(attributes))));
}
public static FieldDeclarationSyntax AddAttribute(this FieldDeclarationSyntax fieldDeclarationSyntax, AttributeSyntax attributeSyntax)
{
var attributeList = SyntaxFactory.AttributeList().AddAttributes(attributeSyntax);
return(fieldDeclarationSyntax.AddAttributeLists(attributeList));
}
public static FieldDeclarationSyntax WithGeneratedAttribute(this FieldDeclarationSyntax node) => node.AddAttributeLists(AttributeList(SingletonSeparatedList(CreateGeneratedCodeAttribute())));