jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/parser/Parser.java

-:c8460f668d0c
+:3a209cbd1d8f
 import static jdk.nashorn.internal.parser.TokenType.SEMICOLON;
 import static jdk.nashorn.internal.parser.TokenType.TERNARY;
 import static jdk.nashorn.internal.parser.TokenType.WHILE;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Stack;
 import jdk.nashorn.internal.codegen.CompilerConstants;
 import jdk.nashorn.internal.codegen.Namespace;
 import jdk.nashorn.internal.ir.AccessNode;
 import jdk.nashorn.internal.ir.BinaryNode;
 import jdk.nashorn.internal.ir.Block;
+import jdk.nashorn.internal.ir.BlockLexicalContext;
 import jdk.nashorn.internal.ir.BreakNode;
 import jdk.nashorn.internal.ir.BreakableNode;
 import jdk.nashorn.internal.ir.CallNode;
 import jdk.nashorn.internal.ir.CaseNode;
 import jdk.nashorn.internal.ir.CatchNode;
 import jdk.nashorn.internal.ir.ContinueNode;
-import jdk.nashorn.internal.ir.DoWhileNode;
 import jdk.nashorn.internal.ir.EmptyNode;
 import jdk.nashorn.internal.ir.ExecuteNode;
 import jdk.nashorn.internal.ir.ForNode;
 import jdk.nashorn.internal.ir.FunctionNode;
 import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
 import jdk.nashorn.internal.ir.IndexNode;
 import jdk.nashorn.internal.ir.LabelNode;
 import jdk.nashorn.internal.ir.LexicalContext;
 import jdk.nashorn.internal.ir.LineNumberNode;
 import jdk.nashorn.internal.ir.LiteralNode;
+import jdk.nashorn.internal.ir.LoopNode;
 import jdk.nashorn.internal.ir.Node;
 import jdk.nashorn.internal.ir.ObjectNode;
 import jdk.nashorn.internal.ir.PropertyKey;
 import jdk.nashorn.internal.ir.PropertyNode;
 import jdk.nashorn.internal.ir.ReturnNode;
 private final ScriptEnvironment env;
 /** Is scripting mode. */
 private final boolean scripting;
-private final LexicalContext lexicalContext = new LexicalContext();
 private List<Node> functionDeclarations;
+private final BlockLexicalContext lc = new BlockLexicalContext();
 /** Namespace for function names where not explicitly given */
 private final Namespace namespace;
 private static final DebugLogger LOG = new DebugLogger("parser");
 * @param errors  error manager
 * @param strict  parser created with strict mode enabled.
 */
 public Parser(final ScriptEnvironment env, final Source source, final ErrorManager errors, final boolean strict) {
 super(source, errors, strict);
-this.env   = env;
+this.env       = env;
 this.namespace = new Namespace(env.getNamespace());
 this.scripting = env._scripting;
 }
 /**
 * "runScript" {@link CompilerConstants#RUN_SCRIPT}
 *
 * @return function node resulting from successful parse
 */
 public FunctionNode parse() {
-return parse(RUN_SCRIPT.tag());
+return parse(RUN_SCRIPT.symbolName());
 }
 /**
 * Execute parse and return the resulting function node.
 * Errors will be thrown and the error manager will contain information
 *
 * @return function node resulting from successful parse
 */
 public FunctionNode parse(final String scriptName) {
 final long t0 = Timing.isEnabled() ? System.currentTimeMillis() : 0L;
-LOG.info(this + " begin for '" + scriptName + "'");
+LOG.info(this, " begin for '", scriptName, "'");
 try {
 stream = new TokenStream();
 lexer  = new Lexer(source, stream, scripting && !env._no_syntax_extensions);
 return null;
 } finally {
 final String end = this + " end '" + scriptName + "'";
 if (Timing.isEnabled()) {
 Timing.accumulateTime(toString(), System.currentTimeMillis() - t0);
-LOG.info(end + "' in " + (System.currentTimeMillis() - t0) + " ms");
+LOG.info(end, "' in ", (System.currentTimeMillis() - t0), " ms");
 } else {
 LOG.info(end);
 }
 }
 }
 *
 * @return New block.
 */
 private Block newBlock() {
 final Block block = new Block(source, token, Token.descPosition(token));
-lexicalContext.push(block);
+return lc.push(block);
-return block;
 }
 /**
 * Set up a new function block.
 *
 * @param ident Name of function.
 * @return New block.
 */
