private void CombineTwoExpressions(Block node, int ndx) { var prevBinary = node[ndx - 1] as BinaryOperator; var curBinary = node[ndx] as BinaryOperator; Lookup lookup; if (prevBinary != null && curBinary != null && prevBinary.IsAssign && curBinary.IsAssign && curBinary.OperatorToken != JSToken.Assign && (lookup = curBinary.Operand1 as Lookup) != null && prevBinary.Operand1.IsEquivalentTo(curBinary.Operand1)) { if (prevBinary.OperatorToken == JSToken.Assign) { // transform: lookup=expr1;lookup[OP]=expr2; ==> lookup=expr1[OP]expr2 var binOp = new BinaryOperator(prevBinary.Operand2.Context.Clone().CombineWith(curBinary.Operand2.Context), prevBinary.Parser) { Operand1 = prevBinary.Operand2, Operand2 = curBinary.Operand2, OperatorToken = JSScanner.StripAssignment(curBinary.OperatorToken), OperatorContext = curBinary.OperatorContext }; prevBinary.Operand2 = binOp; // we are removing the second lookup, so clean up the reference on the field if (lookup.VariableField != null) { lookup.VariableField.References.Remove(lookup); } // and remove the current assignment expression (everything was combined into the previous) node[ndx] = null; } else { // there's lots of ins-and-outs in terms of strings versus numerics versus precedence and all // sorts of stuff. I need to iron this out a little better, but until then, just combine with a comma. // transform: expr1;expr2 ==> expr1,expr2 var binOp = CommaOperator.CombineWithComma(prevBinary.Context.Clone().CombineWith(curBinary.Context), m_parser, prevBinary, curBinary); // replace the previous node and delete the current node[ndx - 1] = binOp; node[ndx] = null; } } else { // transform: expr1;expr2 to expr1,expr2 // use the special comma operator object so we can handle it special // and don't create stack-breakingly deep trees var binOp = CommaOperator.CombineWithComma(node[ndx - 1].Context.Clone().CombineWith(node[ndx].Context), m_parser, node[ndx - 1], node[ndx]); // replace the current node and delete the previous node[ndx] = binOp; node[ndx - 1] = null; } }
public override void Visit(Block node) { if (node != null) { // javascript doesn't have block scope, so there really is no point // in nesting blocks. Unnest any now, before we start combining var statements UnnestBlocks(node); if (m_combineAdjacentVars) { // look at the statements in the block. // if there are multiple var statements adjacent to each other, combine them. // walk BACKWARDS down the list because we'll be removing items when we encounter // multiple vars, etc. // 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) { // if the previous node is not a Var, then we don't need to try and combine // it with the current node var previousVar = node[ndx - 1] as Var; if (previousVar != null && node[ndx] is Var) { // add the items in this VAR to the end of the previous previousVar.Append(node[ndx]); // delete this item from the block node.RemoveAt(ndx); } else { // do the same thing for lexical declarations var previousLex = node[ndx - 1] as LexicalDeclaration; var thisLex = node[ndx] as LexicalDeclaration; if (previousLex != null && thisLex != null) { // but we can only combine them if they are the same type (let or const) if (previousLex.StatementToken == thisLex.StatementToken) { previousLex.Append(node[ndx]); node.RemoveAt(ndx); } } else { // try doing the same for const-statements: combine adjacent ones var previousConst = node[ndx - 1] as ConstStatement; if (previousConst != null && node[ndx] is ConstStatement) { // they are both ConstStatements, so adding the current one to the // previous one will combine them, then delete the latter one. previousConst.Append(node[ndx]); node.RemoveAt(ndx); } } } } } // recurse down the tree after we've combined the adjacent var statements base.Visit(node); } }
public void Visit(Block node) { if (node != null && node.Count > 0) { // there should only be one "statement" node[0].Accept(this); } }
private static int RelocateDirectivePrologue(Block block, int insertAt, DirectivePrologue directivePrologue) { // skip over any important comments while (insertAt < block.Count && (block[insertAt] is ImportantComment)) { ++insertAt; } // if the one we want to insert is already at this spot, then we're good to go if (block[insertAt] != directivePrologue) { // remove it from where it is right now and insert it into the proper location directivePrologue.Parent.ReplaceChild(directivePrologue, null); block.Insert(insertAt, directivePrologue); } // and move up to the next slot return ++insertAt; }
private static int RelocateVar(Block block, int insertAt, Var 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 Var; 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<AstNode>(); 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 VariableDeclaration(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 Lookup(varDecl.VariableField.OriginalContext, varDecl.Parser) { Name = varDecl.Identifier, VariableField = varDecl.VariableField, }; assignments.Add(new BinaryOperator(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 = CommaOperator.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 ForIn; 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 Lookup(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; }
/// <summary> /// Parse the source code using the given settings, getting back an abstract syntax tree Block node as the root /// representing the list of statements in the source code. /// </summary> /// <param name="settings">code settings to use to process the source code</param> /// <returns>root Block node representing the top-level statements</returns> public Block Parse(CodeSettings settings) { // initialize the scanner with our settings // make sure the RawTokens setting is OFF or we won't be able to create our AST InitializeScanner(settings); // make sure we initialize the global scope's strict mode to our flag, whether or not it // is true. This means if the setting is false, we will RESET the flag to false if we are // reusing the scope and a previous Parse call had code that set it to strict with a // program directive. GlobalScope.UseStrict = m_settings.StrictMode; // make sure the global scope knows about our known global names GlobalScope.SetAssumedGlobals(m_settings); // start of a new module m_newModule = true; Block scriptBlock; Block returnBlock; switch (m_settings.SourceMode) { case JavaScriptSourceMode.Program: // simply parse a block of statements returnBlock = scriptBlock = ParseStatements(); break; case JavaScriptSourceMode.Expression: // create a block, get the first token, add in the parse of a single expression, // and we'll go fron there. returnBlock = scriptBlock = new Block(CurrentPositionContext(), this); GetNextToken(); try { var expr = ParseExpression(); if (expr != null) { scriptBlock.Append(expr); scriptBlock.UpdateWith(expr.Context); } } catch (EndOfFileException) { Debug.WriteLine("EOF"); } break; case JavaScriptSourceMode.EventHandler: // we're going to create the global block, add in a function expression with a single // parameter named "event", and then we're going to parse the input as the body of that // function expression. We're going to resolve the global block, but only return the body // of the function. scriptBlock = new Block(null, this); var parameters = new AstNodeList(null, this); parameters.Append(new ParameterDeclaration(null, this) { Name = "event", RenameNotAllowed = true }); var funcExpression = new FunctionObject(null, this) { FunctionType = FunctionType.Expression, ParameterDeclarations = parameters }; scriptBlock.Append(funcExpression); returnBlock = ParseStatements(); funcExpression.Body = returnBlock; break; default: Debug.Fail("Unexpected source mode enumeration"); return null; } // resolve everything ResolutionVisitor.Apply(scriptBlock, GlobalScope, m_settings); if (scriptBlock != null && Settings.MinifyCode) { // this visitor doesn't just reorder scopes. It also combines the adjacent var variables, // unnests blocks, identifies prologue directives, and sets the strict mode on scopes. ReorderScopeVisitor.Apply(scriptBlock, this); // analyze the entire node tree (needed for hypercrunch) // root to leaf (top down) var analyzeVisitor = new AnalyzeNodeVisitor(this); scriptBlock.Accept(analyzeVisitor); // analyze the scope chain (also needed for hypercrunch) // root to leaf (top down) m_globalScope.AnalyzeScope(); // if we want to crunch any names.... if (m_settings.LocalRenaming != LocalRenaming.KeepAll && m_settings.IsModificationAllowed(TreeModifications.LocalRenaming)) { // then do a top-down traversal of the scope tree. For each field that had not // already been crunched (globals and outers will already be crunched), crunch // the name with a crunch iterator that does not use any names in the verboten set. m_globalScope.AutoRenameFields(); } // if we want to evaluate literal expressions, do so now if (m_settings.EvalLiteralExpressions) { var visitor = new EvaluateLiteralVisitor(this); scriptBlock.Accept(visitor); } // if any of the conditions we check for in the final pass are available, then // make the final pass if (m_settings.IsModificationAllowed(TreeModifications.BooleanLiteralsToNotOperators)) { var visitor = new FinalPassVisitor(this); scriptBlock.Accept(visitor); } // we want to walk all the scopes to make sure that any generated // variables that haven't been crunched have been assigned valid // variable names that don't collide with any existing variables. m_globalScope.ValidateGeneratedNames(); } if (returnBlock.Parent != null) { returnBlock.Parent = null; } return returnBlock; }
// // statements (we should only hit expressions) // public void Visit(Block node) { Debug.Fail("shouldn't get here"); }
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; } } } } } } } } }
public void Visit(Block node) { // not applicable; terminate }
private static void CombineWithPreviousVar(Block node, int ndx, Var previousVar) { var binaryOp = node[ndx] as BinaryOperator; Lookup lookup; if (binaryOp != null && binaryOp.IsAssign && (lookup = binaryOp.Operand1 as Lookup) != 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. } } }
private static AstNode FindLastStatement(Block node) { // start with the last statement in the block and back up over any function declarations // or important comments until we get the last statement var lastStatementIndex = node.Count - 1; while (lastStatementIndex >= 0 && (node[lastStatementIndex] is FunctionObject || node[lastStatementIndex] is ImportantComment)) { --lastStatementIndex; } return lastStatementIndex >= 0 ? node[lastStatementIndex] : null; }
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; } } }
private static void StripDebugStatements(Block node) { // walk the list backwards for (int ndx = node.Count - 1; ndx >= 0; --ndx) { // if this item pops positive... if (node[ndx].IsDebuggerStatement) { // just remove it DetachReferences.Apply(node[ndx]); node.RemoveAt(ndx); } } }
private void CombineReturnWithExpression(Block node, int ndx, ReturnNode returnNode) { // see if the return node has an expression operand if (returnNode.Operand != null && returnNode.Operand.IsExpression) { // check for lookup[ASSIGN]expr2;return expr1. var beforeExpr = node[ndx - 1] as BinaryOperator; Lookup lookup; if (beforeExpr != null && beforeExpr.IsAssign && (lookup = beforeExpr.Operand1 as Lookup) != null) { if (returnNode.Operand.IsEquivalentTo(lookup)) { // we have lookup[ASSIGN]expr2;return lookup. // if lookup is a local variable in the current scope, we can replace with return expr2; // if lookup is an outer reference, we can replace with return lookup[ASSIGN]expr2 if (beforeExpr.OperatorToken == JSToken.Assign) { // check to see if lookup is in the current scope from which we are returning if (lookup.VariableField == null || lookup.VariableField.OuterField != null || lookup.VariableField.IsReferencedInnerScope) { // transform: lookup[ASSIGN]expr2;return lookup => return lookup[ASSIGN]expr2 // lookup points to outer field (or we don't know) // replace the operand on the return node with the previous expression and // delete the previous node. // first be sure to remove the lookup in the return operand from the references // to field. DetachReferences.Apply(returnNode.Operand); returnNode.Operand = beforeExpr; node[ndx - 1] = null; } else { // transform: lookup[ASSIGN]expr2;return lookup => return expr2 // lookup is a variable local to the current scope, so when we return, the // variable won't exists anymore anyway. // replace the operand on the return node oprand with the right-hand operand of the // previous expression and delete the previous node. // we're eliminating the two lookups altogether, so remove them both from the // field's reference table. var varField = lookup.VariableField; DetachReferences.Apply(lookup, returnNode.Operand); returnNode.Operand = beforeExpr.Operand2; node[ndx - 1] = null; // now that we've eliminated the two lookups, see if the local variable isn't // referenced anymore. If it isn't, we might be able to remove the variable, too. // (need to pick up those changes to keep track of a field's declarations, though) if (varField.RefCount == 0) { // it's not. if there's only one declaration and it either has no initializer or // is initialized to a constant, get rid of it. var nameDecl = varField.OnlyDeclaration; if (nameDecl != null) { // we only had one declaration. if (nameDecl.Initializer == null || nameDecl.Initializer.IsConstant) { // and it either had no initializer or it was initialized to a constant. // but it has no references, so let's whack it. Actually, only if it was // a var-decl (leave parameter and function decls alone). var varDecl = nameDecl as VariableDeclaration; if (varDecl != null) { // save the declaration parent (var, const, or let) and remove the // child vardecl from its list var declStatement = varDecl.Parent as Declaration; declStatement.Remove(varDecl); varField.WasRemoved = true; // if the parent statement is now empty, remove it, too. this will // move everything up one index, but that'll just mean an extra loop. if (declStatement.Count == 0) { declStatement.Parent.ReplaceChild(declStatement, null); } } } } } } } else { // it's an assignment, but it's not =. That means it's one of the OP= operators. // we can't remove the field altogether. But we can move the assignment into the // return statement and get rid of the lone lookup. // transform: lookup OP= expr;return lookup => return lookup OP= expr; if (lookup.VariableField != null) { // we're getting rid of the lookup, so remove it from the field's list of references DetachReferences.Apply(returnNode.Operand); } // remove the expression from the block and put it in the operand of // the return statement. node.RemoveAt(ndx - 1); returnNode.Operand = beforeExpr; // is this field scoped only to this function? if (lookup.VariableField != null && lookup.VariableField.OuterField == null && !lookup.VariableField.IsReferencedInnerScope) { // in fact, the lookup is in the current scope, so assigning to it is a waste // because we're going to return (this is a return statement, after all). // we can get rid of the assignment part and just keep the operator: // transform: lookup OP= expr;return lookup => return lookup OP expr; beforeExpr.OperatorToken = JSScanner.StripAssignment(beforeExpr.OperatorToken); } } } else { // transform: expr1;return expr2 to return expr1,expr2 var binOp = CommaOperator.CombineWithComma(null, m_parser, node[ndx - 1], returnNode.Operand); // replace the operand on the return node with the new expression and // delete the previous node returnNode.Operand = binOp; node[ndx - 1] = null; } } else { // transform: expr1;return expr2 to return expr1,expr2 var binOp = CommaOperator.CombineWithComma(null, m_parser, node[ndx - 1], returnNode.Operand); // replace the operand on the return node with the new expression and // delete the previous node returnNode.Operand = binOp; node[ndx - 1] = null; } } }
//--------------------------------------------------------------------------------------- // ParseTryStatement // // TryStatement : // 'try' Block Catch Finally // // Catch : // <empty> | 'catch' '(' Identifier ')' Block // // Finally : // <empty> | // 'finally' Block //--------------------------------------------------------------------------------------- private AstNode ParseTryStatement() { Context tryCtx = m_currentToken.Clone(); Context catchContext = null; Context finallyContext = null; Context tryEndContext = null; Block body = null; Context idContext = null; Block handler = null; Block finally_block = null; RecoveryTokenException excInFinally = null; m_blockType.Add(BlockType.Block); try { bool catchOrFinally = false; GetNextToken(); if (JSToken.LeftCurly != m_currentToken.Token) { ReportError(JSError.NoLeftCurly); } m_noSkipTokenSet.Add(NoSkipTokenSet.s_NoTrySkipTokenSet); try { body = ParseBlock(out tryEndContext); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_NoTrySkipTokenSet, exc) == -1) { // do nothing and just return the containing block, if any throw; } else { body = exc._partiallyComputedNode as Block; if (body == null) { body = new Block(exc._partiallyComputedNode.Context, this); body.Append(exc._partiallyComputedNode); } } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_NoTrySkipTokenSet); } if (JSToken.Catch == m_currentToken.Token) { m_noSkipTokenSet.Add(NoSkipTokenSet.s_NoTrySkipTokenSet); try { catchOrFinally = true; catchContext = m_currentToken.Clone(); GetNextToken(); if (JSToken.LeftParenthesis != m_currentToken.Token) { ReportError(JSError.NoLeftParenthesis); } GetNextToken(); if (JSToken.Identifier != m_currentToken.Token) { string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token); if (null != identifier) { idContext = m_currentToken.Clone(); } else { ReportError(JSError.NoIdentifier); } } else { idContext = m_currentToken.Clone(); } GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { if (JSToken.RightParenthesis != m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); } GetNextToken(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = null; // rethrow throw; } else { if (m_currentToken.Token == JSToken.RightParenthesis) { GetNextToken(); } } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); } if (JSToken.LeftCurly != m_currentToken.Token) { ReportError(JSError.NoLeftCurly); } // parse the block handler = ParseBlock(); tryCtx.UpdateWith(handler.Context); } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode == null) { handler = new Block(CurrentPositionContext(), this); } else { handler = exc._partiallyComputedNode as Block; if (handler == null) { handler = new Block(exc._partiallyComputedNode.Context, this); handler.Append(exc._partiallyComputedNode); } } if (IndexOfToken(NoSkipTokenSet.s_NoTrySkipTokenSet, exc) == -1) { throw; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_NoTrySkipTokenSet); } } try { if (JSToken.Finally == m_currentToken.Token) { finallyContext = m_currentToken.Clone(); GetNextToken(); m_blockType.Add(BlockType.Finally); try { finally_block = ParseBlock(); catchOrFinally = true; } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } tryCtx.UpdateWith(finally_block.Context); } } catch (RecoveryTokenException exc) { excInFinally = exc; // thrown later so we can execute code below } if (!catchOrFinally) { ReportError(JSError.NoCatch, true); finally_block = new Block(CurrentPositionContext(), this); // make a dummy empty block } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } ParameterDeclaration catchParameter = null; if (idContext != null) { catchParameter = new ParameterDeclaration(idContext, this) { Name = idContext.Code }; } if (excInFinally != null) { excInFinally._partiallyComputedNode = new TryNode(tryCtx, this) { TryBlock = body, CatchContext = catchContext, CatchParameter = catchParameter, CatchBlock = handler, FinallyContext = finallyContext, FinallyBlock = finally_block }; throw excInFinally; } return new TryNode(tryCtx, this) { TryBlock = body, CatchContext = catchContext, CatchParameter = catchParameter, CatchBlock = handler, FinallyContext = finallyContext, FinallyBlock = finally_block }; }
Block ParseBlock(out Context closingBraceContext) { closingBraceContext = null; m_blockType.Add(BlockType.Block); Block codeBlock = new Block(m_currentToken.Clone(), this); codeBlock.BraceOnNewLine = m_foundEndOfLine; GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet); try { try { while (JSToken.RightCurly != m_currentToken.Token) { try { // pass false because we really only want Statements, and FunctionDeclarations // are technically not statements. We'll still handle them, but we'll issue a warning. codeBlock.Append(ParseStatement(false)); } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode != null) codeBlock.Append(exc._partiallyComputedNode); if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1) throw; } } // make sure any important comments before the closing brace are kept if (m_importantComments.Count > 0 && m_settings.PreserveImportantComments && m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments)) { // we have important comments before the EOF. Add the comment(s) to the program. foreach (var importantComment in m_importantComments) { codeBlock.Append(new ImportantComment(importantComment, this)); } m_importantComments.Clear(); } } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = codeBlock; throw; } } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet); m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); m_blockType.RemoveAt(m_blockType.Count - 1); } closingBraceContext = m_currentToken.Clone(); // update the block context codeBlock.Context.UpdateWith(m_currentToken); GetNextToken(); return codeBlock; }
private FunctionObject ParseFunction(FunctionType functionType, Context fncCtx) { Lookup name = null; AstNodeList formalParameters = null; Block body = null; bool inExpression = (functionType == FunctionType.Expression); Context paramsContext = null; GetNextToken(); // get the function name or make an anonymous function if in expression "position" if (JSToken.Identifier == m_currentToken.Token) { name = new Lookup(m_currentToken.Clone(), this) { Name = m_scanner.Identifier }; GetNextToken(); } else { string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token); if (null != identifier) { name = new Lookup(m_currentToken.Clone(), this) { Name = identifier }; GetNextToken(); } else { if (!inExpression) { // if this isn't a function expression, then we need to throw an error because // function DECLARATIONS always need a valid identifier name ReportError(JSError.NoIdentifier, m_currentToken.Clone(), true); // BUT if the current token is a left paren, we don't want to use it as the name. // (fix for issue #14152) if (m_currentToken.Token != JSToken.LeftParenthesis && m_currentToken.Token != JSToken.LeftCurly) { identifier = m_currentToken.Code; name = new Lookup(CurrentPositionContext(), this) { Name = identifier }; GetNextToken(); } } } } // make a new state and save the old one List<BlockType> blockType = m_blockType; m_blockType = new List<BlockType>(16); Dictionary<string, LabelInfo> labelTable = m_labelTable; m_labelTable = new Dictionary<string, LabelInfo>(); try { // get the formal parameters if (JSToken.LeftParenthesis != m_currentToken.Token) { // we expect a left paren at this point for standard cross-browser support. // BUT -- some versions of IE allow an object property expression to be a function name, like window.onclick. // we still want to throw the error, because it syntax errors on most browsers, but we still want to // be able to parse it and return the intended results. // Skip to the open paren and use whatever is in-between as the function name. Doesn't matter that it's // an invalid identifier; it won't be accessible as a valid field anyway. bool expandedIndentifier = false; while (m_currentToken.Token != JSToken.LeftParenthesis && m_currentToken.Token != JSToken.LeftCurly && m_currentToken.Token != JSToken.Semicolon && m_currentToken.Token != JSToken.EndOfFile) { name.Context.UpdateWith(m_currentToken); GetNextToken(); expandedIndentifier = true; } // if we actually expanded the identifier context, then we want to report that // the function name needs to be an identifier. Otherwise we didn't expand the // name, so just report that we expected an open paren at this point. if (expandedIndentifier) { name.Name = name.Context.Code; name.Context.HandleError(JSError.FunctionNameMustBeIdentifier, false); } else { ReportError(JSError.NoLeftParenthesis, true); } } if (m_currentToken.Token == JSToken.LeftParenthesis) { // create the parameter list formalParameters = new AstNodeList(m_currentToken.Clone(), this); paramsContext = m_currentToken.Clone(); // skip the open paren GetNextToken(); // create the list of arguments and update the context while (JSToken.RightParenthesis != m_currentToken.Token) { String id = null; m_noSkipTokenSet.Add(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet); try { ParameterDeclaration paramDecl = null; if (JSToken.Identifier != m_currentToken.Token && (id = JSKeyword.CanBeIdentifier(m_currentToken.Token)) == null) { if (JSToken.LeftCurly == m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); break; } else if (JSToken.Comma == m_currentToken.Token) { // We're missing an argument (or previous argument was malformed and // we skipped to the comma.) Keep trying to parse the argument list -- // we will skip the comma below. ReportError(JSError.SyntaxError, true); } else { ReportError(JSError.SyntaxError, true); SkipTokensAndThrow(); } } else { if (null == id) { id = m_scanner.Identifier; } paramDecl = new ParameterDeclaration(m_currentToken.Clone(), this) { Name = id, Position = formalParameters.Count }; formalParameters.Append(paramDecl); GetNextToken(); } // got an arg, it should be either a ',' or ')' if (JSToken.RightParenthesis == m_currentToken.Token) { break; } else if (JSToken.Comma == m_currentToken.Token) { // append the comma context as the terminator for the parameter paramDecl.IfNotNull(p => p.TerminatingContext = m_currentToken.Clone()); } else { // deal with error in some "intelligent" way if (JSToken.LeftCurly == m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); break; } else { if (JSToken.Identifier == m_currentToken.Token) { // it's possible that the guy was writing the type in C/C++ style (i.e. int x) ReportError(JSError.NoCommaOrTypeDefinitionError); } else ReportError(JSError.NoComma); } } GetNextToken(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet, exc) == -1) throw; } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet); } } fncCtx.UpdateWith(m_currentToken); GetNextToken(); } // read the function body of non-abstract functions. if (JSToken.LeftCurly != m_currentToken.Token) ReportError(JSError.NoLeftCurly, true); m_blockType.Add(BlockType.Block); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet); m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); try { // parse the block locally to get the exact end of function body = new Block(m_currentToken.Clone(), this); body.BraceOnNewLine = m_foundEndOfLine; GetNextToken(); var possibleDirectivePrologue = true; while (JSToken.RightCurly != m_currentToken.Token) { try { // function body's are SourceElements (Statements + FunctionDeclarations) var statement = ParseStatement(true); if (possibleDirectivePrologue) { var constantWrapper = statement as ConstantWrapper; if (constantWrapper != null && constantWrapper.PrimitiveType == PrimitiveType.String) { // if it's already a directive prologues, we're good to go if (!(constantWrapper is DirectivePrologue)) { // make the statement a directive prologue instead of a constant wrapper statement = new DirectivePrologue(constantWrapper.Value.ToString(), constantWrapper.Context, constantWrapper.Parser) { MayHaveIssues = constantWrapper.MayHaveIssues }; } } else if (!m_newModule) { // no longer considering constant wrappers possibleDirectivePrologue = false; } } else if (m_newModule) { // we scanned into a new module -- we might find directive prologues again possibleDirectivePrologue = true; } // add it to the body body.Append(statement); } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode != null) { body.Append(exc._partiallyComputedNode); } if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1) throw; } } // make sure any important comments before the closing brace are kept if (m_importantComments.Count > 0 && m_settings.PreserveImportantComments && m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments)) { // we have important comments before the EOF. Add the comment(s) to the program. foreach (var importantComment in m_importantComments) { body.Append(new ImportantComment(importantComment, this)); } m_importantComments.Clear(); } body.Context.UpdateWith(m_currentToken); fncCtx.UpdateWith(m_currentToken); } catch (EndOfFileException) { // if we get an EOF here, we never had a chance to find the closing curly-brace fncCtx.HandleError(JSError.UnclosedFunction, true); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = new FunctionObject(fncCtx, this) { FunctionType = (inExpression ? FunctionType.Expression : FunctionType.Declaration), IdContext = name.IfNotNull(n => n.Context), Name = name.IfNotNull(n => n.Name), ParameterDeclarations = formalParameters, ParametersContext = paramsContext, Body = body }; throw; } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet); } GetNextToken(); } finally { // restore state m_blockType = blockType; m_labelTable = labelTable; } return new FunctionObject(fncCtx, this) { FunctionType = functionType, IdContext = name.IfNotNull(n => n.Context), Name = name.IfNotNull(n => n.Name), ParameterDeclarations = formalParameters, ParametersContext = paramsContext, Body = body }; }
//--------------------------------------------------------------------------------------- // ParseIfStatement // // IfStatement : // 'if' '(' Expression ')' Statement ElseStatement // // ElseStatement : // <empty> | // 'else' Statement //--------------------------------------------------------------------------------------- private IfNode ParseIfStatement() { Context ifCtx = m_currentToken.Clone(); AstNode condition = null; AstNode trueBranch = null; AstNode falseBranch = null; Context elseCtx = null; m_blockType.Add(BlockType.Block); try { // parse condition GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { if (JSToken.LeftParenthesis != m_currentToken.Token) ReportError(JSError.NoLeftParenthesis); GetNextToken(); condition = ParseExpression(); // parse statements if (JSToken.RightParenthesis != m_currentToken.Token) { ifCtx.UpdateWith(condition.Context); ReportError(JSError.NoRightParenthesis); } else ifCtx.UpdateWith(m_currentToken); GetNextToken(); } catch (RecoveryTokenException exc) { // make up an if condition if (exc._partiallyComputedNode != null) condition = exc._partiallyComputedNode; else condition = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this); if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = null; // really not much to pass up // the if condition was so bogus we do not have a chance to make an If node, give up throw; } else { 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 = condition as BinaryOperator; if (binOp != null && binOp.OperatorToken == JSToken.Assign) { condition.Context.HandleError(JSError.SuspectAssignment); } m_noSkipTokenSet.Add(NoSkipTokenSet.s_IfBodyNoSkipTokenSet); if (JSToken.Semicolon == m_currentToken.Token) { m_currentToken.HandleError(JSError.SuspectSemicolon); } else if (JSToken.LeftCurly != m_currentToken.Token) { // if the statements aren't withing curly-braces, throw a possible error ReportError(JSError.StatementBlockExpected, CurrentPositionContext(), true); } try { // parse a Statement, not a SourceElement trueBranch = ParseStatement(false); } catch (RecoveryTokenException exc) { // make up a block for the if part if (exc._partiallyComputedNode != null) trueBranch = exc._partiallyComputedNode; else trueBranch = new Block(CurrentPositionContext(), this); if (IndexOfToken(NoSkipTokenSet.s_IfBodyNoSkipTokenSet, exc) == -1) { // we have to pass the exception to someone else, make as much as you can from the if exc._partiallyComputedNode = new IfNode(ifCtx, this) { Condition = condition, TrueBlock = AstNode.ForceToBlock(trueBranch) }; throw; } } finally { if (trueBranch != null) { ifCtx.UpdateWith(trueBranch.Context); } m_noSkipTokenSet.Remove(NoSkipTokenSet.s_IfBodyNoSkipTokenSet); } // parse else, if any if (JSToken.Else == m_currentToken.Token) { elseCtx = m_currentToken.Clone(); GetNextToken(); if (JSToken.Semicolon == m_currentToken.Token) { m_currentToken.HandleError(JSError.SuspectSemicolon); } else if (JSToken.LeftCurly != m_currentToken.Token && JSToken.If != m_currentToken.Token) { // if the statements aren't withing curly-braces (or start another if-statement), throw a possible error ReportError(JSError.StatementBlockExpected, CurrentPositionContext(), true); } try { // parse a Statement, not a SourceElement falseBranch = ParseStatement(false); } catch (RecoveryTokenException exc) { // make up a block for the else part if (exc._partiallyComputedNode != null) falseBranch = exc._partiallyComputedNode; else falseBranch = new Block(CurrentPositionContext(), this); exc._partiallyComputedNode = new IfNode(ifCtx, this) { Condition = condition, TrueBlock = AstNode.ForceToBlock(trueBranch), ElseContext = elseCtx, FalseBlock = AstNode.ForceToBlock(falseBranch) }; throw; } finally { if (falseBranch != null) { ifCtx.UpdateWith(falseBranch.Context); } } } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } return new IfNode(ifCtx, this) { Condition = condition, TrueBlock = AstNode.ForceToBlock(trueBranch), ElseContext = elseCtx, FalseBlock = AstNode.ForceToBlock(falseBranch) }; }
//--------------------------------------------------------------------------------------- // ParseStatements // // statements : // <empty> | // statement statements // //--------------------------------------------------------------------------------------- private Block ParseStatements() { var program = new Block(CurrentPositionContext(), this); m_blockType.Add(BlockType.Block); m_useCurrentForNext = false; try { // get the first token GetNextToken(); // if the block doesn't have a proper file context, then let's set it from the // first token -- that token might have had a ///#source directive! if (string.IsNullOrEmpty(program.Context.Document.FileContext)) { program.Context.Document.FileContext = m_currentToken.Document.FileContext; } m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); m_noSkipTokenSet.Add(NoSkipTokenSet.s_TopLevelNoSkipTokenSet); try { var possibleDirectivePrologue = true; int lastEndPosition = m_currentToken.EndPosition; while (m_currentToken.Token != JSToken.EndOfFile) { AstNode ast = null; try { // parse a statement -- pass true because we really want a SourceElement, // which is a Statement OR a FunctionDeclaration. Technically, FunctionDeclarations // are not statements! ast = ParseStatement(true); // if we are still possibly looking for directive prologues if (possibleDirectivePrologue) { var constantWrapper = ast as ConstantWrapper; if (constantWrapper != null && constantWrapper.PrimitiveType == PrimitiveType.String) { if (!(constantWrapper is DirectivePrologue)) { // use a directive prologue node instead ast = new DirectivePrologue(constantWrapper.Value.ToString(), ast.Context, ast.Parser) { MayHaveIssues = constantWrapper.MayHaveIssues }; } } else if (!m_newModule) { // nope -- no longer finding directive prologues possibleDirectivePrologue = false; } } else if (m_newModule) { // we aren't looking for directive prologues anymore, but we did scan // into a new module after that last AST, so reset the flag because that // new module might have directive prologues for next time possibleDirectivePrologue = true; } } catch (RecoveryTokenException exc) { if (TokenInList(NoSkipTokenSet.s_TopLevelNoSkipTokenSet, exc) || TokenInList(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc)) { ast = exc._partiallyComputedNode; GetNextToken(); } else { m_useCurrentForNext = false; do { GetNextToken(); } while (m_currentToken.Token != JSToken.EndOfFile && !TokenInList(NoSkipTokenSet.s_TopLevelNoSkipTokenSet, m_currentToken.Token) && !TokenInList(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, m_currentToken.Token)); } } if (null != ast) { // append the token to the program program.Append(ast); // set the last end position to be the start of the current token. // if we parse the next statement and the end is still the start, we know // something is up and might get into an infinite loop. lastEndPosition = m_currentToken.EndPosition; } else if (!m_scanner.IsEndOfFile && m_currentToken.StartLinePosition == lastEndPosition) { // didn't parse a statement, we're not at the EOF, and we didn't move // anywhere in the input stream. If we just keep looping around, we're going // to get into an infinite loop. Break it. m_currentToken.HandleError(JSError.ApplicationError, true); break; } } if (m_importantComments.Count > 0 && m_settings.PreserveImportantComments && m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments)) { // we have important comments before the EOF. Add the comment(s) to the program. foreach(var importantComment in m_importantComments) { program.Append(new ImportantComment(importantComment, this)); } m_importantComments.Clear(); } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_TopLevelNoSkipTokenSet); m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); } } catch (EndOfFileException) { } catch (ScannerException se) { // a scanner exception implies that the end of file has been reached with an error. // Mark the end of file as the error location EOFError(se.Error); } program.UpdateWith(CurrentPositionContext()); return program; }
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(Block node) { if (node != null) { node.Index = NextOrderIndex; if (node.BlockScope == null && node.Parent != null && !(node.Parent is SwitchCase) && !(node.Parent is FunctionObject) && !(node.Parent is ConditionalCompilationComment)) { node.BlockScope = new BlockScope(CurrentLexicalScope, node.Context, m_settings) { IsInWithScope = m_withDepth > 0 }; } if (node.BlockScope != null) { m_lexicalStack.Push(node.BlockScope); } try { // recurse the block statements for (var ndx = 0; ndx < node.Count; ++ndx) { var statement = node[ndx]; if (statement != null) { statement.Accept(this); } } } finally { // be sure to reset the unreachable flag when we exit this block m_isUnreachable = false; if (node.BlockScope != null) { Debug.Assert(CurrentLexicalScope == node.BlockScope); m_lexicalStack.Pop(); } } // now, if the block has no lex-decls, we really don't need a separate scope. if (node.BlockScope != null && !(node.BlockScope is WithScope) && !(node.BlockScope is CatchScope) && node.BlockScope.LexicallyDeclaredNames.Count == 0) { CollapseBlockScope(node.BlockScope); node.BlockScope = null; } } }
//--------------------------------------------------------------------------------------- // ParseDoStatement // // DoStatement: // 'do' Statement 'while' '(' Expression ')' //--------------------------------------------------------------------------------------- private DoWhile ParseDoStatement() { var doCtx = m_currentToken.Clone(); Context whileContext = null; Context terminatorContext = null; AstNode body = null; AstNode condition = null; m_blockType.Add(BlockType.Loop); try { GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_DoWhileBodyNoSkipTokenSet); // 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) { // make up a block for the do while if (exc._partiallyComputedNode != null) body = exc._partiallyComputedNode; else body = new Block(CurrentPositionContext(), this); if (IndexOfToken(NoSkipTokenSet.s_DoWhileBodyNoSkipTokenSet, exc) == -1) { // we have to pass the exception to someone else, make as much as you can from the 'do while' exc._partiallyComputedNode = new DoWhile(doCtx.UpdateWith(CurrentPositionContext()), this) { Body = AstNode.ForceToBlock(body), Condition = new ConstantWrapper(false, PrimitiveType.Boolean, CurrentPositionContext(), this) }; throw; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_DoWhileBodyNoSkipTokenSet); } if (JSToken.While != m_currentToken.Token) { ReportError(JSError.NoWhile); } whileContext = m_currentToken.Clone(); doCtx.UpdateWith(whileContext); GetNextToken(); if (JSToken.LeftParenthesis != m_currentToken.Token) { ReportError(JSError.NoLeftParenthesis); } GetNextToken(); // catch here so the body of the do_while is not thrown away m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { condition = ParseExpression(); if (JSToken.RightParenthesis != m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); doCtx.UpdateWith(condition.Context); } else { doCtx.UpdateWith(m_currentToken); } GetNextToken(); } catch (RecoveryTokenException exc) { // make up a condition if (exc._partiallyComputedNode != null) condition = exc._partiallyComputedNode; else condition = new ConstantWrapper(false, PrimitiveType.Boolean, CurrentPositionContext(), this); if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { exc._partiallyComputedNode = new DoWhile(doCtx, this) { Body = AstNode.ForceToBlock(body), WhileContext = whileContext, Condition = condition }; throw; } else { if (JSToken.RightParenthesis == m_currentToken.Token) GetNextToken(); } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); } if (JSToken.Semicolon == m_currentToken.Token) { // JScript 5 allowed statements like // do{print(++x)}while(x<10) print(0) // even though that does not strictly follow the automatic semicolon insertion // rules for the required semi after the while(). For backwards compatibility // we should continue to support this. terminatorContext = m_currentToken.Clone(); GetNextToken(); } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } // 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 = condition as BinaryOperator; if (binOp != null && binOp.OperatorToken == JSToken.Assign) { condition.Context.HandleError(JSError.SuspectAssignment); } return new DoWhile(doCtx, this) { Body = AstNode.ForceToBlock(body), WhileContext = whileContext, Condition = condition, TerminatingContext = terminatorContext }; }
private static int RelocateFunction(Block block, int insertAt, FunctionObject funcDecl) { if (block[insertAt] != funcDecl) { // technically function declarations can only be direct children of the program or a function block. // and since we are passing in such a block, the parent of the function declaration better be that // block. If it isn't, we don't want to move it because it's not in an allowed place, and different // browsers treat that situation differently. Some browsers would process such funcdecls as if // they were a direct child of the main block. Others will treat it like a function expression with // an external name, and only assign the function to the name if that line of code is actually // executed. So since there's a difference, just leave them as-is and only move valid funcdecls. if (funcDecl.Parent == block) { // remove the function from it's parent, which will take it away from where it is right now. funcDecl.Parent.ReplaceChild(funcDecl, null); // now insert it into the block at the new location, incrementing the location so the next function // will be inserted after it. It is important that they be in the same order as the source, or the semantics // will change when there are functions with the same name. block.Insert(insertAt++, funcDecl); } } else { // we're already in the right place. Just increment the pointer to move to the next position // for next time ++insertAt; } // return the new position return insertAt; }
//--------------------------------------------------------------------------------------- // ParseWhileStatement // // WhileStatement : // 'while' '(' Expression ')' Statement //--------------------------------------------------------------------------------------- private WhileNode ParseWhileStatement() { Context whileCtx = m_currentToken.Clone(); AstNode condition = null; AstNode body = null; m_blockType.Add(BlockType.Loop); try { GetNextToken(); if (JSToken.LeftParenthesis != m_currentToken.Token) { ReportError(JSError.NoLeftParenthesis); } GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { condition = ParseExpression(); if (JSToken.RightParenthesis != m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); whileCtx.UpdateWith(condition.Context); } else whileCtx.UpdateWith(m_currentToken); GetNextToken(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { // abort the while there is really no much to do here exc._partiallyComputedNode = null; throw; } else { // make up a condition if (exc._partiallyComputedNode != null) condition = exc._partiallyComputedNode; else condition = new ConstantWrapper(false, PrimitiveType.Boolean, CurrentPositionContext(), this); if (JSToken.RightParenthesis == m_currentToken.Token) 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 = condition as BinaryOperator; if (binOp != null && binOp.OperatorToken == JSToken.Assign) { condition.Context.HandleError(JSError.SuspectAssignment); } // 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 = exc._partiallyComputedNode; else body = new Block(CurrentPositionContext(), this); exc._partiallyComputedNode = new WhileNode(whileCtx, this) { Condition = condition, Body = AstNode.ForceToBlock(body) }; throw; } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } return new WhileNode(whileCtx, this) { Condition = condition, Body = AstNode.ForceToBlock(body) }; }
// unnest any child blocks private void UnnestBlocks(Block node) { // walk the list of items backwards -- if we come // to any blocks, unnest the block recursively. // Remove any empty statements as well. // We walk backwards because we could be adding any number of statements // and we don't want to have to modify the counter. for (int ndx = node.Count - 1; ndx >= 0; --ndx) { var nestedBlock = node[ndx] as Block; if (nestedBlock != null) { // unnest recursively UnnestBlocks(nestedBlock); // if the block has a block scope, then we can't really unnest it // without merging lexical scopes if (nestedBlock.BlockScope == null) { // remove the nested block node.RemoveAt(ndx); // then start adding the statements in the nested block to our own. // go backwards so we can just keep using the same index node.InsertRange(ndx, nestedBlock.Children); } } else if (node[ndx] is EmptyStatement) { // remove empty statements (lone semicolons) node.RemoveAt(ndx); } else if (ndx > 0) { // see if the previous node is a conditional-compilation comment, because // we will also combine adjacent those var previousComment = node[ndx - 1] as ConditionalCompilationComment; if (previousComment != null) { ConditionalCompilationComment thisComment = node[ndx] as ConditionalCompilationComment; if (thisComment != null) { // two adjacent conditional comments -- combine them into the first. previousComment.Statements.Append(thisComment.Statements); // and remove the second one (which is now a duplicate) node.RemoveAt(ndx); } } } } }
//--------------------------------------------------------------------------------------- // ParseWithStatement // // WithStatement : // 'with' '(' Expression ')' Statement //--------------------------------------------------------------------------------------- private WithNode ParseWithStatement() { Context withCtx = m_currentToken.Clone(); AstNode obj = null; Block block = null; m_blockType.Add(BlockType.Block); try { GetNextToken(); if (JSToken.LeftParenthesis != m_currentToken.Token) ReportError(JSError.NoLeftParenthesis); GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); try { obj = ParseExpression(); if (JSToken.RightParenthesis != m_currentToken.Token) { withCtx.UpdateWith(obj.Context); ReportError(JSError.NoRightParenthesis); } else withCtx.UpdateWith(m_currentToken); GetNextToken(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1) { // give up exc._partiallyComputedNode = null; throw; } else { if (exc._partiallyComputedNode == null) obj = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this); else obj = exc._partiallyComputedNode; withCtx.UpdateWith(obj.Context); if (exc._token == JSToken.RightParenthesis) GetNextToken(); } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); } // 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 AstNode statement = ParseStatement(false); // but make sure we save it as a block block = statement as Block; if (block == null) { block = new Block(statement.Context, this); block.Append(statement); } } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode == null) { block = new Block(CurrentPositionContext(), this); } else { block = exc._partiallyComputedNode as Block; if (block == null) { block = new Block(exc._partiallyComputedNode.Context, this); block.Append(exc._partiallyComputedNode); } } exc._partiallyComputedNode = new WithNode(withCtx, this) { WithObject = obj, Body = block }; throw; } } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } return new WithNode(withCtx, this) { WithObject = obj, Body = block }; }
public static void Apply(Block block, JSParser parser) { // create a new instance of the visitor and apply it to the block var visitor = new ReorderScopeVisitor(parser); block.Accept(visitor); // if there were any module directive prologues we need to promote, do them first var insertAt = 0; if (visitor.m_moduleDirectives != null) { foreach (var directivePrologue in visitor.m_moduleDirectives) { insertAt = RelocateDirectivePrologue(block, insertAt, directivePrologue); } } // Make sure that we skip over any remaining comments and directive prologues. // we do NOT want to insert anything between the start of the scope and any directive prologues. while (insertAt < block.Count && (block[insertAt] is DirectivePrologue || block[insertAt] is ImportantComment)) { ++insertAt; } // first, we want to move all function declarations to the top of this block if (visitor.m_functionDeclarations != null) { foreach (var funcDecl in visitor.m_functionDeclarations) { insertAt = RelocateFunction(block, insertAt, funcDecl); } } // special case: if there is only one var statement in the entire scope, // then just leave it alone because we will only add bytes by moving it around, // or be byte-neutral at best (no initializers and not in a for-statement). if (visitor.m_varStatements != null && visitor.m_varStatements.Count > 1) { // then we want to move all variable declarations after to the top (after the functions) foreach (var varStatement in visitor.m_varStatements) { insertAt = RelocateVar(block, insertAt, varStatement); } } // then we want to do the same thing for all child functions (declarations AND other) if (visitor.m_functionDeclarations != null) { foreach (var funcDecl in visitor.m_functionDeclarations) { Apply(funcDecl.Body, parser); } } if (visitor.m_functionExpressions != null) { foreach (var funcExpr in visitor.m_functionExpressions) { Apply(funcExpr.Body, parser); } } }
private AstNode ParseSwitchStatement() { Context switchCtx = m_currentToken.Clone(); AstNode expr = null; AstNodeList cases = null; var braceOnNewLine = false; Context braceContext = null; m_blockType.Add(BlockType.Switch); try { // read switch(expr) GetNextToken(); if (JSToken.LeftParenthesis != m_currentToken.Token) ReportError(JSError.NoLeftParenthesis); GetNextToken(); m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); m_noSkipTokenSet.Add(NoSkipTokenSet.s_SwitchNoSkipTokenSet); try { expr = ParseExpression(); if (JSToken.RightParenthesis != m_currentToken.Token) { ReportError(JSError.NoRightParenthesis); } GetNextToken(); if (JSToken.LeftCurly != m_currentToken.Token) { ReportError(JSError.NoLeftCurly); } braceOnNewLine = m_foundEndOfLine; braceContext = m_currentToken.Clone(); GetNextToken(); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1 && IndexOfToken(NoSkipTokenSet.s_SwitchNoSkipTokenSet, exc) == -1) { // give up exc._partiallyComputedNode = null; throw; } else { if (exc._partiallyComputedNode == null) expr = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this); else expr = exc._partiallyComputedNode; if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) != -1) { if (exc._token == JSToken.RightParenthesis) GetNextToken(); if (JSToken.LeftCurly != m_currentToken.Token) { ReportError(JSError.NoLeftCurly); } braceOnNewLine = m_foundEndOfLine; braceContext = m_currentToken.Clone(); GetNextToken(); } } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_SwitchNoSkipTokenSet); m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet); } // parse the switch body cases = new AstNodeList(CurrentPositionContext(), this); bool defaultStatement = false; m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet); try { while (JSToken.RightCurly != m_currentToken.Token) { SwitchCase caseClause = null; AstNode caseValue = null; var caseCtx = m_currentToken.Clone(); Context colonContext = null; m_noSkipTokenSet.Add(NoSkipTokenSet.s_CaseNoSkipTokenSet); try { if (JSToken.Case == m_currentToken.Token) { // get the case GetNextToken(); caseValue = ParseExpression(); } else if (JSToken.Default == m_currentToken.Token) { // get the default if (defaultStatement) { // we report an error but we still accept the default ReportError(JSError.DupDefault, true); } else { defaultStatement = true; } GetNextToken(); } else { // This is an error, there is no case or default. Assume a default was missing and keep going defaultStatement = true; ReportError(JSError.BadSwitch); } if (JSToken.Colon != m_currentToken.Token) { ReportError(JSError.NoColon); } else { colonContext = m_currentToken.Clone(); } // read the statements inside the case or default GetNextToken(); } catch (RecoveryTokenException exc) { // right now we can only get here for the 'case' statement if (IndexOfToken(NoSkipTokenSet.s_CaseNoSkipTokenSet, exc) == -1) { // ignore the current case or default exc._partiallyComputedNode = null; throw; } else { caseValue = exc._partiallyComputedNode; if (exc._token == JSToken.Colon) { GetNextToken(); } } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_CaseNoSkipTokenSet); } m_blockType.Add(BlockType.Block); try { var statements = new Block(m_currentToken.Clone(), this); m_noSkipTokenSet.Add(NoSkipTokenSet.s_SwitchNoSkipTokenSet); m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); try { while (JSToken.RightCurly != m_currentToken.Token && JSToken.Case != m_currentToken.Token && JSToken.Default != m_currentToken.Token) { try { // parse a Statement, not a SourceElement statements.Append(ParseStatement(false)); } catch (RecoveryTokenException exc) { if (exc._partiallyComputedNode != null) { statements.Append(exc._partiallyComputedNode); exc._partiallyComputedNode = null; } if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1) { throw; } } } } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_SwitchNoSkipTokenSet, exc) == -1) { caseClause = new SwitchCase(caseCtx, this) { CaseValue = caseValue, ColonContext = colonContext, Statements = statements }; cases.Append(caseClause); throw; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet); m_noSkipTokenSet.Remove(NoSkipTokenSet.s_SwitchNoSkipTokenSet); } caseCtx.UpdateWith(statements.Context); caseClause = new SwitchCase(caseCtx, this) { CaseValue = caseValue, ColonContext = colonContext, Statements = statements }; cases.Append(caseClause); } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } } } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1) { //save what you can a rethrow switchCtx.UpdateWith(CurrentPositionContext()); exc._partiallyComputedNode = new Switch(switchCtx, this) { Expression = expr, BraceContext = braceContext, Cases = cases, BraceOnNewLine = braceOnNewLine }; throw; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet); } switchCtx.UpdateWith(m_currentToken); GetNextToken(); } finally { m_blockType.RemoveAt(m_blockType.Count - 1); } return new Switch(switchCtx, this) { Expression = expr, BraceContext = braceContext, Cases = cases, BraceOnNewLine = braceOnNewLine }; }
public void SwapBranches() { Block temp = m_trueBlock; m_trueBlock = m_falseBlock; m_falseBlock = temp; }
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); } }