public override SyntaxNode VisitIfStatement(IfStatementSyntax node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (_previousIf == null || _previousIf.Equals(IfElseChainAnalysis.GetPreviousIf(node))) { if (node.Statement != null && !node.Statement.IsKind(SyntaxKind.Block)) { IfStatementSyntax ifStatement = node.WithStatement(SyntaxFactory.Block(node.Statement)); _previousIf = ifStatement; return(base.VisitIfStatement(ifStatement)); } else { _previousIf = node; } } return(base.VisitIfStatement(node)); }
private static bool CheckContainingNode(SyntaxNode node) { switch (node.Kind()) { case SyntaxKind.ForEachStatement: case SyntaxKind.ForStatement: case SyntaxKind.UsingStatement: case SyntaxKind.WhileStatement: case SyntaxKind.DoStatement: case SyntaxKind.LockStatement: case SyntaxKind.FixedStatement: case SyntaxKind.UnsafeStatement: case SyntaxKind.TryStatement: case SyntaxKind.CheckedStatement: case SyntaxKind.UncheckedStatement: return(true); case SyntaxKind.IfStatement: return(IfElseChainAnalysis.IsTopmostIf((IfStatementSyntax)node)); case SyntaxKind.ElseClause: return(IfElseChainAnalysis.IsEndOfChain((ElseClauseSyntax)node)); } return(false); }
private static void AddBracesToIfElseChain(CodeRefactoringContext context, IfStatementSyntax ifStatement) { if (IfElseChainAnalysis.IsTopmostIf(ifStatement) && ifStatement.Else != null && ifStatement.IfKeyword.Span.Contains(context.Span)) { var result = new IfElseChainAnalysisResult(ifStatement); if (result.AddBracesToChain) { context.RegisterRefactoring( "Add braces to if-else chain", cancellationToken => { return(AddBracesToIfElseChainRefactoring.RefactorAsync( context.Document, ifStatement, cancellationToken)); }); } if (result.RemoveBracesFromChain) { context.RegisterRefactoring( "Remove braces from if-else chain", cancellationToken => { return(RemoveBracesFromIfElseChainRefactoring.RefactorAsync( context.Document, ifStatement, cancellationToken)); }); } } }
private void AnalyzeStatement(SyntaxNodeAnalysisContext context) { if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true) { return; } if (!context.Node.IsKind(SyntaxKind.IfStatement) || IfElseChainAnalysis.IsIsolatedIf((IfStatementSyntax)context.Node)) { BlockSyntax block = EmbeddedStatementAnalysis.GetBlockThatCanBeEmbeddedStatement(context.Node); if (block != null && !block.OpenBraceToken.IsMissing && !block.CloseBraceToken.IsMissing && block.OpenBraceToken.LeadingTrivia.IsWhitespaceOrEndOfLine() && block.OpenBraceToken.TrailingTrivia.IsWhitespaceOrEndOfLine() && block.CloseBraceToken.LeadingTrivia.IsWhitespaceOrEndOfLine() && block.CloseBraceToken.TrailingTrivia.IsWhitespaceOrEndOfLine()) { context.ReportDiagnostic( DiagnosticDescriptors.RemoveBracesFromStatement, block.GetLocation()); DiagnosticHelper.FadeOutBraces(context, block, DiagnosticDescriptors.RemoveBracesFromStatementFadeOut); } } }
private static SyntaxNode GetContainingBlock(SyntaxNode node) { if (node.IsKind(SyntaxKind.ElseClause)) { return(IfElseChainAnalysis.GetTopmostIf((ElseClauseSyntax)node)?.Parent); } else { return(node.Parent); } }
internal IfElseChainAnalysisResult(IfStatementSyntax ifStatement) { if (ifStatement == null) { throw new ArgumentNullException(nameof(ifStatement)); } bool anyHasEmbedded = false; bool anyHasBlock = false; bool allSupportsEmbedded = true; int cnt = 0; foreach (SyntaxNode node in IfElseChainAnalysis.GetChain(ifStatement)) { cnt++; StatementSyntax statement = GetStatement(node); if (!anyHasEmbedded && !statement.IsKind(SyntaxKind.Block)) { anyHasEmbedded = true; } if (!anyHasBlock && statement.IsKind(SyntaxKind.Block)) { anyHasBlock = true; } if (allSupportsEmbedded && !SupportsEmbedded(statement)) { allSupportsEmbedded = false; } if (cnt > 1 && anyHasEmbedded && !allSupportsEmbedded) { AddBracesToChain = true; return; } } if (cnt > 1 && allSupportsEmbedded && anyHasBlock) { RemoveBracesFromChain = true; if (anyHasEmbedded) { AddBracesToChain = true; } } }
private static SyntaxNode GetNewRoot(StatementSyntax statement, SyntaxNode oldRoot, IEnumerable <StatementSyntax> newNodes) { if (statement.Parent.IsKind(SyntaxKind.ElseClause)) { IfStatementSyntax ifStatement = IfElseChainAnalysis.GetTopmostIf((ElseClauseSyntax)statement.Parent); var block = (BlockSyntax)ifStatement.Parent; int index = block.Statements.IndexOf(ifStatement); BlockSyntax newBlock = block.RemoveNode(statement.Parent, SyntaxRemoveOptions.KeepNoTrivia); newBlock = newBlock.WithStatements(newBlock.Statements.InsertRange(index + 1, newNodes)); return(oldRoot.ReplaceNode(block, newBlock)); } else { return(oldRoot.ReplaceNode(statement.Parent, newNodes)); } }
public static void Analyze(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement) { if (IfElseChainAnalysis.IsIsolatedIf(ifStatement) && CheckCondition(ifStatement.Condition)) { IfStatementSyntax ifStatement2 = GetContainedIfStatement(ifStatement); if (ifStatement2 != null && ifStatement2.Else == null && CheckCondition(ifStatement2.Condition)) { context.ReportDiagnostic( DiagnosticDescriptors.MergeIfStatementWithContainedIfStatement, ifStatement.GetLocation()); FadeOut(context, ifStatement, ifStatement2); } } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); IfStatementSyntax ifStatement = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <IfStatementSyntax>(); if (ifStatement == null) { return; } ifStatement = IfElseChainAnalysis.GetTopmostIf(ifStatement); CodeAction codeAction = CodeAction.Create( "Add braces to if-else chain", cancellationToken => AddBracesToIfElseChainRefactoring.RefactorAsync(context.Document, ifStatement, cancellationToken), DiagnosticIdentifiers.AddBracesToIfElseChain + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
private static void SwapStatements(CodeRefactoringContext context, IfStatementSyntax ifStatement) { if (IfElseChainAnalysis.IsTopmostIf(ifStatement) && ifStatement.Statement != null && ifStatement.Condition != null && ifStatement.Condition.Span.Contains(context.Span)) { StatementSyntax falseStatement = ifStatement.Else?.Statement; if (falseStatement != null && !falseStatement.IsKind(SyntaxKind.IfStatement)) { context.RegisterRefactoring( "Swap if-else statements", cancellationToken => { return(SwapStatementsAsync( context.Document, ifStatement, cancellationToken)); }); } } }
private void AnalyzeStatement(SyntaxNodeAnalysisContext context) { if (GeneratedCodeAnalyzer?.IsGeneratedCode(context) == true) { return; } AnalyzeEmbeddedStatement(context); if (context.Node.IsKind(SyntaxKind.IfStatement) && !IfElseChainAnalysis.IsIsolatedIf((IfStatementSyntax)context.Node)) { return; } StatementSyntax statement = EmbeddedStatementAnalysis.GetEmbeddedStatementThatShouldBeInsideBlock(context.Node); if (statement != null) { context.ReportDiagnostic( DiagnosticDescriptors.AddBracesToStatement, statement.GetLocation()); } }