protected override SyntaxNode VisitWhileStatement(WhileStatementSyntax node)
{
if (!node.DescendentNodes().OfType <BlockSyntax>().Any())
{
node = node.Update(node.WhileKeyword, node.OpenParenToken, node.Condition, node.CloseParenToken, Syntax.Block(statements: node.Statement));
}
return(base.VisitWhileStatement(node));
}
protected override SyntaxNode VisitWhileStatement(WhileStatementSyntax node)
{
ExpressionSyntax conditional = RewritePostfixUnarys(node.Condition);
node = node.Update(node.WhileKeyword, node.OpenParenToken, conditional, node.CloseParenToken,
GetLoopBlock(node.Statement));
return(base.VisitWhileStatement((WhileStatementSyntax)node.WithAdditionalAnnotations(this.isLoop)));
}
protected override SyntaxNode VisitWhileStatement(WhileStatementSyntax node)
{
node = node.Update (node.WhileKeyword, node.OpenParenToken, node.Condition, node.CloseParenToken,
GetLoopBlock (node.Statement));
return base.VisitWhileStatement ((WhileStatementSyntax)node.WithAdditionalAnnotations (this.isLoop));
}
protected override SyntaxNode VisitWhileStatement(WhileStatementSyntax node)
{
ExpressionSyntax conditional = RewritePostfixUnarys (node.Condition);
node = node.Update (node.WhileKeyword, node.OpenParenToken, conditional, node.CloseParenToken,
GetLoopBlock (node.Statement));
return base.VisitWhileStatement ((WhileStatementSyntax)node.WithAdditionalAnnotations (this.isLoop));
}
protected override SyntaxNode VisitWhileStatement(WhileStatementSyntax node)
{
if (!node.DescendentNodes().OfType<BlockSyntax>().Any())
node = node.Update (node.WhileKeyword, node.OpenParenToken, node.Condition, node.CloseParenToken, Syntax.Block (statements: node.Statement));
return base.VisitWhileStatement (node);
}
private static async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken)
{
ExpressionSyntax condition = ifStatement.Condition;
ElseClauseSyntax elseClause = ifStatement.Else;
if ((ifStatement.Statement as BlockSyntax)?.Statements.Any() == false)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax newCondition = Negator.LogicallyNegate(condition, semanticModel, cancellationToken);
StatementSyntax statement = elseClause.Statement;
if (statement is IfStatementSyntax nestedIf)
{
newCondition = LogicalAndExpression(newCondition.Parenthesize(), nestedIf.Condition.Parenthesize());
statement = nestedIf.Statement;
}
cancellationToken.ThrowIfCancellationRequested();
IfStatementSyntax newNode = ifStatement.Update(
ifStatement.IfKeyword,
ifStatement.OpenParenToken,
newCondition,
ifStatement.CloseParenToken,
statement,
default(ElseClauseSyntax));
newNode = newNode.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken).ConfigureAwait(false));
}
else if (elseClause != null)
{
WhileStatementSyntax whileStatement = null;
SyntaxNode newNode = null;
if (ifStatement.Parent is BlockSyntax block)
{
whileStatement = (WhileStatementSyntax)block.Parent;
}
else
{
block = Block();
whileStatement = (WhileStatementSyntax)ifStatement.Parent;
}
cancellationToken.ThrowIfCancellationRequested();
BlockSyntax newBlock = (ifStatement.Statement is BlockSyntax ifBlock)
? block.WithStatements(ifBlock.Statements)
: block.WithStatements(SingletonList(ifStatement.Statement));
newNode = whileStatement.Update(
whileStatement.WhileKeyword,
whileStatement.OpenParenToken,
ifStatement.Condition,
whileStatement.CloseParenToken,
newBlock);
newNode = newNode.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(whileStatement, newNode, cancellationToken).ConfigureAwait(false));
}
else
{
var block = (BlockSyntax)ifStatement.Parent;
SyntaxList <StatementSyntax> statements = block.Statements;
BlockSyntax newBlock = block.WithStatements(statements.Remove(ifStatement));
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax newCondition = Negator.LogicallyNegate(condition, semanticModel, cancellationToken);
SyntaxNode newNode = block.Parent;
switch (block.Parent)
{
case WhileStatementSyntax whileStatement:
{
cancellationToken.ThrowIfCancellationRequested();
if (statements.IsFirst(ifStatement))
{
newNode = whileStatement.Update(
whileStatement.WhileKeyword,
whileStatement.OpenParenToken,
newCondition,
whileStatement.CloseParenToken,
newBlock);
}
else
{
newNode = DoStatement(
Token(whileStatement.WhileKeyword.LeadingTrivia, SyntaxKind.DoKeyword, whileStatement.CloseParenToken.TrailingTrivia),
newBlock.WithoutTrailingTrivia(),
WhileKeyword(),
OpenParenToken(),
newCondition,
CloseParenToken(),
SemicolonToken().WithTrailingTrivia(newBlock.GetTrailingTrivia()));
}
break;
}
case DoStatementSyntax doStatement:
{
cancellationToken.ThrowIfCancellationRequested();
if (statements.IsLast(ifStatement))
{
newNode = doStatement.Update(
doStatement.DoKeyword,
newBlock,
doStatement.WhileKeyword,
doStatement.OpenParenToken,
newCondition,
doStatement.CloseParenToken,
doStatement.SemicolonToken);
}
else
{
newNode = WhileStatement(
Token(doStatement.DoKeyword.LeadingTrivia, SyntaxKind.WhileKeyword, SyntaxTriviaList.Empty),
OpenParenToken(),
newCondition,
Token(SyntaxTriviaList.Empty, SyntaxKind.CloseParenToken, doStatement.DoKeyword.TrailingTrivia),
newBlock.WithTrailingTrivia(doStatement.GetTrailingTrivia()));
}
break;
}
default:
{
Debug.Fail(block.Parent.Kind().ToString());
break;
}
}
newNode = newNode.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(block.Parent, newNode, cancellationToken).ConfigureAwait(false));
}
}
