void PossiblyBreakExpressionList(BinaryExpression node, BlockStatement parentBlock, AstNodeList nodeList)
{
// if the first item can be broken, then we an break it and be done.
// otherwise we're going to have to walk until we find a breaking place
if (CanBeBroken(nodeList[0]))
{
// break the first item. insert the left-hand side at our position and
// recurse it. Then rotate the node.
var index = parentBlock.IndexOf(node);
var temp = node.Operand1;
RotateOpeator(node, nodeList);
parentBlock.Insert(index, temp);
// assumes nothing will cause the node to be deleted, because then it
// would cause us to miss the following item
temp.Accept(this);
}
else
{
// the first one can't be broken, so find the first one that can (if any)
for (var ndx = 1; ndx < nodeList.Count; ++ndx)
{
if (CanBeBroken(nodeList[ndx]))
{
if (ndx == 1)
{
// the second item is where we are breaking it, so we're going to pull
// the first item, replace the list with that first item, then insert
// a new comma operator after the current node
var temp = nodeList[0];
nodeList.RemoveAt(0);
node.Operand2 = temp;
// if there's nothing left, then let it die. Otherwise split off
// the remainder and insert after the current item.
if (nodeList.Count > 0)
{
parentBlock.InsertAfter(node, CreateSplitNodeFromEnd(nodeList, 0));
}
}
else
{
// split off items from the index where we want to split, and insert
// it after the current node and leave the node list where it is.
parentBlock.InsertAfter(node, CreateSplitNodeFromEnd(nodeList, ndx));
}
// and now that we've broken it, bail.
break;
}
}
// regardless if anything changed, recurse this node now
base.Visit(node);
}
}
void PossiblyBreakExpressionStatement(BinaryExpression node, BlockStatement parentBlock)
{
var nodeList = node.Operand2 as AstNodeList;
if (nodeList != null)
{
PossiblyBreakExpressionList(node, parentBlock, nodeList);
}
else
{
// not a list
if (CanBeBroken(node.Operand2))
{
// flatten the operator. We have to explicitly recurse the left-hand side.
var temp = node.Operand1;
parentBlock.ReplaceChild(node, temp);
parentBlock.InsertAfter(temp, node.Operand2);
temp.Accept(this);
}
else
{
// no change; just recurse normally
base.Visit(node);
}
}
}