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