119 lines
3.9 KiB
C#
119 lines
3.9 KiB
C#
using System.Collections.Generic;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;
|
|
|
|
namespace Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
|
|
public sealed class AttributeSyntax : CSharpSyntaxNode
|
|
{
|
|
private NameSyntax? name;
|
|
|
|
private AttributeArgumentListSyntax? argumentList;
|
|
|
|
public NameSyntax Name => ((SyntaxNode)this).GetRedAtZero<NameSyntax>(ref name);
|
|
|
|
public AttributeArgumentListSyntax? ArgumentList => ((SyntaxNode)this).GetRed<AttributeArgumentListSyntax>(ref argumentList, 1);
|
|
|
|
internal string GetErrorDisplayName()
|
|
{
|
|
return Name.ErrorDisplayName();
|
|
}
|
|
|
|
internal AttributeArgumentSyntax? GetNamedArgumentSyntax(string namedArgName)
|
|
{
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
|
if (argumentList != null)
|
|
{
|
|
Enumerator<AttributeArgumentSyntax> enumerator = argumentList.Arguments.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
AttributeArgumentSyntax current = enumerator.Current;
|
|
if (current.NameEquals != null)
|
|
{
|
|
SyntaxToken identifier = current.NameEquals.Name.Identifier;
|
|
if (((SyntaxToken)(ref identifier)).ValueText == namedArgName)
|
|
{
|
|
return current;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal AttributeSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
|
|
: base((GreenNode)(object)green, parent, position)
|
|
{
|
|
}
|
|
|
|
internal override SyntaxNode? GetNodeSlot(int index)
|
|
{
|
|
return (SyntaxNode?)(index switch
|
|
{
|
|
0 => ((SyntaxNode)this).GetRedAtZero<NameSyntax>(ref name),
|
|
1 => ((SyntaxNode)this).GetRed<AttributeArgumentListSyntax>(ref argumentList, 1),
|
|
_ => null,
|
|
});
|
|
}
|
|
|
|
internal override SyntaxNode? GetCachedSlot(int index)
|
|
{
|
|
return (SyntaxNode?)(index switch
|
|
{
|
|
0 => name,
|
|
1 => argumentList,
|
|
_ => null,
|
|
});
|
|
}
|
|
|
|
public override void Accept(CSharpSyntaxVisitor visitor)
|
|
{
|
|
visitor.VisitAttribute(this);
|
|
}
|
|
|
|
public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor)
|
|
{
|
|
return visitor.VisitAttribute(this);
|
|
}
|
|
|
|
public AttributeSyntax Update(NameSyntax name, AttributeArgumentListSyntax? argumentList)
|
|
{
|
|
if (name != Name || argumentList != ArgumentList)
|
|
{
|
|
AttributeSyntax attributeSyntax = SyntaxFactory.Attribute(name, argumentList);
|
|
SyntaxAnnotation[] annotations = ((SyntaxNode)this).GetAnnotations();
|
|
if (annotations == null || annotations.Length == 0)
|
|
{
|
|
return attributeSyntax;
|
|
}
|
|
return attributeSyntax.WithAnnotations(annotations);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public AttributeSyntax WithName(NameSyntax name)
|
|
{
|
|
return Update(name, ArgumentList);
|
|
}
|
|
|
|
public AttributeSyntax WithArgumentList(AttributeArgumentListSyntax? argumentList)
|
|
{
|
|
return Update(Name, argumentList);
|
|
}
|
|
|
|
public AttributeSyntax AddArgumentListArguments(params AttributeArgumentSyntax[] items)
|
|
{
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
|
|
AttributeArgumentListSyntax attributeArgumentListSyntax = ArgumentList ?? SyntaxFactory.AttributeArgumentList();
|
|
return WithArgumentList(attributeArgumentListSyntax.WithArguments(attributeArgumentListSyntax.Arguments.AddRange((IEnumerable<AttributeArgumentSyntax>)items)));
|
|
}
|
|
}
|