private static Task <Document> RefactorAsync(
Document document,
SyntaxToken token,
CancellationToken cancellationToken)
{
SyntaxToken newToken = token.AppendToTrailingTrivia(CSharpFactory.NewLineTrivia());
return(document.ReplaceTokenAsync(token, newToken, cancellationToken));
}
/// <summary>
/// Creates a new node with all modifiers removed.
/// </summary>
/// <param name="node"></param>
public TNode RemoveAll(TNode node)
{
SyntaxTokenList modifiers = GetModifiers(node);
if (!modifiers.Any())
{
return(node);
}
SyntaxToken firstModifier = modifiers[0];
if (modifiers.Count == 1)
{
return(Remove(node, firstModifier));
}
SyntaxToken nextToken = modifiers.Last().GetNextToken();
if (!nextToken.IsKind(SyntaxKind.None))
{
SyntaxTriviaList trivia = firstModifier.LeadingTrivia;
trivia = trivia.AddRange(firstModifier.TrailingTrivia.EmptyIfWhitespace());
for (int i = 1; i < modifiers.Count; i++)
{
trivia = trivia.AddRange(modifiers[i].LeadingAndTrailingTrivia().EmptyIfWhitespace());
}
trivia = trivia.AddRange(nextToken.LeadingTrivia.EmptyIfWhitespace());
node = node.ReplaceToken(nextToken, nextToken.WithLeadingTrivia(trivia));
}
else
{
SyntaxToken previousToken = firstModifier.GetPreviousToken();
if (!previousToken.IsKind(SyntaxKind.None))
{
SyntaxTriviaList trivia = firstModifier.LeadingAndTrailingTrivia();
for (int i = 1; i < modifiers.Count; i++)
{
trivia = trivia.AddRange(modifiers[i].LeadingAndTrailingTrivia().EmptyIfWhitespace());
}
node = node.ReplaceToken(nextToken, nextToken.AppendToTrailingTrivia(trivia));
}
}
return(WithModifiers(node, default(SyntaxTokenList)));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
Diagnostic diagnostic = context.Diagnostics[0];
SyntaxToken token = root.FindToken(context.Span.Start);
if (token.IsKind(SyntaxKind.CommaToken))
{
CodeAction codeAction = CodeAction.Create(
Title,
cancellationToken =>
{
SyntaxToken newToken = token.AppendToTrailingTrivia(CSharpFactory.NewLine());
return(context.Document.ReplaceTokenAsync(token, newToken, cancellationToken));
},
base.GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
else
{
if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration))
{
return;
}
CodeAction codeAction = CodeAction.Create(
Title,
cancellationToken =>
{
MemberDeclarationSyntax newMemberDeclaration = memberDeclaration.AppendToTrailingTrivia(CSharpFactory.NewLine());
return(context.Document.ReplaceNodeAsync(memberDeclaration, newMemberDeclaration, cancellationToken));
},
base.GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
private static PropertyDeclarationSyntax ReplaceMethodWithProperty(MethodDeclarationSyntax methodDeclaration, string propertyName)
{
SyntaxToken identifier = Identifier(propertyName).WithTriviaFrom(methodDeclaration.Identifier);
ParameterListSyntax parameterList = methodDeclaration.ParameterList;
if (parameterList?.IsMissing == false)
{
identifier = identifier.AppendToTrailingTrivia(
parameterList.OpenParenToken.GetLeadingAndTrailingTrivia().Concat(
parameterList.CloseParenToken.GetLeadingAndTrailingTrivia()));
}
if (methodDeclaration.ExpressionBody != null)
{
return(PropertyDeclaration(
methodDeclaration.AttributeLists,
methodDeclaration.Modifiers,
methodDeclaration.ReturnType,
methodDeclaration.ExplicitInterfaceSpecifier,
identifier,
default(AccessorListSyntax),
methodDeclaration.ExpressionBody,
default(EqualsValueClauseSyntax),
methodDeclaration.SemicolonToken));
}
else
{
return(PropertyDeclaration(
methodDeclaration.AttributeLists,
methodDeclaration.Modifiers,
methodDeclaration.ReturnType,
methodDeclaration.ExplicitInterfaceSpecifier,
identifier,
CreateAccessorList(methodDeclaration)));
}
}
public static SyntaxToken AppendEndOfLineToTrailingTrivia(this SyntaxToken token)
{
SyntaxTrivia endOfLine = SyntaxTriviaAnalysis.GetEndOfLine(token);
return(token.AppendToTrailingTrivia(endOfLine));
}
