public static void MoveModifier(
CodeFixContext context,
Diagnostic diagnostic,
SyntaxNode node,
SyntaxToken modifier,
string title = null,
string additionalKey = null,
IModifierComparer comparer = null)
{
Document document = context.Document;
SyntaxKind kind = modifier.Kind();
CodeAction codeAction = CodeAction.Create(
title ?? GetRemoveModifierTitle(kind),
cancellationToken =>
{
SyntaxNode newNode = node
.RemoveModifier(modifier)
.InsertModifier(kind, comparer);
return(document.ReplaceNodeAsync(node, newNode, cancellationToken));
},
GetEquivalenceKey(diagnostic, additionalKey));
context.RegisterCodeFix(codeAction, diagnostic);
}
public static TNode ChangeAccessibility <TNode>(
TNode node,
Accessibility newAccessibility,
IModifierComparer comparer = null) where TNode : SyntaxNode
{
return(ChangeAccessibility(node, AccessibilityInfo.Create(node.GetModifiers()), newAccessibility, comparer));
}
public static void AddModifier <TNode>(
CodeFixContext context,
Diagnostic diagnostic,
IEnumerable <TNode> nodes,
SyntaxKind kind,
string title = null,
string additionalKey = null,
IModifierComparer comparer = null) where TNode : SyntaxNode
{
if (nodes is IList <TNode> list &&
list.Count == 1)
{
AddModifier(context, diagnostic, list[0], kind, title, additionalKey, comparer);
return;
}
CodeAction codeAction = CodeAction.Create(
title ?? GetAddModifierTitle(kind),
cancellationToken =>
{
return(context.Solution().ReplaceNodesAsync(
nodes,
(f, g) => AddModifier(f, kind, comparer),
cancellationToken));
},
GetEquivalenceKey(diagnostic, additionalKey));
context.RegisterCodeFix(codeAction, diagnostic);
}
public static TNode ChangeAccessibility <TNode>(
TNode node,
Accessibility newAccessibility,
IModifierComparer comparer = null) where TNode : SyntaxNode
{
AccessibilityInfo info = SyntaxInfo.AccessibilityInfo(node);
AccessibilityInfo newInfo = ChangeAccessibility(info, newAccessibility, comparer);
return((TNode)newInfo.Node);
}
public static AccessibilityInfo ChangeAccessibility(
AccessibilityInfo info,
Accessibility newAccessibility,
IModifierComparer comparer = null)
{
if (!info.Success)
{
return(info);
}
Accessibility accessibility = info.Accessibility;
if (accessibility == newAccessibility)
{
return(info);
}
comparer = comparer ?? ModifierComparer.Instance;
SyntaxNode node = info.Node;
if (IsSingleTokenAccessibility(accessibility) &&
IsSingleTokenAccessibility(newAccessibility))
{
int insertIndex = comparer.GetInsertIndex(info.Modifiers, GetKind(newAccessibility));
if (info.TokenIndex == insertIndex ||
info.TokenIndex == insertIndex - 1)
{
SyntaxToken newToken = CreateToken(newAccessibility).WithTriviaFrom(info.Token);
SyntaxTokenList newModifiers = info.Modifiers.Replace(info.Token, newToken);
return(info.WithModifiers(newModifiers));
}
}
if (accessibility != Accessibility.NotApplicable)
{
node = Modifier.RemoveAt(node, Math.Max(info.TokenIndex, info.SecondTokenIndex));
if (info.SecondTokenIndex != -1)
{
node = Modifier.RemoveAt(node, Math.Min(info.TokenIndex, info.SecondTokenIndex));
}
}
if (newAccessibility != Accessibility.NotApplicable)
{
node = InsertModifier(node, newAccessibility, comparer);
}
return(SyntaxInfo.AccessibilityInfo(node));
}
private static Task <Document> AddModifierAsync <TNode>(
Document document,
TNode node,
SyntaxKind modifierKind,
IModifierComparer comparer = null,
CancellationToken cancellationToken = default(CancellationToken)) where TNode : SyntaxNode
{
TNode newNode = AddModifier(node, modifierKind, comparer);
return(document.ReplaceNodeAsync(node, newNode, cancellationToken));
}
public static void AddModifier(
CodeFixContext context,
Diagnostic diagnostic,
SyntaxNode node,
SyntaxKind modifierKind,
string title = null,
string additionalKey = null,
IModifierComparer comparer = null)
{
Document document = context.Document;
AddModifier(context, document, diagnostic, node, modifierKind, title, additionalKey, comparer);
}
private static TNode AddModifier <TNode>(
TNode node,
SyntaxKind modifierKind,
IModifierComparer comparer = null) where TNode : SyntaxNode
{
switch (modifierKind)
{
case SyntaxKind.AbstractKeyword:
{
node = node
.RemoveModifier(SyntaxKind.VirtualKeyword)
.RemoveModifier(SyntaxKind.OverrideKeyword);
break;
}
case SyntaxKind.VirtualKeyword:
{
node = node
.RemoveModifier(SyntaxKind.AbstractKeyword)
.RemoveModifier(SyntaxKind.OverrideKeyword);
break;
}
case SyntaxKind.OverrideKeyword:
{
node = node
.RemoveModifier(SyntaxKind.AbstractKeyword)
.RemoveModifier(SyntaxKind.VirtualKeyword);
break;
}
case SyntaxKind.StaticKeyword:
{
if (node.Kind() == SyntaxKind.ConstructorDeclaration)
{
node = Modifier.RemoveAccess(node);
}
node = node.RemoveModifier(SyntaxKind.SealedKeyword);
break;
}
}
return(node.InsertModifier(modifierKind, comparer));
}
internal static TNode ChangeAccessibility <TNode>(
TNode node,
AccessibilityInfo info,
Accessibility newAccessibility,
IModifierComparer comparer = null) where TNode : SyntaxNode
{
Accessibility accessibility = info.Accessibility;
if (accessibility == newAccessibility)
{
return(node);
}
comparer = comparer ?? ModifierComparer.Instance;
if (IsSingleTokenAccessibility(accessibility) &&
IsSingleTokenAccessibility(newAccessibility))
{
int insertIndex = comparer.GetInsertIndex(info.Modifiers, GetKind(newAccessibility));
if (info.Index == insertIndex ||
info.Index == insertIndex - 1)
{
SyntaxToken newToken = CreateToken(newAccessibility).WithTriviaFrom(info.Token);
SyntaxTokenList newModifiers = info.Modifiers.Replace(info.Token, newToken);
return(node.WithModifiers(newModifiers));
}
}
if (accessibility != Accessibility.NotApplicable)
{
node = ModifierHelper.RemoveModifierAt(node, Math.Max(info.Index, info.AdditionalIndex));
if (accessibility == Accessibility.ProtectedOrInternal)
{
node = ModifierHelper.RemoveModifierAt(node, Math.Min(info.Index, info.AdditionalIndex));
}
}
if (newAccessibility != Accessibility.NotApplicable)
{
node = (TNode)InsertModifier(node, newAccessibility, comparer);
}
return(node);
}
public static void AddModifier(
CodeFixContext context,
Document document,
Diagnostic diagnostic,
SyntaxNode node,
SyntaxKind modifierKind,
string title = null,
string additionalKey = null,
IModifierComparer comparer = null)
{
CodeAction codeAction = CodeAction.Create(
title ?? GetAddModifierTitle(modifierKind, node),
cancellationToken => AddModifierAsync(document, node, modifierKind, comparer, cancellationToken),
GetEquivalenceKey(diagnostic, additionalKey));
context.RegisterCodeFix(codeAction, diagnostic);
}
public TNode InsertModifier(TNode node, SyntaxToken modifier, IModifierComparer comparer = null)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
SyntaxTokenList modifiers = GetModifiers(node);
Debug.Assert(modifiers.Any() || modifiers == default(SyntaxTokenList), node.ToString());
if (!modifiers.Any())
{
SyntaxNodeOrToken nodeOrToken = FindNodeOrTokenAfterModifiers(node);
if (!nodeOrToken.IsKind(SyntaxKind.None))
{
SyntaxTriviaList trivia = nodeOrToken.GetLeadingTrivia();
if (trivia.Any())
{
SyntaxTriviaList leadingTrivia = modifier.LeadingTrivia;
if (!leadingTrivia.IsSingleElasticMarker())
{
trivia = trivia.AddRange(leadingTrivia);
}
if (nodeOrToken.IsNode)
{
SyntaxNode node2 = nodeOrToken.AsNode();
node = node.ReplaceNode(node2, node2.WithoutLeadingTrivia());
}
else
{
SyntaxToken token = nodeOrToken.AsToken();
node = node.ReplaceToken(token, token.WithoutLeadingTrivia());
}
return(WithModifiers(node, TokenList(modifier.WithLeadingTrivia(trivia))));
}
}
}
return(WithModifiers(node, modifiers.InsertModifier(modifier, comparer ?? ModifierComparer.Instance)));
}
internal static async Task <Document> InsertModifierAsync(
this Document document,
SyntaxNode node,
SyntaxKind modifierKind,
IModifierComparer comparer = null,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxTokenList modifiers = node.GetModifiers();
if (!modifiers.Contains(modifierKind))
{
SyntaxNode newNode = node.InsertModifier(modifierKind, comparer);
return(await document.ReplaceNodeAsync(node, newNode, cancellationToken).ConfigureAwait(false));
}
else
{
return(document);
}
}
private static MemberDeclarationSyntax AddModifier(
MemberDeclarationSyntax memberDeclaration,
SyntaxKind kind,
IModifierComparer comparer = null)
{
switch (kind)
{
case SyntaxKind.AbstractKeyword:
{
memberDeclaration = memberDeclaration
.RemoveModifier(SyntaxKind.VirtualKeyword)
.RemoveModifier(SyntaxKind.OverrideKeyword);
break;
}
case SyntaxKind.VirtualKeyword:
{
memberDeclaration = memberDeclaration
.RemoveModifier(SyntaxKind.AbstractKeyword)
.RemoveModifier(SyntaxKind.OverrideKeyword);
break;
}
case SyntaxKind.OverrideKeyword:
{
memberDeclaration = memberDeclaration
.RemoveModifier(SyntaxKind.AbstractKeyword)
.RemoveModifier(SyntaxKind.VirtualKeyword);
break;
}
}
return(memberDeclaration.InsertModifier(kind, comparer));
}
private static SyntaxNode InsertModifier(SyntaxNode node, Accessibility accessibility, IModifierComparer comparer)
{
switch (accessibility)
{
case Accessibility.Private:
{
return(node.InsertModifier(SyntaxKind.PrivateKeyword, comparer));
}
case Accessibility.Protected:
{
return(node.InsertModifier(SyntaxKind.ProtectedKeyword, comparer));
}
case Accessibility.ProtectedAndInternal:
{
node = node.InsertModifier(SyntaxKind.PrivateKeyword, comparer);
return(node.InsertModifier(SyntaxKind.ProtectedKeyword, comparer));
}
case Accessibility.Internal:
{
return(node.InsertModifier(SyntaxKind.InternalKeyword, comparer));
}
case Accessibility.Public:
{
return(node.InsertModifier(SyntaxKind.PublicKeyword, comparer));
}
case Accessibility.ProtectedOrInternal:
{
node = node.InsertModifier(SyntaxKind.ProtectedKeyword, comparer);
return(node.InsertModifier(SyntaxKind.InternalKeyword, comparer));
}
}
return(node);
}
public static ConstructorDeclarationSyntax InsertModifier(ConstructorDeclarationSyntax constructorDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (constructorDeclaration == null)
{
throw new ArgumentNullException(nameof(constructorDeclaration));
}
SyntaxTokenList modifiers = constructorDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken identifier = constructorDeclaration.Identifier;
return(constructorDeclaration
.WithIdentifier(identifier.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(identifier.LeadingTrivia))));
}
return(constructorDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static ConversionOperatorDeclarationSyntax InsertModifier(ConversionOperatorDeclarationSyntax conversionOperatorDeclaration, SyntaxKind modifierKind, IModifierComparer comparer)
{
return(InsertModifier(conversionOperatorDeclaration, Token(modifierKind), comparer));
}
public static DelegateDeclarationSyntax InsertModifier(DelegateDeclarationSyntax delegateDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (delegateDeclaration == null)
{
throw new ArgumentNullException(nameof(delegateDeclaration));
}
SyntaxTokenList modifiers = delegateDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken delegateKeyword = delegateDeclaration.DelegateKeyword;
return(delegateDeclaration
.WithDelegateKeyword(delegateKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(delegateKeyword.LeadingTrivia))));
}
return(delegateDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static PropertyDeclarationSyntax InsertModifier(PropertyDeclarationSyntax propertyDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (propertyDeclaration == null)
{
throw new ArgumentNullException(nameof(propertyDeclaration));
}
SyntaxTokenList modifiers = propertyDeclaration.Modifiers;
if (!modifiers.Any())
{
TypeSyntax type = propertyDeclaration.Type;
return(propertyDeclaration
.WithType(type.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(type.GetLeadingTrivia()))));
}
return(propertyDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public TNode InsertModifier(TNode node, SyntaxToken modifier, IModifierComparer comparer = null)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
SyntaxTokenList modifiers = GetModifiers(node);
int insertIndex = (comparer ?? ModifierComparer.Instance).GetInsertIndex(modifiers, modifier);
var token = default(SyntaxToken);
if (!modifiers.Any() ||
insertIndex == modifiers.Count)
{
SyntaxNodeOrToken nodeOrToken = FindNodeOrTokenAfterModifiers(node);
if (nodeOrToken.IsToken)
{
token = nodeOrToken.AsToken();
}
else if (nodeOrToken.IsNode)
{
token = nodeOrToken.AsNode().GetFirstToken();
}
}
else
{
token = modifiers[insertIndex];
}
if (token != default(SyntaxToken))
{
SyntaxTriviaList newLeadingTrivia = token.LeadingTrivia;
if (newLeadingTrivia.Any())
{
SyntaxTriviaList leadingTrivia = modifier.LeadingTrivia;
if (!leadingTrivia.IsSingleElasticMarker())
{
newLeadingTrivia = newLeadingTrivia.AddRange(leadingTrivia);
}
modifier = modifier.WithLeadingTrivia(newLeadingTrivia);
SyntaxToken newToken = token.WithoutLeadingTrivia();
if (!modifiers.Any() ||
insertIndex == modifiers.Count)
{
node = node.ReplaceToken(token, newToken);
}
else
{
modifiers = modifiers.ReplaceAt(insertIndex, newToken);
}
}
if (modifier.TrailingTrivia.IsSingleElasticMarker())
{
modifier = modifier.WithTrailingTrivia(TriviaList(Space));
}
}
modifiers = modifiers.Insert(insertIndex, modifier);
return(WithModifiers(node, modifiers));
}
public static PropertyDeclarationSyntax InsertModifier(PropertyDeclarationSyntax propertyDeclaration, SyntaxKind modifierKind, IModifierComparer comparer)
{
return(InsertModifier(propertyDeclaration, Token(modifierKind), comparer));
}
private static MemberDeclarationSyntax GetNewMemberDeclaration(MemberDeclarationSyntax member, Accessibility accessibility, IModifierComparer comparer)
{
SyntaxKind modifierKind = GetFirstModifierKind(accessibility);
switch (member.Kind())
{
case SyntaxKind.ClassDeclaration:
{
ClassDeclarationSyntax declaration = ((ClassDeclarationSyntax)member)
.InsertModifier(modifierKind, comparer);
if (accessibility == Accessibility.ProtectedOrInternal)
{
return(declaration.InsertModifier(SyntaxKind.InternalKeyword, comparer));
}
return(declaration);
}
case SyntaxKind.ConstructorDeclaration:
{
return(((ConstructorDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.ConversionOperatorDeclaration:
{
return(((ConversionOperatorDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.DelegateDeclaration:
{
return(((DelegateDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.EnumDeclaration:
{
return(((EnumDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.EventDeclaration:
{
return(((EventDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.EventFieldDeclaration:
{
return(((EventFieldDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.FieldDeclaration:
{
return(((FieldDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.IndexerDeclaration:
{
return(((IndexerDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.InterfaceDeclaration:
{
InterfaceDeclarationSyntax declaration = ((InterfaceDeclarationSyntax)member)
.InsertModifier(modifierKind, comparer);
if (accessibility == Accessibility.ProtectedOrInternal)
{
return(declaration.InsertModifier(SyntaxKind.InternalKeyword, comparer));
}
return(declaration);
}
case SyntaxKind.MethodDeclaration:
{
return(((MethodDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.OperatorDeclaration:
{
return(((OperatorDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.PropertyDeclaration:
{
return(((PropertyDeclarationSyntax)member).InsertModifier(modifierKind, comparer));
}
case SyntaxKind.StructDeclaration:
{
StructDeclarationSyntax declaration = ((StructDeclarationSyntax)member)
.InsertModifier(modifierKind, comparer);
if (accessibility == Accessibility.ProtectedOrInternal)
{
return(declaration.InsertModifier(SyntaxKind.InternalKeyword, comparer));
}
return(declaration);
}
default:
{
Debug.Fail(member.Kind().ToString());
return(member);
}
}
}
public static ConversionOperatorDeclarationSyntax InsertModifier(ConversionOperatorDeclarationSyntax conversionOperatorDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (conversionOperatorDeclaration == null)
{
throw new ArgumentNullException(nameof(conversionOperatorDeclaration));
}
SyntaxTokenList modifiers = conversionOperatorDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken implicitOrExplicitKeyword = conversionOperatorDeclaration.ImplicitOrExplicitKeyword;
return(conversionOperatorDeclaration
.WithImplicitOrExplicitKeyword(implicitOrExplicitKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(implicitOrExplicitKeyword.LeadingTrivia))));
}
return(conversionOperatorDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static TNode InsertModifier <TNode>(TNode node, SyntaxToken modifier, IModifierComparer comparer = null) where TNode : SyntaxNode
{
switch (node.Kind())
{
case SyntaxKind.ClassDeclaration:
return((TNode)(SyntaxNode)ClassDeclarationModifierHelper.Instance.InsertModifier((ClassDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.ConstructorDeclaration:
return((TNode)(SyntaxNode)ConstructorDeclarationModifierHelper.Instance.InsertModifier((ConstructorDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.ConversionOperatorDeclaration:
return((TNode)(SyntaxNode)ConversionOperatorDeclarationModifierHelper.Instance.InsertModifier((ConversionOperatorDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.DelegateDeclaration:
return((TNode)(SyntaxNode)DelegateDeclarationModifierHelper.Instance.InsertModifier((DelegateDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.DestructorDeclaration:
return((TNode)(SyntaxNode)DestructorDeclarationModifierHelper.Instance.InsertModifier((DestructorDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.EnumDeclaration:
return((TNode)(SyntaxNode)EnumDeclarationModifierHelper.Instance.InsertModifier((EnumDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.EventDeclaration:
return((TNode)(SyntaxNode)EventDeclarationModifierHelper.Instance.InsertModifier((EventDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.EventFieldDeclaration:
return((TNode)(SyntaxNode)EventFieldDeclarationModifierHelper.Instance.InsertModifier((EventFieldDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.FieldDeclaration:
return((TNode)(SyntaxNode)FieldDeclarationModifierHelper.Instance.InsertModifier((FieldDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.IndexerDeclaration:
return((TNode)(SyntaxNode)IndexerDeclarationModifierHelper.Instance.InsertModifier((IndexerDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.InterfaceDeclaration:
return((TNode)(SyntaxNode)InterfaceDeclarationModifierHelper.Instance.InsertModifier((InterfaceDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.MethodDeclaration:
return((TNode)(SyntaxNode)MethodDeclarationModifierHelper.Instance.InsertModifier((MethodDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.OperatorDeclaration:
return((TNode)(SyntaxNode)OperatorDeclarationModifierHelper.Instance.InsertModifier((OperatorDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.PropertyDeclaration:
return((TNode)(SyntaxNode)PropertyDeclarationModifierHelper.Instance.InsertModifier((PropertyDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.StructDeclaration:
return((TNode)(SyntaxNode)StructDeclarationModifierHelper.Instance.InsertModifier((StructDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
case SyntaxKind.AddAccessorDeclaration:
case SyntaxKind.RemoveAccessorDeclaration:
case SyntaxKind.UnknownAccessorDeclaration:
return((TNode)(SyntaxNode)AccessorDeclarationModifierHelper.Instance.InsertModifier((AccessorDeclarationSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.LocalDeclarationStatement:
return((TNode)(SyntaxNode)LocalDeclarationStatementModifierHelper.Instance.InsertModifier((LocalDeclarationStatementSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.LocalFunctionStatement:
return((TNode)(SyntaxNode)LocalFunctionStatementModifierHelper.Instance.InsertModifier((LocalFunctionStatementSyntax)(SyntaxNode)node, modifier, comparer));
case SyntaxKind.Parameter:
return((TNode)(SyntaxNode)ParameterModifierHelper.Instance.InsertModifier((ParameterSyntax)(SyntaxNode)node, modifier, comparer));
}
Debug.Assert(node.IsKind(SyntaxKind.IncompleteMember), node.ToString());
return(node);
}
public static TNode InsertModifier <TNode>(TNode node, SyntaxKind modifierKind, IModifierComparer comparer = null) where TNode : SyntaxNode
{
return(InsertModifier(node, Token(modifierKind), comparer));
}
public static StructDeclarationSyntax InsertModifier(StructDeclarationSyntax structDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (structDeclaration == null)
{
throw new ArgumentNullException(nameof(structDeclaration));
}
SyntaxTokenList modifiers = structDeclaration.Modifiers;
if (!modifiers.Any())
{
SyntaxToken structKeyword = structDeclaration.Keyword;
return(structDeclaration
.WithKeyword(structKeyword.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(structKeyword.LeadingTrivia))));
}
return(structDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public AccessibilityInfo WithAccessibility(Accessibility newAccessibility, IModifierComparer comparer = null)
{
return(ChangeAccessibilityHelper.ChangeAccessibility(this, newAccessibility, comparer));
}
public static StructDeclarationSyntax InsertModifier(StructDeclarationSyntax structDeclaration, SyntaxKind modifierKind, IModifierComparer comparer)
{
return(InsertModifier(structDeclaration, Token(modifierKind), comparer));
}
public TNode InsertModifier(TNode node, SyntaxKind modifierKind, IModifierComparer comparer = null)
{
return(InsertModifier(node, Token(modifierKind), comparer));
}
public static OperatorDeclarationSyntax InsertModifier(OperatorDeclarationSyntax operatorDeclaration, SyntaxToken modifier, IModifierComparer comparer)
{
if (operatorDeclaration == null)
{
throw new ArgumentNullException(nameof(operatorDeclaration));
}
SyntaxTokenList modifiers = operatorDeclaration.Modifiers;
if (!modifiers.Any())
{
TypeSyntax returnType = operatorDeclaration.ReturnType;
return(operatorDeclaration
.WithReturnType(returnType.WithoutLeadingTrivia())
.WithModifiers(TokenList(modifier.WithLeadingTrivia(returnType.GetLeadingTrivia()))));
}
return(operatorDeclaration.WithModifiers(modifiers.InsertModifier(modifier, comparer)));
}
public static DelegateDeclarationSyntax InsertModifier(DelegateDeclarationSyntax delegateDeclaration, SyntaxKind modifierKind, IModifierComparer comparer)
{
return(InsertModifier(delegateDeclaration, Token(modifierKind), comparer));
}
