public void Visit(ForNode node)
{
if (node != null)
{
node.Index = NextOrderIndex;
if (node.Initializer != null)
{
// if the variable portion of the for-in statement is a lexical
// declaration, then we will create the block node for its body right now
// and add the declaration. This will prevent the body from both creating
// a new lexical scope and from deleting an empty one.
var lexDeclaration = node.Initializer as LexicalDeclaration;
if (lexDeclaration != null)
{
// create the scope on the block
node.BlockScope = new BlockScope(CurrentLexicalScope, node.Context, m_settings)
{
IsInWithScope = m_withDepth > 0
};
m_lexicalStack.Push(node.BlockScope);
}
}
try
{
if (node.Initializer != null)
{
node.Initializer.Accept(this);
}
if (node.Condition != null)
{
node.Condition.Accept(this);
}
if (node.Body != null)
{
node.Body.Accept(this);
}
if (node.Incrementer != null)
{
node.Incrementer.Accept(this);
}
}
finally
{
if (node.BlockScope != null)
{
Debug.Assert(CurrentLexicalScope == node.BlockScope);
m_lexicalStack.Pop();
}
}
}
}
public void Visit(ForNode node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(ForNode node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(ForNode node)
{
Debug.Fail("shouldn't get here");
}
public void Visit(ForNode node)
{
// not applicable; terminate
}
private void DoWhileNode(WhileNode node)
{
// see if the condition is a constant
if (m_parser.Settings.IsModificationAllowed(TreeModifications.EvaluateNumericExpressions))
{
var constantCondition = node.Condition as ConstantWrapper;
if (constantCondition != null)
{
// TODO: (someday) we'd RATHER eliminate the statement altogether if the condition is always false,
// but we'd need to make sure var'd variables and declared functions are properly handled.
try
{
bool isTrue = constantCondition.ToBoolean();
if (isTrue)
{
// the condition is always true, so we should change it to 1
if (m_parser.Settings.IsModificationAllowed(TreeModifications.ChangeWhileToFor))
{
// the condition is always true; we should change it to a for(;;) statement.
// less bytes than while(1)
// check to see if we want to combine a preceding var with a for-statement
AstNode initializer = null;
if (m_parser.Settings.IsModificationAllowed(TreeModifications.MoveVarIntoFor))
{
// if the previous statement is a var, we can move it to the initializer
// and save even more bytes. The parent should always be a block. If not,
// then assume there is no previous.
var parentBlock = node.Parent as Block;
if (parentBlock != null)
{
int whileIndex = parentBlock.IndexOf(node);
if (whileIndex > 0)
{
var previousVar = parentBlock[whileIndex - 1] as Var;
if (previousVar != null)
{
initializer = previousVar;
parentBlock.RemoveAt(whileIndex - 1);
}
}
}
}
// create the for using our body and replace ourselves with it
var forNode = new ForNode(node.Context, m_parser)
{
Initializer = initializer,
Body = node.Body
};
node.Parent.ReplaceChild(node, forNode);
}
else
{
// the condition is always true, so we can replace the condition
// with a 1 -- only one byte
node.Condition = new ConstantWrapper(1, PrimitiveType.Number, null, m_parser);
}
}
else if (constantCondition.IsNotOneOrPositiveZero)
{
// the condition is always false, so we can replace the condition
// with a zero -- only one byte
node.Condition = new ConstantWrapper(0, PrimitiveType.Number, null, m_parser);
}
}
catch (InvalidCastException)
{
// ignore any invalid cast exceptions
}
}
}
}
private void DoForNode(ForNode node)
{
if (m_parser.Settings.IsModificationAllowed(TreeModifications.EvaluateNumericExpressions))
{
ConstantWrapper constantCondition = node.Condition as ConstantWrapper;
if (constantCondition != null)
{
try
{
// if condition is always false, change it to a zero (only one byte)
// and if it is always true, remove it (default behavior)
if (constantCondition.ToBoolean())
{
// always true -- don't need a condition at all
node.Condition = null;
}
else if (constantCondition.IsNotOneOrPositiveZero)
{
// always false and it's not already a zero. Make it so (only one byte)
node.Condition = new ConstantWrapper(0, PrimitiveType.Number, node.Condition.Context, m_parser);
}
}
catch (InvalidCastException)
{
// ignore any invalid cast exceptions
}
}
}
}
public override void Visit(ForNode node)
{
if (node != null)
{
// depth-first
base.Visit(node);
DoForNode(node);
}
}
public void Visit(ForNode node)
{
if (node != null)
{
node.Index = NextOrderIndex;
if (node.Initializer != null)
{
// if the variable portion of the for-in statement is a lexical
// declaration, then we will create the block node for its body right now
// and add the declaration. This will prevent the body from both creating
// a new lexical scope and from deleting an empty one.
var lexDeclaration = node.Initializer as LexicalDeclaration;
if (lexDeclaration != null)
{
// create the scope on the block
node.BlockScope = new BlockScope(CurrentLexicalScope, node.Context, m_settings)
{
IsInWithScope = m_withDepth > 0
};
m_lexicalStack.Push(node.BlockScope);
}
}
try
{
if (node.Initializer != null)
{
node.Initializer.Accept(this);
}
if (node.Condition != null)
{
node.Condition.Accept(this);
}
if (node.Body != null)
{
node.Body.Accept(this);
}
if (node.Incrementer != null)
{
node.Incrementer.Accept(this);
}
}
finally
{
if (node.BlockScope != null)
{
Debug.Assert(CurrentLexicalScope == node.BlockScope);
m_lexicalStack.Pop();
}
}
}
}
public void Visit(ForNode node)
{
Debug.Fail("shouldn't get here");
}
private AstNode ParseForStatement()
{
m_blockType.Add(BlockType.Loop);
AstNode forNode = null;
try
{
Context forCtx = m_currentToken.Clone();
GetNextToken();
if (JSToken.LeftParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoLeftParenthesis);
}
GetNextToken();
bool isForIn = false, recoveryInForIn = false;
AstNode lhs = null, initializer = null, condOrColl = null, increment = null;
Context operatorContext = null;
Context separator1Context = null;
Context separator2Context = null;
try
{
if (JSToken.Var == m_currentToken.Token
|| JSToken.Let == m_currentToken.Token
|| JSToken.Const == m_currentToken.Token)
{
isForIn = true;
Declaration declaration;
if (m_currentToken.Token == JSToken.Var)
{
declaration = new Var(m_currentToken.Clone(), this);
}
else
{
declaration = new LexicalDeclaration(m_currentToken.Clone(), this)
{
StatementToken = m_currentToken.Token
};
}
declaration.Append(ParseIdentifierInitializer(JSToken.In));
// a list of variable initializers is allowed only in a for(;;)
while (JSToken.Comma == m_currentToken.Token)
{
isForIn = false;
declaration.Append(ParseIdentifierInitializer(JSToken.In));
//initializer = new Comma(initializer.context.CombineWith(var.context), initializer, var);
}
initializer = declaration;
// if it could still be a for..in, now it's time to get the 'in'
// TODO: for ES6 might be 'of'
if (isForIn)
{
if (JSToken.In == m_currentToken.Token
|| (m_currentToken.Token == JSToken.Identifier && string.CompareOrdinal(m_currentToken.Code, "of") == 0))
{
operatorContext = m_currentToken.Clone();
GetNextToken();
condOrColl = ParseExpression();
}
else
{
isForIn = false;
}
}
}
else
{
if (JSToken.Semicolon != m_currentToken.Token)
{
bool isLHS;
initializer = ParseUnaryExpression(out isLHS, false);
if (isLHS && (JSToken.In == m_currentToken.Token
|| (m_currentToken.Token == JSToken.Identifier && string.CompareOrdinal(m_currentToken.Code, "of") == 0)))
{
isForIn = true;
operatorContext = m_currentToken.Clone();
lhs = initializer;
initializer = null;
GetNextToken();
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
try
{
condOrColl = ParseExpression();
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = null;
throw;
}
else
{
if (exc._partiallyComputedNode == null)
condOrColl = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this); // what could we put here?
else
condOrColl = exc._partiallyComputedNode;
}
if (exc._token == JSToken.RightParenthesis)
{
GetNextToken();
recoveryInForIn = true;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
}
}
else
{
initializer = ParseExpression(initializer, false, isLHS, JSToken.In);
}
}
}
}
catch (RecoveryTokenException exc)
{
// error is too early abort for
exc._partiallyComputedNode = null;
throw;
}
// at this point we know whether or not is a for..in
if (isForIn)
{
if (!recoveryInForIn)
{
if (JSToken.RightParenthesis != m_currentToken.Token)
ReportError(JSError.NoRightParenthesis);
forCtx.UpdateWith(m_currentToken);
GetNextToken();
}
AstNode body = null;
// if the statements aren't withing curly-braces, throw a possible error
if (JSToken.LeftCurly != m_currentToken.Token)
{
ReportError(JSError.StatementBlockExpected, CurrentPositionContext(), true);
}
try
{
// parse a Statement, not a SourceElement
body = ParseStatement(false);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode == null)
body = new Block(CurrentPositionContext(), this);
else
body = exc._partiallyComputedNode;
exc._partiallyComputedNode = new ForIn(forCtx, this)
{
Variable = (lhs != null ? lhs : initializer),
OperatorContext = operatorContext,
Collection = condOrColl,
Body = AstNode.ForceToBlock(body),
};
throw;
}
// for (a in b)
// lhs = a, initializer = null
// for (var a in b)
// lhs = null, initializer = var a
forNode = new ForIn(forCtx, this)
{
Variable = (lhs != null ? lhs : initializer),
OperatorContext = operatorContext,
Collection = condOrColl,
Body = AstNode.ForceToBlock(body),
};
}
else
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
try
{
if (JSToken.Semicolon == m_currentToken.Token)
{
separator1Context = m_currentToken.Clone();
}
else
{
ReportError(JSError.NoSemicolon);
if (JSToken.Colon == m_currentToken.Token)
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet);
try
{
SkipTokensAndThrow();
}
catch (RecoveryTokenException)
{
if (JSToken.Semicolon == m_currentToken.Token)
{
m_useCurrentForNext = false;
}
else
{
throw;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_VariableDeclNoSkipTokenSet);
}
}
}
GetNextToken();
if (JSToken.Semicolon != m_currentToken.Token)
{
condOrColl = ParseExpression();
if (JSToken.Semicolon != m_currentToken.Token)
{
ReportError(JSError.NoSemicolon);
}
}
separator2Context = m_currentToken.Clone();
GetNextToken();
if (JSToken.RightParenthesis != m_currentToken.Token)
{
increment = ParseExpression();
}
if (JSToken.RightParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
}
forCtx.UpdateWith(m_currentToken);
GetNextToken();
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = null;
throw;
}
else
{
// discard any partial info, just genrate empty condition and increment and keep going
exc._partiallyComputedNode = null;
if (condOrColl == null)
condOrColl = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this);
}
if (exc._token == JSToken.RightParenthesis)
{
GetNextToken();
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
}
// if this is an assignment, throw a warning in case the developer
// meant to use == instead of =
// but no warning if the condition is wrapped in parens.
var binOp = condOrColl as BinaryOperator;
if (binOp != null && binOp.OperatorToken == JSToken.Assign)
{
condOrColl.Context.HandleError(JSError.SuspectAssignment);
}
AstNode body = null;
// if the statements aren't withing curly-braces, throw a possible error
if (JSToken.LeftCurly != m_currentToken.Token)
{
ReportError(JSError.StatementBlockExpected, CurrentPositionContext(), true);
}
try
{
// parse a Statement, not a SourceElement
body = ParseStatement(false);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode == null)
body = new Block(CurrentPositionContext(), this);
else
body = exc._partiallyComputedNode;
exc._partiallyComputedNode = new ForNode(forCtx, this)
{
Initializer = initializer,
Separator1Context = separator1Context,
Condition = condOrColl,
Separator2Context = separator2Context,
Incrementer = increment,
Body = AstNode.ForceToBlock(body)
};
throw;
}
forNode = new ForNode(forCtx, this)
{
Initializer = initializer,
Separator1Context = separator1Context,
Condition = condOrColl,
Separator2Context = separator2Context,
Incrementer = increment,
Body = AstNode.ForceToBlock(body)
};
}
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
}
return forNode;
}
public void Visit(ForNode node)
{
// not applicable; terminate
}
public override void Visit(Block node)
{
if (node != null)
{
// if this block has a block scope, then look at the lexically-declared names (if any)
// and throw an error if any are defined as var's within this scope (ES6 rules).
// if this is the body of a function object, use the function scope.
ActivationObject lexicalScope = node.BlockScope;
if (lexicalScope == null)
{
var functionObject = node.Parent as FunctionObject;
if (functionObject != null)
{
lexicalScope = functionObject.FunctionScope;
}
}
if (lexicalScope != null)
{
foreach (var lexDecl in lexicalScope.LexicallyDeclaredNames)
{
var varDecl = lexicalScope.VarDeclaredName(lexDecl.Name);
if (varDecl != null)
{
// collision.
// if the lexical declaration is a let or const declaration (as opposed to a function declaration),
// then force the warning to an error. This is so the function declaration will remain a warning if
// it collides with a var.
varDecl.NameContext.HandleError(JSError.DuplicateLexicalDeclaration, lexDecl is LexicalDeclaration);
// mark them both a no-rename to preserve the collision in the output
lexDecl.VariableField.IfNotNull(v => v.CanCrunch = false);
varDecl.VariableField.IfNotNull(v => v.CanCrunch = false);
}
}
}
// we might things differently if these statements are the body collection for a function
// because we can assume the implicit return statement at the end of it
bool isFunctionLevel = (node.Parent is FunctionObject);
// if we want to remove debug statements...
if (m_parser.Settings.StripDebugStatements && m_parser.Settings.IsModificationAllowed(TreeModifications.StripDebugStatements))
{
// do it now before we try doing other things
StripDebugStatements(node);
}
// analyze all the statements in our block and recurse them
if (node.BlockScope != null)
{
m_scopeStack.Push(node.BlockScope);
}
try
{
// don't call the base class to recurse -- let's walk the block
// backwards in case any of the children opt to delete themselves.
for (var ndx = node.Count - 1; ndx >= 0; --ndx)
{
node[ndx].Accept(this);
}
}
finally
{
if (node.BlockScope != null)
{
m_scopeStack.Pop();
}
}
if (m_parser.Settings.RemoveUnneededCode)
{
// go forward, and check the count each iteration because we might be ADDING statements to the block.
// let's look at all our if-statements. If a true-clause ends in a return, then we don't
// need the else-clause; we can pull its statements out and stick them after the if-statement.
// also, if we encounter a return-, break- or continue-statement, we can axe everything after it
for (var ndx = 0; ndx < node.Count; ++ndx)
{
// see if it's an if-statement with both a true and a false block
var ifNode = node[ndx] as IfNode;
if (ifNode != null
&& ifNode.TrueBlock != null
&& ifNode.TrueBlock.Count > 0
&& ifNode.FalseBlock != null)
{
// now check to see if the true block ends in a return statement
if (ifNode.TrueBlock[ifNode.TrueBlock.Count - 1] is ReturnNode)
{
// transform: if(cond){statements1;return}else{statements2} to if(cond){statements1;return}statements2
// it does. insert all the false-block statements after the if-statement
node.InsertRange(ndx + 1, ifNode.FalseBlock.Children);
// and then remove the false block altogether
ifNode.FalseBlock = null;
}
}
else if (node[ndx] is ReturnNode
|| node[ndx] is Break
|| node[ndx] is ContinueNode
|| node[ndx] is ThrowNode)
{
// we have an exit node -- no statments afterwards will be executed, so clear them out.
// transform: {...;return;...} to {...;return}
// transform: {...;break;...} to {...;break}
// transform: {...;continue;...} to {...;continue}
// transform: {...;throw;...} to {...;throw}
// we've found an exit statement, and it's not the last statement in the function.
// walk the rest of the statements and delete anything that isn't a function declaration
// or a var- or const-statement.
for (var ndxRemove = node.Count - 1; ndxRemove > ndx; --ndxRemove)
{
var funcObject = node[ndxRemove] as FunctionObject;
if (funcObject == null || funcObject.FunctionType != FunctionType.Declaration)
{
// if it's a const-statement, leave it.
// we COULD check to see if the constant is referenced anywhere and delete
// any that aren't. Maybe later.
// we also don't want to do like the var-statements and remove the initializers.
// Not sure if any browsers would fail a const WITHOUT an initializer.
if (!(node[ndxRemove] is ConstStatement))
{
var varStatement = node[ndxRemove] as Var;
if (varStatement != null)
{
// var statements can't be removed, but any initializers should
// be deleted since they won't get executed.
for (var ndxDecl = 0; ndxDecl < varStatement.Count; ++ndxDecl)
{
if (varStatement[ndxDecl].Initializer != null)
{
varStatement[ndxDecl].Initializer = null;
}
}
}
else
{
// not a function declaration, and not a var statement -- get rid of it
DetachReferences.Apply(node[ndxRemove]);
node.RemoveAt(ndxRemove);
}
}
}
}
}
}
}
// now check the last statement -- if it's an if-statement where the true-block is a single return
// and there is no false block, convert this one statement to a conditional. We might back it out later
// if we don't combine the conditional with other stuff.
// but we can only do this if we're at the functional level because of the implied return at the end
// of that block.
if (isFunctionLevel && node.Count > 0
&& m_parser.Settings.IsModificationAllowed(TreeModifications.IfConditionReturnToCondition))
{
ReturnNode returnNode;
var ifNode = FindLastStatement(node) as IfNode;
if (ifNode != null && ifNode.FalseBlock == null
&& ifNode.TrueBlock.Count == 1
&& (returnNode = ifNode.TrueBlock[0] as ReturnNode) != null)
{
// if the return node doesn't have an operand, then we can just replace the if-statement with its conditional
if (returnNode.Operand == null)
{
// if the condition is a constant, then eliminate it altogether
if (ifNode.Condition.IsConstant)
{
// delete the node altogether. Because the condition is a constant,
// there is no else-block, and the if-block only contains a return
// with no expression, we don't have anything to detach.
node.ReplaceChild(ifNode, null);
}
else
{
// transform: {...;if(cond)return;} to {...;cond;}
node.ReplaceChild(ifNode, ifNode.Condition);
}
}
else if (returnNode.Operand.IsExpression)
{
// this is a strategic replacement that might pay off later. And if
// it doesn't, we'll eventually back it out after all the other stuff
// if applied on top of it.
// transform: if(cond)return expr;} to return cond?expr:void 0}
var conditional = new Conditional(null, m_parser)
{
Condition = ifNode.Condition,
TrueExpression = returnNode.Operand,
FalseExpression = CreateVoidNode()
};
// replace the if-statement with the new return node
node.ReplaceChild(ifNode, new ReturnNode(ifNode.Context, m_parser)
{
Operand = conditional
});
Optimize(conditional);
}
}
}
// now walk through and combine adjacent expression statements, and adjacent var-for statements
// and adjecent expression-return statements
if (m_parser.Settings.IsModificationAllowed(TreeModifications.CombineAdjacentExpressionStatements))
{
CombineExpressions(node);
}
// check to see if we want to combine a preceding var with a for-statement
if (m_parser.Settings.IsModificationAllowed(TreeModifications.MoveVarIntoFor))
{
// look at the statements in the block.
// walk BACKWARDS down the list because we'll be removing items when we encounter
// var statements that can be moved inside a for statement's initializer
// we also don't need to check the first one, since there is nothing before it.
for (int ndx = node.Count - 1; ndx > 0; --ndx)
{
// see if the previous statement is a var statement
// (we've already combined adjacent var-statements)
ForNode forNode;
WhileNode whileNode;
var previousVar = node[ndx - 1] as Var;
if (previousVar != null && (forNode = node[ndx] as ForNode) != null)
{
// BUT if the var statement has any initializers containing an in-operator, first check
// to see if we haven't killed that move before we try moving it. Opera 11 seems to have
// an issue with that syntax, even if properly parenthesized.
if (m_parser.Settings.IsModificationAllowed(TreeModifications.MoveInExpressionsIntoForStatement)
|| !previousVar.ContainsInOperator)
{
// and see if the forNode's initializer is empty
if (forNode.Initializer != null)
{
// not empty -- see if it is a Var node
Var varInitializer = forNode.Initializer as Var;
if (varInitializer != null)
{
// transform: var decls1;for(var decls2;...) to for(var decls1,decls2;...)
// we want to PREPEND the initializers in the previous var-statement
// to our for-statement's initializer var-statement list
varInitializer.InsertAt(0, previousVar);
// then remove the previous var statement
node.RemoveAt(ndx - 1);
// this will bump the for node up one position in the list, so the next iteration
// will be right back on this node in case there are other var statements we need
// to combine
}
else
{
// we want to see if the initializer expression is a series of one or more
// simple assignments to variables that are in the previous var statement.
// if all the expressions are assignments to variables that are defined in the
// previous var statement, then we can just move the var statement into the
// for statement.
var binaryOp = forNode.Initializer as BinaryOperator;
if (binaryOp != null && AreAssignmentsInVar(binaryOp, previousVar))
{
// transform: var decls;for(expr1;...) to for(var decls,expr1;...)
// WHERE expr1 only consists of assignments to variables that are declared
// in that previous var-statement.
// TODO: we *could* also do it is the expr1 assignments are to lookups that are
// defined in THIS scope (not any outer scopes), because it wouldn't hurt to have
// then in a var statement again.
// create a list and fill it with all the var-decls created from the assignment
// operators in the expression
var varDecls = new List<VariableDeclaration>();
ConvertAssignmentsToVarDecls(binaryOp, varDecls, m_parser);
// then go through and append each one to the var statement before us
foreach (var varDecl in varDecls)
{
previousVar.Append(varDecl);
}
// move the previous var-statement into our initializer
forNode.Initializer = previousVar;
// and remove the previous var-statement from the list.
node.RemoveAt(ndx - 1);
// this will bump the for node up one position in the list, so the next iteration
// will be right back on this node, but the initializer will not be null
}
}
}
else
{
// transform: var decls;for(;...) to for(var decls;...)
// if it's empty, then we're free to add the previous var statement
// to this for statement's initializer. remove it from it's current
// position and add it as the initializer
node.RemoveAt(ndx - 1);
forNode.Initializer = previousVar;
// this will bump the for node up one position in the list, so the next iteration
// will be right back on this node, but the initializer will not be null
}
}
}
else if (previousVar != null
&& (whileNode = node[ndx] as WhileNode) != null
&& m_parser.Settings.IsModificationAllowed(TreeModifications.ChangeWhileToFor))
{
// transform: var ...;while(cond)... => for(var ...;cond;)...
node[ndx] = new ForNode(null, m_parser)
{
Initializer = previousVar,
Condition = whileNode.Condition,
Body = whileNode.Body
};
node.RemoveAt(ndx - 1);
}
}
}
// see if the last statement is a return statement
ReturnNode lastReturn;
if ((lastReturn = FindLastStatement(node) as ReturnNode) != null)
{
// set this flag to true if we end up adding an expression to the block.
// before exiting, we'll go through and combine adjacent expressions again if this
// flag has been set to true.
bool changedStatementToExpression = false;
// get the index of the statement before the last return
// (skip over function decls and importand comments)
var indexPrevious = PreviousStatementIndex(node, lastReturn);
// just out of curiosity, let's see if we fit a common pattern:
// var name=expr;return name;
// or
// const name=expr;return name;
// if so, we can cut out the var and simply return the expression
Lookup lookup;
if ((lookup = lastReturn.Operand as Lookup) != null && indexPrevious >= 0)
{
// use the base class for both the var- and const-statements so we will
// pick them both up at the same time
var varStatement = node[indexPrevious] as Declaration;
if (varStatement != null)
{
// if the last vardecl in the var statement matches the return lookup, and no
// other references exist for this field (refcount == 1)...
VariableDeclaration varDecl;
if ((varDecl = varStatement[varStatement.Count - 1]).Initializer != null
&& varDecl.IsEquivalentTo(lookup)
&& varDecl.VariableField.RefCount == 1)
{
// clean up the field's references because we're removing both the lookup reference
// in the return statement and the vardecl.
varDecl.VariableField.References.Remove(lookup);
varDecl.VariableField.Declarations.Remove(varDecl);
if (varStatement.Count == 1)
{
// transform: ...;var name=expr;return name} to ...;return expr}
// there's only one vardecl in the var, so get rid of the entire statement
lastReturn.Operand = varDecl.Initializer;
node.RemoveAt(indexPrevious);
}
else
{
// multiple vardecls are in the statement; we only need to get rid of the last one
lastReturn.Operand = varDecl.Initializer;
varStatement[varStatement.Count - 1] = null;
}
}
}
}
// check to see if we can combine the return statement with a previous if-statement
// into a simple return-conditional. The true statement needs to have no false block,
// and only one statement in the true block.
Conditional conditional;
IfNode previousIf;
while (indexPrevious >= 0
&& lastReturn != null
&& (previousIf = node[indexPrevious] as IfNode) != null
&& previousIf.TrueBlock != null && previousIf.TrueBlock.Count == 1
&& previousIf.FalseBlock == null)
{
// assume no change is made for this loop
bool somethingChanged = false;
// and that one true-block statement needs to be a return statement
var previousReturn = previousIf.TrueBlock[0] as ReturnNode;
if (previousReturn != null)
{
if (lastReturn.Operand == null)
{
if (previousReturn.Operand == null)
{
// IF we are at the function level, then the block ends in an implicit return (undefined)
// and we can change this if to just the condition. If we aren't at the function level,
// then we have to leave the return, but we can replace the if with just the condition.
if (!isFunctionLevel)
{
// not at the function level, so the return must stay.
if (previousIf.Condition.IsConstant)
{
// transform: if(cond)return;return} to return}
node.RemoveAt(indexPrevious);
somethingChanged = true;
}
else
{
// transform: if(cond)return;return} to cond;return}
node[indexPrevious] = previousIf.Condition;
}
}
else if (previousIf.Condition.IsConstant)
{
// transform: remove if(cond)return;return} because cond is a constant
node.ReplaceChild(lastReturn, null);
node.RemoveAt(indexPrevious);
somethingChanged = true;
}
else
{
// transform: if(cond)return;return} to cond}
// replace the final return with just the condition, then remove the previous if
if (node.ReplaceChild(lastReturn, previousIf.Condition))
{
node.RemoveAt(indexPrevious);
somethingChanged = true;
}
}
}
else
{
// transform: if(cond)return expr;return} to return cond?expr:void 0
conditional = new Conditional(null, m_parser)
{
Condition = previousIf.Condition,
TrueExpression = previousReturn.Operand,
FalseExpression = CreateVoidNode()
};
// replace the final return with the new return, then delete the previous if-statement
if (node.ReplaceChild(lastReturn, new ReturnNode(null, m_parser)
{
Operand = conditional
}))
{
node.RemoveAt(indexPrevious);
Optimize(conditional);
somethingChanged = true;
}
}
}
else
{
if (previousReturn.Operand == null)
{
// transform: if(cond)return;return expr} to return cond?void 0:expr
conditional = new Conditional(null, m_parser)
{
Condition = previousIf.Condition,
TrueExpression = CreateVoidNode(),
FalseExpression = lastReturn.Operand
};
// replace the final return with the new return, then delete the previous if-statement
if (node.ReplaceChild(lastReturn, new ReturnNode(null, m_parser)
{
Operand = conditional
}))
{
node.RemoveAt(indexPrevious);
Optimize(conditional);
somethingChanged = true;
}
}
else if (previousReturn.Operand.IsEquivalentTo(lastReturn.Operand))
{
if (previousIf.Condition.IsConstant)
{
// the condition is constant, and the returns return the same thing.
// get rid of the if statement altogether.
// transform: if(cond)return expr;return expr} to return expr}
DetachReferences.Apply(previousReturn.Operand);
node.RemoveAt(indexPrevious);
somethingChanged = true;
}
else
{
// transform: if(cond)return expr;return expr} to return cond,expr}
// create a new binary op with the condition and the final-return operand,
// replace the operand on the final-return with the new binary operator,
// and then delete the previous if-statement
DetachReferences.Apply(previousReturn.Operand);
lastReturn.Operand = CommaOperator.CombineWithComma(null, m_parser, previousIf.Condition, lastReturn.Operand);
node.RemoveAt(indexPrevious);
somethingChanged = true;
}
}
else
{
// transform: if(cond)return expr1;return expr2} to return cond?expr1:expr2}
// create a new conditional with the condition and the return operands,
// replace the operand on the final-return with the new conditional operator,
// and then delete the previous if-statement
// transform: if(cond)return expr1;return expr2} to return cond?expr1:expr2}
conditional = new Conditional(null, m_parser)
{
Condition = previousIf.Condition,
TrueExpression = previousReturn.Operand,
FalseExpression = lastReturn.Operand
};
// replace the operand on the final-return with the new conditional operator,
// and then delete the previous if-statement
lastReturn.Operand = conditional;
node.RemoveAt(indexPrevious);
Optimize(conditional);
somethingChanged = true;
}
}
}
if (!somethingChanged)
{
// nothing changed -- break out of the loop
break;
}
else
{
// set the flag that indicates something changed in at least one of these loops
changedStatementToExpression = true;
// and since we changed something, we need to bump the index down one
// AFTER we grab the last return node (which has slipped into the same position
// as the previous node)
lastReturn = node[indexPrevious--] as ReturnNode;
}
}
// if we added any more expressions since we ran our expression-combination logic,
// run it again.
if (changedStatementToExpression
&& m_parser.Settings.IsModificationAllowed(TreeModifications.CombineAdjacentExpressionStatements))
{
CombineExpressions(node);
}
// and FINALLY, we want to see if what we did previously didn't pan out and we end
// in something like return cond?expr:void 0, in which case we want to change it
// back to a simple if(condition)return expr; (saves four bytes).
// see if the last statement is a return statement that returns a conditional
if (lastReturn != null
&& (conditional = lastReturn.Operand as Conditional) != null)
{
var unaryOperator = conditional.FalseExpression as UnaryOperator;
if (unaryOperator != null
&& unaryOperator.OperatorToken == JSToken.Void
&& unaryOperator.Operand is ConstantWrapper)
{
unaryOperator = conditional.TrueExpression as UnaryOperator;
if (unaryOperator != null && unaryOperator.OperatorToken == JSToken.Void)
{
if (isFunctionLevel)
{
// transform: ...;return cond?void 0:void 0} to ...;cond}
// function level ends in an implicit "return void 0"
node.ReplaceChild(lastReturn, conditional.Condition);
}
else
{
// transform: ...;return cond?void 0:void 0} to ...;cond;return}
// non-function level doesn't end in an implicit return,
// so we need to break them out into two statements
node.ReplaceChild(lastReturn, conditional.Condition);
node.Append(new ReturnNode(null, m_parser));
}
}
else if (isFunctionLevel)
{
// transform: ...;return cond?expr:void 0} to ...;if(cond)return expr}
// (only works at the function-level because of the implicit return statement)
var ifNode = new IfNode(lastReturn.Context, m_parser)
{
Condition = conditional.Condition,
TrueBlock = AstNode.ForceToBlock(new ReturnNode(null, m_parser)
{
Operand = conditional.TrueExpression
})
};
node.ReplaceChild(lastReturn, ifNode);
}
}
else if (isFunctionLevel)
{
unaryOperator = conditional.TrueExpression as UnaryOperator;
if (unaryOperator != null
&& unaryOperator.OperatorToken == JSToken.Void
&& unaryOperator.Operand is ConstantWrapper)
{
// transform: ...;return cond?void 0;expr} to ...;if(!cond)return expr}
// (only works at the function level because of the implicit return)
// get the logical-not of the conditional
var logicalNot = new LogicalNot(conditional.Condition, m_parser);
logicalNot.Apply();
// create a new if-node based on the condition, with the branches swapped
// (true-expression goes to false-branch, false-expression goes to true-branch
var ifNode = new IfNode(lastReturn.Context, m_parser)
{
Condition = conditional.Condition,
TrueBlock = AstNode.ForceToBlock(new ReturnNode(null, m_parser)
{
Operand = conditional.FalseExpression
})
};
node.ReplaceChild(lastReturn, ifNode);
}
}
}
}
if (m_parser.Settings.IsModificationAllowed(TreeModifications.CombineEquivalentIfReturns))
{
// walk backwards looking for if(cond1)return expr1;if(cond2)return expr2;
// (backwards, because we'll be combining those into one statement, reducing the number of statements.
// don't go all the way to zero, because each loop will compare the statement to the PREVIOUS
// statement, and the first statement (index==0) has no previous statement.
for (var ndx = node.Count - 1; ndx > 0; --ndx)
{
// see if the current statement is an if-statement with no else block, and a true
// block that contains a single return-statement WITH an expression.
AstNode currentExpr = null;
AstNode condition2;
if (IsIfReturnExpr(node[ndx], out condition2, ref currentExpr) != null)
{
// see if the previous statement is also the same pattern, but with
// the equivalent expression as its return operand
AstNode condition1;
var matchedExpression = currentExpr;
var ifNode = IsIfReturnExpr(node[ndx - 1], out condition1, ref matchedExpression);
if (ifNode != null)
{
// it is a match!
// let's combine them -- we'll add the current condition to the
// previous condition with a logical-or and delete the current statement.
// transform: if(cond1)return expr;if(cond2)return expr; to if(cond1||cond2)return expr;
ifNode.Condition = new BinaryOperator(null, m_parser)
{
Operand1 = condition1,
Operand2 = condition2,
OperatorToken = JSToken.LogicalOr,
TerminatingContext = ifNode.TerminatingContext ?? node.TerminatingContext
};
DetachReferences.Apply(currentExpr);
node.RemoveAt(ndx);
}
}
}
}
if (isFunctionLevel
&& m_parser.Settings.IsModificationAllowed(TreeModifications.InvertIfReturn))
{
// walk backwards looking for if (cond) return; whenever we encounter that statement,
// we can change it to if (!cond) and put all subsequent statements in the block inside the
// if's true-block.
for (var ndx = node.Count - 1; ndx >= 0; --ndx)
{
var ifNode = node[ndx] as IfNode;
if (ifNode != null
&& ifNode.FalseBlock == null
&& ifNode.TrueBlock != null
&& ifNode.TrueBlock.Count == 1)
{
var returnNode = ifNode.TrueBlock[0] as ReturnNode;
if (returnNode != null && returnNode.Operand == null)
{
// we have if(cond)return;
// logical-not the condition, remove the return statement,
// and move all subsequent sibling statements inside the if-statement.
LogicalNot.Apply(ifNode.Condition, m_parser);
ifNode.TrueBlock.Clear();
var ndxMove = ndx + 1;
if (node.Count == ndxMove + 1)
{
// there's only one statement after our if-node.
// see if it's ALSO an if-node with no else block.
var secondIfNode = node[ndxMove] as IfNode;
if (secondIfNode != null && (secondIfNode.FalseBlock == null || secondIfNode.FalseBlock.Count == 0))
{
// it is!
// transform: if(cond1)return;if(cond2){...} => if(!cond1&&cond2){...}
// (the cond1 is already inverted at this point)
// combine cond2 with cond1 via a logical-and,
// move all secondIf statements inside the if-node,
// remove the secondIf node.
node.RemoveAt(ndxMove);
ifNode.Condition = new BinaryOperator(null, m_parser)
{
Operand1 = ifNode.Condition,
Operand2 = secondIfNode.Condition,
OperatorToken = JSToken.LogicalAnd
};
ifNode.TrueBlock = secondIfNode.TrueBlock;
}
else if (node[ndxMove].IsExpression
&& m_parser.Settings.IsModificationAllowed(TreeModifications.IfConditionCallToConditionAndCall))
{
// now we have if(cond)expr; optimize that!
var expression = node[ndxMove];
node.RemoveAt(ndxMove);
IfConditionExpressionToExpression(ifNode, expression);
}
}
// just move all the following statements inside the if-statement
while (node.Count > ndxMove)
{
var movedNode = node[ndxMove];
node.RemoveAt(ndxMove);
ifNode.TrueBlock.Append(movedNode);
}
}
}
}
}
else
{
var isIteratorBlock = node.Parent is ForNode
|| node.Parent is ForIn
|| node.Parent is WhileNode
|| node.Parent is DoWhile;
if (isIteratorBlock
&& m_parser.Settings.IsModificationAllowed(TreeModifications.InvertIfContinue))
{
// walk backwards looking for if (cond) continue; whenever we encounter that statement,
// we can change it to if (!cond) and put all subsequent statements in the block inside the
// if's true-block.
for (var ndx = node.Count - 1; ndx >= 0; --ndx)
{
var ifNode = node[ndx] as IfNode;
if (ifNode != null
&& ifNode.FalseBlock == null
&& ifNode.TrueBlock != null
&& ifNode.TrueBlock.Count == 1)
{
var continueNode = ifNode.TrueBlock[0] as ContinueNode;
// if there's no label, then we're good. Otherwise we can only make this optimization
// if the label refers to the parent iterator node.
if (continueNode != null
&& (string.IsNullOrEmpty(continueNode.Label) || (LabelMatchesParent(continueNode.Label, node.Parent))))
{
// if this is the last statement, then we don't really need the if at all
// and can just replace it with its condition
if (ndx < node.Count - 1)
{
// we have if(cond)continue;st1;...stn;
// logical-not the condition, remove the continue statement,
// and move all subsequent sibling statements inside the if-statement.
LogicalNot.Apply(ifNode.Condition, m_parser);
ifNode.TrueBlock.Clear();
// TODO: if we removed a labeled continue, do we need to fix up some label references?
var ndxMove = ndx + 1;
if (node.Count == ndxMove + 1)
{
// there's only one statement after our if-node.
// see if it's ALSO an if-node with no else block.
var secondIfNode = node[ndxMove] as IfNode;
if (secondIfNode != null && (secondIfNode.FalseBlock == null || secondIfNode.FalseBlock.Count == 0))
{
// it is!
// transform: if(cond1)continue;if(cond2){...} => if(!cond1&&cond2){...}
// (the cond1 is already inverted at this point)
// combine cond2 with cond1 via a logical-and,
// move all secondIf statements inside the if-node,
// remove the secondIf node.
ifNode.Condition = new BinaryOperator(null, m_parser)
{
Operand1 = ifNode.Condition,
Operand2 = secondIfNode.Condition,
OperatorToken = JSToken.LogicalAnd
};
ifNode.TrueBlock = secondIfNode.TrueBlock;
node.RemoveAt(ndxMove);
}
else if (node[ndxMove].IsExpression
&& m_parser.Settings.IsModificationAllowed(TreeModifications.IfConditionCallToConditionAndCall))
{
// now we have if(cond)expr; optimize that!
var expression = node[ndxMove];
node.RemoveAt(ndxMove);
IfConditionExpressionToExpression(ifNode, expression);
}
}
// just move all the following statements inside the if-statement
while (node.Count > ndxMove)
{
var movedNode = node[ndxMove];
node.RemoveAt(ndxMove);
ifNode.TrueBlock.Append(movedNode);
}
}
else
{
// we have if(cond)continue} -- nothing after the if.
// the loop is going to continue anyway, so replace the if-statement
// with the condition and be done
if (ifNode.Condition.IsConstant)
{
// consition is constant -- get rid of the if-statement altogether
node.RemoveAt(ndx);
}
else
{
// condition isn't constant
node[ndx] = ifNode.Condition;
}
}
}
}
}
}
}
}
}
private void CombineForNodeWithExpression(Block node, int ndx, ForNode forNode)
{
// if we aren't allowing in-operators to be moved into for-statements, then
// first check to see if that previous expression statement is free of in-operators
// before trying to move it.
if (m_parser.Settings.IsModificationAllowed(TreeModifications.MoveInExpressionsIntoForStatement)
|| !node[ndx - 1].ContainsInOperator)
{
if (forNode.Initializer == null)
{
// transform: expr1;for(;...) to for(expr1;...)
// simply move the previous expression to the for-statement's initializer
forNode.Initializer = node[ndx - 1];
node[ndx - 1] = null;
}
else if (forNode.Initializer.IsExpression)
{
// transform: expr1;for(expr2;...) to for(expr1,expr2;...)
var binOp = CommaOperator.CombineWithComma(null, m_parser, node[ndx - 1], forNode.Initializer);
// replace the initializer with the new binary operator and remove the previous node
forNode.Initializer = binOp;
node[ndx - 1] = null;
}
}
}
public override void Visit(ForNode node)
{
if (node != null)
{
// if this for-statement has it's own lexical scope, then it's an error
// if the any of the field names declared in this scope is also defined inside the body.
if (node.BlockScope != null)
{
foreach (var field in node.BlockScope.LexicallyDeclaredNames)
{
// if the block has a lexical scope, check it for conflicts
if (node.Body != null && node.Body.BlockScope != null)
{
var lexDecl = node.Body.BlockScope.LexicallyDeclaredName(field.Name);
if (lexDecl != null)
{
// report the error (lex/const/funcdecl collision)
lexDecl.NameContext.HandleError(JSError.DuplicateLexicalDeclaration, true);
// link the inner one to the outer one so any renaming stays in sync.
if (lexDecl.VariableField != null)
{
lexDecl.VariableField.OuterField = field.VariableField;
if (field.VariableField != null && !lexDecl.VariableField.CanCrunch)
{
field.VariableField.CanCrunch = false;
}
}
}
}
// check to make sure there are no var-decl'd names with the same name. Those will
// get carried up to this scope so we don't need to check the block scope (if any)
var varDecl = node.BlockScope.VarDeclaredName(field.Name);
if (varDecl != null)
{
// report the error (lex/const collides with var) or warning (funcdecl collides with var)
varDecl.NameContext.HandleError(JSError.DuplicateLexicalDeclaration, field is LexicalDeclaration);
// and mark them both as no-rename
varDecl.VariableField.IfNotNull(v => v.CanCrunch = false);
field.VariableField.IfNotNull(v => v.CanCrunch = false);
}
}
}
// if we are stripping debugger statements and the body is
// just a debugger statement, replace it with a null
// (but only if the body doesn't have its own lexical scope)
if (m_parser.Settings.StripDebugStatements
&& m_parser.Settings.IsModificationAllowed(TreeModifications.StripDebugStatements)
&& node.Body != null
&& node.Body.IsDebuggerStatement
&& node.Body.BlockScope == null)
{
node.Body = null;
}
// recurse
base.Visit(node);
// if the body is now empty (and doesn't have its own lexical scope), make it null
if (node.Body != null && node.Body.Count == 0 && node.Body.BlockScope == null)
{
node.Body = null;
}
}
}
private void CombineWithPreviousExpression(Block node, int ndx)
{
IfNode ifNode;
ForNode forNode;
WhileNode whileNode;
ReturnNode returnNode;
if (node[ndx].IsExpression)
{
CombineTwoExpressions(node, ndx);
}
else if ((returnNode = node[ndx] as ReturnNode) != null)
{
CombineReturnWithExpression(node, ndx, returnNode);
}
else if ((forNode = node[ndx] as ForNode) != null)
{
CombineForNodeWithExpression(node, ndx, forNode);
}
else if ((ifNode = node[ndx] as IfNode) != null)
{
// transform: expr;if(cond)... => if(expr,cond)...
// combine the previous expression with the if-condition via comma, then delete
// the previous statement.
ifNode.Condition = CommaOperator.CombineWithComma(null, m_parser, node[ndx - 1], ifNode.Condition);
node.RemoveAt(ndx - 1);
}
else if ((whileNode = node[ndx] as WhileNode) != null
&& m_parser.Settings.IsModificationAllowed(TreeModifications.ChangeWhileToFor))
{
// transform: expr;while(cond)... => for(expr;cond;)...
// zero-sum, and maybe a little worse for performance because of the nop iterator,
// but combines two statements into one, which may have savings later on.
var initializer = node[ndx - 1];
node[ndx] = new ForNode(null, m_parser)
{
Initializer = initializer,
Condition = whileNode.Condition,
Body = whileNode.Body
};
node.RemoveAt(ndx - 1);
}
}