public static Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
VariableDeclarationSyntax declaration = forStatement.Declaration;
var incrementor = (PostfixUnaryExpressionSyntax)forStatement.Incrementors[0];
VariableDeclarationSyntax newDeclaration = declaration.ReplaceNode(
declaration.Variables[0].Initializer.Value,
SubtractExpression(
((BinaryExpressionSyntax)forStatement.Condition).Right,
NumericLiteralExpression(1)));
BinaryExpressionSyntax newCondition = GreaterThanOrEqualExpression(
((BinaryExpressionSyntax)forStatement.Condition).Left,
NumericLiteralExpression(0));
SeparatedSyntaxList <ExpressionSyntax> newIncrementors = forStatement.Incrementors.Replace(
incrementor,
incrementor.WithOperatorToken(Token(SyntaxKind.MinusMinusToken)));
ForStatementSyntax newForStatement = forStatement
.WithDeclaration(newDeclaration)
.WithCondition(newCondition)
.WithIncrementors(newIncrementors);
return(document.ReplaceNodeAsync(forStatement, newForStatement, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
VariableDeclarationSyntax declaration = forStatement.Declaration;
var incrementor = (PostfixUnaryExpressionSyntax)forStatement.Incrementors[0];
var initializerValue = (BinaryExpressionSyntax)declaration.Variables[0].Initializer.Value;
VariableDeclarationSyntax newDeclaration = declaration.ReplaceNode(
initializerValue,
NumericLiteralExpression(0));
BinaryExpressionSyntax newCondition = ((BinaryExpressionSyntax)forStatement.Condition)
.WithOperatorToken(LessThanToken())
.WithRight(initializerValue.Left);
SeparatedSyntaxList <ExpressionSyntax> newIncrementors = forStatement.Incrementors.Replace(
incrementor,
incrementor.WithOperatorToken(PlusPlusToken()));
ForStatementSyntax newForStatement = forStatement
.WithDeclaration(newDeclaration)
.WithCondition(newCondition)
.WithIncrementors(newIncrementors);
return(document.ReplaceNodeAsync(forStatement, newForStatement, cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
VariableDeclarationSyntax declaration = forStatement.Declaration;
var incrementor = (PostfixUnaryExpressionSyntax)forStatement.Incrementors[0];
var initializerValue = (BinaryExpressionSyntax)declaration.Variables[0].Initializer.Value;
VariableDeclarationSyntax newDeclaration = declaration.ReplaceNode(
initializerValue,
ZeroLiteralExpression());
BinaryExpressionSyntax newCondition = ((BinaryExpressionSyntax)forStatement.Condition)
.WithOperatorToken(Token(SyntaxKind.LessThanToken))
.WithRight(initializerValue.Left);
SeparatedSyntaxList <ExpressionSyntax> newIncrementors = forStatement.Incrementors.Replace(
incrementor,
incrementor.WithOperatorToken(Token(SyntaxKind.PlusPlusToken)));
ForStatementSyntax newForStatement = forStatement
.WithDeclaration(newDeclaration)
.WithCondition(newCondition)
.WithIncrementors(newIncrementors);
root = root.ReplaceNode(forStatement, newForStatement);
return(document.WithSyntaxRoot(root));
}
public CSharpSyntaxNode Convert(ForStatement node)
{
ForStatementSyntax csForStatement = SyntaxFactory.ForStatement(node.Statement.ToCsNode <StatementSyntax>());
Node initializer = node.Initializer;
if (initializer != null)
{
if (initializer.Kind == NodeKind.VariableDeclarationList)
{
csForStatement = csForStatement.WithDeclaration(initializer.ToCsNode <VariableDeclarationSyntax>());
}
else
{
csForStatement = csForStatement.AddInitializers(node.Initializers.ToCsNodes <ExpressionSyntax>());
}
}
if (node.Condition != null)
{
csForStatement = csForStatement.WithCondition(node.Condition.ToCsNode <ExpressionSyntax>());
}
if (node.Incrementors != null)
{
csForStatement = csForStatement.AddIncrementors(node.Incrementors.ToCsNodes <ExpressionSyntax>());
}
return(csForStatement);
}
public override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
if (node != this.ContainerOfStatementsOrFieldToReplace)
{
return(base.VisitForStatement(node));
}
return(node.WithDeclaration(VisitNode(node.Declaration))
.WithInitializers(VisitList(node.Initializers))
.WithCondition(VisitNode(node.Condition))
.WithIncrementors(VisitList(node.Incrementors))
.WithStatement(ReplaceStatementIfNeeded(node.Statement)));
}
static async Task <Document> ReplaceFor(Document document, ForStatementSyntax oldFor,
VariableDeclarationSyntax newDeclaration,
SeparatedSyntaxList <ExpressionSyntax> newInitializers,
BinaryExpressionSyntax newCondition)
{
var newFor = oldFor
.WithDeclaration(newDeclaration)
.WithInitializers(newInitializers)
.WithCondition(newCondition)
.WithIncrementors(ToggleIncrement(oldFor))
.WithAdditionalAnnotations(Formatter.Annotation);
return(await ReplaceFor(document, oldFor, newFor));
}
public static async Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
VariableDeclarationSyntax declaration = forStatement.Declaration;
var incrementor = (PostfixUnaryExpressionSyntax)forStatement.Incrementors[0];
VariableDeclarationSyntax newDeclaration = declaration.ReplaceNode(
declaration.Variables[0].Initializer.Value,
BinaryExpression(
SyntaxKind.SubtractExpression,
((BinaryExpressionSyntax)forStatement.Condition).Right,
LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(1))));
BinaryExpressionSyntax newCondition = BinaryExpression(
SyntaxKind.GreaterThanOrEqualExpression,
((BinaryExpressionSyntax)forStatement.Condition).Left,
LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0)));
SeparatedSyntaxList <ExpressionSyntax> newIncrementors = forStatement.Incrementors.Replace(
incrementor,
incrementor.WithOperatorToken(Token(SyntaxKind.MinusMinusToken)));
ForStatementSyntax newForStatement = forStatement
.WithDeclaration(newDeclaration)
.WithCondition(newCondition)
.WithIncrementors(newIncrementors);
SyntaxNode newRoot = oldRoot.ReplaceNode(forStatement, newForStatement);
return(document.WithSyntaxRoot(newRoot));
}
