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); }