public static async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
ElseClauseSyntax elseClause = ifStatement.Else;
StatementSyntax whenTrue = ifStatement.Statement;
StatementSyntax whenFalse = elseClause.Statement;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ElseClauseSyntax newElseClause = null;
if ((whenFalse as BlockSyntax)?.Statements.Any() != false)
{
newElseClause = elseClause.WithStatement(whenTrue.WithTriviaFrom(whenFalse));
}
IfStatementSyntax newIfStatement = ifStatement
.WithCondition(Negator.LogicallyNegate(ifStatement.Condition, semanticModel, cancellationToken))
.WithStatement(whenFalse.WithTriviaFrom(whenTrue))
.WithElse(newElseClause)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false));
}
private async Task <Document> AddMissingBracesAsync(Document document, SyntaxNode errorStatement, CancellationToken c)
{
// With two different node types, I'll build up the appropriate new statements for each
// type and plug them in with common code.
SyntaxNode toReplace = null;
if (errorStatement is IfStatementSyntax)
{
IfStatementSyntax newIfStatement = errorStatement as IfStatementSyntax;
newIfStatement = newIfStatement.WithStatement(SyntaxFactory.Block(newIfStatement.Statement)).WithAdditionalAnnotations(Formatter.Annotation);
toReplace = newIfStatement;
}
else if (errorStatement is ElseClauseSyntax)
{
ElseClauseSyntax newElseStatement = errorStatement as ElseClauseSyntax;
newElseStatement = newElseStatement.WithStatement(SyntaxFactory.Block(newElseStatement.Statement)).WithAdditionalAnnotations(Formatter.Annotation);
toReplace = newElseStatement;
}
if (toReplace != null)
{
// Poke in our new call and update the document.
var root = await document.GetSyntaxRootAsync(c);
var newRoot = root.ReplaceNode(errorStatement, toReplace);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
else
{
return(null);
}
}
protected Task <Document> RemoveBracesAsync(Document document, SyntaxNode root, StatementSyntax statement, ElseClauseSyntax elseClause, CancellationToken token)
{
var newElseClause = elseClause.WithStatement(statement);
var newRoot = root.ReplaceNode(elseClause, newElseClause);
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}
private static async Task <Document> InvertIfElseAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ElseClauseSyntax elseClause = ifStatement.Else;
StatementSyntax whenTrue = ifStatement.Statement;
StatementSyntax whenFalse = elseClause.Statement;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IfStatementSyntax newIfStatement = ifStatement.Update(
ifKeyword: ifStatement.IfKeyword,
openParenToken: ifStatement.OpenParenToken,
condition: SyntaxInverter.LogicallyInvert(ifStatement.Condition, semanticModel, cancellationToken),
closeParenToken: ifStatement.CloseParenToken,
statement: whenFalse.WithTriviaFrom(whenTrue),
@else: elseClause.WithStatement(whenTrue.WithTriviaFrom(whenFalse)));
newIfStatement = newIfStatement.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false));
}
public static ElseClauseSyntax AddBraces(ElseClauseSyntax elseClause)
{
Debug.Assert(elseClause != null && NeedsBraces(elseClause));
return elseClause
.WithStatement(SyntaxFactory.Block(elseClause.Statement))
.WithAdditionalAnnotations(Formatter.Annotation);
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax node)
{
if (node != this.ContainerOfStatementsOrFieldToReplace)
{
return(base.VisitElseClause(node));
}
return(node.WithStatement(ReplaceStatementIfNeeded(node.Statement)));
}
public override SyntaxNode?VisitElseClause(ElseClauseSyntax node)
{
if (node.Statement is BlockSyntax)
{
return(base.VisitElseClause(node));
}
return(base.VisitElseClause(node.WithStatement(SyntaxFactory.Block(node.Statement))));
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax node)
{
if (_previousIf.Equals(node.Parent) &&
node.Statement?.Kind() == SyntaxKind.Block)
{
return(node.WithStatement(((BlockSyntax)node.Statement).Statements[0]));
}
return(base.VisitElseClause(node));
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax node)
{
if (!ShouldRun(node))
{
return(base.VisitElseClause(node));
}
var newNode = node.WithStatement(SyntaxFactory.EmptyStatement());
return(newNode);
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax elseClause)
{
if (elseClause.Statement is BlockSyntax)
{
return(base.VisitElseClause(elseClause));
}
return(base.VisitElseClause(
elseClause.WithStatement(
SyntaxFactory.Block(
SyntaxFactory.SingletonList(
elseClause.Statement)))));
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax node)
{
var blockResumeLocation = GetBlockResumeLocation(node.Statement);
node = (ElseClauseSyntax)base.VisitElseClause(node);
// We leave "else if" alone.
if (node.Statement.Kind() == SyntaxKind.IfStatement)
{
return(node);
}
node = node.WithStatement(InjectedBlock(node.Statement, blockResumeLocation));
return(node);
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (_previousIf.Equals(node.Parent) &&
node.Statement?.IsKind(SyntaxKind.Block, SyntaxKind.IfStatement) == false)
{
return(node.WithStatement(SyntaxFactory.Block(node.Statement)));
}
return(base.VisitElseClause(node));
}
public static Task <Document> RefactorAsync(
Document document,
ElseClauseSyntax elseClause,
CancellationToken cancellationToken)
{
var block = (BlockSyntax)elseClause.Statement;
var ifStatement = (IfStatementSyntax)block.Statements[0];
ElseClauseSyntax newElseClause = elseClause
.WithStatement(ifStatement)
.WithElseKeyword(elseClause.ElseKeyword.WithoutTrailingTrivia())
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(elseClause, newElseClause, cancellationToken));
}
public override SyntaxNode VisitElseClause(ElseClauseSyntax node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (_previousIf.Equals(node.Parent) &&
node.Statement != null &&
node.Statement.IsKind(SyntaxKind.Block))
{
return(node.WithStatement(((BlockSyntax)node.Statement).Statements[0]));
}
return(base.VisitElseClause(node));
}
private static async Task <Document> RemoveBracesFromElseClauseAsync(
Document document,
ElseClauseSyntax elseClause,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var block = (BlockSyntax)elseClause.Statement;
var ifStatement = (IfStatementSyntax)block.Statements[0];
ElseClauseSyntax newElseClause = elseClause
.WithStatement(ifStatement)
.WithElseKeyword(elseClause.ElseKeyword.WithoutTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(elseClause, newElseClause);
return(document.WithSyntaxRoot(newRoot));
}
ElseClauseSyntax GetNewIfWithElse(ElseClauseSyntax elseNode, StatementSyntax singleStatementInsideElse)
{
var newElse =
elseNode
.WithElseKeyword(
elseNode.ElseKeyword
.WithTrailingTrivia()
)
.WithStatement(
singleStatementInsideElse
.WithLeadingTrivia(SyntaxFactory.Space)
//.WithTrailingTrivia(trailingTriviaList)
);
if (singleStatementInsideElse is ReturnStatementSyntax returnStatement)
{
if (returnStatement.Expression == null || returnStatement.Expression is LiteralExpressionSyntax || returnStatement.Expression.Span.Length <= MAX_RETURN_STATEMENT_LENGTH)
{
return(newElse);
}
}
if (singleStatementInsideElse is IfStatementSyntax == false)
{
if (
singleStatementInsideElse.WithoutTrivia().DescendantTrivia().Any(t => t.IsKind(SyntaxKind.EndOfLineTrivia))
||
singleStatementInsideElse.Span.Length + 5 > MAX_IF_LINE_LENGTH
)
{
return(elseNode.WithStatement(singleStatementInsideElse));
}
}
return(newElse);
}
private SyntaxNode GetNewElseNode(ElseClauseSyntax elseClause)
{
return(elseClause.WithStatement(SyntaxFactory.Block(elseClause.Statement)));
}
private SyntaxNode GetNewElseNode(ElseClauseSyntax elseClause)
{
return elseClause.WithStatement(SyntaxFactory.Block(elseClause.Statement));
}