public static async Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
CancellationToken cancellationToken = default(CancellationToken))
{
IEnumerable <StatementSyntax> newNodes = GetNewNodes(statement)
.Select(f => f.WithFormatterAnnotation());
if (statement.Parent.IsKind(SyntaxKind.ElseClause))
{
IfStatementSyntax ifStatement = IfElseChain.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(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false));
}
else
{
return(await document.ReplaceNodeAsync(statement.Parent, newNodes, cancellationToken).ConfigureAwait(false));
}
}
private static SyntaxNode GetContainingBlock(SyntaxNode node)
{
if (node.IsKind(SyntaxKind.ElseClause))
{
return(IfElseChain.GetTopmostIf((ElseClauseSyntax)node)?.Parent);
}
else
{
return(node.Parent);
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, ContinueStatementSyntax continueStatement)
{
SyntaxNode parent = continueStatement.Parent;
if (parent?.IsKind(SyntaxKind.Block) == true)
{
var block = (BlockSyntax)parent;
parent = parent.Parent;
if (parent != null)
{
SyntaxKind kind = parent.Kind();
if (CanContainContinueStatement(kind))
{
if (block.Statements.IsLast(continueStatement) &&
!continueStatement.SpanContainsDirectives())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantContinueStatement, continueStatement);
}
}
else if (kind == SyntaxKind.ElseClause)
{
var elseClause = (ElseClauseSyntax)parent;
if (IfElseChain.IsEndOfChain(elseClause))
{
IfStatementSyntax ifStatement = IfElseChain.GetTopmostIf(elseClause);
parent = ifStatement.Parent;
if (parent?.IsKind(SyntaxKind.Block) == true)
{
block = (BlockSyntax)parent;
parent = parent.Parent;
if (CanContainContinueStatement(parent) &&
block.Statements.IsLast(ifStatement) &&
!elseClause.SpanContainsDirectives())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantContinueStatement, continueStatement);
}
}
}
}
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, ElseClauseSyntax elseClause)
{
StatementSyntax statement = elseClause.Statement;
SyntaxToken elseKeyword = elseClause.ElseKeyword;
if (statement?.IsKind(SyntaxKind.Block, SyntaxKind.IfStatement) == false &&
context.SyntaxTree().IsMultiLineSpan(TextSpan.FromBounds(elseKeyword.SpanStart, statement.SpanStart)))
{
IfStatementSyntax topmostIf = IfElseChain.GetTopmostIf(elseClause);
if (topmostIf != null)
{
Analyze(context, topmostIf, elseKeyword, statement);
}
}
}
private static IfStatementSyntax GetTopmostIf(BlockSyntax block)
{
SyntaxNode parent = block.Parent;
switch (parent?.Kind())
{
case SyntaxKind.IfStatement:
return(IfElseChain.GetTopmostIf((IfStatementSyntax)parent));
case SyntaxKind.ElseClause:
return(IfElseChain.GetTopmostIf((ElseClauseSyntax)parent));
default:
return(null);
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
IfStatementSyntax ifStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <IfStatementSyntax>();
if (ifStatement == null)
{
return;
}
ifStatement = IfElseChain.GetTopmostIf(ifStatement);
CodeAction codeAction = CodeAction.Create(
"Remove braces from if-else",
cancellationToken => RemoveBracesFromIfElseElseRefactoring.RefactorAsync(context.Document, ifStatement, cancellationToken),
DiagnosticIdentifiers.RemoveBracesFromIfElse + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, context.Diagnostics);
}
private static IfStatementSyntax GetTopmostIf(StatementSyntax statement)
{
SyntaxNode parent = statement.Parent;
if (parent != null)
{
if (parent.IsKind(SyntaxKind.ElseClause))
{
return(IfElseChain.GetTopmostIf((ElseClauseSyntax)parent));
}
else
{
var parentStatement = parent as IfStatementSyntax;
if (parentStatement != null)
{
return(IfElseChain.GetTopmostIf(parentStatement));
}
}
}
return(null);
}
private static StatementSyntax GetStatement(
RefactoringContext context,
BlockSyntax block,
SyntaxNode parent)
{
switch (parent?.Kind())
{
case SyntaxKind.WhileStatement:
case SyntaxKind.DoStatement:
case SyntaxKind.ForStatement:
case SyntaxKind.ForEachStatement:
case SyntaxKind.FixedStatement:
case SyntaxKind.CheckedStatement:
case SyntaxKind.UncheckedStatement:
case SyntaxKind.UnsafeStatement:
case SyntaxKind.UsingStatement:
case SyntaxKind.LockStatement:
{
if (block.OpenBraceToken.Span.Contains(context.Span) ||
block.CloseBraceToken.Span.Contains(context.Span))
{
if (parent.IsKind(SyntaxKind.UsingStatement))
{
var usingStatement = (UsingStatementSyntax)parent;
while (usingStatement.IsParentKind(SyntaxKind.UsingStatement))
{
usingStatement = (UsingStatementSyntax)usingStatement.Parent;
}
return(usingStatement);
}
return((StatementSyntax)parent);
}
break;
}
case SyntaxKind.TryStatement:
{
var tryStatement = (TryStatementSyntax)parent;
if (tryStatement.Block?.OpenBraceToken.Span.Contains(context.Span) == true)
{
return((StatementSyntax)parent);
}
break;
}
case SyntaxKind.IfStatement:
{
var ifStatement = (IfStatementSyntax)parent;
if (IfElseChain.IsTopmostIf(ifStatement) &&
block.OpenBraceToken.Span.Contains(context.Span))
{
return(ifStatement);
}
if (ifStatement.Else == null &&
block.CloseBraceToken.Span.Contains(context.Span))
{
return(ifStatement);
}
break;
}
case SyntaxKind.ElseClause:
{
var elseClause = (ElseClauseSyntax)parent;
if (block.CloseBraceToken.Span.Contains(context.Span))
{
return(IfElseChain.GetTopmostIf(elseClause));
}
break;
}
case SyntaxKind.CatchClause:
{
var catchClause = (CatchClauseSyntax)parent;
if (catchClause.IsParentKind(SyntaxKind.TryStatement))
{
var tryStatement = (TryStatementSyntax)catchClause.Parent;
if (tryStatement.Finally == null &&
catchClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true)
{
return(tryStatement);
}
}
break;
}
case SyntaxKind.FinallyClause:
{
var finallyClause = (FinallyClauseSyntax)parent;
if (finallyClause.IsParentKind(SyntaxKind.TryStatement))
{
var tryStatement = (TryStatementSyntax)finallyClause.Parent;
if (finallyClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true)
{
return(tryStatement);
}
}
break;
}
}
return(null);
}
