public void VisitNode(JSWhileLoop wl)
{
// Extract the last non-block statement from the body of the while loop
var lastChild = wl.Children.LastOrDefault();
while (lastChild is JSBlockStatement)
{
var bs = lastChild as JSBlockStatement;
if (bs.IsControlFlow)
{
break;
}
else
{
lastChild = bs.Statements.LastOrDefault();
}
}
// Is it a continue expression?
var lastES = lastChild as JSExpressionStatement;
if (lastES != null)
{
var lastContinue = lastES.Expression as JSContinueExpression;
if (
(lastContinue != null) &&
(lastContinue.TargetLoop == wl.Index)
)
{
// Spurious continue, so murder it
wl.ReplaceChildRecursive(lastContinue, new JSNullExpression());
if (TraceLevel >= 1)
{
Console.WriteLine("// Pruning spurious continue expression {0}", lastContinue);
}
MadeChanges = true;
}
}
LoopIndexStack.Push(wl.Index.GetValueOrDefault(-1));
VisitChildren(wl);
LoopIndexStack.Pop();
}
public void VisitNode(JSWhileLoop whileLoop)
{
JSVariable initVariable = null, lastVariable = null;
JSBinaryOperator initOperator = null;
JSExpression initValue = null;
var prevEStmt = PreviousSibling as JSExpressionStatement;
var prevVDS = PreviousSibling as JSVariableDeclarationStatement;
if (prevEStmt != null)
{
var boe = prevEStmt.Expression as JSBinaryOperatorExpression;
if (
(boe != null) &&
(boe.Operator is JSAssignmentOperator) &&
(boe.Left is JSVariable)
)
{
initVariable = (JSVariable)boe.Left;
initOperator = boe.Operator;
initValue = boe.Right;
}
}
else if (prevVDS != null)
{
var decl = prevVDS.Declarations.FirstOrDefault(
(d) => !d.IsNull
);
if (decl != null)
{
initVariable = (JSVariable)decl.Left;
initOperator = decl.Operator;
initValue = decl.Right;
}
}
var lastStatement = whileLoop.Statements.LastOrDefault();
while ((lastStatement != null) && (lastStatement.GetType() == typeof(JSBlockStatement)))
{
lastStatement = ((JSBlockStatement)lastStatement).Statements.LastOrDefault();
}
var lastExpressionStatement = lastStatement as JSExpressionStatement;
if (lastExpressionStatement != null)
{
var lastUoe = lastExpressionStatement.Expression as JSUnaryOperatorExpression;
var lastBoe = lastExpressionStatement.Expression as JSBinaryOperatorExpression;
if ((lastUoe != null) && (lastUoe.Operator is JSUnaryMutationOperator))
{
lastVariable = lastUoe.Expression as JSVariable;
}
else if ((lastBoe != null) && (lastBoe.Operator is JSAssignmentOperator))
{
lastVariable = lastBoe.Left as JSVariable;
if (
(lastVariable != null) &&
!lastBoe.Right.SelfAndChildrenRecursive.Any(
(n) => lastVariable.Equals(n)
)
)
{
lastVariable = null;
}
}
}
var lastIfStatement = lastStatement as JSIfStatement;
if (
(lastIfStatement != null) &&
whileLoop.Condition is JSBooleanLiteral &&
((JSBooleanLiteral)whileLoop.Condition).Value
)
{
var innerStatement = lastIfStatement.TrueClause;
while (innerStatement is JSBlockStatement)
{
var bs = (JSBlockStatement)innerStatement;
if (bs.Statements.Count != 1)
{
innerStatement = null;
break;
}
innerStatement = bs.Statements[0];
}
var eStmt = innerStatement as JSExpressionStatement;
if (eStmt != null)
{
var breakExpr = eStmt.Expression as JSBreakExpression;
if ((breakExpr != null) && (breakExpr.TargetLoop == whileLoop.Index))
{
whileLoop.ReplaceChildRecursive(lastIfStatement, new JSNullStatement());
var doLoop = new JSDoLoop(
new JSUnaryOperatorExpression(JSOperator.LogicalNot, lastIfStatement.Condition, TypeSystem.Boolean),
whileLoop.Statements.ToArray()
);
doLoop.Index = whileLoop.Index;
ParentNode.ReplaceChild(whileLoop, doLoop);
VisitChildren(doLoop);
return;
}
}
}
bool cantBeFor = false;
if ((initVariable != null) && (lastVariable != null) &&
!initVariable.Equals(lastVariable)
)
{
cantBeFor = true;
}
else if ((initVariable ?? lastVariable) == null)
{
cantBeFor = true;
}
else if (!whileLoop.Condition.SelfAndChildrenRecursive.Any(
(n) => (initVariable ?? lastVariable).Equals(n)
))
{
cantBeFor = true;
}
else if (
!PostSwitchTransform && (
(lastStatement is JSSwitchStatement) ||
(lastStatement is JSLabelGroupStatement)
)
)
{
cantBeFor = true;
}
if (!cantBeFor)
{
JSStatement initializer = null, increment = null;
if (initVariable != null)
{
initializer = PreviousSibling as JSStatement;
ParentNode.ReplaceChild(PreviousSibling, new JSNullStatement());
}
if (lastVariable != null)
{
increment = lastExpressionStatement;
whileLoop.ReplaceChildRecursive(lastExpressionStatement, new JSNullStatement());
}
var forLoop = new JSForLoop(
initializer, whileLoop.Condition, increment,
whileLoop.Statements.ToArray()
);
forLoop.Index = whileLoop.Index;
ParentNode.ReplaceChild(whileLoop, forLoop);
VisitChildren(forLoop);
}
else
{
VisitChildren(whileLoop);
}
}