private async Task <Document> MakeForeachAsync(Document document, ForStatementSyntax forStatement, CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var forBlock = forStatement.Statement as BlockSyntax;
var condition = forStatement.Condition as BinaryExpressionSyntax;
var arrayAccessor = condition.Right as MemberAccessExpressionSyntax;
var arrayId = semanticModel.GetSymbolInfo(arrayAccessor.Expression).Symbol as ILocalSymbol;
var controlVarId = semanticModel.GetDeclaredSymbol(forStatement.Declaration.Variables.Single());
var arrayDeclarations = (from s in forBlock.Statements.OfType <LocalDeclarationStatementSyntax>()
where s.Declaration.Variables.Count == 1
let declaration = s.Declaration.Variables.First()
where declaration?.Initializer?.Value is ElementAccessExpressionSyntax
let init = (ElementAccessExpressionSyntax)declaration.Initializer.Value
let initSymbol = semanticModel.GetSymbolInfo(init.ArgumentList.Arguments.First().Expression).Symbol
where controlVarId.Equals(initSymbol)
let someArrayInit = semanticModel.GetSymbolInfo(init.Expression).Symbol as ILocalSymbol
where someArrayInit.Equals(arrayId)
select s).ToList();
var arrayDeclaration = arrayDeclarations.First();
var blockForFor = forBlock.RemoveNode(arrayDeclaration, SyntaxRemoveOptions.KeepLeadingTrivia);
var forEachStatement = SyntaxFactory.ForEachStatement(SyntaxFactory.ParseTypeName("var"), arrayDeclaration.Declaration.Variables.First().Identifier, arrayAccessor.Expression, blockForFor)
.WithLeadingTrivia(forStatement.GetLeadingTrivia())
.WithTrailingTrivia(forStatement.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
var root = await document.GetSyntaxRootAsync();
var newRoot = root.ReplaceNode <SyntaxNode, SyntaxNode>(forStatement, forEachStatement);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
public override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia()))
{
return(null);
}
return(base.VisitForStatement(node));
}
public static Task <Document> RefactorAsync(
Document document,
ForStatementSyntax forStatement,
CancellationToken cancellationToken)
{
var statements = new List <StatementSyntax>();
VariableDeclarationSyntax declaration = forStatement.Declaration;
if (declaration != null)
{
statements.Add(LocalDeclarationStatement(declaration));
}
else
{
foreach (ExpressionSyntax initializer in forStatement.Initializers)
{
statements.Add(ExpressionStatement(initializer));
}
}
StatementSyntax statement = forStatement.Statement ?? Block();
SeparatedSyntaxList <ExpressionSyntax> incrementors = forStatement.Incrementors;
if (incrementors.Any())
{
if (!statement.IsKind(SyntaxKind.Block))
{
statement = Block(statement);
}
ExpressionStatementSyntax[] incrementorStatements = incrementors
.Select(f => ExpressionStatement(f).WithFormatterAnnotation())
.ToArray();
var rewriter = new InsertIncrementorsBeforeContinueRewriter(incrementorStatements);
statement = (StatementSyntax)rewriter.Visit(statement);
statement = ((BlockSyntax)statement).AddStatements(incrementorStatements);
}
statements.Add(WhileStatement(forStatement.Condition ?? TrueLiteralExpression(), statement));
statements[0] = statements[0].WithLeadingTrivia(forStatement.GetLeadingTrivia());
if (forStatement.IsEmbedded())
{
return(document.ReplaceNodeAsync(forStatement, Block(statements), cancellationToken));
}
else
{
return(document.ReplaceNodeAsync(forStatement, statements, cancellationToken));
}
}
