public void Visit(JsVar node)
{
Debug.Fail("shouldn't get here");
}
public void Visit(JsVar node)
{
// not applicable; terminate
}
private JsAstNode ParseForStatement()
{
m_blockType.Add(BlockType.Loop);
JsAstNode forNode = null;
try
{
JsContext forCtx = m_currentToken.Clone();
GetNextToken();
if (JsToken.LeftParenthesis != m_currentToken.Token)
{
ReportError(JsError.NoLeftParenthesis);
}
GetNextToken();
bool isForIn = false, recoveryInForIn = false;
JsAstNode lhs = null, initializer = null, condOrColl = null, increment = null;
JsContext operatorContext = null;
JsContext separator1Context = null;
JsContext separator2Context = null;
try
{
if (JsToken.Var == m_currentToken.Token
|| JsToken.Let == m_currentToken.Token
|| JsToken.Const == m_currentToken.Token)
{
isForIn = true;
JsDeclaration declaration;
if (m_currentToken.Token == JsToken.Var)
{
declaration = new JsVar(m_currentToken.Clone(), this);
}
else
{
declaration = new JsLexicalDeclaration(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 JsConstantWrapper(true, JsPrimitiveType.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();
}
JsAstNode 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
// and ignore any important comments that spring up right here.
body = ParseStatement(false, true);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode == null)
body = new JsBlock(CurrentPositionContext(), this);
else
body = exc._partiallyComputedNode;
exc._partiallyComputedNode = new JsForIn(forCtx, this)
{
Variable = (lhs != null ? lhs : initializer),
OperatorContext = operatorContext,
Collection = condOrColl,
Body = JsAstNode.ForceToBlock(body),
};
throw;
}
// for (a in b)
// lhs = a, initializer = null
// for (var a in b)
// lhs = null, initializer = var a
forNode = new JsForIn(forCtx, this)
{
Variable = (lhs != null ? lhs : initializer),
OperatorContext = operatorContext,
Collection = condOrColl,
Body = JsAstNode.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 JsConstantWrapper(true, JsPrimitiveType.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 JsBinaryOperator;
if (binOp != null && binOp.OperatorToken == JsToken.Assign)
{
condOrColl.Context.HandleError(JsError.SuspectAssignment);
}
JsAstNode 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
// and ignore any important comments that spring up right here.
body = ParseStatement(false, true);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode == null)
body = new JsBlock(CurrentPositionContext(), this);
else
body = exc._partiallyComputedNode;
exc._partiallyComputedNode = new JsForNode(forCtx, this)
{
Initializer = initializer,
Separator1Context = separator1Context,
Condition = condOrColl,
Separator2Context = separator2Context,
Incrementer = increment,
Body = JsAstNode.ForceToBlock(body)
};
throw;
}
forNode = new JsForNode(forCtx, this)
{
Initializer = initializer,
Separator1Context = separator1Context,
Condition = condOrColl,
Separator2Context = separator2Context,
Incrementer = increment,
Body = JsAstNode.ForceToBlock(body)
};
}
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
}
return forNode;
}
//---------------------------------------------------------------------------------------
// ParseVariableStatement
//
// VariableStatement :
// 'var' VariableDeclarationList
// or
// 'const' VariableDeclarationList
// or
// 'let' VariableDeclarationList
//
// VariableDeclarationList :
// VariableDeclaration |
// VariableDeclaration ',' VariableDeclarationList
//
// VariableDeclaration :
// Identifier Initializer
//
// Initializer :
// <empty> |
// '=' AssignmentExpression
//---------------------------------------------------------------------------------------
private JsAstNode ParseVariableStatement()
{
// create the appropriate statement: var- or const-statement
JsDeclaration varList;
if (m_currentToken.Token == JsToken.Var)
{
varList = new JsVar(m_currentToken.Clone(), this);
}
else if (m_currentToken.Token == JsToken.Const || m_currentToken.Token == JsToken.Let)
{
if (m_currentToken.Token == JsToken.Const && m_settings.ConstStatementsMozilla)
{
varList = new JsConstStatement(m_currentToken.Clone(), this);
}
else
{
varList = new JsLexicalDeclaration(m_currentToken.Clone(), this)
{
StatementToken = m_currentToken.Token
};
}
}
else
{
Debug.Fail("shouldn't get here");
return null;
}
bool single = true;
JsAstNode vdecl = null;
JsAstNode identInit = null;
for (; ; )
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfLineToken);
try
{
identInit = ParseIdentifierInitializer(JsToken.None);
}
catch (RecoveryTokenException exc)
{
// an exception is passing by, possibly bringing some info, save the info if any
if (exc._partiallyComputedNode != null)
{
if (!single)
{
varList.Append(exc._partiallyComputedNode);
varList.Context.UpdateWith(exc._partiallyComputedNode.Context);
exc._partiallyComputedNode = varList;
}
}
if (IndexOfToken(NoSkipTokenSet.s_EndOfLineToken, exc) == -1)
throw;
else
{
if (single)
identInit = exc._partiallyComputedNode;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfLineToken);
}
if (identInit != null)
{
vdecl = identInit;
varList.Append(vdecl);
}
if (m_currentToken.Token == JsToken.Comma)
{
single = false;
vdecl.IfNotNull(d => d.TerminatingContext = m_currentToken.Clone());
}
else if (m_currentToken.Token == JsToken.Semicolon)
{
varList.TerminatingContext = m_currentToken.Clone();
GetNextToken();
break;
}
else if (m_foundEndOfLine || m_currentToken.Token == JsToken.RightCurly || m_currentToken.Token == JsToken.EndOfFile)
{
// semicolon insertion rules
// a right-curly or an end of line is something we don't WANT to throw a warning for.
// Just too common and doesn't really warrant a warning (in my opinion)
if (JsToken.RightCurly != m_currentToken.Token && JsToken.EndOfFile != m_currentToken.Token)
{
ReportError(JsError.SemicolonInsertion, varList.Context.IfNotNull(c => c.FlattenToEnd()), true);
}
break;
}
else
{
ReportError(JsError.NoSemicolon, false);
break;
}
}
if (vdecl != null)
{
varList.Context.UpdateWith(vdecl.Context);
}
return varList;
}
private static int RelocateVar(JsBlock block, int insertAt, JsVar varStatement)
{
// if the var statement is at the next position to insert, then we don't need
// to do anything.
if (block[insertAt] != varStatement)
{
// check to see if the current position is a var and we are the NEXT statement.
// if that's the case, we don't need to break out the initializer, just append all the
// vardecls as-is to the current position.
var existingVar = block[insertAt] as JsVar;
if (existingVar != null && block[insertAt + 1] == varStatement)
{
// just append our vardecls to the insertion point, then delete our statement
existingVar.Append(varStatement);
block.RemoveAt(insertAt + 1);
}
else
{
// iterate through the decls and count how many have initializers
var initializerCount = 0;
for (var ndx = 0; ndx < varStatement.Count; ++ndx)
{
if (varStatement[ndx].Initializer != null)
{
++initializerCount;
}
}
// if there are more than two decls with initializers, then we won't actually
// be gaining anything by moving the var to the top. We'll get rid of the four
// bytes for the "var ", but we'll be adding two bytes for the name and comma
// because name=init will still need to remain behind.
if (initializerCount <= 2)
{
// first iterate through all the declarations in the var statement,
// constructing an expression statement that is made up of assignment
// operators for each of the declarations that have initializers (if any)
// and removing all the initializers
var assignments = new List <JsAstNode>();
for (var ndx = 0; ndx < varStatement.Count; ++ndx)
{
var varDecl = varStatement[ndx];
if (varDecl.Initializer != null)
{
if (varDecl.IsCCSpecialCase)
{
// create a vardecl with the same name and no initializer
var copyDecl = new JsVariableDeclaration(varDecl.Context, varDecl.Parser)
{
Identifier = varDecl.Identifier,
NameContext = varDecl.VariableField.OriginalContext,
VariableField = varDecl.VariableField
};
// replace the special vardecl with the copy
varStatement[ndx] = copyDecl;
// add the original vardecl to the list of "assignments"
assignments.Add(varDecl);
// add the new decl to the field's declaration list, and remove the old one
// because we're going to change that to an assignment.
varDecl.VariableField.Declarations.Add(copyDecl);
varDecl.VariableField.Declarations.Remove(varDecl);
}
else
{
// hold on to the object so we don't lose it to the GC
var initializer = varDecl.Initializer;
// remove it from the vardecl
varDecl.Initializer = null;
// create an assignment operator for a lookup to the name
// as the left, and the initializer as the right, and add it to the list
var lookup = new JsLookup(varDecl.VariableField.OriginalContext, varDecl.Parser)
{
Name = varDecl.Identifier,
VariableField = varDecl.VariableField,
};
assignments.Add(new JsBinaryOperator(varDecl.Context, varDecl.Parser)
{
Operand1 = lookup,
Operand2 = initializer,
OperatorToken = JsToken.Assign,
OperatorContext = varDecl.AssignContext
});
// add the new lookup to the field's references
varDecl.VariableField.References.Add(lookup);
}
}
}
// now if there were any initializers...
if (assignments.Count > 0)
{
// we want to create one big expression from all the assignments and replace the
// var statement with the assignment(s) expression. Start at position n=1 and create
// a binary operator of n-1 as the left, n as the right, and using a comma operator.
var expression = assignments[0];
for (var ndx = 1; ndx < assignments.Count; ++ndx)
{
expression = JsCommaOperator.CombineWithComma(null, expression.Parser, expression, assignments[ndx]);
}
// replace the var with the expression.
// we still have a pointer to the var, so we can insert it back into the proper
// place next.
varStatement.Parent.ReplaceChild(varStatement, expression);
}
else
{
// no initializers.
// if the parent is a for-in statement...
var forInParent = varStatement.Parent as JsForIn;
if (forInParent != null)
{
// we want to replace the var statement with a lookup for the var
// there should be only one vardecl
var varDecl = varStatement[0];
var lookup = new JsLookup(varDecl.VariableField.OriginalContext, varStatement.Parser)
{
Name = varDecl.Identifier,
VariableField = varDecl.VariableField
};
varStatement.Parent.ReplaceChild(varStatement, lookup);
varDecl.VariableField.References.Add(lookup);
}
else
{
// just remove the var statement altogether
varStatement.Parent.ReplaceChild(varStatement, null);
}
}
// if the statement at the insertion point is a var-statement already,
// then we just need to append our vardecls to it. Otherwise we'll insert our
// var statement at the right point
if (existingVar != null)
{
// append the varstatement we want to move to the existing var, which will
// transfer all the vardecls to it.
existingVar.Append(varStatement);
}
else
{
// move the var to the insert point, incrementing the position or next time
block.Insert(insertAt, varStatement);
}
}
}
}
return(insertAt);
}
public void Visit(JsVar node)
{
if (node != null)
{
// declarations get a -1 position index
node.Index = -1;
for (var ndx = 0; ndx < node.Count; ++ndx)
{
var decl = node[ndx];
if (decl != null)
{
decl.Accept(this);
}
}
}
}
public void Visit(JsVar node)
{
if (node != null)
{
var symbol = StartSymbol(node);
// save the no-in state -- we'll reset before processing each initializer
var isNoIn = m_noIn;
Output("var");
MarkSegment(node, null, node.Context);
SetContextOutputPosition(node.Context);
m_startOfStatement = false;
Indent();
var useNewLines = !(node.Parent is JsForNode);
for (var ndx = 0; ndx < node.Count; ++ndx)
{
var decl = node[ndx];
if (decl != null)
{
if (ndx > 0)
{
OutputPossibleLineBreak(',');
if (useNewLines)
{
NewLine();
}
else if (m_settings.OutputMode == MinifierOutputMode.MultipleLines)
{
OutputPossibleLineBreak(' ');
}
}
// be sure to set the no-in state to whatever it was when we entered
// this node, because each declaration might reset it as it's outputting
// its child nodes
m_noIn = isNoIn;
decl.Accept(this);
}
}
Unindent();
EndSymbol(symbol);
}
}
private static bool AreAssignmentsInVar(JsBinaryOperator binaryOp, JsVar varStatement)
{
bool areAssignmentsInVar = false;
if (binaryOp != null)
{
// we only want to pop positive for the simple assign (=). If it's any of the
// complex assigns (+=, -=, etc) then we don't want to combine them.
if (binaryOp.OperatorToken == JsToken.Assign)
{
// see if the left-hand side is a simple lookup
JsLookup lookup = binaryOp.Operand1 as JsLookup;
if (lookup != null)
{
// it is. see if that variable is in the previous var statement
areAssignmentsInVar = varStatement.Contains(lookup.Name);
}
}
else if (binaryOp.OperatorToken == JsToken.Comma)
{
// this is a comma operator, so we will return true only if both
// left and right operators are assignments to vars defined in the
// var statement
areAssignmentsInVar = AreAssignmentsInVar(binaryOp.Operand1 as JsBinaryOperator, varStatement)
&& AreAssignmentsInVar(binaryOp.Operand2 as JsBinaryOperator, varStatement);
}
}
return areAssignmentsInVar;
}
public override void Visit(JsVar node)
{
if (node != null)
{
// don't bother creating a list of var-statements if we're not going to move them.
// and if we are inside a conditional-compilation comment level, then don't move them
// either.
// don't bother moving const-statements.
if (m_moveVarStatements && m_conditionalCommentLevel == 0)
{
if (m_varStatements == null)
{
m_varStatements = new List<JsVar>();
}
// add the node to the list of variable declarations
m_varStatements.Add(node);
}
// and recurse
base.Visit(node);
}
}
private static int RelocateVar(JsBlock block, int insertAt, JsVar varStatement)
{
// if the var statement is at the next position to insert, then we don't need
// to do anything.
if (block[insertAt] != varStatement)
{
// check to see if the current position is a var and we are the NEXT statement.
// if that's the case, we don't need to break out the initializer, just append all the
// vardecls as-is to the current position.
var existingVar = block[insertAt] as JsVar;
if (existingVar != null && block[insertAt + 1] == varStatement)
{
// just append our vardecls to the insertion point, then delete our statement
existingVar.Append(varStatement);
block.RemoveAt(insertAt + 1);
}
else
{
// iterate through the decls and count how many have initializers
var initializerCount = 0;
for (var ndx = 0; ndx < varStatement.Count; ++ndx)
{
if (varStatement[ndx].Initializer != null)
{
++initializerCount;
}
}
// if there are more than two decls with initializers, then we won't actually
// be gaining anything by moving the var to the top. We'll get rid of the four
// bytes for the "var ", but we'll be adding two bytes for the name and comma
// because name=init will still need to remain behind.
if (initializerCount <= 2)
{
// first iterate through all the declarations in the var statement,
// constructing an expression statement that is made up of assignment
// operators for each of the declarations that have initializers (if any)
// and removing all the initializers
var assignments = new List<JsAstNode>();
for (var ndx = 0; ndx < varStatement.Count; ++ndx)
{
var varDecl = varStatement[ndx];
if (varDecl.Initializer != null)
{
if (varDecl.IsCCSpecialCase)
{
// create a vardecl with the same name and no initializer
var copyDecl = new JsVariableDeclaration(varDecl.Context, varDecl.Parser)
{
Identifier = varDecl.Identifier,
NameContext = varDecl.VariableField.OriginalContext,
VariableField = varDecl.VariableField
};
// replace the special vardecl with the copy
varStatement[ndx] = copyDecl;
// add the original vardecl to the list of "assignments"
assignments.Add(varDecl);
// add the new decl to the field's declaration list, and remove the old one
// because we're going to change that to an assignment.
varDecl.VariableField.Declarations.Add(copyDecl);
varDecl.VariableField.Declarations.Remove(varDecl);
}
else
{
// hold on to the object so we don't lose it to the GC
var initializer = varDecl.Initializer;
// remove it from the vardecl
varDecl.Initializer = null;
// create an assignment operator for a lookup to the name
// as the left, and the initializer as the right, and add it to the list
var lookup = new JsLookup(varDecl.VariableField.OriginalContext, varDecl.Parser)
{
Name = varDecl.Identifier,
VariableField = varDecl.VariableField,
};
assignments.Add(new JsBinaryOperator(varDecl.Context, varDecl.Parser)
{
Operand1 = lookup,
Operand2 = initializer,
OperatorToken = JsToken.Assign,
OperatorContext = varDecl.AssignContext
});
// add the new lookup to the field's references
varDecl.VariableField.References.Add(lookup);
}
}
}
// now if there were any initializers...
if (assignments.Count > 0)
{
// we want to create one big expression from all the assignments and replace the
// var statement with the assignment(s) expression. Start at position n=1 and create
// a binary operator of n-1 as the left, n as the right, and using a comma operator.
var expression = assignments[0];
for (var ndx = 1; ndx < assignments.Count; ++ndx)
{
expression = JsCommaOperator.CombineWithComma(null, expression.Parser, expression, assignments[ndx]);
}
// replace the var with the expression.
// we still have a pointer to the var, so we can insert it back into the proper
// place next.
varStatement.Parent.ReplaceChild(varStatement, expression);
}
else
{
// no initializers.
// if the parent is a for-in statement...
var forInParent = varStatement.Parent as JsForIn;
if (forInParent != null)
{
// we want to replace the var statement with a lookup for the var
// there should be only one vardecl
var varDecl = varStatement[0];
var lookup = new JsLookup(varDecl.VariableField.OriginalContext, varStatement.Parser)
{
Name = varDecl.Identifier,
VariableField = varDecl.VariableField
};
varStatement.Parent.ReplaceChild(varStatement, lookup);
varDecl.VariableField.References.Add(lookup);
}
else
{
// just remove the var statement altogether
varStatement.Parent.ReplaceChild(varStatement, null);
}
}
// if the statement at the insertion point is a var-statement already,
// then we just need to append our vardecls to it. Otherwise we'll insert our
// var statement at the right point
if (existingVar != null)
{
// append the varstatement we want to move to the existing var, which will
// transfer all the vardecls to it.
existingVar.Append(varStatement);
}
else
{
// move the var to the insert point, incrementing the position or next time
block.Insert(insertAt, varStatement);
}
}
}
}
return insertAt;
}
private static bool VarDeclExists(JsVar node, int ndx, string name)
{
// only need to look forward from the index passed
for (; ndx < node.Count; ++ndx)
{
// string must be exact match
if (string.CompareOrdinal(node[ndx].Identifier, name) == 0)
{
// there is at least one -- we can bail
return true;
}
}
// if we got here, we didn't find any matches
return false;
}
private static void DeleteNoInits(JsVar node, int min, string name)
{
// walk backwards from the end of the list down to (and including) the minimum index
for (int ndx = node.Count - 1; ndx >= min; --ndx)
{
var varDecl = node[ndx];
// if the name matches and there is no initializer...
if (string.CompareOrdinal(varDecl.Identifier, name) == 0
&& varDecl.Initializer == null)
{
// ...remove it from the list and from the field's declarations
node.RemoveAt(ndx);
varDecl.VariableField.Declarations.Remove(varDecl);
}
}
}
private static void CombineWithPreviousVar(JsBlock node, int ndx, JsVar previousVar)
{
var binaryOp = node[ndx] as JsBinaryOperator;
JsLookup lookup;
if (binaryOp != null
&& binaryOp.IsAssign
&& (lookup = binaryOp.Operand1 as JsLookup) != null
&& lookup.VariableField != null
&& !ContainsReference(binaryOp.Operand2, lookup.VariableField)
&& previousVar[previousVar.Count - 1].VariableField == lookup.VariableField)
{
var varDecl = previousVar[previousVar.Count - 1];
if (varDecl.Initializer != null)
{
if (binaryOp.OperatorToken == JsToken.Assign)
{
// we have var name=expr1;name=expr2. If expr1 is a constant, we will
// get rid of it entirely and replace it with expr2. Otherwise we don't
// know about any side-effects, so just leave it be.
if (varDecl.Initializer.IsConstant)
{
// transform: var name=const;name=expr ==> var name=expr
varDecl.Initializer = binaryOp.Operand2;
// getting rid of the lookup, so clean up its references
lookup.VariableField.IfNotNull(v => v.References.Remove(lookup));
node[ndx] = null;
}
}
else
{
// we have var name=expr1;name[OP]=expr2.
// transform: var name=expr1;name[OP]=expr2 ==> var name=expr1[OP]expr2
// getting rid of the lookup, so clean up its references
lookup.VariableField.IfNotNull(v => v.References.Remove(lookup));
// reuse the binary op by stripping the assignment to just the operator,
// clobbering the lookup on operand1 with the vardecl assignment,
// and expanding the context to include the initializer.
binaryOp.OperatorToken = JsScanner.StripAssignment(binaryOp.OperatorToken);
binaryOp.Operand1 = varDecl.Initializer;
binaryOp.UpdateWith(binaryOp.Operand1.Context);
// set the adjusted binary op to the vardecl initializer and remove the
// current statement (that points to the binary op)
varDecl.Initializer = binaryOp;
node[ndx] = null;
}
}
else if (binaryOp.OperatorToken == JsToken.Assign)
{
// transform: var name;name=expr ==> var name=expr
lookup.VariableField.IfNotNull(v => v.References.Remove(lookup));
varDecl.Initializer = binaryOp.Operand2;
node[ndx] = null;
}
else
{
// we have var name;name[OP]=expr.
// leave it alone???? we could make var name=undefined[OP]expr1, if we have a good undefined value.
}
}
}
public void Visit(JsVar node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(JsVar node)
{
Debug.Fail("shouldn't get here");
}
public void Visit(JsVar node)
{
// starts with 'var', so we don't care
}
public override void Visit(JsVar node)
{
if (node != null)
{
// first we want to weed out duplicates that don't have initializers
// var a=1, a=2 is okay, but var a, a=2 and var a=2, a should both be just var a=2,
// and var a, a should just be var a
if (m_parser.Settings.IsModificationAllowed(JsTreeModifications.RemoveDuplicateVar))
{
// first we want to weed out duplicates that don't have initializers
// var a=1, a=2 is okay, but var a, a=2 and var a=2, a should both be just var a=2,
// and var a, a should just be var a
int ndx = 0;
while (ndx < node.Count)
{
string thisName = node[ndx].Identifier;
// handle differently if we have an initializer or not
if (node[ndx].Initializer != null)
{
// the current vardecl has an initializer, so we want to delete any other
// vardecls of the same name in the rest of the list with no initializer
// and move on to the next item afterwards
DeleteNoInits(node, ++ndx, thisName);
}
else
{
// this vardecl has no initializer, so we can delete it if there is ANY
// other vardecl with the same name (whether or not it has an initializer)
if (VarDeclExists(node, ndx + 1, thisName))
{
// don't increment the index; we just deleted the current item,
// so the next item just slid into this position
node[ndx].VariableField.Declarations.Remove(node[ndx]);
node.RemoveAt(ndx);
}
else
{
// nope -- it's the only one. Move on to the next
++ndx;
}
}
}
}
// recurse the analyze
base.Visit(node);
}
}