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