private static async Task <Document> RemoveRedundantCommaAsync(
Document document,
InitializerExpressionSyntax initializer,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxToken lastComma = initializer.Expressions.GetSeparators().Last();
SyntaxTriviaList newTrailingTrivia = initializer.Expressions.Last().GetTrailingTrivia()
.AddRange(lastComma.GetLeadingAndTrailingTrivia());
SeparatedSyntaxList <ExpressionSyntax> newExpressions = initializer
.Expressions
.ReplaceSeparator(
lastComma,
SyntaxFactory.MissingToken(SyntaxKind.CommaToken));
ExpressionSyntax lastExpression = newExpressions.Last();
newExpressions = newExpressions
.Replace(lastExpression, lastExpression.WithTrailingTrivia(newTrailingTrivia));
InitializerExpressionSyntax newInitializer = initializer
.WithExpressions(newExpressions);
SyntaxNode newRoot = oldRoot.ReplaceNode(initializer, newInitializer);
return(document.WithSyntaxRoot(newRoot));
}
public static void Analyze(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (!node.IsKind(SyntaxKind.IfStatement) ||
!IfElseChain.IsPartOfChain((IfStatementSyntax)node))
{
BlockSyntax block = GetBlockThatCanBeEmbeddedStatement(node);
if (block != null)
{
SyntaxToken openBrace = block.OpenBraceToken;
SyntaxToken closeBrace = block.CloseBraceToken;
if (!openBrace.IsMissing &&
!closeBrace.IsMissing &&
openBrace.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
closeBrace.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveBraces,
block,
GetName(node));
context.ReportBraces(DiagnosticDescriptors.RemoveBracesFadeOut, block);
}
}
}
}
public TNode RemoveModifiers(TNode node)
{
SyntaxTokenList modifiers = GetModifiers(node);
if (!modifiers.Any())
{
return(node);
}
SyntaxToken firstModifier = modifiers.First();
if (modifiers.Count == 1)
{
return(RemoveModifier(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].GetLeadingAndTrailingTrivia().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.GetLeadingAndTrailingTrivia();
for (int i = 1; i < modifiers.Count; i++)
{
trivia = trivia.AddRange(modifiers[i].GetLeadingAndTrailingTrivia().EmptyIfWhitespace());
}
node = node.ReplaceToken(nextToken, nextToken.AppendToTrailingTrivia(trivia));
}
}
return(WithModifiers(node, default(SyntaxTokenList)));
}
private static Func <CancellationToken, Task <Document> > GetCreateChangedDocument(CodeFixContext context, SyntaxNode node)
{
switch (node.Kind())
{
case SyntaxKind.MethodDeclaration:
{
var methodDeclaration = (MethodDeclarationSyntax)node;
SyntaxToken semicolonToken = methodDeclaration.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
ParameterListSyntax parameterList = methodDeclaration.ParameterList;
if (parameterList == null)
{
break;
}
return(cancellationToken =>
{
MethodDeclarationSyntax newNode = methodDeclaration
.WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetLeadingAndTrailingTrivia()))
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block())
.WithFormatterAnnotation();
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
case SyntaxKind.ConstructorDeclaration:
{
var constructorDeclaration = (ConstructorDeclarationSyntax)node;
SyntaxToken semicolonToken = constructorDeclaration.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
ParameterListSyntax parameterList = constructorDeclaration.ParameterList;
if (parameterList == null)
{
break;
}
return(cancellationToken =>
{
ConstructorDeclarationSyntax newNode = constructorDeclaration
.WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetLeadingAndTrailingTrivia()))
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block())
.WithFormatterAnnotation();
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
case SyntaxKind.DestructorDeclaration:
{
var destructorDeclaration = (DestructorDeclarationSyntax)node;
SyntaxToken semicolonToken = destructorDeclaration.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
ParameterListSyntax parameterList = destructorDeclaration.ParameterList;
if (parameterList == null)
{
break;
}
return(cancellationToken =>
{
DestructorDeclarationSyntax newNode = destructorDeclaration
.WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetLeadingAndTrailingTrivia()))
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block())
.WithFormatterAnnotation();
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
case SyntaxKind.OperatorDeclaration:
{
var operatorDeclaration = (OperatorDeclarationSyntax)node;
SyntaxToken semicolonToken = operatorDeclaration.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
ParameterListSyntax parameterList = operatorDeclaration.ParameterList;
if (parameterList == null)
{
break;
}
return(cancellationToken =>
{
OperatorDeclarationSyntax newNode = operatorDeclaration
.WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetLeadingAndTrailingTrivia()))
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block())
.WithFormatterAnnotation();
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
case SyntaxKind.ConversionOperatorDeclaration:
{
var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)node;
SyntaxToken semicolonToken = conversionOperatorDeclaration.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
ParameterListSyntax parameterList = conversionOperatorDeclaration.ParameterList;
if (parameterList == null)
{
break;
}
return(cancellationToken =>
{
ConversionOperatorDeclarationSyntax newNode = conversionOperatorDeclaration
.WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetLeadingAndTrailingTrivia()))
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block())
.WithFormatterAnnotation();
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
{
var accessorDeclaration = (AccessorDeclarationSyntax)node;
SyntaxToken semicolonToken = accessorDeclaration.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
return(cancellationToken =>
{
AccessorDeclarationSyntax newNode = accessorDeclaration
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block(
Token(default(SyntaxTriviaList), SyntaxKind.OpenBraceToken, TriviaList(ElasticSpace)),
default(SyntaxList <StatementSyntax>),
Token(default(SyntaxTriviaList), SyntaxKind.CloseBraceToken, semicolonToken.GetLeadingAndTrailingTrivia())));
SyntaxToken keyword = newNode.Keyword;
if (!keyword.HasTrailingTrivia)
{
newNode = newNode.WithKeyword(keyword.WithTrailingTrivia(ElasticSpace));
}
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
case SyntaxKind.LocalFunctionStatement:
{
var localFunction = (LocalFunctionStatementSyntax)node;
SyntaxToken semicolonToken = localFunction.SemicolonToken;
if (semicolonToken.Kind() == SyntaxKind.None)
{
break;
}
ParameterListSyntax parameterList = localFunction.ParameterList;
if (parameterList == null)
{
break;
}
return(cancellationToken =>
{
LocalFunctionStatementSyntax newNode = localFunction
.WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetLeadingAndTrailingTrivia()))
.WithSemicolonToken(default(SyntaxToken))
.WithBody(Block())
.WithFormatterAnnotation();
return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken);
});
}
}
Debug.Fail(node.Kind().ToString());
return(null);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveUnusedVariable))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
SyntaxToken token = root.FindToken(context.Span.Start);
Debug.Assert(!token.IsKind(SyntaxKind.None), $"{nameof(token)} is none");
if (token.IsKind(SyntaxKind.None))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.VariableIsDeclaredButNeverUsed:
case CompilerDiagnosticIdentifiers.VariableIsAssignedButItsValueIsNeverUsed:
{
switch (token.Parent.Kind())
{
case SyntaxKind.VariableDeclarator:
{
var variableDeclarator = (VariableDeclaratorSyntax)token.Parent;
var variableDeclaration = (VariableDeclarationSyntax)variableDeclarator.Parent;
if (variableDeclaration.Variables.Count == 1)
{
var localDeclarationStatement = (LocalDeclarationStatementSyntax)variableDeclaration.Parent;
if (!localDeclarationStatement.SpanContainsDirectives())
{
CodeAction codeAction = CodeAction.Create(
"Remove unused variable",
cancellationToken => context.Document.RemoveNodeAsync(localDeclarationStatement, RemoveHelper.GetRemoveOptions(localDeclarationStatement)),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
}
else if (!variableDeclarator.SpanContainsDirectives())
{
CodeAction codeAction = CodeAction.Create(
"Remove unused variable",
cancellationToken => context.Document.RemoveNodeAsync(variableDeclarator, RemoveHelper.GetRemoveOptions(variableDeclarator)),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case SyntaxKind.CatchDeclaration:
{
var catchDeclaration = (CatchDeclarationSyntax)token.Parent;
CodeAction codeAction = CodeAction.Create(
"Remove unused variable",
cancellationToken =>
{
CatchDeclarationSyntax newNode = catchDeclaration
.WithIdentifier(default(SyntaxToken))
.WithCloseParenToken(catchDeclaration.CloseParenToken.PrependToLeadingTrivia(token.GetLeadingAndTrailingTrivia()))
.WithFormatterAnnotation();
return(context.Document.ReplaceNodeAsync(catchDeclaration, newNode, context.CancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case SyntaxKind.LocalFunctionStatement:
{
var localFunction = (LocalFunctionStatementSyntax)token.Parent;
CodeAction codeAction = CodeAction.Create(
"Remove unused local function",
cancellationToken => context.Document.RemoveStatementAsync(localFunction, context.CancellationToken),
GetEquivalenceKey(diagnostic, "LocalFunction"));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
break;
}
}
}
}
