public override SyntaxNode VisitConditionalExpression(ConditionalExpressionSyntax node) { // throw new NotImplementedException("Virtualization: conditional expression - a ? true : false not supported"); //TODO: this is a naive implementation, i.e. it treats only simple cases, not recursive ones var conditionExpression = node.Condition; string conditionVarIdentifier = ConditionIdentifier; var newConditionVar = SyntaxFactoryExtensions.LocalVariableDeclaration(conditionVarIdentifier, conditionExpression, SyntaxKind.BoolKeyword).NormalizeWhitespace().WithTriviaFrom(node); var newCondition = SyntaxFactory.IdentifierName(conditionVarIdentifier).WithTriviaFrom(conditionExpression); ExpressionStatementSyntax parentExpression = (ExpressionStatementSyntax)GetParentExpression(node); markedNodes.Add(parentExpression.Expression); // p // // var trueBranch = node.WhenTrue; // var falseBranch = node.WhenFalse; // // var statement = SyntaxFactory.IfStatement(newCondition, SyntaxFactory.ExpressionStatement(trueBranch), SyntaxFactory.ElseClause(SyntaxFactory.ExpressionStatement(falseBranch))); // // replacementNodes.Add(new Tuple<ExpressionSyntax, IdentifierNameSyntax, StatementSyntax>(condition, newCondition, newConditionVar)); return(node); }
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { currentWhileNode = node; continueStatements.Add(currentWhileNode, new List <SyntaxNode>()); breakStatements.Add(currentWhileNode, new List <SyntaxNode>()); var nodeVisited = (WhileStatementSyntax)base.VisitWhileStatement(node); var condition = nodeVisited.Condition; if (condition.Kind() == SyntaxKind.IdentifierName) //check if the code was formatted before to while(condition) { return(nodeVisited); } string conditionVarIdentifier = ConditionIdentifier; var newConditionVar = SyntaxFactoryExtensions.LocalVariableDeclaration(conditionVarIdentifier, condition, SyntaxKind.BoolKeyword).NormalizeWhitespace().WithTriviaFrom(nodeVisited); var newCondition = SyntaxFactory.IdentifierName(conditionVarIdentifier).WithTriviaFrom(condition); markedNodes.Add(condition); markedNodes.Add(node); whileReplacementNodes.Add(new Tuple <ExpressionSyntax, IdentifierNameSyntax, StatementSyntax, WhileStatementSyntax>(condition, newCondition, newConditionVar, node)); return(nodeVisited); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { node = (InvocationExpressionSyntax)base.VisitInvocationExpression(node); if ((node.Kind() != SyntaxKind.InvocationExpression)) { return(node); } //only one invocation is skipped. if (node.Parent.Kind() == SyntaxKind.SimpleAssignmentExpression) { bottomUp = 0; return(node); } if (node.Parent.Kind() == SyntaxKind.EqualsValueClause) { bottomUp = 0; return(node); } if (node.Parent.Kind() == SyntaxKind.Block) { bottomUp = 0; return(node); } if (node.Parent.Kind() == SyntaxKind.ExpressionStatement) { if (node.Parent.Parent.Kind() == SyntaxKind.Block) { bottomUp = 0; return(node); } } int markedNodesCount = markedNodes.Count(); if (markedNodesCount > 0) { bottomUp++; return(node); } if (bottomUp + 2 < VirtualizationContext.MAX_INVOCATIONS) { bottomUp++; return(node); } string tempName = TemporaryVarIdentifier; var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, node); var tempIdentifier = SyntaxFactory.IdentifierName(tempName); var tuple = new Tuple <ExpressionSyntax, IdentifierNameSyntax, SyntaxNode>(node, tempIdentifier, tempVar); var parent = GetParentExpression(node); markedNodes.Add(parent); replacementNodes.Add(tuple); bottomUp++; return(node); }
public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node) { node = (BinaryExpressionSyntax)base.VisitBinaryExpression(node); if ((node.Kind() != SyntaxKind.AddExpression) && (node.Kind() != SyntaxKind.SubtractExpression) ) { return(node); } if (node.Parent.Kind() == SyntaxKind.SimpleAssignmentExpression) { bottomUp = 0; return(node); } if (node.Parent.Kind() == SyntaxKind.EqualsValueClause) { bottomUp = 0; return(node); } int markedNodesCount = markedNodes.Count(); if (markedNodesCount > 0) { bottomUp++; return(node); } if (bottomUp + 2 < VirtualizationContext.MAX_OPERANDS) { bottomUp++; return(node); } string tempName = VAR_NAME + VAR_COUNTER++; var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, node); var tempIdentifier = SyntaxFactory.IdentifierName(tempName); var tuple = new Tuple <ExpressionSyntax, IdentifierNameSyntax, SyntaxNode>(node, tempIdentifier, tempVar); var parent = GetParentExpression(node); markedNodes.Add(parent); replacementNodes.Add(tuple); bottomUp++; return(node); }
public override SyntaxNode VisitSwitchStatement(SwitchStatementSyntax node) { node = (SwitchStatementSyntax)base.VisitSwitchStatement(node); var condition = node.Expression; if (condition.Kind() == SyntaxKind.IdentifierName) { return(node); } string conditionVarIdentifier = ConditionIdentifier; var newConditionVar = SyntaxFactoryExtensions.LocalVariableDeclaration(conditionVarIdentifier, condition).NormalizeWhitespace().WithTriviaFrom(node); var newCondition = SyntaxFactory.IdentifierName(conditionVarIdentifier).WithTriviaFrom(condition); markedNodes.Add(condition); replacementNodes.Add(new Tuple <ExpressionSyntax, IdentifierNameSyntax, StatementSyntax>(condition, newCondition, newConditionVar)); return(node); }
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node) { node = (LocalDeclarationStatementSyntax)base.VisitLocalDeclarationStatement(node); if (node.Declaration.Variables.Count != 1) { return(node); } if (!node.Declaration.Type.ToString().Equals("var")) { return(node); } var identifier = node.Declaration.Variables.First().Identifier.ValueText; var initializerValue = node.Declaration.Variables.First().Initializer.Value; var typeInfo = _virtualizationContext.semanticModel.GetTypeInfo(initializerValue).Type; string type = typeInfo.ToString(); markedNodes.Add(node); var newVar = SyntaxFactoryExtensions.LocalVariableDeclaration(identifier, initializerValue, type); return(newVar); }
public SyntaxNode VisitPrePostExpression(PrefixUnaryExpressionSyntax pre, PostfixUnaryExpressionSyntax post) { SyntaxNode node = null; if (pre == null) { node = post; } if (post == null) { node = pre; } if (node == null) { return(node); } bool postDecr = (node.Kind() == SyntaxKind.PostDecrementExpression); bool postIncr = (node.Kind() == SyntaxKind.PostIncrementExpression); bool preDecr = (node.Kind() == SyntaxKind.PreDecrementExpression); bool preIncr = (node.Kind() == SyntaxKind.PreIncrementExpression); bool condition = postDecr || postIncr || preDecr || preIncr; if (!condition) { return(node); } int markedNodesCount = markedNodes.Count(); if (markedNodesCount > 0) { return(node); } ExpressionSyntax operand = null; int operationType = 0; // 0 - pre, 1 - post if (postDecr || postIncr) { operationType = 1; operand = ((PostfixUnaryExpressionSyntax)node).Operand; } else { operand = ((PrefixUnaryExpressionSyntax)node).Operand; } string tempName = TemporaryVarIdentifier + "_" + operationType; StatementSyntax indexUpdate = null; if (postIncr || preIncr) { indexUpdate = IncrementIndex(operand); } else if (postDecr || preDecr) { indexUpdate = DecrementIndex(operand); } var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, operand); var tempIdentifier = SyntaxFactory.IdentifierName(tempName); var tuple = new Tuple <SyntaxNode, IdentifierNameSyntax, int, SyntaxNode, SyntaxNode>(node, tempIdentifier, operationType, tempVar, indexUpdate); var parent = GetParentExpression(node); markedNodes.Add(parent); replacementNodes.Add(tuple); return(node); }
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; var trueCondition = SyntaxFactoryExtensions.LocalVariableDeclaration(initializer.Identifier.Text, SyntaxFactoryExtensions.BooleanLiteralExpression(true), SyntaxKind.BoolKeyword).NormalizeWhitespace().WithTriviaFrom(localCondition); oldBody = oldBody.InsertNodesBefore(whileStatement, new List <SyntaxNode>() { trueCondition }); 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); //convert DoWhile into While var newWhile = SyntaxFactory.WhileStatement(SyntaxFactory.IdentifierName(initializer.Identifier), whileBody); oldBody = oldBody.ReplaceNode(currentWhile, newWhile); } } return(oldBody); }