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