public static ConstructorDeclarationSyntax AddStaticModifier(ConstructorDeclarationSyntax constructorDeclaration)
{
SyntaxTokenList modifiers = constructorDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
SyntaxTokenList newModifiers = modifiers;
if (modifiers.ContainsAccessModifier())
{
newModifiers = modifiers.RemoveAccessModifiers();
if (newModifiers.Any())
{
newModifiers = newModifiers.ReplaceAt(0, newModifiers[0].WithLeadingTrivia(modifiers[0].LeadingTrivia));
newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword);
}
else
{
newModifiers = Inserter.InsertModifier(newModifiers, CSharpFactory.StaticKeyword().WithLeadingTrivia(modifiers[0].LeadingTrivia));
}
}
else
{
newModifiers = Inserter.InsertModifier(newModifiers, SyntaxKind.StaticKeyword);
}
return(constructorDeclaration.WithModifiers(newModifiers));
}
else
{
return(constructorDeclaration);
}
}
public static async Task <Document> RefactorAsync(
Document document,
ClassDeclarationSyntax classDeclaration,
SyntaxKind modifierKind,
CancellationToken cancellationToken = default(CancellationToken))
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (classDeclaration == null)
{
throw new ArgumentNullException(nameof(classDeclaration));
}
SyntaxTokenList modifiers = classDeclaration.Modifiers;
Debug.Assert(!modifiers.Contains(modifierKind), modifierKind.ToString());
if (!modifiers.Contains(modifierKind))
{
SyntaxToken modifier = Token(modifierKind);
ClassDeclarationSyntax newClassDeclaration = Inserter.InsertModifier(classDeclaration, modifier);
return(await document.ReplaceNodeAsync(classDeclaration, newClassDeclaration, cancellationToken).ConfigureAwait(false));
}
else
{
return(document);
}
}
public static Task <Document> RefactorAsync(
Document document,
FieldDeclarationSyntax fieldDeclaration,
CancellationToken cancellationToken)
{
FieldDeclarationSyntax newNode = Inserter.InsertModifier(fieldDeclaration, SyntaxKind.ReadOnlyKeyword);
return(document.ReplaceNodeAsync(fieldDeclaration, newNode, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
MemberDeclarationSyntax memberDeclaration,
OverrideInfo overrideInfo,
CancellationToken cancellationToken)
{
SyntaxTokenList modifiers = memberDeclaration.GetModifiers();
Accessibility accessibility = overrideInfo.Symbol.DeclaredAccessibility;
Accessibility newAccessibility = overrideInfo.OverridenSymbol.DeclaredAccessibility;
int index = IndexOfFirstAccessModifier(modifiers);
SyntaxTokenList newModifiers = modifiers;
if (index == -1)
{
foreach (SyntaxToken modifier in Modifiers.FromAccessibility(newAccessibility))
{
newModifiers = Inserter.InsertModifier(newModifiers, modifier);
}
}
else
{
SyntaxToken modifier = modifiers[index];
if (accessibility == Accessibility.ProtectedOrInternal)
{
SyntaxToken newModifier = CreateAccessModifier(newAccessibility)
.WithLeadingTrivia(modifier.LeadingTrivia)
.WithTrailingTrivia(modifiers[index + 1].TrailingTrivia);
newModifiers = newModifiers
.ReplaceAt(index, newModifier)
.RemoveAt(index + 1);
}
else if (newAccessibility == Accessibility.ProtectedOrInternal)
{
newModifiers = newModifiers
.ReplaceAt(index, ProtectedKeyword().WithLeadingTrivia(modifier.LeadingTrivia))
.Insert(index + 1, InternalKeyword().WithTrailingTrivia(modifier.TrailingTrivia));
}
else
{
SyntaxToken newModifier = CreateAccessModifier(newAccessibility).WithTriviaFrom(modifier);
newModifiers = newModifiers.ReplaceAt(index, newModifier);
}
}
return(document.ReplaceNodeAsync(memberDeclaration, memberDeclaration.SetModifiers(newModifiers), cancellationToken));
}
public static EventFieldDeclarationSyntax AddStaticModifier(EventFieldDeclarationSyntax eventFieldDeclaration)
{
SyntaxTokenList modifiers = eventFieldDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
return(Inserter.InsertModifier(eventFieldDeclaration, SyntaxKind.StaticKeyword));
}
else
{
return(eventFieldDeclaration);
}
}
public static PropertyDeclarationSyntax AddStaticModifier(PropertyDeclarationSyntax propertyDeclaration)
{
SyntaxTokenList modifiers = propertyDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
return(Inserter.InsertModifier(propertyDeclaration, SyntaxKind.StaticKeyword));
}
else
{
return(propertyDeclaration);
}
}
public static MethodDeclarationSyntax AddStaticModifier(MethodDeclarationSyntax methodDeclaration)
{
SyntaxTokenList modifiers = methodDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
return(Inserter.InsertModifier(methodDeclaration, SyntaxKind.StaticKeyword));
}
else
{
return(methodDeclaration);
}
}
public static EventFieldDeclarationSyntax AddStaticModifier(EventFieldDeclarationSyntax eventFieldDeclaration)
{
if (eventFieldDeclaration == null)
{
throw new ArgumentNullException(nameof(eventFieldDeclaration));
}
SyntaxTokenList modifiers = eventFieldDeclaration.Modifiers;
if (!modifiers.Contains(SyntaxKind.StaticKeyword))
{
return(Inserter.InsertModifier(eventFieldDeclaration, SyntaxKind.StaticKeyword));
}
else
{
return(eventFieldDeclaration);
}
}
private static SyntaxTokenList GetNewModifiers(SyntaxTokenList modifiers, Accessibility accessibility)
{
switch (accessibility)
{
case Accessibility.Public:
{
return(Inserter.InsertModifier(modifiers, SyntaxKind.PublicKeyword));
}
case Accessibility.Internal:
{
return(Inserter.InsertModifier(modifiers, SyntaxKind.InternalKeyword));
}
case Accessibility.Protected:
{
return(Inserter.InsertModifier(modifiers, SyntaxKind.ProtectedKeyword));
}
case Accessibility.ProtectedOrInternal:
{
modifiers = Inserter.InsertModifier(modifiers, SyntaxKind.ProtectedKeyword);
return(Inserter.InsertModifier(modifiers, SyntaxKind.InternalKeyword));
}
case Accessibility.Private:
{
return(Inserter.InsertModifier(modifiers, SyntaxKind.PrivateKeyword));
}
default:
{
Debug.Assert(false, accessibility.ToString());
return(modifiers);
}
}
}
