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