-private FunctionNode newFunctionBlock(final IdentNode ident) {
+private FunctionNode newFunctionNode(final long startToken, final IdentNode ident, final List<IdentNode> parameters, final FunctionNode.Kind kind) {
 // Build function name.
 final StringBuilder sb = new StringBuilder();
-final FunctionNode parentFunction = getFunction();
+final FunctionNode parentFunction = lc.getCurrentFunction();
-if(parentFunction != null && !parentFunction.isProgram()) {
+if (parentFunction != null && !parentFunction.isProgram()) {
 sb.append(parentFunction.getName()).append('$');
 }
-sb.append(ident != null ? ident.getName() : FUNCTION_PREFIX.tag());
+sb.append(ident != null ? ident.getName() : FUNCTION_PREFIX.symbolName());
 final String name = namespace.uniqueName(sb.toString());
-assert parentFunction != null || name.equals(RUN_SCRIPT.tag())  : "name = " + name;// must not rename runScript().
+assert parentFunction != null || name.equals(RUN_SCRIPT.symbolName())  : "name = " + name;// must not rename runScript().
+int flags = 0;
+if (parentFunction == null) {
+flags |= FunctionNode.IS_PROGRAM;
+}
+if (isStrictMode) {
+flags |= FunctionNode.IS_STRICT;
+}
 // Start new block.
-final FunctionNode functionBlock = new FunctionNode(source, token, Token.descPosition(token), namespace, ident, name);
+FunctionNode functionNode =
-if(parentFunction == null) {
+new FunctionNode(
-functionBlock.setProgram();
+source,
-}
+token,
-functionBlock.setStrictMode(isStrictMode);
+Token.descPosition(token),
-functionBlock.setState(errors.hasErrors() ? CompilationState.PARSE_ERROR : CompilationState.PARSED);
+startToken,
-lexicalContext.push(functionBlock);
+namespace,
+ident,
-return functionBlock;
+name,
+parameters,
+kind,
+flags);
+functionNode = functionNode.setState(lc, errors.hasErrors() ? CompilationState.PARSE_ERROR : CompilationState.PARSED);
+lc.push(functionNode);
+// Create new block, and just put it on the context stack, restoreFunctionNode() will associate it with the
+// FunctionNode.
+newBlock();
+return functionNode;
 }
 /**
 * Restore the current block.
 */
-private void restoreBlock(Block block) {
+private Block restoreBlock(final Block block) {
-lexicalContext.pop(block);
+return lc.pop(block);//.setFlag(lc, flags);
+}
+private FunctionNode restoreFunctionNode(final FunctionNode functionNode, final long lastToken) {
+final Block newBody = restoreBlock(lc.getFunctionBody(functionNode));
+return lc.pop(functionNode).setBody(lc, newBody).setLastToken(lc, lastToken);
 }
 /**
 * Get the statements in a block.
 * @return Block statements.
 */
 private Block getBlock(final boolean needsBraces) {
 // Set up new block. Captures LBRACE.
-final Block newBlock = newBlock();
+Block newBlock = newBlock();
 try {
-pushControlNode(newBlock);
 // Block opening brace.
 if (needsBraces) {
 expect(LBRACE);
 }
+// Accumulate block statements.
-try {
+statementList();
-// Accumulate block statements.
-statementList();
-} finally {
-popControlNode();
-}
 } finally {
-restoreBlock(newBlock);
+newBlock = restoreBlock(newBlock);
 }
 final int possibleEnd = Token.descPosition(token) + Token.descLength(token);
 // Block closing brace.
 private Block getStatement() {
 if (type == LBRACE) {
 return getBlock(true);
 }
 // Set up new block. Captures first token.
-final Block newBlock = newBlock();
+Block newBlock = newBlock();
 try {
-// Accumulate statements.
 statement();
 } finally {
-restoreBlock(newBlock);
+newBlock = restoreBlock(newBlock);
 }
 return newBlock;
 }
 /**
 * Detect calls to special functions.
 * @param ident Called function.
 */
 private void detectSpecialFunction(final IdentNode ident) {
 final String name = ident.getName();
-if (EVAL.tag().equals(name)) {
+if (EVAL.symbolName().equals(name)) {
-final Iterator<FunctionNode> it = lexicalContext.getFunctions();
+markWithOrEval(lc, FunctionNode.HAS_EVAL);
-if(it.hasNext()) {
-it.next().setHasEval(it);
-}
 }
 }
 /**
 * Detect use of special properties.
 * @param ident Referenced property.
 */
 private void detectSpecialProperty(final IdentNode ident) {
 final String name = ident.getName();
-if (ARGUMENTS.tag().equals(name)) {
+if (ARGUMENTS.symbolName().equals(name)) {
-getFunction().setUsesArguments();
+lc.setFlag(lc.getCurrentFunction(), FunctionNode.USES_ARGUMENTS);
 }
 }
 /**
 * Tells whether a IdentNode can be used as L-value of an assignment
 case ASSIGN_SUB:
 if (!(lhs instanceof AccessNode ||
 lhs instanceof IndexNode ||
 lhs instanceof IdentNode)) {
 if (env._early_lvalue_error) {
-error(JSErrorType.REFERENCE_ERROR, AbstractParser.message("invalid.lvalue"), lhs.getToken());
+throw error(JSErrorType.REFERENCE_ERROR, AbstractParser.message("invalid.lvalue"), lhs.getToken());
 }
 return referenceError(lhs, rhs);
 }
 if (lhs instanceof IdentNode) {
 * @param expression Left hand side expression.
 * @param isPostfix  Prefix or postfix.
 * @return           Reduced expression.
 */
 private Node incDecExpression(final long firstToken, final TokenType tokenType, final Node expression, final boolean isPostfix) {
-long incDecToken = firstToken;
 if (isPostfix) {
-incDecToken = Token.recast(incDecToken, tokenType == DECPREFIX ? DECPOSTFIX : INCPOSTFIX);
+return new UnaryNode(source, Token.recast(firstToken, tokenType == DECPREFIX ? DECPOSTFIX : INCPOSTFIX), expression.getStart(), Token.descPosition(firstToken) + Token.descLength(firstToken), expression);
 }
-final UnaryNode node = new UnaryNode(source, incDecToken, expression);
+return new UnaryNode(source, firstToken, expression);
-if (isPostfix) {
+}
-node.setStart(expression.getStart());
-node.setFinish(Token.descPosition(incDecToken) + Token.descLength(incDecToken));
-}
-return node;
-}
-/**
-* Find a label node in the label stack.
-* @param ident Ident to find.
-* @return null or the found label node.
-*/
-private LabelNode findLabel(final IdentNode ident) {
-for (final LabelNode labelNode : getFunction().getLabelStack()) {
-if (labelNode.getLabel().equals(ident)) {
-return labelNode;
-}
-}
-return null;
-}
-/**
-* Add a label to the label stack.
-* @param labelNode Label to add.
-*/
-private void pushLabel(final LabelNode labelNode) {
-getFunction().getLabelStack().push(labelNode);
-}
-/**
-* Remove a label from the label stack.
-*/
-private void popLabel() {
-getFunction().getLabelStack().pop();
-}
-/**
-* Track the current nesting of controls for break and continue.
-* @param node For, while, do or switch node.
-*/
-private void pushControlNode(final Node node) {
-final boolean isLoop = node instanceof WhileNode;
-final boolean isBreakable = node instanceof BreakableNode || node instanceof Block;
-final FunctionNode function = getFunction();
-function.getControlStack().push(node);
-for (final LabelNode labelNode : function.getLabelStack()) {
-if (isBreakable && labelNode.getBreakNode() == null) {
-labelNode.setBreakNode(node);
-}
-if (isLoop && labelNode.getContinueNode() == null) {
-labelNode.setContinueNode(node);
-}
-}
-}
-/**
-* Finish with control.
-*/
-private void popControlNode() {
-// Get control stack.
-final Stack<Node> controlStack = getFunction().getControlStack();
-// Can be empty if missing brace.
-if (!controlStack.isEmpty()) {
-controlStack.pop();
-}
-}
-private void popControlNode(final Node node) {
-// Get control stack.
-final Stack<Node> controlStack = getFunction().getControlStack();
-// Can be empty if missing brace.
-if (!controlStack.isEmpty() && controlStack.peek() == node) {
-controlStack.pop();
-}
-}
-private boolean isInWithBlock() {
-final Stack<Node> controlStack = getFunction().getControlStack();
-for (int i = controlStack.size() - 1; i >= 0; i--) {
-final Node node = controlStack.get(i);
-if (node instanceof WithNode) {
-return true;
-}
-}
-return false;
-}
-private <T extends Node> T findControl(final Class<T> ctype) {
-final Stack<Node> controlStack = getFunction().getControlStack();
-for (int i = controlStack.size() - 1; i >= 0; i--) {
-final Node node = controlStack.get(i);
-if (ctype.isAssignableFrom(node.getClass())) {
-return ctype.cast(node);
-}
-}
-return null;
-}
-private <T extends Node> List<T> findControls(final Class<T> ctype, final Node to) {
-final List<T> nodes = new ArrayList<>();
-final Stack<Node> controlStack = getFunction().getControlStack();
-for (int i = controlStack.size() - 1; i >= 0; i--) {
-final Node node = controlStack.get(i);
-if (to == node) {
-break; //stop looking
-}
-if (ctype.isAssignableFrom(node.getClass())) {
-nodes.add(ctype.cast(node));
-}
-}
-return nodes;
-}
-private <T extends Node> int countControls(final Class<T> ctype, final Node to) {
-return findControls(ctype, to).size();
-}
 /**
 * -----------------------------------------------------------------------
 *
 * Grammar based on
 private FunctionNode program(final String scriptName) {
 // Make a fake token for the script.
 final long functionToken = Token.toDesc(FUNCTION, 0, source.getLength());
 // Set up the script to append elements.
-final FunctionNode script = newFunctionBlock(new IdentNode(source, functionToken, Token.descPosition(functionToken), scriptName));
+FunctionNode script = newFunctionNode(
+functionToken,
-script.setKind(FunctionNode.Kind.SCRIPT);
+new IdentNode(source, functionToken, Token.descPosition(functionToken), scriptName),
-script.setFirstToken(functionToken);
+new ArrayList<IdentNode>(),
+FunctionNode.Kind.SCRIPT);
 functionDeclarations = new ArrayList<>();
 sourceElements();
-script.prependStatements(functionDeclarations);
+addFunctionDeclarations(script);
 functionDeclarations = null;
 expect(EOF);
-script.setLastToken(token);
 script.setFinish(source.getLength() - 1);
+script = restoreFunctionNode(script, token); //commit code
+script = script.setBody(lc, script.getBody().setNeedsScope(lc));
 return script;
 }
 /**
 * Directive value or null if statement is not a directive.
 return null;
 }
 /**
-* Return last node in a statement list.
-*
-* @param statements Statement list.
-*
-* @return Last (non-debug) statement or null if empty block.
-*/
-private static Node lastStatement(final List<Node> statements) {
-for (int lastIndex = statements.size() - 1; lastIndex >= 0; lastIndex--) {
-final Node node = statements.get(lastIndex);
-if (!node.isDebug()) {
-return node;
-}
-}
-return null;
-}
-/**
 * SourceElements :
 *      SourceElement
 *      SourceElements SourceElement
 *
 * See 14
 statement(true);
 // check for directive prologues
 if (checkDirective) {
 // skip any debug statement like line number to get actual first line
-final Node lastStatement = lastStatement(getBlock().getStatements());
+final Node lastStatement = lc.getLastStatement();
 // get directive prologue, if any
 final String directive = getDirective(lastStatement);
 // If we have seen first non-directive statement,
 }
 // handle use strict directive
 if ("use strict".equals(directive)) {
 isStrictMode = true;
-final FunctionNode function = getFunction();
+final FunctionNode function = lc.getCurrentFunction();
-function.setStrictMode(true);
+lc.setFlag(lc.getCurrentFunction(), FunctionNode.IS_STRICT);
 // We don't need to check these, if lexical environment is already strict
 if (!oldStrictMode && directiveStmts != null) {
 // check that directives preceding this one do not violate strictness
 for (final Node statement : directiveStmts) {
 }
 }
 }
 }
 } catch (final Exception e) {
-// Recover parsing.
+//recover parsing
 recover(e);
 }
 // No backtracking from here on.
 stream.commit(k);
 if (type == FUNCTION) {
 // As per spec (ECMA section 12), function declarations as arbitrary statement
 // is not "portable". Implementation can issue a warning or disallow the same.
 if (isStrictMode && !topLevel) {
-error(AbstractParser.message("strict.no.func.here"), token);
+throw error(AbstractParser.message("strict.no.func.here"), token);
 }
 functionExpression(true, topLevel);
 return;
 }
-getBlock().addStatement(lineNumberNode);
+if (lineNumberNode != null) {
+appendStatement(lineNumberNode);
+}
 switch (type) {
 case LBRACE:
 block();
 break;
 * see 12.1
 *
 * Parse a statement block.
 */
 private void block() {
-// Get statements in block.
 final Block newBlock = getBlock(true);
 // Force block execution.
-final ExecuteNode executeNode = new ExecuteNode(source, newBlock.getToken(), finish, newBlock);
+appendStatement(new ExecuteNode(source, newBlock.getToken(), finish, newBlock));
-getBlock().addStatement(executeNode);
 }
 /**
 * StatementList :
 *      Statement
 private void verifyStrictIdent(final IdentNode ident, final String contextString) {
 if (isStrictMode) {
 switch (ident.getName()) {
 case "eval":
 case "arguments":
-error(AbstractParser.message("strict.name", ident.getName(), contextString), ident.getToken());
+throw error(AbstractParser.message("strict.name", ident.getName(), contextString), ident.getToken());
 default:
 break;
 }
 }
 }
 }
 // Allocate var node.
 final VarNode var = new VarNode(source, varToken, finish, name, init);
 vars.add(var);
-// Add to current block.
+appendStatement(var);
-getBlock().addStatement(var);
 if (type != COMMARIGHT) {
 break;
 }
 next();
 // If is a statement then handle end of line.
 if (isStatement) {
 boolean semicolon = type == SEMICOLON;
 endOfLine();
 if (semicolon) {
-getBlock().setFinish(finish);
+lc.getCurrentBlock().setFinish(finish);
 }
 }
 return vars;
 }
 *
 * Parse an empty statement.
 */
 private void emptyStatement() {
 if (env._empty_statements) {
-getBlock().addStatement(new EmptyNode(source, token,
+appendStatement(new EmptyNode(source, token, Token.descPosition(token) + Token.descLength(token)));
-Token.descPosition(token) + Token.descLength(token)));
 }
 // SEMICOLON checked in caller.
 next();
 }
 final Node expression = expression();
 ExecuteNode executeNode = null;
 if (expression != null) {
 executeNode = new ExecuteNode(source, expressionToken, finish, expression);
-getBlock().addStatement(executeNode);
+appendStatement(executeNode);
 } else {
 expect(null);
 }
 endOfLine();
 if (executeNode != null) {
 executeNode.setFinish(finish);
-getBlock().setFinish(finish);
+lc.getCurrentBlock().setFinish(finish);
 }
 }
 /**
 * IfStatement :
 final long ifToken = token;
 // IF tested in caller.
 next();
 expect(LPAREN);
-// Get the test expression.
 final Node test = expression();
 expect(RPAREN);
-// Get the pass statement.
 final Block pass = getStatement();
-// Assume no else.
 Block fail = null;
 if (type == ELSE) {
 next();
-// Get the else block.
 fail = getStatement();
 }
-// Construct and add new if node.
+appendStatement(new IfNode(source, ifToken, fail != null ? fail.getFinish() : pass.getFinish(), test, pass, fail));
-final IfNode ifNode = new IfNode(source, ifToken, fail != null ? fail.getFinish() : pass.getFinish(), test, pass, fail);
-getBlock().addStatement(ifNode);
 }
 /**
 * ... IterationStatement:
 *           ...
 *
 * Parse a FOR statement.
 */
 private void forStatement() {
 // Create FOR node, capturing FOR token.
-final ForNode forNode = new ForNode(source, token, Token.descPosition(token));
+ForNode forNode = new ForNode(source, token, Token.descPosition(token), null, null, null, null, ForNode.IS_FOR);
-pushControlNode(forNode);
 // Set up new block for scope of vars. Captures first token.
-final Block outer = newBlock();
+Block outer = newBlock();
+lc.push(forNode);
 try {
 // FOR tested in caller.
 next();
 // Nashorn extension: for each expression.
 // iterate property values rather than property names.
 if (!env._no_syntax_extensions && type == IDENT && "each".equals(getValue())) {
-forNode.setIsForEach();
+forNode = forNode.setIsForEach(lc);
 next();
 }
 expect(LPAREN);
-/// Capture control information.
+List<VarNode> vars = null;
-forControl(forNode);
+switch (type) {
+case VAR:
+// Var statements captured in for outer block.
+vars = variableStatement(false);
+break;
+case SEMICOLON:
+break;
+default:
+final Node expression = expression(unaryExpression(), COMMARIGHT.getPrecedence(), true);
+forNode = forNode.setInit(lc, expression);
+break;
+}
+switch (type) {
+case SEMICOLON:
+// for (init; test; modify)
+expect(SEMICOLON);
+if (type != SEMICOLON) {
+forNode = forNode.setTest(lc, expression());
+}
+expect(SEMICOLON);
+if (type != RPAREN) {
+forNode = forNode.setModify(lc, expression());
+}
+break;
+case IN:
+forNode = forNode.setIsForIn(lc);
+if (vars != null) {
+// for (var i in obj)
+if (vars.size() == 1) {
+forNode = forNode.setInit(lc, new IdentNode(vars.get(0).getName()));
+} else {
+// for (var i, j in obj) is invalid
+throw error(AbstractParser.message("many.vars.in.for.in.loop"), vars.get(1).getToken());
+}
+} else {
+// for (expr in obj)
+final Node init = forNode.getInit();
+assert init != null : "for..in init expression can not be null here";
+// check if initial expression is a valid L-value
+if (!(init instanceof AccessNode ||
+init instanceof IndexNode ||
+init instanceof IdentNode)) {
+throw error(AbstractParser.message("not.lvalue.for.in.loop"), init.getToken());
+}
+if (init instanceof IdentNode) {
+if (!checkIdentLValue((IdentNode)init)) {
+throw error(AbstractParser.message("not.lvalue.for.in.loop"), init.getToken());
+}
+verifyStrictIdent((IdentNode)init, "for-in iterator");
+}
+}
+next();
+// Get the collection expression.
+forNode = forNode.setModify(lc, expression());
+break;
+default:
+expect(SEMICOLON);
+break;
+}
 expect(RPAREN);
 // Set the for body.
 final Block body = getStatement();
-forNode.setBody(body);
+forNode = forNode.setBody(lc, body);
 forNode.setFinish(body.getFinish());
 outer.setFinish(body.getFinish());
-// Add for to current block.
+appendStatement(forNode);
-getBlock().addStatement(forNode);
 } finally {
-restoreBlock(outer);
+lc.pop(forNode);
-popControlNode();
+outer = restoreBlock(outer);
 }
-getBlock().addStatement(new ExecuteNode(source, outer.getToken(), outer.getFinish(), outer));
+appendStatement(new ExecuteNode(source, outer.getToken(), outer.getFinish(), outer));
 }
 /**
 * ... IterationStatement :
 *           ...
 *
 * Parse the control section of a FOR statement.  Also used for
 * comprehensions.
 * @param forNode Owning FOR.
 */
-private void forControl(final ForNode forNode) {
-List<VarNode> vars = null;
-switch (type) {
-case VAR:
-// Var statements captured in for outer block.
-vars = variableStatement(false);
-break;
-case SEMICOLON:
-break;
-default:
-final Node expression = expression(unaryExpression(), COMMARIGHT.getPrecedence(), true);
-forNode.setInit(expression);
-}
-switch (type) {
-case SEMICOLON:
-// for (init; test; modify)
-expect(SEMICOLON);
-// Get the test expression.
-if (type != SEMICOLON) {
-forNode.setTest(expression());
-}
-expect(SEMICOLON);
-// Get the modify expression.
-if (type != RPAREN) {
-final Node expression = expression();
-forNode.setModify(expression);
-}
-break;
-case IN:
-forNode.setIsForIn();
-if (vars != null) {
-// for (var i in obj)
-if (vars.size() == 1) {
-forNode.setInit(new IdentNode(vars.get(0).getName()));
-} else {
-// for (var i, j in obj) is invalid
-error(AbstractParser.message("many.vars.in.for.in.loop"), vars.get(1).getToken());
-}
-} else {
-// for (expr in obj)
-final Node init = forNode.getInit();
-assert init != null : "for..in init expression can not be null here";
-// check if initial expression is a valid L-value
-if (!(init instanceof AccessNode ||
-init instanceof IndexNode ||
-init instanceof IdentNode)) {
-error(AbstractParser.message("not.lvalue.for.in.loop"), init.getToken());
-}
-if (init instanceof IdentNode) {
-if (!checkIdentLValue((IdentNode)init)) {
-error(AbstractParser.message("not.lvalue.for.in.loop"), init.getToken());
-}
-verifyStrictIdent((IdentNode)init, "for-in iterator");
-}
-}
-next();
-// Get the collection expression.
-forNode.setModify(expression());
-break;
-default:
-expect(SEMICOLON);
-break;
-}
-}
 /**
 * ...IterationStatement :
 *           ...
 *           while ( Expression ) Statement
 final long whileToken = token;
 // WHILE tested in caller.
 next();
 // Construct WHILE node.
-final WhileNode whileNode = new WhileNode(source, whileToken, Token.descPosition(whileToken));
+WhileNode whileNode = new WhileNode(source, whileToken, Token.descPosition(whileToken), false);
-pushControlNode(whileNode);
+lc.push(whileNode);
 try {
 expect(LPAREN);
+whileNode = whileNode.setTest(lc, expression());
-// Get the test expression.
-final Node test = expression();
-whileNode.setTest(test);
 expect(RPAREN);
+whileNode = whileNode.setBody(lc, getStatement());
-// Get WHILE body.
+appendStatement(whileNode);
-final Block statements = getStatement();
-whileNode.setBody(statements);
-whileNode.setFinish(statements.getFinish());
-// Add WHILE node.
-getBlock().addStatement(whileNode);
 } finally {
-popControlNode();
+lc.pop(whileNode);
 }
 }
 /**
 * ...IterationStatement :
 // Capture DO token.
 final long doToken = token;
 // DO tested in the caller.
 next();
-final WhileNode doWhileNode = new DoWhileNode(source, doToken, Token.descPosition(doToken));
+WhileNode doWhileNode = new WhileNode(source, doToken, Token.descPosition(doToken), true);
-pushControlNode(doWhileNode);
+lc.push(doWhileNode);
 try {
 // Get DO body.
-final Block statements = getStatement();
+doWhileNode = doWhileNode.setBody(lc, getStatement());
-doWhileNode.setBody(statements);
 expect(WHILE);
 expect(LPAREN);
+doWhileNode = doWhileNode.setTest(lc, expression());
-// Get the test expression.
-final Node test = expression();
-doWhileNode.setTest(test);
 expect(RPAREN);
 if (type == SEMICOLON) {
 endOfLine();
 }
 doWhileNode.setFinish(finish);
+appendStatement(doWhileNode);
-// Add DO node.
-getBlock().addStatement(doWhileNode);
 } finally {
-popControlNode();
+lc.pop(doWhileNode);
 }
 }
 /**
 * ContinueStatement :
 case EOL:
 break;
 default:
 final IdentNode ident = getIdent();
-labelNode = findLabel(ident);
+labelNode = lc.findLabel(ident.getName());
 if (labelNode == null) {
-error(AbstractParser.message("undefined.label", ident.getName()), ident.getToken());
+throw error(AbstractParser.message("undefined.label", ident.getName()), ident.getToken());
 }
 break;
 }
-final Node targetNode = labelNode != null ? labelNode.getContinueNode() : findControl(WhileNode.class);
+final IdentNode label = labelNode == null ? null : labelNode.getLabel();
+final LoopNode targetNode = lc.getContinueTo(label);
 if (targetNode == null) {
-error(AbstractParser.message("illegal.continue.stmt"), continueToken);
+throw error(AbstractParser.message("illegal.continue.stmt"), continueToken);
 }
 endOfLine();
 // Construct and add CONTINUE node.
-final ContinueNode continueNode = new ContinueNode(source, continueToken, finish, labelNode, targetNode, findControl(TryNode.class));
+appendStatement(new ContinueNode(source, continueToken, finish, label == null ? null : new IdentNode(label)));
-continueNode.setScopeNestingLevel(countControls(WithNode.class, targetNode));
-getBlock().addStatement(continueNode);
 }
 /**
 * BreakStatement :
 *      break Identifier? ; // [no LineTerminator here]
 case EOL:
 break;
 default:
 final IdentNode ident = getIdent();
-labelNode = findLabel(ident);
+labelNode = lc.findLabel(ident.getName());
 if (labelNode == null) {
-error(AbstractParser.message("undefined.label", ident.getName()), ident.getToken());
+throw error(AbstractParser.message("undefined.label", ident.getName()), ident.getToken());
 }
 break;
 }
-final Node targetNode = labelNode != null ? labelNode.getBreakNode() : findControl(BreakableNode.class);
+//either an explicit label - then get its node or just a "break" - get first breakable
+//targetNode is what we are breaking out from.
+final IdentNode label = labelNode == null ? null : labelNode.getLabel();
+final BreakableNode targetNode = lc.getBreakable(label);
 if (targetNode == null) {
-error(AbstractParser.message("illegal.break.stmt"), breakToken);
+throw error(AbstractParser.message("illegal.break.stmt"), breakToken);
 }
 endOfLine();
 // Construct and add BREAK node.
-final BreakNode breakNode = new BreakNode(source, breakToken, finish, labelNode, targetNode, findControl(TryNode.class));
+appendStatement(new BreakNode(source, breakToken, finish, label == null ? null : new IdentNode(label)));
-breakNode.setScopeNestingLevel(countControls(WithNode.class, targetNode));
-getBlock().addStatement(breakNode);
 }
 /**
 * ReturnStatement :
 *      return Expression? ; // [no LineTerminator here]
 *
 * Parse RETURN statement.
 */
 private void returnStatement() {
 // check for return outside function
-if (getFunction().getKind() == FunctionNode.Kind.SCRIPT) {
+if (lc.getCurrentFunction().getKind() == FunctionNode.Kind.SCRIPT) {
-error(AbstractParser.message("invalid.return"));
+throw error(AbstractParser.message("invalid.return"));
 }
 // Capture RETURN token.
 final long returnToken = token;
 // RETURN tested in caller.
 }
 endOfLine();
 // Construct and add RETURN node.
-final ReturnNode returnNode = new ReturnNode(source, returnToken, finish, expression, findControl(TryNode.class));
+appendStatement(new ReturnNode(source, returnToken, finish, expression));
-getBlock().addStatement(returnNode);
 }
 /**
 * YieldStatement :
 *      yield Expression? ; // [no LineTerminator here]
 }
 endOfLine();
 // Construct and add YIELD node.
-final ReturnNode yieldNode = new ReturnNode(source, yieldToken, finish, expression, findControl(TryNode.class));
+appendStatement(new ReturnNode(source, yieldToken, finish, expression));
-getBlock().addStatement(yieldNode);
 }
 /**
 * WithStatement :
 *      with ( Expression ) Statement
 // WITH tested in caller.
 next();
 // ECMA 12.10.1 strict mode restrictions
 if (isStrictMode) {
-error(AbstractParser.message("strict.no.with"), withToken);
+throw error(AbstractParser.message("strict.no.with"), withToken);
 }
 // Get WITH expression.
-final WithNode withNode = new WithNode(source, withToken, finish, null, null);
+WithNode withNode = new WithNode(source, withToken, finish);
-final Iterator<FunctionNode> it = lexicalContext.getFunctions();
+markWithOrEval(lc, FunctionNode.HAS_WITH);
-if(it.hasNext()) {
-it.next().setHasWith(it);
-}
 try {
-pushControlNode(withNode);
+lc.push(withNode);
 expect(LPAREN);
+withNode = withNode.setExpression(lc, expression());
-final Node expression = expression();
-withNode.setExpression(expression);
 expect(RPAREN);
+withNode = withNode.setBody(lc, getStatement());
-// Get WITH body.
-final Block statements = getStatement();
-withNode.setBody(statements);
-withNode.setFinish(finish);
 } finally {
-popControlNode(withNode);
+lc.pop(withNode);
 }
-getBlock().addStatement(withNode);
+appendStatement(withNode);
 }
 /**
 * SwitchStatement :
 *      switch ( Expression ) CaseBlock
 * See 12.11
 *
 * Parse SWITCH statement.
 */
 private void switchStatement() {
-// Capture SWITCH token.
 final long switchToken = token;
 // SWITCH tested in caller.
 next();
 // Create and add switch statement.
-final SwitchNode switchNode = new SwitchNode(source, switchToken, Token.descPosition(switchToken));
+SwitchNode switchNode = new SwitchNode(source, switchToken, Token.descPosition(switchToken), null, new ArrayList<CaseNode>(), null);
-pushControlNode(switchNode);
+lc.push(switchNode);
 try {
 expect(LPAREN);
+switchNode = switchNode.setExpression(lc, expression());
-// Get switch expression.
-final Node switchExpression = expression();
-switchNode.setExpression(switchExpression);
 expect(RPAREN);
 expect(LBRACE);
 // Prepare to accumulate cases.
 final long caseToken = token;
 switch (type) {
 case CASE:
 next();
-// Get case expression.
 caseExpression = expression();
 break;
 case DEFAULT:
 if (defaultCase != null) {
-error(AbstractParser.message("duplicate.default.in.switch"));
+throw error(AbstractParser.message("duplicate.default.in.switch"));
 }
 next();
 break;
 default:
 // Force an error.
 expect(CASE);
 }
 cases.add(caseNode);
 }
-switchNode.setCases(cases);
+switchNode = switchNode.setCases(lc, cases, defaultCase);
-switchNode.setDefaultCase(defaultCase);
 next();
 switchNode.setFinish(finish);
-getBlock().addStatement(switchNode);
+appendStatement(switchNode);
 } finally {
-popControlNode();
+lc.pop(switchNode);
 }
 }
 /**
 * LabelledStatement :
 // Get label ident.
 final IdentNode ident = getIdent();
 expect(COLON);
-if (findLabel(ident) != null) {
+if (lc.findLabel(ident.getName()) != null) {
-error(AbstractParser.message("duplicate.label", ident.getName()), labelToken);
+throw error(AbstractParser.message("duplicate.label", ident.getName()), labelToken);
 }
+LabelNode labelNode = new LabelNode(source, labelToken, finish, ident, null);
 try {
-// Create and add label.
+lc.push(labelNode);
-final LabelNode labelNode = new LabelNode(source, labelToken, finish, ident, null);
+labelNode = labelNode.setBody(lc, getStatement());
-pushLabel(labelNode);
-// Get and save body.
-final Block statements = getStatement();
-labelNode.setBody(statements);
 labelNode.setFinish(finish);
+appendStatement(labelNode);
-getBlock().addStatement(labelNode);
 } finally {
-// Remove label.
+assert lc.peek() instanceof LabelNode;
-popLabel();
+lc.pop(labelNode);
 }
 }
 /**
 * ThrowStatement :
 expression = expression();
 break;
 }
 if (expression == null) {
-error(AbstractParser.message("expected.operand", type.getNameOrType()));
+throw error(AbstractParser.message("expected.operand", type.getNameOrType()));
 }
 endOfLine();
-// Construct and add THROW node.
+appendStatement(new ThrowNode(source, throwToken, finish, expression));
-final ThrowNode throwNode = new ThrowNode(source, throwToken, finish, expression, findControl(TryNode.class));
-getBlock().addStatement(throwNode);
 }
 /**
 * TryStatement :
 *      try Block Catch
 final long tryToken = token;
 // TRY tested in caller.
 next();
 // Container block needed to act as target for labeled break statements
-final Block outer = newBlock();
+Block outer = newBlock();
-pushControlNode(outer);
 // Create try.
-final TryNode tryNode = new TryNode(source, tryToken, Token.descPosition(tryToken), findControl(TryNode.class));
-pushControlNode(tryNode);
 try {
-// Get TRY body.
+final Block       tryBody     = getBlock(true);
-final Block tryBody = getBlock(true);
-// Prepare to accumulate catches.
 final List<Block> catchBlocks = new ArrayList<>();
 while (type == CATCH) {
-// Capture CATCH token.
 final long catchToken = token;
 next();
 expect(LPAREN);
-// Get exception ident.
 final IdentNode exception = getIdent();
 // ECMA 12.4.1 strict mode restrictions
 verifyStrictIdent(exception, "catch argument");
 // Check for conditional catch.
 Node ifExpression = null;
 if (type == IF) {
 next();
 // Get the exception condition.
 ifExpression = expression();
 }
 expect(RPAREN);
-final Block catchBlock = newBlock();
+Block catchBlock = newBlock();
 try {
 // Get CATCH body.
 final Block catchBody = getBlock(true);
-// Create and add catch.
 final CatchNode catchNode = new CatchNode(source, catchToken, finish, exception, ifExpression, catchBody);
-getBlock().addStatement(catchNode);
+appendStatement(catchNode);
+} finally {
+catchBlock = restoreBlock(catchBlock);
 catchBlocks.add(catchBlock);
-} finally {
-restoreBlock(catchBlock);
 }
 // If unconditional catch then should to be the end.
 if (ifExpression == null) {
 break;
 }
 }
-popControlNode();
 // Prepare to capture finally statement.
 Block finallyStatements = null;
 if (type == FINALLY) {
 next();
-// Get FINALLY body.
 finallyStatements = getBlock(true);
 }
 // Need at least one catch or a finally.
 if (catchBlocks.isEmpty() && finallyStatements == null) {
-error(AbstractParser.message("missing.catch.or.finally"), tryToken);
+throw error(AbstractParser.message("missing.catch.or.finally"), tryToken);
 }
-tryNode.setBody(tryBody);
+final TryNode tryNode = new TryNode(source, tryToken, Token.descPosition(tryToken), tryBody, catchBlocks, finallyStatements);
-tryNode.setCatchBlocks(catchBlocks);
+// Add try.
-tryNode.setFinallyBody(finallyStatements);
+assert lc.peek() == outer;
+appendStatement(tryNode);
 tryNode.setFinish(finish);
 outer.setFinish(finish);
-// Add try.
-outer.addStatement(tryNode);
 } finally {
-popControlNode(tryNode);
+outer = restoreBlock(outer);
-restoreBlock(outer);
+}
-popControlNode(outer);
-}
+appendStatement(new ExecuteNode(source, outer.getToken(), outer.getFinish(), outer));
-getBlock().addStatement(new ExecuteNode(source, outer.getToken(), outer.getFinish(), outer));
 }
 /**
 * DebuggerStatement :
 *      debugger ;
 private void  debuggerStatement() {
 // Capture DEBUGGER token.
 final long debuggerToken = token;
 // DEBUGGER tested in caller.
 next();
 endOfLine();
+appendStatement(new RuntimeNode(source, debuggerToken, finish, RuntimeNode.Request.DEBUGGER, new ArrayList<Node>()));
-final RuntimeNode runtimeNode = new RuntimeNode(source, debuggerToken, finish, RuntimeNode.Request.DEBUGGER, new ArrayList<Node>());
-getBlock().addStatement(runtimeNode);
 }
 /**
 * PrimaryExpression :
 *      this
 }
 detectSpecialProperty(ident);
 return ident;
 case OCTAL:
 if (isStrictMode) {
-error(AbstractParser.message("strict.no.octal"), token);
+throw error(AbstractParser.message("strict.no.octal"), token);
 }
 case STRING:
 case ESCSTRING:
 case DECIMAL:
 case HEXADECIMAL:
 // Add the following expression to arguments.
 arguments.add(expression());
 // Skip ending of edit string expression.
 expect(RBRACE);
-return new CallNode(source, primaryToken, finish, execIdent, arguments);
+return new CallNode(source, primaryToken, finish, execIdent, arguments, 0);
 }
 /**
 * ArrayLiteral :
 *      [ Elision? ]
 break;
 default:
 if (!elision) {
-error(AbstractParser.message("expected.comma", type.getNameOrType()));
+throw error(AbstractParser.message("expected.comma", type.getNameOrType()));
 }
 // Add expression element.
 final Node expression = assignmentExpression(false);
 if (expression != null) {
 // LBRACE tested in caller.
 next();
 // Object context.
 // Prepare to accumulate elements.
-final List<Node> elements = new ArrayList<>();
+// final List<Node> elements = new ArrayList<>();
-final Map<Object, PropertyNode> map = new HashMap<>();
+final Map<String, PropertyNode> map = new LinkedHashMap<>();
 // Create a block for the object literal.
 boolean commaSeen = true;
 loop:
 while (true) {
 commaSeen = true;
 break;
 default:
 if (!commaSeen) {
-error(AbstractParser.message("expected.comma", type.getNameOrType()));
+throw error(AbstractParser.message("expected.comma", type.getNameOrType()));
 }
 commaSeen = false;
 // Get and add the next property.
 final PropertyNode property = propertyAssignment();
-final Object key = property.getKeyName();
+final String key = property.getKeyName();
 final PropertyNode existingProperty = map.get(key);
-if (existingProperty != null) {
+if (existingProperty == null) {
+map.put(key, property);
+// elements.add(property);
+break;
+}
 // ECMA section 11.1.5 Object Initialiser
 // point # 4 on property assignment production
-final Node value  = property.getValue();
+final Node         value  = property.getValue();
-final Node getter = property.getGetter();
+final FunctionNode getter = property.getGetter();
-final Node setter = property.getSetter();
+final FunctionNode setter = property.getSetter();
-final Node prevValue  = existingProperty.getValue();
+final Node         prevValue  = existingProperty.getValue();
-final Node prevGetter = existingProperty.getGetter();
+final FunctionNode prevGetter = existingProperty.getGetter();
-final Node prevSetter = existingProperty.getSetter();
+final FunctionNode prevSetter = existingProperty.getSetter();
 boolean redefinitionOk = true;
 // ECMA 11.1.5 strict mode restrictions
 if (isStrictMode) {
 if (value != null && prevValue != null) {
 redefinitionOk = false;
 }
 }
 final boolean isPrevAccessor = prevGetter != null || prevSetter != null;
-final boolean isAccessor = getter != null || setter != null;
+final boolean isAccessor     = getter != null     || setter != null;
 // data property redefined as accessor property
 if (prevValue != null && isAccessor) {
 redefinitionOk = false;
 }
 redefinitionOk = false;
 }
 }
 if (!redefinitionOk) {
-error(AbstractParser.message("property.redefinition", key.toString()), property.getToken());
+throw error(AbstractParser.message("property.redefinition", key.toString()), property.getToken());
 }
+PropertyNode newProperty = existingProperty;
 if (value != null) {
-final Node existingValue = existingProperty.getValue();
+if (prevValue == null) {
+map.put(key, newProperty = newProperty.setValue(value));
-if (existingValue == null) {
-existingProperty.setValue(value);
 } else {
-final long propertyToken = Token.recast(existingProperty.getToken(), COMMARIGHT);
+final long propertyToken = Token.recast(newProperty.getToken(), COMMARIGHT);
-existingProperty.setValue(new BinaryNode(source, propertyToken, existingValue, value));
+map.put(key, newProperty = newProperty.setValue(new BinaryNode(source, propertyToken, prevValue, value)));
 }
-existingProperty.setGetter(null);
+map.put(key, newProperty = newProperty.setGetter(null).setSetter(null));
-existingProperty.setSetter(null);
 }
 if (getter != null) {
-existingProperty.setGetter(getter);
+map.put(key, newProperty = newProperty.setGetter(getter));
 }
 if (setter != null) {
-existingProperty.setSetter(setter);
+map.put(key, newProperty = newProperty.setSetter(setter));
 }
-} else {
+break;
-map.put(key, property);
+}
-elements.add(property);
+}
-}
+return new ObjectNode(source, objectToken, finish, new ArrayList<Node>(map.values()));
-break;
-}
-}
-return new ObjectNode(source, objectToken, finish, elements);
 }
 /**
 * PropertyName :
 *      IdentifierName
 switch (type) {
 case IDENT:
 return getIdent();
 case OCTAL:
 if (isStrictMode) {
-error(AbstractParser.message("strict.no.octal"), token);
+throw error(AbstractParser.message("strict.no.octal"), token);
 }
 case STRING:
 case ESCSTRING:
 case DECIMAL:
 case HEXADECIMAL:
 private PropertyNode propertyAssignment() {
 // Capture firstToken.
 final long propertyToken = token;
 FunctionNode functionNode;
-List<IdentNode> parameters;
-PropertyNode propertyNode;
 PropertyKey propertyName;
 if (type == IDENT) {
 // Get IDENT.
 final String ident = (String)expectValue(IDENT);
 final PropertyKey getIdent = propertyName();
 final String getterName = getIdent.getPropertyName();
 final IdentNode getNameNode = new IdentNode(source, ((Node)getIdent).getToken(), finish, "get " + getterName);
 expect(LPAREN);
 expect(RPAREN);
-parameters = new ArrayList<>();
+functionNode = functionBody(getSetToken, getNameNode, new ArrayList<IdentNode>(), FunctionNode.Kind.GETTER);
-functionNode = functionBody(getSetToken, getNameNode, parameters, FunctionNode.Kind.GETTER);
+return new PropertyNode(source, propertyToken, finish, getIdent, null, functionNode, null);
-propertyNode = new PropertyNode(source, propertyToken, finish, getIdent, null);
-propertyNode.setGetter(functionNode);
-return propertyNode;
 case "set":
 final PropertyKey setIdent = propertyName();
 final String setterName = setIdent.getPropertyName();
 final IdentNode setNameNode = new IdentNode(source, ((Node)setIdent).getToken(), finish, "set " + setterName);
 expect(LPAREN);
 final IdentNode argIdent = getIdent();
 verifyStrictIdent(argIdent, "setter argument");
 expect(RPAREN);
-parameters = new ArrayList<>();
+List<IdentNode> parameters = new ArrayList<>();
 parameters.add(argIdent);
 functionNode = functionBody(getSetToken, setNameNode, parameters, FunctionNode.Kind.SETTER);
-propertyNode = new PropertyNode(source, propertyToken, finish, setIdent, null);
+return new PropertyNode(source, propertyToken, finish, setIdent, null, null, functionNode);
-propertyNode.setSetter(functionNode);
-return propertyNode;
 default:
 break;
 }
 }
 propertyName = propertyName();
 }
 expect(COLON);
-final Node value = assignmentExpression(false);
+return new PropertyNode(source, propertyToken, finish, propertyName, assignmentExpression(false), null, null);
-propertyNode =  new PropertyNode(source, propertyToken, finish, propertyName, value);
+}
-return propertyNode;
+private int callNodeFlags() {
+return lc.inWith() ? CallNode.IN_WITH_BLOCK : 0;
 }
 /**
 * LeftHandSideExpression :
 *      NewExpression
 // Catch special functions.
 if (lhs instanceof IdentNode) {
 detectSpecialFunction((IdentNode)lhs);
 }
-lhs = new CallNode(source, callToken, finish, lhs, arguments);
+lhs = new CallNode(source, callToken, finish, lhs, arguments, callNodeFlags());
-if (isInWithBlock()) {
-((CallNode)lhs).setInWithBlock();
-}
 }
 loop:
 while (true) {
 // Capture token.
 case LPAREN:
 // Get NEW or FUNCTION arguments.
 final List<Node> arguments = argumentList();
 // Create call node.
-lhs = new CallNode(source, callToken, finish, lhs, arguments);
+lhs = new CallNode(source, callToken, finish, lhs, arguments, callNodeFlags());
-if (isInWithBlock()) {
-((CallNode)lhs).setInWithBlock();
-}
 break;
 case LBRACKET:
 next();
 if (!env._no_syntax_extensions && type == LBRACE) {
 arguments.add(objectLiteral());
 }
-final CallNode callNode = new CallNode(source, constructor.getToken(), finish, constructor, arguments);
+final CallNode callNode = new CallNode(source, constructor.getToken(), finish, constructor, arguments, callNodeFlags());
-if (isInWithBlock()) {
-callNode.setInWithBlock();
-}
 return new UnaryNode(source, newToken, callNode);
 }
 /**
 break;
 case PERIOD:
 if (lhs == null) {
-error(AbstractParser.message("expected.operand", type.getNameOrType()));
+throw error(AbstractParser.message("expected.operand", type.getNameOrType()));
-return null;
 }
 next();
 final IdentNode property = getIdentifierName();
 name = new IdentNode(source, functionToken, Token.descPosition(functionToken), tmpName);
 isAnonymous = true;
 }
 expect(LPAREN);
 final List<IdentNode> parameters = formalParameterList();
 expect(RPAREN);
-final FunctionNode functionNode = functionBody(functionToken, name, parameters, FunctionNode.Kind.NORMAL);
+FunctionNode functionNode = functionBody(functionToken, name, parameters, FunctionNode.Kind.NORMAL);
 if (isStatement) {
-if(topLevel) {
+if (topLevel) {
-functionNode.setIsDeclared();
+functionNode = functionNode.setFlag(lc, FunctionNode.IS_DECLARED);
 }
-if(ARGUMENTS.tag().equals(name.getName())) {
+if (ARGUMENTS.symbolName().equals(name.getName())) {
-getFunction().setDefinesArguments();
+functionNode = functionNode.setFlag(lc, FunctionNode.DEFINES_ARGUMENTS);
 }
 }
 if (isAnonymous) {
-functionNode.setIsAnonymous();
+functionNode = functionNode.setFlag(lc, FunctionNode.IS_ANONYMOUS);
 }
 final int arity = parameters.size();
-final boolean strict = functionNode.isStrictMode();
+final boolean strict = functionNode.isStrict();
 if (arity > 1) {
 final HashSet<String> parametersSet = new HashSet<>(arity);
 for (int i = arity - 1; i >= 0; i--) {
 final IdentNode parameter = parameters.get(i);
 String parameterName = parameter.getName();
-if (ARGUMENTS.tag().equals(parameterName)) {
+if (ARGUMENTS.symbolName().equals(parameterName)) {
-functionNode.setDefinesArguments();
+functionNode = functionNode.setFlag(lc, FunctionNode.DEFINES_ARGUMENTS);
 }
 if (parametersSet.contains(parameterName)) {
 // redefinition of parameter name
 if (strict) {
-error(AbstractParser.message("strict.param.redefinition", parameterName), parameter.getToken());
+throw error(AbstractParser.message("strict.param.redefinition", parameterName), parameter.getToken());
-} else {
-// rename in non-strict mode
-parameterName = functionNode.uniqueName(parameterName);
-final long parameterToken = parameter.getToken();
-parameters.set(i, new IdentNode(source, parameterToken, Token.descPosition(parameterToken), functionNode.uniqueName(parameterName)));
 }
+// rename in non-strict mode
+parameterName = functionNode.uniqueName(parameterName);
+final long parameterToken = parameter.getToken();
+parameters.set(i, new IdentNode(source, parameterToken, Token.descPosition(parameterToken), functionNode.uniqueName(parameterName)));
 }
 parametersSet.add(parameterName);
 }
 } else if (arity == 1) {
-if (ARGUMENTS.tag().equals(parameters.get(0).getName())) {
+if (ARGUMENTS.symbolName().equals(parameters.get(0).getName())) {
-functionNode.setDefinesArguments();
+functionNode = functionNode.setFlag(lc, FunctionNode.DEFINES_ARGUMENTS);
 }
 }
 if (isStatement) {
-final VarNode varNode = new VarNode(source, functionToken, finish, name, functionNode, true);
+final VarNode varNode = new VarNode(source, functionToken, finish, name, functionNode, VarNode.IS_STATEMENT);
-if(topLevel) {
+if (topLevel) {
 functionDeclarations.add(lineNumber);
 functionDeclarations.add(varNode);
 } else {
-final Block block = getBlock();
+appendStatement(lineNumber);
-block.addStatement(lineNumber);
+appendStatement(varNode);
-block.addStatement(varNode);
 }
 }
 return functionNode;
 }
 * Parse function body.
 * @return function node (body.)
 */
 private FunctionNode functionBody(final long firstToken, final IdentNode ident, final List<IdentNode> parameters, final FunctionNode.Kind kind) {
 FunctionNode functionNode = null;
+long lastToken = 0L;
 try {
 // Create a new function block.
-functionNode = newFunctionBlock(ident);
+functionNode = newFunctionNode(firstToken, ident, parameters, kind);
-functionNode.setParameters(parameters);
-functionNode.setKind(kind);
-functionNode.setFirstToken(firstToken);
 // Nashorn extension: expression closures
 if (!env._no_syntax_extensions && type != LBRACE) {
 /*
 * Example:
 * print(square(3));
 */
 // just expression as function body
 final Node expr = expression();
+assert lc.getCurrentBlock() == lc.getFunctionBody(functionNode);
 // create a return statement - this creates code in itself and does not need to be
 // wrapped into an ExecuteNode
-final ReturnNode  returnNode = new ReturnNode(source, expr.getToken(), finish, expr, null);
+final ReturnNode returnNode = new ReturnNode(source, expr.getToken(), finish, expr);
+appendStatement(returnNode);
-// add the return statement
+lastToken = token;
-functionNode.addStatement(returnNode);
-functionNode.setLastToken(token);
 functionNode.setFinish(Token.descPosition(token) + Token.descLength(token));
 } else {
 expect(LBRACE);
 // Gather the function elements.
 final List<Node> prevFunctionDecls = functionDeclarations;
 functionDeclarations = new ArrayList<>();
 try {
 sourceElements();
-functionNode.prependStatements(functionDeclarations);
+addFunctionDeclarations(functionNode);
 } finally {
 functionDeclarations = prevFunctionDecls;
 }
-functionNode.setLastToken(token);
+lastToken = token;
 expect(RBRACE);
 functionNode.setFinish(finish);
 }
 } finally {
-restoreBlock(functionNode);
+functionNode = restoreFunctionNode(functionNode, lastToken);
 }
 return functionNode;
+}
+private void addFunctionDeclarations(final FunctionNode functionNode) {
+assert lc.peek() == lc.getFunctionBody(functionNode);
+VarNode lastDecl = null;
+for (int i = functionDeclarations.size() - 1; i >= 0; i--) {
+Node decl = functionDeclarations.get(i);
+if (lastDecl == null && decl instanceof VarNode) {
+decl = lastDecl = ((VarNode)decl).setFlag(VarNode.IS_LAST_FUNCTION_DECLARATION);
+lc.setFlag(functionNode, FunctionNode.HAS_FUNCTION_DECLARATIONS);
+}
+prependStatement(decl);
+}
 }
 private RuntimeNode referenceError(final Node lhs, final Node rhs) {
 final ArrayList<Node> args = new ArrayList<>();
 args.add(lhs);
 args.add(LiteralNode.newInstance(source, lhs.getToken(), lhs.getFinish()));
 } else {
 args.add(rhs);
 }
 args.add(LiteralNode.newInstance(source, lhs.getToken(), lhs.getFinish(), lhs.toString()));
-final RuntimeNode runtimeNode = new RuntimeNode(source, lhs.getToken(),
+return new RuntimeNode(source, lhs.getToken(), lhs.getFinish(), RuntimeNode.Request.REFERENCE_ERROR, args);
-lhs.getFinish(), RuntimeNode.Request.REFERENCE_ERROR, args);
-return runtimeNode;
 }
 /*
 * parse LHS [a, b, ..., c].
 *
 case ADD:
 case SUB:
 case BIT_NOT:
 case NOT:
 next();
 final Node expr = unaryExpression();
-/*
-// Not sure if "delete <ident>" is a compile-time error or a
-// runtime error in strict mode.
-if (isStrictMode) {
-if (unaryTokenType == DELETE && expr instanceof IdentNode) {
-error(message("strict.cant.delete.ident", ((IdentNode)expr).getName()), expr.getToken());
-}
-}
-*/
 return new UnaryNode(source, unaryToken, expr);
 case INCPREFIX:
 case DECPREFIX:
 final TokenType opType = type;
 break;
 }
 }
 if (expression == null) {
-error(AbstractParser.message("expected.operand", type.getNameOrType()));
+throw error(AbstractParser.message("expected.operand", type.getNameOrType()));
 }
 return expression;
 }
 private Node expression() {
 // TODO - Destructuring array.
 // Include commas in expression parsing.
 return expression(unaryExpression(), COMMARIGHT.getPrecedence(), false);
 }
 private Node expression(final Node exprLhs, final int minPrecedence, final boolean noIn) {
 // Get the precedence of the next operator.
 int precedence = type.getPrecedence();
 Node lhs = exprLhs;
 @Override
 public String toString() {
 return "[JavaScript Parsing]";
 }
-private Block getBlock() {
+private static void markWithOrEval(final LexicalContext lc, int flag) {
-return lexicalContext.getCurrentBlock();
+final Iterator<FunctionNode> iter = lc.getFunctions();
-}
+boolean flaggedCurrentFn = false;
+while (iter.hasNext()) {
-private FunctionNode getFunction() {
+final FunctionNode fn = iter.next();
-return lexicalContext.getCurrentFunction();
+if (!flaggedCurrentFn) {
+lc.setFlag(fn, flag);
+flaggedCurrentFn = true;
+} else {
+lc.setFlag(fn, FunctionNode.HAS_DESCENDANT_WITH_OR_EVAL);
+}
+lc.setFlag(lc.getFunctionBody(fn), Block.NEEDS_SCOPE);
+}
+}
+private void prependStatement(final Node statement) {
+lc.prependStatement(statement);
+}
+private void appendStatement(final Node statement) {
+lc.appendStatement(statement);
 }
 }

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/nashorn/internal/parser/Parser.java

src/jdk/nashorn/internal/parser/Parser.java