private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
var markedNodesCount = markedNodes.Count;
while (markedNodesCount > 0)
{
var firstExpression = replacementNodes[0];
var firstParent = markedNodes[0];
oldBody = oldBody.TrackNodes(new List <SyntaxNode>()
{
firstExpression.Item1, firstParent
});
//simple increment: index++; --index;
if (firstExpression.Item1.Parent.Kind() == SyntaxKind.ExpressionStatement)
{
var currentOperation = oldBody.GetCurrentNode(firstExpression.Item1);
var indexUpdate = ((ExpressionStatementSyntax)firstExpression.Item5).Expression;
oldBody = oldBody.ReplaceNode(currentOperation, indexUpdate);
oldBody = this.Refactor(oldBody);
markedNodesCount = markedNodes.Count;
continue;
}
if (firstExpression.Item3 == 0) //pre operation type
{
var currentParent = oldBody.GetCurrentNode(firstParent);
oldBody = oldBody.InsertNodesBefore(currentParent, new List <SyntaxNode>()
{
firstExpression.Item5
});
currentParent = oldBody.GetCurrentNode(firstParent);
oldBody = oldBody.InsertNodesBefore(currentParent, new List <SyntaxNode>()
{
firstExpression.Item4
});
}
else //post opertion type
{
var currentParent = oldBody.GetCurrentNode(firstParent);
oldBody = oldBody.InsertNodesBefore(currentParent, new List <SyntaxNode>()
{
firstExpression.Item4
});
currentParent = oldBody.GetCurrentNode(firstParent);
oldBody = oldBody.InsertNodesBefore(currentParent, new List <SyntaxNode>()
{
firstExpression.Item5
});
}
var updatedOperation = oldBody.GetCurrentNode(firstExpression.Item1);
oldBody = oldBody.ReplaceNode(updatedOperation, firstExpression.Item2);
oldBody = this.Refactor(oldBody);
markedNodesCount = markedNodes.Count;
}
return(oldBody);
}
//STEP 2
private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
oldBody = oldBody.TrackNodes(this.markedNodes);
foreach (var tuple in this.replacementNodes)
{
var currentA = oldBody.GetCurrentNode(tuple.Item1);
if (currentA != null)
{
var whileStatement = currentA.Parent;
oldBody = oldBody.InsertNodesBefore(whileStatement, new List <SyntaxNode>()
{
tuple.Item3
});
var currentB = oldBody.GetCurrentNode(tuple.Item1);
oldBody = oldBody.ReplaceNode(currentB, tuple.Item2);
var currentWhile = oldBody.GetCurrentNode(tuple.Item4);
//modify body
var whileBody = currentWhile.Statement as BlockSyntax;
//create new statement
var localCondition = tuple.Item3 as LocalDeclarationStatementSyntax;
var initializer = localCondition.Declaration.Variables.First();
var assignment = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(initializer.Identifier), initializer.Initializer.Value));
var newStatements = whileBody.Statements.Add(assignment);
whileBody = whileBody.WithStatements(newStatements);
//updateWhile
var newWhile = currentWhile.WithStatement(whileBody);
oldBody = oldBody.ReplaceNode(currentWhile, newWhile);
}
}
return(oldBody);
}
private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
var markedNodesCount = markedNodes.Count;
while (markedNodesCount > 0)
{
var firstExpression = replacementNodes[0];
var firstParent = markedNodes[0];
oldBody = oldBody.TrackNodes(new List <SyntaxNode>()
{
firstExpression.Item1, firstParent
});
var currentParent = oldBody.GetCurrentNode(firstParent);
oldBody = oldBody.InsertNodesBefore(currentParent, new List <SyntaxNode>()
{
firstExpression.Item3
});
var currentExpression = oldBody.GetCurrentNode(firstExpression.Item1);
oldBody = oldBody.ReplaceNode(currentExpression, firstExpression.Item2);
oldBody = this.Refactor(oldBody);
markedNodesCount = markedNodes.Count;
}
return(oldBody);
}
private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
List <SyntaxNode> nodesToTrack = this.markedNodes;
var continueSts = continueStatements.SelectMany(x => x.Value);
var breakSts = breakStatements.SelectMany(x => x.Value);
nodesToTrack.AddRange(continueSts);
nodesToTrack.AddRange(breakSts);
oldBody = oldBody.TrackNodes(nodesToTrack);
foreach (var tuple in this.whileReplacementNodes)
{
var currentA = oldBody.GetCurrentNode(tuple.Item1);
if (currentA != null)
{
//create new statement
var localCondition = tuple.Item3 as LocalDeclarationStatementSyntax;
var initializer = localCondition.Declaration.Variables.First();
var updateCondition = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(initializer.Identifier), initializer.Initializer.Value));
var whileStatement = currentA.Parent;
oldBody = oldBody.InsertNodesBefore(whileStatement, new List <SyntaxNode>()
{
tuple.Item3
});
var currentB = oldBody.GetCurrentNode(tuple.Item1);
oldBody = oldBody.ReplaceNode(currentB, tuple.Item2);
//update continue statements
foreach (var cont in continueStatements[tuple.Item4])
{
var currentContinue = oldBody.GetCurrentNode(cont);
oldBody = oldBody.ReplaceNode(currentContinue, new List <SyntaxNode>()
{
updateCondition, cont
});
}
//update break statements
foreach (var brk in breakStatements[tuple.Item4])
{
var currentBreak = oldBody.GetCurrentNode(brk);
var invalidateCondition = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(initializer.Identifier), SyntaxFactoryExtensions.BooleanLiteralExpression(false)));
oldBody = oldBody.ReplaceNode(currentBreak, new List <SyntaxNode>()
{
invalidateCondition, SyntaxFactory.ContinueStatement()
});
}
var currentWhile = oldBody.GetCurrentNode(tuple.Item4);
//modify body
var whileBody = currentWhile.Statement as BlockSyntax;
var newStatements = whileBody.Statements.Add(updateCondition);
whileBody = whileBody.WithStatements(newStatements);
//updateWhile
var newWhile = currentWhile.WithStatement(whileBody);
oldBody = oldBody.ReplaceNode(currentWhile, newWhile);
}
}
return(oldBody);
}
/// <summary>
/// Добавление выражения в конец метода или перед return
/// </summary>
/// <param name="method"></param>
/// <param name="expression"></param>
/// <returns></returns>
public MethodDeclarationSyntax AddExpressionToFinishOrBeforeReturnMethodsBody(MethodDeclarationSyntax method,
ExpressionStatementSyntax expression)
{
if (method.Body == null)
{
return(method);
}
IEnumerable <SyntaxNode> retStatements = method.Body.ChildNodes().Where(p =>
p.Kind() == SyntaxKind.ReturnStatement);
BlockSyntax newBlock = method.Body;
if (retStatements.Count() == 0)
{
return(AddExpressionToMethodsBody(method, expression));
}
else
{
foreach (var item in retStatements)
{
newBlock = newBlock.InsertNodesBefore(item, new List <SyntaxNode> {
expression
});
//Console.WriteLine(item.GetText());
}
}
method = method.ReplaceNode(method.Body, newBlock.NormalizeWhitespace());
return(method);
//throw new Exception("Не реализовано");
}
private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
List <SyntaxNode> nodesToTrack = this.markedNodes;
var continueSts = continueStatements.SelectMany(x => x.Value);
var breakSts = breakStatements.SelectMany(x => x.Value);
nodesToTrack.AddRange(continueSts);
nodesToTrack.AddRange(breakSts);
oldBody = oldBody.TrackNodes(nodesToTrack);
foreach (var tuple in this.forReplacementNodes)
{
var currentFor = oldBody.GetCurrentNode(tuple.Item4);
if (currentFor != null)
{
string oldName = tuple.Item1.Variables.First().Identifier.ValueText;
string newName = ConditionIdentifier;
var renameVisitor = new RenameVisitor(oldName, newName);
var newIndexer = (VariableDeclarationSyntax)renameVisitor.Visit(tuple.Item1);
oldBody = oldBody.InsertNodesBefore(currentFor, new List <SyntaxNode>()
{
SyntaxFactory.LocalDeclarationStatement(newIndexer)
});
var newCurrentFor = oldBody.GetCurrentNode(tuple.Item4);
//create while
var whileBody = currentFor.Statement as BlockSyntax;
//update continue statements
foreach (var cont in continueStatements[tuple.Item4])
{
var currentContinue = whileBody.GetCurrentNode(cont);
whileBody = whileBody.ReplaceNode(currentContinue, new List <SyntaxNode>()
{
SyntaxFactory.ExpressionStatement(tuple.Item3), cont
});
}
//update break statements
foreach (var brk in breakStatements[tuple.Item4])
{
var currentBreak = whileBody.GetCurrentNode(brk);
whileBody = whileBody.ReplaceNode(currentBreak, new List <SyntaxNode>()
{
SyntaxFactory.ExpressionStatement(tuple.Item3), brk
});
}
var newStatements = whileBody.Statements.Add(SyntaxFactory.ExpressionStatement(tuple.Item3));
whileBody = whileBody.WithStatements(newStatements);
var whileStatement = SyntaxFactory.WhileStatement(tuple.Item2, whileBody);
whileStatement = (WhileStatementSyntax)renameVisitor.Visit(whileStatement);
//updateFor
oldBody = oldBody.ReplaceNode(newCurrentFor, whileStatement);
}
}
return(oldBody);
}
private static bool TryRewriteBodyClause(QueryClauseSyntax clause, YieldStatementSyntax dummyYield, ref BlockSyntax body)
{
if (clause is WhereClauseSyntax whereClauseSyntax)
{
body = body.InsertNodesBefore(FindDummyYieldIn(body), new[]
{
IfStatement(
BinaryExpression(SyntaxKind.EqualsExpression, MaybeParenthesizedExpression(whereClauseSyntax.Condition),
LiteralExpression(SyntaxKind.FalseLiteralExpression)), ContinueStatement())
});
return(true);
}
if (clause is LetClauseSyntax letClauseSyntax)
{
body = body.InsertNodesBefore(FindDummyYieldIn(body), new[]
{
LocalDeclarationStatement(
VariableDeclaration(IdentifierName("var"), SingletonSeparatedList(VariableDeclarator(
letClauseSyntax.Identifier)
.WithInitializer(
EqualsValueClause(letClauseSyntax.Expression)
)
)
)
)
});
return(true);
}
if (clause is FromClauseSyntax fromClauseSyntax)
{
var nestedStmt = ForEachStatement(
IdentifierName("var"),
fromClauseSyntax.Identifier,
fromClauseSyntax.Expression,
Block().AddStatements(dummyYield));
body = body.ReplaceNode(FindDummyYieldIn(body), nestedStmt);
return(true);
}
return(false);
}
public override SyntaxNode VisitBlock(BlockSyntax node)
{
node = (BlockSyntax)base.VisitBlock(node);
foreach (StatementSyntax statement in node.Statements)
{
if (statement.IsKind(SyntaxKind.ContinueStatement))
{
return(node.InsertNodesBefore(statement, _incrementorStatements));
}
}
return(node);
}
private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
oldBody = oldBody.TrackNodes(this.markedNodes);
foreach (var tuple in this.replacementNodes)
{
var currentA = oldBody.GetCurrentNode(tuple.Item1);
if (currentA != null)
{
var ifStatement = currentA.Parent;
oldBody = oldBody.InsertNodesBefore(ifStatement, new List <SyntaxNode>()
{
tuple.Item3
});
var currentB = oldBody.GetCurrentNode(tuple.Item1);
oldBody = oldBody.ReplaceNode(currentB, tuple.Item2);
}
}
return(oldBody);
}
public BlockSyntax AddVariablesToBlock(BlockSyntax block)
{
//block = block.
int totalVariables = Variables.Count;
int currentVariable = 0;
//SyntaxToken insertAfter = block.GetFirstToken();
SyntaxNode insertNode = null;
bool insertIsAfter = true;
int insertSpanStart = 0;
foreach (var variable in Variables.OrderBy(n => n.Key))
{
currentVariable++;
if (currentVariable < 3)
{
continue;
}
if (variable.Value.Static &&
variable.Value.Used == true)
{
if (variable.Value.Used == false)
{
Console.WriteLine();
}
//SyntaxToken firstToken = block.DescendantTokens().Where(n => n.HasAnnotation(new SyntaxAnnotation("StaticVar", variable.Key.ToString()))).Single();
//find the static value
object staticValue = GetCurrentValue(variable.Key);
//SyntaxKind literalKind;
//if (staticValue is string)
//{
// staticValue = "\"" + (string)staticValue + "\"";
//}
//foreach (var node in block.DescendantNodes().OfType<LiteralExpressionSyntax>().Where(n => n.GetText().ToString() == staticValue.ToString()))
//{
// Console.WriteLine();
// //insertAfter = node.DescendantNodes().Where(n => n.Kind() == SyntaxKind.SemicolonToken).First();
// break;
//}
//SyntaxNode fromNode = null;
//if (insertAfterNode == null)
//{
// fromNode = block;
//}
//else
//{
// fromNode = insertAfterNode;
//}
//foreach (var token in block.DescendantTokens().Where(n => n.ValueText == staticValue.ToString()).Where(o => o.SpanStart > insertSpanStart).First())
//{
var tokens = block.DescendantTokens().Where(n => n.ValueText == staticValue.ToString() && n.SpanStart > insertSpanStart);
if (tokens.Count() > 0)
{
var token = tokens.First();
SyntaxToken insertToken = FindNextSemi(token);
if (insertToken.Kind() == SyntaxKind.SemicolonToken)
{
insertNode = insertToken.Parent;
insertIsAfter = true;
}
else
{
if (insertToken.Parent.ChildNodes().Count() > 0)
{
insertNode = insertToken.Parent.ChildNodes().First();
insertIsAfter = false;
}
else
{
insertNode = insertToken.Parent;
insertIsAfter = true;
}
}
insertSpanStart = token.SpanStart;
// break;
//}
}
}
else
{
//SyntaxTokenList newTokens = new SyntaxTokenList();
//newTokens = newTokens.Add(insertAfter);
LocalDeclarationStatementSyntax localDeclarationStatementSyntax = GetVariableDeclaration(variable.Value);
//newTokens.Add(variableToken.DescendantNodesAndTokensAndSelf);
//block = block.ReplaceToken(insertAfter, insertAfter);
//StatementSyntax statementSyntax = localDeclarationStatementSyntax as StatementSyntax;
//var varNode = SyntaxFactory.("\"valid regex\"");
//SyntaxAnnotation syntaxAnnotation = new SyntaxAnnotation("Variable", variable.Key.ToString());
BlockSyntax addBlock = SyntaxFactory.Block(localDeclarationStatementSyntax); //.WithAdditionalAnnotations(syntaxAnnotation);
if (insertNode == null)
{
block = block.InsertNodesBefore(block.ChildNodes().First(), addBlock.ChildNodes());
}
else
{
if (insertIsAfter)
{
block = block.InsertNodesAfter(insertNode, addBlock.ChildNodes());
}
else
{
block = block.InsertNodesBefore(insertNode, addBlock.ChildNodes());
}
}
//insertAfterNode = block.DescendantNodes().OfType<LocalDeclarationStatementSyntax>().Where(n => n.HasAnnotation(syntaxAnnotation)).Single();
insertNode = block.DescendantNodes().OfType <LocalDeclarationStatementSyntax>().Last();
insertSpanStart = insertNode.SpanStart;
insertIsAfter = true;
}
}
return(block);
}
