private static async Task <Document> ConvertWhileStatementToForStatementAsync(
Document document,
WhileStatementSyntax whileStatement,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
ForStatementSyntax newNode = ForStatement(
Token(SyntaxKind.ForKeyword)
.WithTriviaFrom(whileStatement.WhileKeyword),
Token(
whileStatement.OpenParenToken.LeadingTrivia,
SyntaxKind.OpenParenToken,
default(SyntaxTriviaList)),
null,
default(SeparatedSyntaxList <ExpressionSyntax>),
Token(SyntaxKind.SemicolonToken),
null,
Token(SyntaxKind.SemicolonToken),
default(SeparatedSyntaxList <ExpressionSyntax>),
Token(
default(SyntaxTriviaList),
SyntaxKind.CloseParenToken,
whileStatement.CloseParenToken.TrailingTrivia),
whileStatement.Statement);
newNode = newNode
.WithTriviaFrom(whileStatement)
.WithFormatterAnnotation();
SyntaxNode newRoot = oldRoot.ReplaceNode(whileStatement, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public static Task <Document> RefactorAsync(
Document document,
WhileStatementSyntax whileStatement,
CancellationToken cancellationToken)
{
ForStatementSyntax newNode = ForStatement(
Token(SyntaxKind.ForKeyword).WithTriviaFrom(whileStatement.WhileKeyword),
Token(
whileStatement.OpenParenToken.LeadingTrivia,
SyntaxKind.OpenParenToken,
default(SyntaxTriviaList)),
default(VariableDeclarationSyntax),
default(SeparatedSyntaxList <ExpressionSyntax>),
SemicolonToken(),
default(ExpressionSyntax),
SemicolonToken(),
default(SeparatedSyntaxList <ExpressionSyntax>),
Token(
default(SyntaxTriviaList),
SyntaxKind.CloseParenToken,
whileStatement.CloseParenToken.TrailingTrivia),
whileStatement.Statement);
newNode = newNode
.WithTriviaFrom(whileStatement)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(whileStatement, newNode, cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (forEachStatement == null)
{
throw new ArgumentNullException(nameof(forEachStatement));
}
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(
semanticModel.GetDeclaredSymbol(forEachStatement),
document.Project.Solution,
cancellationToken).ConfigureAwait(false);
string identifier = Identifier.EnsureUniqueLocalName(Identifier.DefaultForVariableName, forEachStatement.Statement.SpanStart, semanticModel, cancellationToken);
ForStatementSyntax forStatement = ForStatement(
declaration: VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(NumericLiteralExpression(0))),
initializers: default(SeparatedSyntaxList <ExpressionSyntax>),
condition: LessThanExpression(
IdentifierName(identifier),
SimpleMemberAccessExpression(
IdentifierName(forEachStatement.Expression.ToString()),
IdentifierName(GetCountOrLengthPropertyName(forEachStatement.Expression, semanticModel, cancellationToken)))),
incrementors: SingletonSeparatedList <ExpressionSyntax>(
PostIncrementExpression(
IdentifierName(identifier))),
statement: forEachStatement.Statement.ReplaceNodes(
GetIdentifiers(root, referencedSymbols),
(f, g) =>
{
return(ElementAccessExpression(
IdentifierName(forEachStatement.Expression.ToString()),
BracketedArgumentList(
SingletonSeparatedList(Argument(IdentifierName(identifier))))
).WithTriviaFrom(f));
}));
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithFormatterAnnotation();
root = root.ReplaceNode(forEachStatement, forStatement);
return(document.WithSyntaxRoot(root));
}
public static async Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
ForStatementSyntax forStatement = await GetForStatementAsync(
document,
forEachStatement,
cancellationToken);
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(forEachStatement, forStatement);
return(document.WithSyntaxRoot(newRoot));
}
public static Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
SemanticModel semanticModel,
bool reverseLoop = false,
CancellationToken cancellationToken = default(CancellationToken))
{
string name = NameGenerator.Default.EnsureUniqueLocalName(
DefaultNames.ForVariable,
semanticModel,
forEachStatement.Statement.SpanStart,
cancellationToken: cancellationToken);
SyntaxToken identifier = Identifier(name);
if (name != DefaultNames.ForVariable)
{
identifier = identifier.WithRenameAnnotation();
}
ExpressionSyntax forEachExpression = forEachStatement.Expression;
MemberAccessExpressionSyntax countOrLengthMemberAccess = SimpleMemberAccessExpression(
forEachExpression.WithoutTrivia(),
IdentifierName(CSharpUtility.GetCountOrLengthPropertyName(forEachExpression, semanticModel, cancellationToken)));
VariableDeclarationSyntax declaration = null;
BinaryExpressionSyntax condition = null;
PostfixUnaryExpressionSyntax incrementor = null;
if (reverseLoop)
{
declaration = VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(
SubtractExpression(
countOrLengthMemberAccess,
NumericLiteralExpression(1))));
condition = GreaterThanOrEqualExpression(IdentifierName(name), NumericLiteralExpression(0));
incrementor = PostDecrementExpression(IdentifierName(name));
}
else
{
declaration = VariableDeclaration(
IntType(),
identifier,
EqualsValueClause(NumericLiteralExpression(0)));
condition = LessThanExpression(
IdentifierName(name),
countOrLengthMemberAccess);
incrementor = PostIncrementExpression(IdentifierName(name));
}
StatementSyntax statement = forEachStatement.Statement.ReplaceNodes(
GetVariableReferences(forEachStatement, semanticModel, cancellationToken),
(node, _) =>
{
return(ElementAccessExpression(
forEachExpression.WithoutTrivia(),
BracketedArgumentList(SingletonSeparatedList(Argument(IdentifierName(name))))
).WithTriviaFrom(node));
});
ForStatementSyntax forStatement = ForStatement(
declaration: declaration,
initializers: default(SeparatedSyntaxList <ExpressionSyntax>),
condition: condition,
incrementors: SingletonSeparatedList <ExpressionSyntax>(incrementor),
statement: statement);
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(forEachStatement, forStatement, cancellationToken));
}
public static async Task <Document> RefactorAsync(
Document document,
ForEachStatementSyntax forEachStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (forEachStatement == null)
{
throw new ArgumentNullException(nameof(forEachStatement));
}
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(
semanticModel.GetDeclaredSymbol(forEachStatement),
document.Project.Solution,
cancellationToken).ConfigureAwait(false);
ForStatementSyntax forStatement = ForStatement(
declaration: VariableDeclaration(
PredefinedType(Token(SyntaxKind.IntKeyword)),
SingletonSeparatedList(
VariableDeclarator(CounterIdentifierName)
.WithInitializer(
EqualsValueClause(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(0)))))),
initializers: SeparatedList <ExpressionSyntax>(),
condition: BinaryExpression(
SyntaxKind.LessThanExpression,
IdentifierName(CounterIdentifierName),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(forEachStatement.Expression.ToString()),
IdentifierName(GetCountOrLengthPropertyName(forEachStatement.Expression, semanticModel)))),
incrementors: SingletonSeparatedList <ExpressionSyntax>(
PostfixUnaryExpression(
SyntaxKind.PostIncrementExpression,
IdentifierName(CounterIdentifierName))),
statement: forEachStatement.Statement.ReplaceNodes(
GetIdentifiers(root, referencedSymbols),
(f, g) =>
{
return(ElementAccessExpression(
IdentifierName(forEachStatement.Expression.ToString()),
BracketedArgumentList(
SingletonSeparatedList(Argument(IdentifierName(CounterIdentifierName))))
).WithTriviaFrom(f));
}));
forStatement = forStatement
.WithTriviaFrom(forEachStatement)
.WithFormatterAnnotation();
root = root.ReplaceNode(forEachStatement, forStatement);
return(document.WithSyntaxRoot(root));
}
