src/jdk/nashorn/internal/codegen/CodeGenerator.java - toolchain/jdk/jdk9_nashorn - Git at Google

 /*
  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package jdk.nashorn.internal.codegen;

 import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.PRIVATE;
 import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.STATIC;
 import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE;
 import static jdk.nashorn.internal.codegen.CompilerConstants.GET_MAP;
 import static jdk.nashorn.internal.codegen.CompilerConstants.GET_STRING;
 import static jdk.nashorn.internal.codegen.CompilerConstants.QUICK_PREFIX;
 import static jdk.nashorn.internal.codegen.CompilerConstants.REGEX_PREFIX;
 import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;
 import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
 import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_ARRAY_ARG;
 import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_PREFIX;
 import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
 import static jdk.nashorn.internal.codegen.CompilerConstants.constructorNoLookup;
 import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup;
 import static jdk.nashorn.internal.codegen.CompilerConstants.methodDescriptor;
 import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
 import static jdk.nashorn.internal.codegen.CompilerConstants.typeDescriptor;
 import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;
 import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;
 import static jdk.nashorn.internal.ir.Symbol.IS_TEMP;
 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_FAST_SCOPE;
 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_SCOPE;
 import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_STRICT;

 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeMap;
 import jdk.nashorn.internal.codegen.ClassEmitter.Flag;
 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
 import jdk.nashorn.internal.codegen.RuntimeCallSite.SpecializedRuntimeNode;
 import jdk.nashorn.internal.codegen.types.ArrayType;
 import jdk.nashorn.internal.codegen.types.Type;
 import jdk.nashorn.internal.ir.AccessNode;
 import jdk.nashorn.internal.ir.BaseNode;
 import jdk.nashorn.internal.ir.BinaryNode;
 import jdk.nashorn.internal.ir.Block;
 import jdk.nashorn.internal.ir.BlockStatement;
 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.EmptyNode;
 import jdk.nashorn.internal.ir.Expression;
 import jdk.nashorn.internal.ir.ExpressionStatement;
 import jdk.nashorn.internal.ir.ForNode;
 import jdk.nashorn.internal.ir.FunctionNode;
 import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
 import jdk.nashorn.internal.ir.IdentNode;
 import jdk.nashorn.internal.ir.IfNode;
 import jdk.nashorn.internal.ir.IndexNode;
 import jdk.nashorn.internal.ir.LexicalContext;
 import jdk.nashorn.internal.ir.LexicalContextNode;
 import jdk.nashorn.internal.ir.LiteralNode;
 import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
 import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
 import jdk.nashorn.internal.ir.LoopNode;
 import jdk.nashorn.internal.ir.Node;
 import jdk.nashorn.internal.ir.ObjectNode;
 import jdk.nashorn.internal.ir.PropertyNode;
 import jdk.nashorn.internal.ir.ReturnNode;
 import jdk.nashorn.internal.ir.RuntimeNode;
 import jdk.nashorn.internal.ir.RuntimeNode.Request;
 import jdk.nashorn.internal.ir.SplitNode;
 import jdk.nashorn.internal.ir.Statement;
 import jdk.nashorn.internal.ir.SwitchNode;
 import jdk.nashorn.internal.ir.Symbol;
 import jdk.nashorn.internal.ir.TernaryNode;
 import jdk.nashorn.internal.ir.ThrowNode;
 import jdk.nashorn.internal.ir.TryNode;
 import jdk.nashorn.internal.ir.UnaryNode;
 import jdk.nashorn.internal.ir.VarNode;
 import jdk.nashorn.internal.ir.WhileNode;
 import jdk.nashorn.internal.ir.WithNode;
 import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
 import jdk.nashorn.internal.objects.Global;
 import jdk.nashorn.internal.objects.ScriptFunctionImpl;
 import jdk.nashorn.internal.parser.Lexer.RegexToken;
 import jdk.nashorn.internal.parser.TokenType;
 import jdk.nashorn.internal.runtime.Context;
 import jdk.nashorn.internal.runtime.Debug;
 import jdk.nashorn.internal.runtime.DebugLogger;
 import jdk.nashorn.internal.runtime.ECMAException;
 import jdk.nashorn.internal.runtime.JSType;
 import jdk.nashorn.internal.runtime.Property;
 import jdk.nashorn.internal.runtime.PropertyMap;
 import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;
 import jdk.nashorn.internal.runtime.Scope;
 import jdk.nashorn.internal.runtime.ScriptFunction;
 import jdk.nashorn.internal.runtime.ScriptObject;
 import jdk.nashorn.internal.runtime.ScriptRuntime;
 import jdk.nashorn.internal.runtime.Source;
 import jdk.nashorn.internal.runtime.Undefined;
 import jdk.nashorn.internal.runtime.arrays.ArrayData;
 import jdk.nashorn.internal.runtime.linker.LinkerCallSite;

 /**
  * This is the lowest tier of the code generator. It takes lowered ASTs emitted
  * from Lower and emits Java byte code. The byte code emission logic is broken
  * out into MethodEmitter. MethodEmitter works internally with a type stack, and
  * keeps track of the contents of the byte code stack. This way we avoid a large
  * number of special cases on the form
  * <pre>
  * if (type == INT) {
  *     visitInsn(ILOAD, slot);
  * } else if (type == DOUBLE) {
  *     visitInsn(DOUBLE, slot);
  * }
  * </pre>
  * This quickly became apparent when the code generator was generalized to work
  * with all types, and not just numbers or objects.
  * <p>
  * The CodeGenerator visits nodes only once, tags them as resolved and emits
  * bytecode for them.
  */
 final class CodeGenerator extends NodeOperatorVisitor<CodeGeneratorLexicalContext> {

     private static final String GLOBAL_OBJECT = Type.getInternalName(Global.class);

     private static final String SCRIPTFUNCTION_IMPL_OBJECT = Type.getInternalName(ScriptFunctionImpl.class);

     /** Constant data & installation. The only reason the compiler keeps this is because it is assigned
      *  by reflection in class installation */
     private final Compiler compiler;

     /** Call site flags given to the code generator to be used for all generated call sites */
     private final int callSiteFlags;

     /** How many regexp fields have been emitted */
     private int regexFieldCount;

     /** Line number for last statement. If we encounter a new line number, line number bytecode information
      *  needs to be generated */
     private int lastLineNumber = -1;

     /** When should we stop caching regexp expressions in fields to limit bytecode size? */
     private static final int MAX_REGEX_FIELDS = 2 * 1024;

     /** Current method emitter */
     private MethodEmitter method;

     /** Current compile unit */
     private CompileUnit unit;

     private static final DebugLogger LOG   = new DebugLogger("codegen", "nashorn.codegen.debug");

     /** From what size should we use spill instead of fields for JavaScript objects? */
     private static final int OBJECT_SPILL_THRESHOLD = 300;

     private final Set<String> emittedMethods = new HashSet<>();

     /**
      * Constructor.
      *
      * @param compiler
      */
     CodeGenerator(final Compiler compiler) {
         super(new CodeGeneratorLexicalContext());
         this.compiler      = compiler;
         this.callSiteFlags = compiler.getEnv()._callsite_flags;
     }

     /**
      * Gets the call site flags, adding the strict flag if the current function
      * being generated is in strict mode
      *
      * @return the correct flags for a call site in the current function
      */
     int getCallSiteFlags() {
         return lc.getCurrentFunction().isStrict() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags;
     }

     /**
      * Load an identity node
      *
      * @param identNode an identity node to load
      * @return the method generator used
      */
     private MethodEmitter loadIdent(final IdentNode identNode, final Type type) {
         final Symbol symbol = identNode.getSymbol();

         if (!symbol.isScope()) {
             assert symbol.hasSlot() || symbol.isParam();
             return method.load(symbol).convert(type);
         }

         final String name   = symbol.getName();
         final Source source = lc.getCurrentFunction().getSource();

         if (CompilerConstants.__FILE__.name().equals(name)) {
             return method.load(source.getName());
         } else if (CompilerConstants.__DIR__.name().equals(name)) {
             return method.load(source.getBase());
         } else if (CompilerConstants.__LINE__.name().equals(name)) {
             return method.load(source.getLine(identNode.position())).convert(Type.OBJECT);
         } else {
             assert identNode.getSymbol().isScope() : identNode + " is not in scope!";

             final int flags = CALLSITE_SCOPE | getCallSiteFlags();
             method.loadCompilerConstant(SCOPE);

             if (isFastScope(symbol)) {
                 // Only generate shared scope getter for fast-scope symbols so we know we can dial in correct scope.
                 if (symbol.getUseCount() > SharedScopeCall.FAST_SCOPE_GET_THRESHOLD) {
                     return loadSharedScopeVar(type, symbol, flags);
                 }
                 return loadFastScopeVar(type, symbol, flags, identNode.isFunction());
             }
             return method.dynamicGet(type, identNode.getName(), flags, identNode.isFunction());
         }
     }

     /**
      * Check if this symbol can be accessed directly with a putfield or getfield or dynamic load
      *
      * @param symbol symbol to check for fast scope
      * @return true if fast scope
      */
     private boolean isFastScope(final Symbol symbol) {
         if (!symbol.isScope()) {
             return false;
         }

         if (!lc.inDynamicScope()) {
             // If there's no with or eval in context, and the symbol is marked as scoped, it is fast scoped. Such a
             // symbol must either be global, or its defining block must need scope.
             assert symbol.isGlobal() || lc.getDefiningBlock(symbol).needsScope() : symbol.getName();
             return true;
         }

         if (symbol.isGlobal()) {
             // Shortcut: if there's a with or eval in context, globals can't be fast scoped
             return false;
         }

         // Otherwise, check if there's a dynamic scope between use of the symbol and its definition
         final String name = symbol.getName();
         boolean previousWasBlock = false;
         for (final Iterator<LexicalContextNode> it = lc.getAllNodes(); it.hasNext();) {
             final LexicalContextNode node = it.next();
             if (node instanceof Block) {
                 // If this block defines the symbol, then we can fast scope the symbol.
                 final Block block = (Block)node;
                 if (block.getExistingSymbol(name) == symbol) {
                     assert block.needsScope();
                     return true;
                 }
                 previousWasBlock = true;
             } else {
                 if ((node instanceof WithNode && previousWasBlock) || (node instanceof FunctionNode && CodeGeneratorLexicalContext.isFunctionDynamicScope((FunctionNode)node))) {
                     // If we hit a scope that can have symbols introduced into it at run time before finding the defining
                     // block, the symbol can't be fast scoped. A WithNode only counts if we've immediately seen a block
                     // before - its block. Otherwise, we are currently processing the WithNode's expression, and that's
                     // obviously not subjected to introducing new symbols.
                     return false;
                 }
                 previousWasBlock = false;
             }
         }
         // Should've found the symbol defined in a block
         throw new AssertionError();
     }

     private MethodEmitter loadSharedScopeVar(final Type valueType, final Symbol symbol, final int flags) {
         method.load(isFastScope(symbol) ? getScopeProtoDepth(lc.getCurrentBlock(), symbol) : -1);
         final SharedScopeCall scopeCall = lc.getScopeGet(unit, valueType, symbol, flags | CALLSITE_FAST_SCOPE);
         return scopeCall.generateInvoke(method);
     }

     private MethodEmitter loadFastScopeVar(final Type valueType, final Symbol symbol, final int flags, final boolean isMethod) {
         loadFastScopeProto(symbol, false);
         return method.dynamicGet(valueType, symbol.getName(), flags | CALLSITE_FAST_SCOPE, isMethod);
     }

     private MethodEmitter storeFastScopeVar(final Symbol symbol, final int flags) {
         loadFastScopeProto(symbol, true);
         method.dynamicSet(symbol.getName(), flags | CALLSITE_FAST_SCOPE);
         return method;
     }

     private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) {
         int depth = 0;
         final String name = symbol.getName();
         for(final Iterator<Block> blocks = lc.getBlocks(startingBlock); blocks.hasNext();) {
             final Block currentBlock = blocks.next();
             if (currentBlock.getExistingSymbol(name) == symbol) {
                 return depth;
             }
             if (currentBlock.needsScope()) {
                 ++depth;
             }
         }
         return -1;
     }

     private void loadFastScopeProto(final Symbol symbol, final boolean swap) {
         final int depth = getScopeProtoDepth(lc.getCurrentBlock(), symbol);
         assert depth != -1;
         if (depth > 0) {
             if (swap) {
                 method.swap();
             }
             for (int i = 0; i < depth; i++) {
                 method.invoke(ScriptObject.GET_PROTO);
             }
             if (swap) {
                 method.swap();
             }
         }
     }

     /**
      * Generate code that loads this node to the stack. This method is only
      * public to be accessible from the maps sub package. Do not call externally
      *
      * @param node node to load
      *
      * @return the method emitter used
      */
     MethodEmitter load(final Expression node) {
         return load(node, node.hasType() ? node.getType() : null, false);
     }

     // Test whether conversion from source to target involves a call of ES 9.1 ToPrimitive
     // with possible side effects from calling an object's toString or valueOf methods.
     private boolean noToPrimitiveConversion(final Type source, final Type target) {
         // Object to boolean conversion does not cause ToPrimitive call
         return source.isJSPrimitive() || !target.isJSPrimitive() || target.isBoolean();
     }

     MethodEmitter loadBinaryOperands(final Expression lhs, final Expression rhs, final Type type) {
         return loadBinaryOperands(lhs, rhs, type, false);
     }

     private MethodEmitter loadBinaryOperands(final Expression lhs, final Expression rhs, final Type type, final boolean baseAlreadyOnStack) {
         // ECMAScript 5.1 specification (sections 11.5-11.11 and 11.13) prescribes that when evaluating a binary
         // expression "LEFT op RIGHT", the order of operations must be: LOAD LEFT, LOAD RIGHT, CONVERT LEFT, CONVERT
         // RIGHT, EXECUTE OP. Unfortunately, doing it in this order defeats potential optimizations that arise when we
         // can combine a LOAD with a CONVERT operation (e.g. use a dynamic getter with the conversion target type as its
         // return value). What we do here is reorder LOAD RIGHT and CONVERT LEFT when possible; it is possible only when
         // we can prove that executing CONVERT LEFT can't have a side effect that changes the value of LOAD RIGHT.
         // Basically, if we know that either LEFT already is a primitive value, or does not have to be converted to
         // a primitive value, or RIGHT is an expression that loads without side effects, then we can do the
         // reordering and collapse LOAD/CONVERT into a single operation; otherwise we need to do the more costly
         // separate operations to preserve specification semantics.
         if (noToPrimitiveConversion(lhs.getType(), type) || rhs.isLocal()) {
             // Can reorder. Combine load and convert into single operations.
             load(lhs, type, baseAlreadyOnStack);
             load(rhs, type, false);
         } else {
             // Can't reorder. Load and convert separately.
             load(lhs, lhs.getType(), baseAlreadyOnStack);
             load(rhs, rhs.getType(), false);
             method.swap().convert(type).swap().convert(type);
         }

         return method;
     }

     MethodEmitter loadBinaryOperands(final BinaryNode node) {
         return loadBinaryOperands(node.lhs(), node.rhs(), node.getType(), false);
     }

     MethodEmitter load(final Expression node, final Type type) {
         return load(node, type, false);
     }

     private MethodEmitter load(final Expression node, final Type type, final boolean baseAlreadyOnStack) {
         final Symbol symbol = node.getSymbol();

         // If we lack symbols, we just generate what we see.
         if (symbol == null || type == null) {
             node.accept(this);
             return method;
         }

         assert !type.isUnknown();

         /*
          * The load may be of type IdentNode, e.g. "x", AccessNode, e.g. "x.y"
          * or IndexNode e.g. "x[y]". Both AccessNodes and IndexNodes are
          * BaseNodes and the logic for loading the base object is reused
          */
         final CodeGenerator codegen = this;

         node.accept(new NodeVisitor<LexicalContext>(lc) {
             @Override
             public boolean enterIdentNode(final IdentNode identNode) {
                 loadIdent(identNode, type);
                 return false;
             }

             @Override
             public boolean enterAccessNode(final AccessNode accessNode) {
                 if (!baseAlreadyOnStack) {
                     load(accessNode.getBase(), Type.OBJECT);
                 }
                 assert method.peekType().isObject();
                 method.dynamicGet(type, accessNode.getProperty().getName(), getCallSiteFlags(), accessNode.isFunction());
                 return false;
             }

             @Override
             public boolean enterIndexNode(final IndexNode indexNode) {
                 if (!baseAlreadyOnStack) {
                     load(indexNode.getBase(), Type.OBJECT);
                     load(indexNode.getIndex());
                 }
                 method.dynamicGetIndex(type, getCallSiteFlags(), indexNode.isFunction());
                 return false;
             }

             @Override
             public boolean enterFunctionNode(FunctionNode functionNode) {
                 // function nodes will always leave a constructed function object on stack, no need to load the symbol
                 // separately as in enterDefault()
                 lc.pop(functionNode);
                 functionNode.accept(codegen);
                 // NOTE: functionNode.accept() will produce a different FunctionNode that we discard. This incidentally
                 // doesn't cause problems as we're never touching FunctionNode again after it's visited here - codegen
                 // is the last element in the compilation pipeline, the AST it produces is not used externally. So, we
                 // re-push the original functionNode.
                 lc.push(functionNode);
                 method.convert(type);
                 return false;
             }

             @Override
             public boolean enterCallNode(CallNode callNode) {
                 return codegen.enterCallNode(callNode, type);
             }

             @Override
             public boolean enterLiteralNode(LiteralNode<?> literalNode) {
                 return codegen.enterLiteralNode(literalNode, type);
             }

             @Override
             public boolean enterDefault(final Node otherNode) {
                 final Node currentDiscard = codegen.lc.getCurrentDiscard();
                 otherNode.accept(codegen); // generate code for whatever we are looking at.
                 if(currentDiscard != otherNode) {
                     method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there)
                     assert method.peekType() != null;
                     method.convert(type);
                 }
                 return false;
             }
         });

         return method;
     }

     @Override
     public boolean enterAccessNode(final AccessNode accessNode) {
         load(accessNode);
         return false;
     }

     /**
      * Initialize a specific set of vars to undefined. This has to be done at
      * the start of each method for local variables that aren't passed as
      * parameters.
      *
      * @param symbols list of symbols.
      */
     private void initSymbols(final Iterable<Symbol> symbols) {
         final LinkedList<Symbol> numbers = new LinkedList<>();
         final LinkedList<Symbol> objects = new LinkedList<>();

         for (final Symbol symbol : symbols) {
             /*
              * The following symbols are guaranteed to be defined and thus safe
              * from having undefined written to them: parameters internals this
              *
              * Otherwise we must, unless we perform control/escape analysis,
              * assign them undefined.
              */
             final boolean isInternal = symbol.isParam() || symbol.isInternal() || symbol.isThis() || !symbol.canBeUndefined();

             if (symbol.hasSlot() && !isInternal) {
                 assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + lc.getCurrentFunction();
                 if (symbol.getSymbolType().isNumber()) {
                     numbers.add(symbol);
                 } else if (symbol.getSymbolType().isObject()) {
                     objects.add(symbol);
                 }
             }
         }

         initSymbols(numbers, Type.NUMBER);
         initSymbols(objects, Type.OBJECT);
     }

     private void initSymbols(final LinkedList<Symbol> symbols, final Type type) {
         final Iterator<Symbol> it = symbols.iterator();
         if(it.hasNext()) {
             method.loadUndefined(type);
             boolean hasNext;
             do {
                 final Symbol symbol = it.next();
                 hasNext = it.hasNext();
                 if(hasNext) {
                     method.dup();
                 }
                 method.store(symbol);
             } while(hasNext);
         }
     }

     /**
      * Create symbol debug information.
      *
      * @param block block containing symbols.
      */
     private void symbolInfo(final Block block) {
         for (final Symbol symbol : block.getSymbols()) {
             if (symbol.hasSlot()) {
                 method.localVariable(symbol, block.getEntryLabel(), block.getBreakLabel());
             }
         }
     }

     @Override
     public boolean enterBlock(final Block block) {
         if(lc.isFunctionBody() && emittedMethods.contains(lc.getCurrentFunction().getName())) {
             return false;
         }
         method.label(block.getEntryLabel());
         initLocals(block);

         return true;
     }

     @Override
     public Node leaveBlock(final Block block) {
         method.label(block.getBreakLabel());
         symbolInfo(block);

         if (block.needsScope() && !block.isTerminal()) {
             popBlockScope(block);
         }
         return block;
     }

     private void popBlockScope(final Block block) {
         final Label exitLabel     = new Label("block_exit");
         final Label recoveryLabel = new Label("block_catch");
         final Label skipLabel     = new Label("skip_catch");

         /* pop scope a la try-finally */
         method.loadCompilerConstant(SCOPE);
         method.invoke(ScriptObject.GET_PROTO);
         method.storeCompilerConstant(SCOPE);
         method._goto(skipLabel);
         method.label(exitLabel);

         method._catch(recoveryLabel);
         method.loadCompilerConstant(SCOPE);
         method.invoke(ScriptObject.GET_PROTO);
         method.storeCompilerConstant(SCOPE);
         method.athrow();
         method.label(skipLabel);
         method._try(block.getEntryLabel(), exitLabel, recoveryLabel, Throwable.class);
     }

     @Override
     public boolean enterBreakNode(final BreakNode breakNode) {
         lineNumber(breakNode);

         final BreakableNode breakFrom = lc.getBreakable(breakNode.getLabel());
         for (int i = 0; i < lc.getScopeNestingLevelTo(breakFrom); i++) {
             closeWith();
         }
         method.splitAwareGoto(lc, breakFrom.getBreakLabel());

         return false;
     }

     private int loadArgs(final List<Expression> args) {
         return loadArgs(args, null, false, args.size());
     }

     private int loadArgs(final List<Expression> args, final String signature, final boolean isVarArg, final int argCount) {
         // arg have already been converted to objects here.
         if (isVarArg || argCount > LinkerCallSite.ARGLIMIT) {
             loadArgsArray(args);
             return 1;
         }

         // pad with undefined if size is too short. argCount is the real number of args
         int n = 0;
         final Type[] params = signature == null ? null : Type.getMethodArguments(signature);
         for (final Expression arg : args) {
             assert arg != null;
             if (n >= argCount) {
                 load(arg);
                 method.pop(); // we had to load the arg for its side effects
             } else if (params != null) {
                 load(arg, params[n]);
             } else {
                 load(arg);
             }
             n++;
         }

         while (n < argCount) {
             method.loadUndefined(Type.OBJECT);
             n++;
         }

         return argCount;
     }


     @Override
     public boolean enterCallNode(final CallNode callNode) {
         return enterCallNode(callNode, callNode.getType());
     }

     private boolean enterCallNode(final CallNode callNode, final Type callNodeType) {
         lineNumber(callNode.getLineNumber());

         final List<Expression> args = callNode.getArgs();
         final Expression function = callNode.getFunction();
         final Block currentBlock = lc.getCurrentBlock();
         final CodeGeneratorLexicalContext codegenLexicalContext = lc;

         function.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

             private MethodEmitter sharedScopeCall(final IdentNode identNode, final int flags) {
                 final Symbol symbol = identNode.getSymbol();
                 int    scopeCallFlags = flags;
                 method.loadCompilerConstant(SCOPE);
                 if (isFastScope(symbol)) {
                     method.load(getScopeProtoDepth(currentBlock, symbol));
                     scopeCallFlags |= CALLSITE_FAST_SCOPE;
                 } else {
                     method.load(-1); // Bypass fast-scope code in shared callsite
                 }
                 loadArgs(args);
                 final Type[] paramTypes = method.getTypesFromStack(args.size());
                 final SharedScopeCall scopeCall = codegenLexicalContext.getScopeCall(unit, symbol, identNode.getType(), callNodeType, paramTypes, scopeCallFlags);
                 return scopeCall.generateInvoke(method);
             }

             private void scopeCall(final IdentNode node, final int flags) {
                 load(node, Type.OBJECT); // Type.OBJECT as foo() makes no sense if foo == 3
                 // ScriptFunction will see CALLSITE_SCOPE and will bind scope accordingly.
                 method.loadNull(); //the 'this'
                 method.dynamicCall(callNodeType, 2 + loadArgs(args), flags);
             }

             private void evalCall(final IdentNode node, final int flags) {
                 load(node, Type.OBJECT); // Type.OBJECT as foo() makes no sense if foo == 3

                 final Label not_eval  = new Label("not_eval");
                 final Label eval_done = new Label("eval_done");

                 // check if this is the real built-in eval
                 method.dup();
                 globalIsEval();

                 method.ifeq(not_eval);
                 // We don't need ScriptFunction object for 'eval'
                 method.pop();

                 method.loadCompilerConstant(SCOPE); // Load up self (scope).

                 final CallNode.EvalArgs evalArgs = callNode.getEvalArgs();
                 // load evaluated code
                 load(evalArgs.getCode(), Type.OBJECT);
                 // load second and subsequent args for side-effect
                 final List<Expression> args = callNode.getArgs();
                 final int numArgs = args.size();
                 for (int i = 1; i < numArgs; i++) {
                     load(args.get(i)).pop();
                 }
                 // special/extra 'eval' arguments
                 load(evalArgs.getThis());
                 method.load(evalArgs.getLocation());
                 method.load(evalArgs.getStrictMode());
                 method.convert(Type.OBJECT);

                 // direct call to Global.directEval
                 globalDirectEval();
                 method.convert(callNodeType);
                 method._goto(eval_done);

                 method.label(not_eval);
                 // This is some scope 'eval' or global eval replaced by user
                 // but not the built-in ECMAScript 'eval' function call
                 method.loadNull();
                 method.dynamicCall(callNodeType, 2 + loadArgs(args), flags);

                 method.label(eval_done);
             }

             @Override
             public boolean enterIdentNode(final IdentNode node) {
                 final Symbol symbol = node.getSymbol();

                 if (symbol.isScope()) {
                     final int flags = getCallSiteFlags() | CALLSITE_SCOPE;
                     final int useCount = symbol.getUseCount();

                     // Threshold for generating shared scope callsite is lower for fast scope symbols because we know
                     // we can dial in the correct scope. However, we also need to enable it for non-fast scopes to
                     // support huge scripts like mandreel.js.
                     if (callNode.isEval()) {
                         evalCall(node, flags);
                     } else if (useCount <= SharedScopeCall.FAST_SCOPE_CALL_THRESHOLD
                             || (!isFastScope(symbol) && useCount <= SharedScopeCall.SLOW_SCOPE_CALL_THRESHOLD)
                             || CodeGenerator.this.lc.inDynamicScope()) {
                         scopeCall(node, flags);
                     } else {
                         sharedScopeCall(node, flags);
                     }
                     assert method.peekType().equals(callNodeType) : method.peekType() + "!=" + callNode.getType();
                 } else {
                     enterDefault(node);
                 }

                 return false;
             }

             @Override
             public boolean enterAccessNode(final AccessNode node) {
                 load(node.getBase(), Type.OBJECT);
                 method.dup();
                 method.dynamicGet(node.getType(), node.getProperty().getName(), getCallSiteFlags(), true);
                 method.swap();
                 method.dynamicCall(callNodeType, 2 + loadArgs(args), getCallSiteFlags());

                 return false;
             }

             @Override
             public boolean enterFunctionNode(final FunctionNode origCallee) {
                 // NOTE: visiting the callee will leave a constructed ScriptFunction object on the stack if
                 // callee.needsCallee() == true
                 final FunctionNode callee = (FunctionNode)origCallee.accept(CodeGenerator.this);

                 final boolean      isVarArg = callee.isVarArg();
                 final int          argCount = isVarArg ? -1 : callee.getParameters().size();

                 final String signature = new FunctionSignature(true, callee.needsCallee(), callee.getReturnType(), isVarArg ? null : callee.getParameters()).toString();

                 if (callee.isStrict()) { // self is undefined
                     method.loadUndefined(Type.OBJECT);
                 } else { // get global from scope (which is the self)
                     globalInstance();
                 }
                 loadArgs(args, signature, isVarArg, argCount);
                 assert callee.getCompileUnit() != null : "no compile unit for " + callee.getName() + " " + Debug.id(callee) + " " + callNode;
                 method.invokestatic(callee.getCompileUnit().getUnitClassName(), callee.getName(), signature);
                 assert method.peekType().equals(callee.getReturnType()) : method.peekType() + " != " + callee.getReturnType();
                 method.convert(callNodeType);
                 return false;
             }

             @Override
             public boolean enterIndexNode(final IndexNode node) {
                 load(node.getBase(), Type.OBJECT);
                 method.dup();
                 final Type indexType = node.getIndex().getType();
                 if (indexType.isObject() || indexType.isBoolean()) {
                     load(node.getIndex(), Type.OBJECT); //TODO
                 } else {
                     load(node.getIndex());
                 }
                 method.dynamicGetIndex(node.getType(), getCallSiteFlags(), true);
                 method.swap();
                 method.dynamicCall(callNodeType, 2 + loadArgs(args), getCallSiteFlags());

                 return false;
             }

             @Override
             protected boolean enterDefault(final Node node) {
                 // Load up function.
                 load(function, Type.OBJECT); //TODO, e.g. booleans can be used as functions
                 method.loadNull(); // ScriptFunction will figure out the correct this when it sees CALLSITE_SCOPE
                 method.dynamicCall(callNodeType, 2 + loadArgs(args), getCallSiteFlags() | CALLSITE_SCOPE);

                 return false;
             }
         });

         method.store(callNode.getSymbol());

         return false;
     }

     @Override
     public boolean enterContinueNode(final ContinueNode continueNode) {
         lineNumber(continueNode);

         final LoopNode continueTo = lc.getContinueTo(continueNode.getLabel());
         for (int i = 0; i < lc.getScopeNestingLevelTo(continueTo); i++) {
             closeWith();
         }
         method.splitAwareGoto(lc, continueTo.getContinueLabel());

         return false;
     }

     @Override
     public boolean enterEmptyNode(final EmptyNode emptyNode) {
         lineNumber(emptyNode);

         return false;
     }

     @Override
     public boolean enterExpressionStatement(final ExpressionStatement expressionStatement) {
         lineNumber(expressionStatement);

         expressionStatement.getExpression().accept(this);

         return false;
     }

     @Override
     public boolean enterBlockStatement(final BlockStatement blockStatement) {
         lineNumber(blockStatement);

         blockStatement.getBlock().accept(this);

         return false;
     }

     @Override
     public boolean enterForNode(final ForNode forNode) {
         lineNumber(forNode);

         if (forNode.isForIn()) {
             enterForIn(forNode);
         } else {
             enterFor(forNode);
         }

         return false;
     }

     private void enterFor(final ForNode forNode) {
         final Expression init   = forNode.getInit();
         final Expression test   = forNode.getTest();
         final Block      body   = forNode.getBody();
         final Expression modify = forNode.getModify();

         if (init != null) {
             init.accept(this);
         }

         final Label loopLabel = new Label("loop");
         final Label testLabel = new Label("test");

         method._goto(testLabel);
         method.label(loopLabel);
         body.accept(this);
         method.label(forNode.getContinueLabel());

         if (!body.isTerminal() && modify != null) {
             load(modify);
         }

         method.label(testLabel);
         if (test != null) {
             new BranchOptimizer(this, method).execute(test, loopLabel, true);
         } else {
             method._goto(loopLabel);
         }

         method.label(forNode.getBreakLabel());
     }

     private void enterForIn(final ForNode forNode) {
         final Block body   = forNode.getBody();
         final Expression  modify = forNode.getModify();

         final Symbol iter      = forNode.getIterator();
         final Label  loopLabel = new Label("loop");

         final Expression init = forNode.getInit();

         load(modify, Type.OBJECT);
         method.invoke(forNode.isForEach() ? ScriptRuntime.TO_VALUE_ITERATOR : ScriptRuntime.TO_PROPERTY_ITERATOR);
         method.store(iter);
         method._goto(forNode.getContinueLabel());
         method.label(loopLabel);

         new Store<Expression>(init) {
             @Override
             protected void storeNonDiscard() {
                 return;
             }
             @Override
             protected void evaluate() {
                 method.load(iter);
                 method.invoke(interfaceCallNoLookup(Iterator.class, "next", Object.class));
             }
         }.store();

         body.accept(this);

         method.label(forNode.getContinueLabel());
         method.load(iter);
         method.invoke(interfaceCallNoLookup(Iterator.class, "hasNext", boolean.class));
         method.ifne(loopLabel);
         method.label(forNode.getBreakLabel());
     }

     /**
      * Initialize the slots in a frame to undefined.
      *
      * @param block block with local vars.
      */
     private void initLocals(final Block block) {
         lc.nextFreeSlot(block);

         final boolean isFunctionBody = lc.isFunctionBody();

         final FunctionNode function = lc.getCurrentFunction();
         if (isFunctionBody) {
             if(method.hasScope()) {
                 if (function.needsParentScope()) {
                     method.loadCompilerConstant(CALLEE);
                     method.invoke(ScriptFunction.GET_SCOPE);
                 } else {
                     assert function.hasScopeBlock();
                     method.loadNull();
                 }
                 method.storeCompilerConstant(SCOPE);
             }
             if (function.needsArguments()) {
                 initArguments(function);
             }
         }

         /*
          * Determine if block needs scope, if not, just do initSymbols for this block.
          */
         if (block.needsScope()) {
             /*
              * Determine if function is varargs and consequently variables have to
              * be in the scope.
              */
             final boolean varsInScope = function.allVarsInScope();

             // TODO for LET we can do better: if *block* does not contain any eval/with, we don't need its vars in scope.

             final List<String> nameList = new ArrayList<>();
             final List<Symbol> locals   = new ArrayList<>();

             // Initalize symbols and values
             final List<Symbol> newSymbols = new ArrayList<>();
             final List<Symbol> values     = new ArrayList<>();

             final boolean hasArguments = function.needsArguments();

             for (final Symbol symbol : block.getSymbols()) {

                 if (symbol.isInternal() || symbol.isThis() || symbol.isTemp()) {
                     continue;
                 }

                 if (symbol.isVar()) {
                     if (varsInScope || symbol.isScope()) {
                         nameList.add(symbol.getName());
                         newSymbols.add(symbol);
                         values.add(null);
                         assert symbol.isScope()   : "scope for " + symbol + " should have been set in Lower already " + function.getName();
                         assert !symbol.hasSlot()  : "slot for " + symbol + " should have been removed in Lower already" + function.getName();
                     } else {
                         assert symbol.hasSlot() : symbol + " should have a slot only, no scope";
                         locals.add(symbol);
                     }
                 } else if (symbol.isParam() && (varsInScope || hasArguments || symbol.isScope())) {
                     nameList.add(symbol.getName());
                     newSymbols.add(symbol);
                     values.add(hasArguments ? null : symbol);
                     assert symbol.isScope()   : "scope for " + symbol + " should have been set in Lower already " + function.getName() + " varsInScope="+varsInScope+" hasArguments="+hasArguments+" symbol.isScope()=" + symbol.isScope();
                     assert !(hasArguments && symbol.hasSlot())  : "slot for " + symbol + " should have been removed in Lower already " + function.getName();
                 }
             }

             // we may have locals that need to be initialized
             initSymbols(locals);

             /*
              * Create a new object based on the symbols and values, generate
              * bootstrap code for object
              */
             new FieldObjectCreator<Symbol>(this, nameList, newSymbols, values, true, hasArguments) {
                 @Override
                 protected void loadValue(final Symbol value) {
                     method.load(value);
                 }
             }.makeObject(method);

             // runScript(): merge scope into global
             if (isFunctionBody && function.isProgram()) {
                 method.invoke(ScriptRuntime.MERGE_SCOPE);
             }

             method.storeCompilerConstant(SCOPE);
         } else {
             // Since we don't have a scope, parameters didn't get assigned array indices by the FieldObjectCreator, so
             // we need to assign them separately here.
             int nextParam = 0;
             if (isFunctionBody && function.isVarArg()) {
                 for (final IdentNode param : function.getParameters()) {
                     param.getSymbol().setFieldIndex(nextParam++);
                 }
             }

             initSymbols(block.getSymbols());
         }

         // Debugging: print symbols? @see --print-symbols flag
         printSymbols(block, (isFunctionBody ? "Function " : "Block in ") + (function.getIdent() == null ? "<anonymous>" : function.getIdent().getName()));
     }

     private void initArguments(final FunctionNode function) {
         method.loadCompilerConstant(VARARGS);
         if (function.needsCallee()) {
             method.loadCompilerConstant(CALLEE);
         } else {
             // If function is strict mode, "arguments.callee" is not populated, so we don't necessarily need the
             // caller.
             assert function.isStrict();
             method.loadNull();
         }
         method.load(function.getParameters().size());
         globalAllocateArguments();
         method.storeCompilerConstant(ARGUMENTS);
     }

     @Override
     public boolean enterFunctionNode(final FunctionNode functionNode) {
         if (functionNode.isLazy()) {
             // Must do it now; can't postpone it until leaveFunctionNode()
             newFunctionObject(functionNode, functionNode);
             return false;
         }

         final String fnName = functionNode.getName();
         // NOTE: we only emit the method for a function with the given name once. We can have multiple functions with
         // the same name as a result of inlining finally blocks. However, in the future -- with type specialization,
         // notably -- we might need to check for both name *and* signature. Of course, even that might not be
         // sufficient; the function might have a code dependency on the type of the variables in its enclosing scopes,
         // and the type of such a variable can be different in catch and finally blocks. So, in the future we will have
         // to decide to either generate a unique method for each inlined copy of the function, maybe figure out its
         // exact type closure and deduplicate based on that, or just decide that functions in finally blocks aren't
         // worth it, and generate one method with most generic type closure.
         if(!emittedMethods.contains(fnName)) {
             LOG.info("=== BEGIN ", fnName);

             assert functionNode.getCompileUnit() != null : "no compile unit for " + fnName + " " + Debug.id(functionNode);
             unit = lc.pushCompileUnit(functionNode.getCompileUnit());
             assert lc.hasCompileUnits();

             method = lc.pushMethodEmitter(unit.getClassEmitter().method(functionNode));
             // new method - reset last line number
             lastLineNumber = -1;
             // Mark end for variable tables.
             method.begin();
         }

         return true;
     }

     @Override
     public Node leaveFunctionNode(final FunctionNode functionNode) {
         try {
             if(emittedMethods.add(functionNode.getName())) {
                 method.end(); // wrap up this method
                 unit   = lc.popCompileUnit(functionNode.getCompileUnit());
                 method = lc.popMethodEmitter(method);
                 LOG.info("=== END ", functionNode.getName());
             }

             final FunctionNode newFunctionNode = functionNode.setState(lc, CompilationState.EMITTED);
             newFunctionObject(newFunctionNode, functionNode);
             return newFunctionNode;
         } catch (final Throwable t) {
             Context.printStackTrace(t);
             final VerifyError e = new VerifyError("Code generation bug in \"" + functionNode.getName() + "\": likely stack misaligned: " + t + " " + functionNode.getSource().getName());
             e.initCause(t);
             throw e;
         }
     }

     @Override
     public boolean enterIdentNode(final IdentNode identNode) {
         return false;
     }

     @Override
     public boolean enterIfNode(final IfNode ifNode) {
         lineNumber(ifNode);

         final Expression test = ifNode.getTest();
         final Block pass = ifNode.getPass();
         final Block fail = ifNode.getFail();

         final Label failLabel  = new Label("if_fail");
         final Label afterLabel = fail == null ? failLabel : new Label("if_done");

         new BranchOptimizer(this, method).execute(test, failLabel, false);

         boolean passTerminal = false;
         boolean failTerminal = false;

         pass.accept(this);
         if (!pass.hasTerminalFlags()) {
             method._goto(afterLabel); //don't fallthru to fail block
         } else {
             passTerminal = pass.isTerminal();
         }

         if (fail != null) {
             method.label(failLabel);
             fail.accept(this);
             failTerminal = fail.isTerminal();
         }

         //if if terminates, put the after label there
         if (!passTerminal || !failTerminal) {
             method.label(afterLabel);
         }

         return false;
     }

     @Override
     public boolean enterIndexNode(final IndexNode indexNode) {
         load(indexNode);
         return false;
     }

     private void lineNumber(final Statement statement) {
         lineNumber(statement.getLineNumber());
     }

     private void lineNumber(int lineNumber) {
         if (lineNumber != lastLineNumber) {
             method.lineNumber(lineNumber);
         }
         lastLineNumber = lineNumber;
     }

     /**
      * Load a list of nodes as an array of a specific type
      * The array will contain the visited nodes.
      *
      * @param arrayLiteralNode the array of contents
      * @param arrayType        the type of the array, e.g. ARRAY_NUMBER or ARRAY_OBJECT
      *
      * @return the method generator that was used
      */
     private MethodEmitter loadArray(final ArrayLiteralNode arrayLiteralNode, final ArrayType arrayType) {
         assert arrayType == Type.INT_ARRAY || arrayType == Type.LONG_ARRAY || arrayType == Type.NUMBER_ARRAY || arrayType == Type.OBJECT_ARRAY;

         final Expression[]    nodes    = arrayLiteralNode.getValue();
         final Object          presets  = arrayLiteralNode.getPresets();
         final int[]           postsets = arrayLiteralNode.getPostsets();
         final Class<?>        type     = arrayType.getTypeClass();
         final List<ArrayUnit> units    = arrayLiteralNode.getUnits();

         loadConstant(presets);

         final Type elementType = arrayType.getElementType();

         if (units != null) {
             final MethodEmitter savedMethod     = method;
             final FunctionNode  currentFunction = lc.getCurrentFunction();

             for (final ArrayUnit arrayUnit : units) {
                 unit = lc.pushCompileUnit(arrayUnit.getCompileUnit());

                 final String className = unit.getUnitClassName();
                 final String name      = currentFunction.uniqueName(SPLIT_PREFIX.symbolName());
                 final String signature = methodDescriptor(type, ScriptFunction.class, Object.class, ScriptObject.class, type);

                 final MethodEmitter me = unit.getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature);
                 method = lc.pushMethodEmitter(me);

                 method.setFunctionNode(currentFunction);
                 method.begin();

                 fixScopeSlot(currentFunction);

                 method.load(arrayType, SPLIT_ARRAY_ARG.slot());

                 for (int i = arrayUnit.getLo(); i < arrayUnit.getHi(); i++) {
                     storeElement(nodes, elementType, postsets[i]);
                 }

                 method._return();
                 method.end();
                 method = lc.popMethodEmitter(me);

                 assert method == savedMethod;
                 method.loadCompilerConstant(CALLEE);
                 method.swap();
                 method.loadCompilerConstant(THIS);
                 method.swap();
                 method.loadCompilerConstant(SCOPE);
                 method.swap();
                 method.invokestatic(className, name, signature);

                 unit = lc.popCompileUnit(unit);
             }

             return method;
         }

         for (final int postset : postsets) {
             storeElement(nodes, elementType, postset);
         }

         return method;
     }

     private void storeElement(final Expression[] nodes, final Type elementType, final int index) {
         method.dup();
         method.load(index);

         final Expression element = nodes[index];

         if (element == null) {
             method.loadEmpty(elementType);
         } else {
             load(element, elementType);
         }

         method.arraystore();
     }

     private MethodEmitter loadArgsArray(final List<Expression> args) {
         final Object[] array = new Object[args.size()];
         loadConstant(array);

         for (int i = 0; i < args.size(); i++) {
             method.dup();
             method.load(i);
             load(args.get(i), Type.OBJECT); //has to be upcast to object or we fail
             method.arraystore();
         }

         return method;
     }

     /**
      * Load a constant from the constant array. This is only public to be callable from the objects
      * subpackage. Do not call directly.
      *
      * @param string string to load
      */
     void loadConstant(final String string) {
         final String       unitClassName = unit.getUnitClassName();
         final ClassEmitter classEmitter  = unit.getClassEmitter();
         final int          index         = compiler.getConstantData().add(string);

         method.load(index);
         method.invokestatic(unitClassName, GET_STRING.symbolName(), methodDescriptor(String.class, int.class));
         classEmitter.needGetConstantMethod(String.class);
     }

     /**
      * Load a constant from the constant array. This is only public to be callable from the objects
      * subpackage. Do not call directly.
      *
      * @param object object to load
      */
     void loadConstant(final Object object) {
         final String       unitClassName = unit.getUnitClassName();
         final ClassEmitter classEmitter  = unit.getClassEmitter();
         final int          index         = compiler.getConstantData().add(object);
         final Class<?>     cls           = object.getClass();

         if (cls == PropertyMap.class) {
             method.load(index);
             method.invokestatic(unitClassName, GET_MAP.symbolName(), methodDescriptor(PropertyMap.class, int.class));
             classEmitter.needGetConstantMethod(PropertyMap.class);
         } else if (cls.isArray()) {
             method.load(index);
             final String methodName = ClassEmitter.getArrayMethodName(cls);
             method.invokestatic(unitClassName, methodName, methodDescriptor(cls, int.class));
             classEmitter.needGetConstantMethod(cls);
         } else {
             method.loadConstants().load(index).arrayload();
             if (object instanceof ArrayData) {
                 // avoid cast to non-public ArrayData subclass
                 method.checkcast(ArrayData.class);
                 method.invoke(virtualCallNoLookup(ArrayData.class, "copy", ArrayData.class));
             } else if (cls != Object.class) {
                 method.checkcast(cls);
             }
         }
     }

     // literal values
     private MethodEmitter loadLiteral(final LiteralNode<?> node, final Type type) {
         final Object value = node.getValue();

         if (value == null) {
             method.loadNull();
         } else if (value instanceof Undefined) {
             method.loadUndefined(Type.OBJECT);
         } else if (value instanceof String) {
             final String string = (String)value;

             if (string.length() > (MethodEmitter.LARGE_STRING_THRESHOLD / 3)) { // 3 == max bytes per encoded char
                 loadConstant(string);
             } else {
                 method.load(string);
             }
         } else if (value instanceof RegexToken) {
             loadRegex((RegexToken)value);
         } else if (value instanceof Boolean) {
             method.load((Boolean)value);
         } else if (value instanceof Integer) {
             if(type.isEquivalentTo(Type.NUMBER)) {
                 method.load(((Integer)value).doubleValue());
             } else if(type.isEquivalentTo(Type.LONG)) {
                 method.load(((Integer)value).longValue());
             } else {
                 method.load((Integer)value);
             }
         } else if (value instanceof Long) {
             if(type.isEquivalentTo(Type.NUMBER)) {
                 method.load(((Long)value).doubleValue());
             } else {
                 method.load((Long)value);
             }
         } else if (value instanceof Double) {
             method.load((Double)value);
         } else if (node instanceof ArrayLiteralNode) {
             final ArrayLiteralNode arrayLiteral = (ArrayLiteralNode)node;
             final ArrayType atype = arrayLiteral.getArrayType();
             loadArray(arrayLiteral, atype);
             globalAllocateArray(atype);
         } else {
             assert false : "Unknown literal for " + node.getClass() + " " + value.getClass() + " " + value;
         }

         return method;
     }

     private MethodEmitter loadRegexToken(final RegexToken value) {
         method.load(value.getExpression());
         method.load(value.getOptions());
         return globalNewRegExp();
     }

     private MethodEmitter loadRegex(final RegexToken regexToken) {
         if (regexFieldCount > MAX_REGEX_FIELDS) {
             return loadRegexToken(regexToken);
         }
         // emit field
         final String       regexName    = lc.getCurrentFunction().uniqueName(REGEX_PREFIX.symbolName());
         final ClassEmitter classEmitter = unit.getClassEmitter();

         classEmitter.field(EnumSet.of(PRIVATE, STATIC), regexName, Object.class);
         regexFieldCount++;

         // get field, if null create new regex, finally clone regex object
         method.getStatic(unit.getUnitClassName(), regexName, typeDescriptor(Object.class));
         method.dup();
         final Label cachedLabel = new Label("cached");
         method.ifnonnull(cachedLabel);

         method.pop();
         loadRegexToken(regexToken);
         method.dup();
         method.putStatic(unit.getUnitClassName(), regexName, typeDescriptor(Object.class));

         method.label(cachedLabel);
         globalRegExpCopy();

         return method;
     }

     @Override
     public boolean enterLiteralNode(final LiteralNode<?> literalNode) {
         return enterLiteralNode(literalNode, literalNode.getType());
     }

     private boolean enterLiteralNode(final LiteralNode<?> literalNode, final Type type) {
         assert literalNode.getSymbol() != null : literalNode + " has no symbol";
         loadLiteral(literalNode, type).convert(type).store(literalNode.getSymbol());
         return false;
     }

     @Override
     public boolean enterObjectNode(final ObjectNode objectNode) {
         final List<PropertyNode> elements = objectNode.getElements();

         final List<String>     keys    = new ArrayList<>();
         final List<Symbol>     symbols = new ArrayList<>();
         final List<Expression> values  = new ArrayList<>();

         boolean hasGettersSetters = false;
         Expression protoNode = null;

         for (PropertyNode propertyNode: elements) {
             final Expression   value        = propertyNode.getValue();
             final String       key          = propertyNode.getKeyName();
             final Symbol       symbol       = value == null ? null : propertyNode.getKey().getSymbol();

             if (value == null) {
                 hasGettersSetters = true;
             } else if (key.equals(ScriptObject.PROTO_PROPERTY_NAME)) {
                 protoNode = value;
                 continue;
             }

             keys.add(key);
             symbols.add(symbol);
             values.add(value);
         }

         if (elements.size() > OBJECT_SPILL_THRESHOLD) {
             new SpillObjectCreator(this, keys, symbols, values).makeObject(method);
         } else {
             new FieldObjectCreator<Expression>(this, keys, symbols, values) {
                 @Override
                 protected void loadValue(final Expression node) {
                     load(node);
                 }

                 /**
                  * Ensure that the properties start out as object types so that
                  * we can do putfield initializations instead of dynamicSetIndex
                  * which would be the case to determine initial property type
                  * otherwise.
                  *
                  * Use case, it's very expensive to do a million var x = {a:obj, b:obj}
                  * just to have to invalidate them immediately on initialization
                  *
                  * see NASHORN-594
                  */
                 @Override
                 protected MapCreator newMapCreator(final Class<?> fieldObjectClass) {
                     return new MapCreator(fieldObjectClass, keys, symbols) {
                         @Override
                         protected int getPropertyFlags(final Symbol symbol, final boolean hasArguments) {
                             return super.getPropertyFlags(symbol, hasArguments) | Property.IS_ALWAYS_OBJECT;
                         }
                     };
                 }

             }.makeObject(method);
         }

         method.dup();
         if (protoNode != null) {
             load(protoNode);
             method.invoke(ScriptObject.SET_PROTO_CHECK);
         } else {
             globalObjectPrototype();
             method.invoke(ScriptObject.SET_PROTO);
         }

         if (hasGettersSetters) {
             for (final PropertyNode propertyNode : elements) {
                 final FunctionNode getter       = propertyNode.getGetter();
                 final FunctionNode setter       = propertyNode.getSetter();

                 if (getter == null && setter == null) {
                     continue;
                 }

                 method.dup().loadKey(propertyNode.getKey());

                 if (getter == null) {
                     method.loadNull();
                 } else {
                     getter.accept(this);
                 }

                 if (setter == null) {
                     method.loadNull();
                 } else {
                     setter.accept(this);
                 }

                 method.invoke(ScriptObject.SET_USER_ACCESSORS);
             }
         }

         method.store(objectNode.getSymbol());
         return false;
     }

     @Override
     public boolean enterReturnNode(final ReturnNode returnNode) {
         lineNumber(returnNode);

         method.registerReturn();

         final Type returnType = lc.getCurrentFunction().getReturnType();

         final Expression expression = returnNode.getExpression();
         if (expression != null) {
             load(expression);
         } else {
             method.loadUndefined(returnType);
         }

         method._return(returnType);

         return false;
     }

     private static boolean isNullLiteral(final Node node) {
         return node instanceof LiteralNode<?> && ((LiteralNode<?>) node).isNull();
     }

     private boolean nullCheck(final RuntimeNode runtimeNode, final List<Expression> args, final String signature) {
         final Request request = runtimeNode.getRequest();

         if (!Request.isEQ(request) && !Request.isNE(request)) {
             return false;
         }

         assert args.size() == 2 : "EQ or NE or TYPEOF need two args";

         Expression lhs = args.get(0);
         Expression rhs = args.get(1);

         if (isNullLiteral(lhs)) {
             final Expression tmp = lhs;
             lhs = rhs;
             rhs = tmp;
         }

         // this is a null literal check, so if there is implicit coercion
         // involved like {D}x=null, we will fail - this is very rare
         if (isNullLiteral(rhs) && lhs.getType().isObject()) {
             final Label trueLabel  = new Label("trueLabel");
             final Label falseLabel = new Label("falseLabel");
             final Label endLabel   = new Label("end");

             load(lhs);
             method.dup();
             if (Request.isEQ(request)) {
                 method.ifnull(trueLabel);
             } else if (Request.isNE(request)) {
                 method.ifnonnull(trueLabel);
             } else {
                 assert false : "Invalid request " + request;
             }

             method.label(falseLabel);
             load(rhs);
             method.invokestatic(CompilerConstants.className(ScriptRuntime.class), request.toString(), signature);
             method._goto(endLabel);

             method.label(trueLabel);
             // if NE (not strict) this can be "undefined != null" which is supposed to be false
             if (request == Request.NE) {
                 method.loadUndefined(Type.OBJECT);
                 final Label isUndefined = new Label("isUndefined");
                 final Label afterUndefinedCheck = new Label("afterUndefinedCheck");
                 method.if_acmpeq(isUndefined);
                 // not undefined
                 method.load(true);
                 method._goto(afterUndefinedCheck);
                 method.label(isUndefined);
                 method.load(false);
                 method.label(afterUndefinedCheck);
             } else {
                 method.pop();
                 method.load(true);
             }
             method.label(endLabel);
             method.convert(runtimeNode.getType());
             method.store(runtimeNode.getSymbol());

             return true;
         }

         return false;
     }

     private boolean specializationCheck(final RuntimeNode.Request request, final Expression node, final List<Expression> args) {
         if (!request.canSpecialize()) {
             return false;
         }

         assert args.size() == 2;
         final Type returnType = node.getType();

         load(args.get(0));
         load(args.get(1));

         Request finalRequest = request;

         //if the request is a comparison, i.e. one that can be reversed
         //it keeps its semantic, but make sure that the object comes in
         //last
         final Request reverse = Request.reverse(request);
         if (method.peekType().isObject() && reverse != null) { //rhs is object
             if (!method.peekType(1).isObject()) { //lhs is not object
                 method.swap(); //prefer object as lhs
                 finalRequest = reverse;
             }
         }

         method.dynamicRuntimeCall(
                 new SpecializedRuntimeNode(
                     finalRequest,
                     new Type[] {
                         method.peekType(1),
                         method.peekType()
                     },
                     returnType).getInitialName(),
                 returnType,
                 finalRequest);

         method.convert(node.getType());
         method.store(node.getSymbol());

         return true;
     }

     private static boolean isReducible(final Request request) {
         return Request.isComparison(request) || request == Request.ADD;
     }

     @Override
     public boolean enterRuntimeNode(final RuntimeNode runtimeNode) {
         /*
          * First check if this should be something other than a runtime node
          * AccessSpecializer might have changed the type
          *
          * TODO - remove this - Access Specializer will always know after Attr/Lower
          */
         final List<Expression> args = runtimeNode.getArgs();
         if (runtimeNode.isPrimitive() && !runtimeNode.isFinal() && isReducible(runtimeNode.getRequest())) {
             final Expression lhs = args.get(0);
             assert args.size() > 1 : runtimeNode + " must have two args";
             final Expression rhs = args.get(1);

             final Type   type   = runtimeNode.getType();
             final Symbol symbol = runtimeNode.getSymbol();

             switch (runtimeNode.getRequest()) {
             case EQ:
             case EQ_STRICT:
                 return enterCmp(lhs, rhs, Condition.EQ, type, symbol);
             case NE:
             case NE_STRICT:
                 return enterCmp(lhs, rhs, Condition.NE, type, symbol);
             case LE:
                 return enterCmp(lhs, rhs, Condition.LE, type, symbol);
             case LT:
                 return enterCmp(lhs, rhs, Condition.LT, type, symbol);
             case GE:
                 return enterCmp(lhs, rhs, Condition.GE, type, symbol);
             case GT:
                 return enterCmp(lhs, rhs, Condition.GT, type, symbol);
             case ADD:
                 Type widest = Type.widest(lhs.getType(), rhs.getType());
                 load(lhs, widest);
                 load(rhs, widest);
                 method.add();
                 method.convert(type);
                 method.store(symbol);
                 return false;
             default:
                 // it's ok to send this one on with only primitive arguments, maybe INSTANCEOF(true, true) or similar
                 // assert false : runtimeNode + " has all primitive arguments. This is an inconsistent state";
                 break;
             }
         }

         if (nullCheck(runtimeNode, args, new FunctionSignature(false, false, runtimeNode.getType(), args).toString())) {
            return false;
         }

         if (!runtimeNode.isFinal() && specializationCheck(runtimeNode.getRequest(), runtimeNode, args)) {
            return false;
         }

         for (final Expression arg : args) {
             load(arg, Type.OBJECT);
         }

         method.invokestatic(
             CompilerConstants.className(ScriptRuntime.class),
             runtimeNode.getRequest().toString(),
             new FunctionSignature(
                 false,
                 false,
                 runtimeNode.getType(),
                 args.size()).toString());
         method.convert(runtimeNode.getType());
         method.store(runtimeNode.getSymbol());

         return false;
     }

     @Override
     public boolean enterSplitNode(final SplitNode splitNode) {
         final CompileUnit splitCompileUnit = splitNode.getCompileUnit();

         final FunctionNode fn   = lc.getCurrentFunction();
         final String className  = splitCompileUnit.getUnitClassName();
         final String name       = splitNode.getName();

         final Class<?>   rtype          = fn.getReturnType().getTypeClass();
         final boolean    needsArguments = fn.needsArguments();
         final Class<?>[] ptypes         = needsArguments ?
                 new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class, Object.class} :
                 new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class};

         final MethodEmitter caller = method;
         unit = lc.pushCompileUnit(splitCompileUnit);

         final Call splitCall = staticCallNoLookup(
             className,
             name,
             methodDescriptor(rtype, ptypes));

         final MethodEmitter splitEmitter =
                 splitCompileUnit.getClassEmitter().method(
                         splitNode,
                         name,
                         rtype,
                         ptypes);

         method = lc.pushMethodEmitter(splitEmitter);
         method.setFunctionNode(fn);

         assert fn.needsCallee() : "split function should require callee";
         caller.loadCompilerConstant(CALLEE);
         caller.loadCompilerConstant(THIS);
         caller.loadCompilerConstant(SCOPE);
         if (needsArguments) {
             caller.loadCompilerConstant(ARGUMENTS);
         }
         caller.invoke(splitCall);
         caller.storeCompilerConstant(RETURN);

         method.begin();
         // Copy scope to its target slot as first thing because the original slot could be used by return symbol.
         fixScopeSlot(fn);

         method.loadUndefined(fn.getReturnType());
         method.storeCompilerConstant(RETURN);

         return true;
     }

     private void fixScopeSlot(final FunctionNode functionNode) {
         // TODO hack to move the scope to the expected slot (needed because split methods reuse the same slots as the root method)
         if (functionNode.compilerConstant(SCOPE).getSlot() != SCOPE.slot()) {
             method.load(Type.typeFor(ScriptObject.class), SCOPE.slot());
             method.storeCompilerConstant(SCOPE);
         }
     }

     @Override
     public Node leaveSplitNode(final SplitNode splitNode) {
         assert method instanceof SplitMethodEmitter;
         final boolean     hasReturn = method.hasReturn();
         final List<Label> targets   = method.getExternalTargets();

         try {
             // Wrap up this method.

             method.loadCompilerConstant(RETURN);
             method._return(lc.getCurrentFunction().getReturnType());
             method.end();

             unit   = lc.popCompileUnit(splitNode.getCompileUnit());
             method = lc.popMethodEmitter(method);

         } catch (final Throwable t) {
             Context.printStackTrace(t);
             final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + lc.getCurrentFunction().getSource().getName());
             e.initCause(t);
             throw e;
         }

         // Handle return from split method if there was one.
         final MethodEmitter caller = method;
         final int     targetCount = targets.size();

         //no external jump targets or return in switch node
         if (!hasReturn && targets.isEmpty()) {
             return splitNode;
         }

         caller.loadCompilerConstant(SCOPE);
         caller.checkcast(Scope.class);
         caller.invoke(Scope.GET_SPLIT_STATE);

         final Label breakLabel = new Label("no_split_state");
         // Split state is -1 for no split state, 0 for return, 1..n+1 for break/continue

         //the common case is that we don't need a switch
         if (targetCount == 0) {
             assert hasReturn;
             caller.ifne(breakLabel);
             //has to be zero
             caller.label(new Label("split_return"));
             caller.loadCompilerConstant(RETURN);
             caller._return(lc.getCurrentFunction().getReturnType());
             caller.label(breakLabel);
         } else {
             assert !targets.isEmpty();

             final int     low         = hasReturn ? 0 : 1;
             final int     labelCount  = targetCount + 1 - low;
             final Label[] labels      = new Label[labelCount];

             for (int i = 0; i < labelCount; i++) {
                 labels[i] = new Label(i == 0 ? "split_return" : "split_" + targets.get(i - 1));
             }
             caller.tableswitch(low, targetCount, breakLabel, labels);
             for (int i = low; i <= targetCount; i++) {
                 caller.label(labels[i - low]);
                 if (i == 0) {
                     caller.loadCompilerConstant(RETURN);
                     caller._return(lc.getCurrentFunction().getReturnType());
                 } else {
                     // Clear split state.
                     caller.loadCompilerConstant(SCOPE);
                     caller.checkcast(Scope.class);
                     caller.load(-1);
                     caller.invoke(Scope.SET_SPLIT_STATE);
                     caller.splitAwareGoto(lc, targets.get(i - 1));
                 }
             }
             caller.label(breakLabel);
         }

         // If split has a return and caller is itself a split method it needs to propagate the return.
         if (hasReturn) {
             caller.setHasReturn();
         }

         return splitNode;
     }

     @Override
     public boolean enterSwitchNode(final SwitchNode switchNode) {
         lineNumber(switchNode);

         final Expression     expression  = switchNode.getExpression();
         final Symbol         tag         = switchNode.getTag();
         final boolean        allInteger  = tag.getSymbolType().isInteger();
         final List<CaseNode> cases       = switchNode.getCases();
         final CaseNode       defaultCase = switchNode.getDefaultCase();
         final Label          breakLabel  = switchNode.getBreakLabel();

         Label defaultLabel = breakLabel;
         boolean hasDefault = false;

         if (defaultCase != null) {
             defaultLabel = defaultCase.getEntry();
             hasDefault = true;
         }

         if (cases.isEmpty()) {
             // still evaluate expression for side-effects.
             load(expression).pop();
             method.label(breakLabel);
             return false;
         }

         if (allInteger) {
             // Tree for sorting values.
             final TreeMap<Integer, Label> tree = new TreeMap<>();

             // Build up sorted tree.
             for (final CaseNode caseNode : cases) {
                 final Node test = caseNode.getTest();

                 if (test != null) {
                     final Integer value = (Integer)((LiteralNode<?>)test).getValue();
                     final Label   entry = caseNode.getEntry();

                     // Take first duplicate.
                     if (!(tree.containsKey(value))) {
                         tree.put(value, entry);
                     }
                 }
             }

             // Copy values and labels to arrays.
             final int       size   = tree.size();
             final Integer[] values = tree.keySet().toArray(new Integer[size]);
             final Label[]   labels = tree.values().toArray(new Label[size]);

             // Discern low, high and range.
             final int lo    = values[0];
             final int hi    = values[size - 1];
             final int range = hi - lo + 1;

             // Find an unused value for default.
             int deflt = Integer.MIN_VALUE;
             for (final int value : values) {
                 if (deflt == value) {
                     deflt++;
                 } else if (deflt < value) {
                     break;
                 }
             }

             // Load switch expression.
             load(expression);
             final Type type = expression.getType();

             // If expression not int see if we can convert, if not use deflt to trigger default.
             if (!type.isInteger()) {
                 method.load(deflt);
                 final Class<?> exprClass = type.getTypeClass();
                 method.invoke(staticCallNoLookup(ScriptRuntime.class, "switchTagAsInt", int.class, exprClass.isPrimitive()? exprClass : Object.class, int.class));
             }

             // If reasonable size and not too sparse (80%), use table otherwise use lookup.
             if (range > 0 && range < 4096 && range < (size * 5 / 4)) {
                 final Label[] table = new Label[range];
                 Arrays.fill(table, defaultLabel);

                 for (int i = 0; i < size; i++) {
                     final int value = values[i];
                     table[value - lo] = labels[i];
                 }

                 method.tableswitch(lo, hi, defaultLabel, table);
             } else {
                 final int[] ints = new int[size];
                 for (int i = 0; i < size; i++) {
                     ints[i] = values[i];
                 }

                 method.lookupswitch(defaultLabel, ints, labels);
             }
         } else {
             load(expression, Type.OBJECT);
             method.store(tag);

             for (final CaseNode caseNode : cases) {
                 final Expression test = caseNode.getTest();

                 if (test != null) {
                     method.load(tag);
                     load(test, Type.OBJECT);
                     method.invoke(ScriptRuntime.EQ_STRICT);
                     method.ifne(caseNode.getEntry());
                 }
             }

             method._goto(hasDefault ? defaultLabel : breakLabel);
         }

         for (final CaseNode caseNode : cases) {
             method.label(caseNode.getEntry());
             caseNode.getBody().accept(this);
         }

         if (!switchNode.isTerminal()) {
             method.label(breakLabel);
         }

         return false;
     }

     @Override
     public boolean enterThrowNode(final ThrowNode throwNode) {
         lineNumber(throwNode);

         if (throwNode.isSyntheticRethrow()) {
             //do not wrap whatever this is in an ecma exception, just rethrow it
             load(throwNode.getExpression());
             method.athrow();
             return false;
         }

         method._new(ECMAException.class).dup();

         final Source source     = lc.getCurrentFunction().getSource();

         final Expression expression = throwNode.getExpression();
         final int        position   = throwNode.position();
         final int        line       = throwNode.getLineNumber();
         final int        column     = source.getColumn(position);

         load(expression, Type.OBJECT);

         method.load(source.getName());
         method.load(line);
         method.load(column);
         method.invoke(ECMAException.THROW_INIT);

         method.athrow();

         return false;
     }

     @Override
     public boolean enterTryNode(final TryNode tryNode) {
         lineNumber(tryNode);

         final Block       body        = tryNode.getBody();
         final List<Block> catchBlocks = tryNode.getCatchBlocks();
         final Symbol      symbol      = tryNode.getException();
         final Label       entry       = new Label("try");
         final Label       recovery    = new Label("catch");
         final Label       exit        = tryNode.getExit();
         final Label       skip        = new Label("skip");

         method.label(entry);

         body.accept(this);

         if (!body.hasTerminalFlags()) {
             method._goto(skip);
         }

         method.label(exit);

         method._catch(recovery);
         method.store(symbol);

         for (int i = 0; i < catchBlocks.size(); i++) {
             final Block catchBlock = catchBlocks.get(i);

             //TODO this is very ugly - try not to call enter/leave methods directly
             //better to use the implicit lexical context scoping given by the visitor's
             //accept method.
             lc.push(catchBlock);
             enterBlock(catchBlock);

             final CatchNode  catchNode          = (CatchNode)catchBlocks.get(i).getStatements().get(0);
             final IdentNode  exception          = catchNode.getException();
             final Expression exceptionCondition = catchNode.getExceptionCondition();
             final Block      catchBody          = catchNode.getBody();

             new Store<IdentNode>(exception) {
                 @Override
                 protected void storeNonDiscard() {
                     return;
                 }

                 @Override
                 protected void evaluate() {
                     if (catchNode.isSyntheticRethrow()) {
                         method.load(symbol);
                         return;
                     }
                     /*
                      * If caught object is an instance of ECMAException, then
                      * bind obj.thrown to the script catch var. Or else bind the
                      * caught object itself to the script catch var.
                      */
                     final Label notEcmaException = new Label("no_ecma_exception");
                     method.load(symbol).dup()._instanceof(ECMAException.class).ifeq(notEcmaException);
                     method.checkcast(ECMAException.class); //TODO is this necessary?
                     method.getField(ECMAException.THROWN);
                     method.label(notEcmaException);
                 }
             }.store();

             final Label next;

             if (exceptionCondition != null) {
                 next = new Label("next");
                 load(exceptionCondition, Type.BOOLEAN).ifeq(next);
             } else {
                 next = null;
             }

             catchBody.accept(this);

             if (i + 1 != catchBlocks.size() && !catchBody.hasTerminalFlags()) {
                 method._goto(skip);
             }

             if (next != null) {
                 if (i + 1 == catchBlocks.size()) {
                     // no next catch block - rethrow if condition failed
                     method._goto(skip);
                     method.label(next);
                     method.load(symbol).athrow();
                 } else {
                     method.label(next);
                 }
             }

             leaveBlock(catchBlock);
             lc.pop(catchBlock);
         }

         method.label(skip);
         method._try(entry, exit, recovery, Throwable.class);

         // Finally body is always inlined elsewhere so it doesn't need to be emitted

         return false;
     }

     @Override
     public boolean enterVarNode(final VarNode varNode) {

         final Expression init = varNode.getInit();

         if (init == null) {
             return false;
         }

         lineNumber(varNode);

         final IdentNode identNode = varNode.getName();
         final Symbol identSymbol = identNode.getSymbol();
         assert identSymbol != null : "variable node " + varNode + " requires a name with a symbol";

         assert method != null;

         final boolean needsScope = identSymbol.isScope();
         if (needsScope) {
             method.loadCompilerConstant(SCOPE);
         }

         if (needsScope) {
             load(init);
             int flags = CALLSITE_SCOPE | getCallSiteFlags();
             if (isFastScope(identSymbol)) {
                 storeFastScopeVar(identSymbol, flags);
             } else {
                 method.dynamicSet(identNode.getName(), flags);
             }
         } else {
             load(init, identNode.getType());
             method.store(identSymbol);
         }

         return false;
     }

     @Override
     public boolean enterWhileNode(final WhileNode whileNode) {
         lineNumber(whileNode);

         final Expression test          = whileNode.getTest();
         final Block      body          = whileNode.getBody();
         final Label      breakLabel    = whileNode.getBreakLabel();
         final Label      continueLabel = whileNode.getContinueLabel();
         final Label      loopLabel     = new Label("loop");

         if (!whileNode.isDoWhile()) {
             method._goto(continueLabel);
         }

         method.label(loopLabel);
         body.accept(this);
         if (!whileNode.isTerminal()) {
             method.label(continueLabel);
             new BranchOptimizer(this, method).execute(test, loopLabel, true);
             method.label(breakLabel);
         }

         return false;
     }

     private void closeWith() {
         if (method.hasScope()) {
             method.loadCompilerConstant(SCOPE);
             method.invoke(ScriptRuntime.CLOSE_WITH);
             method.storeCompilerConstant(SCOPE);
         }
     }

     @Override
     public boolean enterWithNode(final WithNode withNode) {
         final Expression expression = withNode.getExpression();
         final Node       body       = withNode.getBody();

         // It is possible to have a "pathological" case where the with block does not reference *any* identifiers. It's
         // pointless, but legal. In that case, if nothing else in the method forced the assignment of a slot to the
         // scope object, its' possible that it won't have a slot assigned. In this case we'll only evaluate expression
         // for its side effect and visit the body, and not bother opening and closing a WithObject.
         final boolean hasScope = method.hasScope();

         final Label tryLabel;
         if (hasScope) {
             tryLabel = new Label("with_try");
             method.label(tryLabel);
             method.loadCompilerConstant(SCOPE);
         } else {
             tryLabel = null;
         }

         load(expression, Type.OBJECT);

         if (hasScope) {
             // Construct a WithObject if we have a scope
             method.invoke(ScriptRuntime.OPEN_WITH);
             method.storeCompilerConstant(SCOPE);
         } else {
             // We just loaded the expression for its side effect and to check
             // for null or undefined value.
             globalCheckObjectCoercible();
         }


         // Always process body
         body.accept(this);

         if (hasScope) {
             // Ensure we always close the WithObject
             final Label endLabel   = new Label("with_end");
             final Label catchLabel = new Label("with_catch");
             final Label exitLabel  = new Label("with_exit");

             if (!body.isTerminal()) {
                 closeWith();
                 method._goto(exitLabel);
             }

             method.label(endLabel);

             method._catch(catchLabel);
             closeWith();
             method.athrow();

             method.label(exitLabel);

             method._try(tryLabel, endLabel, catchLabel);
         }
         return false;
     }

     @Override
     public boolean enterADD(final UnaryNode unaryNode) {
         load(unaryNode.rhs(), unaryNode.getType());
         assert unaryNode.getType().isNumeric();
         method.store(unaryNode.getSymbol());
         return false;
     }

     @Override
     public boolean enterBIT_NOT(final UnaryNode unaryNode) {
         load(unaryNode.rhs(), Type.INT).load(-1).xor().store(unaryNode.getSymbol());
         return false;
     }

     @Override
     public boolean enterDECINC(final UnaryNode unaryNode) {
         final Expression rhs         = unaryNode.rhs();
         final Type       type        = unaryNode.getType();
         final TokenType  tokenType   = unaryNode.tokenType();
         final boolean    isPostfix   = tokenType == TokenType.DECPOSTFIX || tokenType == TokenType.INCPOSTFIX;
         final boolean    isIncrement = tokenType == TokenType.INCPREFIX || tokenType == TokenType.INCPOSTFIX;

         assert !type.isObject();

         new SelfModifyingStore<UnaryNode>(unaryNode, rhs) {

             @Override
             protected void evaluate() {
                 load(rhs, type, true);
                 if (!isPostfix) {
                     if (type.isInteger()) {
                         method.load(isIncrement ? 1 : -1);
                     } else if (type.isLong()) {
                         method.load(isIncrement ? 1L : -1L);
                     } else {
                         method.load(isIncrement ? 1.0 : -1.0);
                     }
                     method.add();
                 }
             }

             @Override
             protected void storeNonDiscard() {
                 super.storeNonDiscard();
                 if (isPostfix) {
                     if (type.isInteger()) {
                         method.load(isIncrement ? 1 : -1);
                     } else if (type.isLong()) {
                         method.load(isIncrement ? 1L : 1L);
                     } else {
                         method.load(isIncrement ? 1.0 : -1.0);
                     }
                     method.add();
                 }
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterDISCARD(final UnaryNode unaryNode) {
         final Expression rhs = unaryNode.rhs();

         lc.pushDiscard(rhs);
         load(rhs);

         if (lc.getCurrentDiscard() == rhs) {
             assert !rhs.isAssignment();
             method.pop();
             lc.popDiscard();
         }

         return false;
     }

     @Override
     public boolean enterNEW(final UnaryNode unaryNode) {
         final CallNode callNode = (CallNode)unaryNode.rhs();
         final List<Expression> args   = callNode.getArgs();

         // Load function reference.
         load(callNode.getFunction(), Type.OBJECT); // must detect type error

         method.dynamicNew(1 + loadArgs(args), getCallSiteFlags());
         method.store(unaryNode.getSymbol());

         return false;
     }

     @Override
     public boolean enterNOT(final UnaryNode unaryNode) {
         final Expression rhs = unaryNode.rhs();

         load(rhs, Type.BOOLEAN);

         final Label trueLabel  = new Label("true");
         final Label afterLabel = new Label("after");

         method.ifne(trueLabel);
         method.load(true);
         method._goto(afterLabel);
         method.label(trueLabel);
         method.load(false);
         method.label(afterLabel);
         method.store(unaryNode.getSymbol());

         return false;
     }

     @Override
     public boolean enterSUB(final UnaryNode unaryNode) {
         assert unaryNode.getType().isNumeric();
         load(unaryNode.rhs(), unaryNode.getType()).neg().store(unaryNode.getSymbol());
         return false;
     }

     @Override
     public boolean enterVOID(final UnaryNode unaryNode) {
         load(unaryNode.rhs()).pop();
         method.loadUndefined(Type.OBJECT);

         return false;
     }

     private void enterNumericAdd(final Expression lhs, final Expression rhs, final Type type, final Symbol symbol) {
         loadBinaryOperands(lhs, rhs, type);
         method.add(); //if the symbol is optimistic, it always needs to be written, not on the stack?
         method.store(symbol);
     }

     @Override
     public boolean enterADD(final BinaryNode binaryNode) {
         final Expression lhs = binaryNode.lhs();
         final Expression rhs = binaryNode.rhs();

         final Type type = binaryNode.getType();
         if (type.isNumeric()) {
             enterNumericAdd(lhs, rhs, type, binaryNode.getSymbol());
         } else {
             loadBinaryOperands(binaryNode);
             method.add();
             method.store(binaryNode.getSymbol());
         }

         return false;
     }

     private boolean enterAND_OR(final BinaryNode binaryNode) {
         final Expression lhs = binaryNode.lhs();
         final Expression rhs = binaryNode.rhs();

         final Label skip = new Label("skip");

         load(lhs, Type.OBJECT).dup().convert(Type.BOOLEAN);

         if (binaryNode.tokenType() == TokenType.AND) {
             method.ifeq(skip);
         } else {
             method.ifne(skip);
         }

         method.pop();
         load(rhs, Type.OBJECT);
         method.label(skip);
         method.store(binaryNode.getSymbol());

         return false;
     }

     @Override
     public boolean enterAND(final BinaryNode binaryNode) {
         return enterAND_OR(binaryNode);
     }

     @Override
     public boolean enterASSIGN(final BinaryNode binaryNode) {
         final Expression lhs = binaryNode.lhs();
         final Expression rhs = binaryNode.rhs();

         final Type lhsType = lhs.getType();
         final Type rhsType = rhs.getType();

         if (!lhsType.isEquivalentTo(rhsType)) {
             //this is OK if scoped, only locals are wrong
         }

         new Store<BinaryNode>(binaryNode, lhs) {
             @Override
             protected void evaluate() {
                 if ((lhs instanceof IdentNode) && !lhs.getSymbol().isScope()) {
                     load(rhs, lhsType);
                 } else {
                     load(rhs);
                 }
             }
         }.store();

         return false;
     }

     /**
      * Helper class for assignment ops, e.g. *=, += and so on..
      */
     private abstract class AssignOp extends SelfModifyingStore<BinaryNode> {

         /** The type of the resulting operation */
         private final Type opType;

         /**
          * Constructor
          *
          * @param node the assign op node
          */
         AssignOp(final BinaryNode node) {
             this(node.getType(), node);
         }

         /**
          * Constructor
          *
          * @param opType type of the computation - overriding the type of the node
          * @param node the assign op node
          */
         AssignOp(final Type opType, final BinaryNode node) {
             super(node, node.lhs());
             this.opType = opType;
         }

         protected abstract void op();

         @Override
         protected void evaluate() {
             loadBinaryOperands(assignNode.lhs(), assignNode.rhs(), opType, true);
             op();
             method.convert(assignNode.getType());
         }
     }

     @Override
     public boolean enterASSIGN_ADD(final BinaryNode binaryNode) {
         assert RuntimeNode.Request.ADD.canSpecialize();
         final Type lhsType = binaryNode.lhs().getType();
         final Type rhsType = binaryNode.rhs().getType();
         final boolean specialize = binaryNode.getType() == Type.OBJECT;

         new AssignOp(binaryNode) {

             @Override
             protected void op() {
                 if (specialize) {
                     method.dynamicRuntimeCall(
                             new SpecializedRuntimeNode(
                                 Request.ADD,
                                 new Type[] {
                                     lhsType,
                                     rhsType,
                                 },
                                 Type.OBJECT).getInitialName(),
                             Type.OBJECT,
                             Request.ADD);
                 } else {
                     method.add();
                 }
             }

             @Override
             protected void evaluate() {
                 super.evaluate();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
         new AssignOp(Type.INT, binaryNode) {
             @Override
             protected void op() {
                 method.and();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
         new AssignOp(Type.INT, binaryNode) {
             @Override
             protected void op() {
                 method.or();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
         new AssignOp(Type.INT, binaryNode) {
             @Override
             protected void op() {
                 method.xor();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_DIV(final BinaryNode binaryNode) {
         new AssignOp(binaryNode) {
             @Override
             protected void op() {
                 method.div();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_MOD(final BinaryNode binaryNode) {
         new AssignOp(binaryNode) {
             @Override
             protected void op() {
                 method.rem();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_MUL(final BinaryNode binaryNode) {
         new AssignOp(binaryNode) {
             @Override
             protected void op() {
                 method.mul();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_SAR(final BinaryNode binaryNode) {
         new AssignOp(Type.INT, binaryNode) {
             @Override
             protected void op() {
                 method.sar();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_SHL(final BinaryNode binaryNode) {
         new AssignOp(Type.INT, binaryNode) {
             @Override
             protected void op() {
                 method.shl();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_SHR(final BinaryNode binaryNode) {
         new AssignOp(Type.INT, binaryNode) {
             @Override
             protected void op() {
                 method.shr();
                 method.convert(Type.LONG).load(JSType.MAX_UINT).and();
             }
         }.store();

         return false;
     }

     @Override
     public boolean enterASSIGN_SUB(final BinaryNode binaryNode) {
         new AssignOp(binaryNode) {
             @Override
             protected void op() {
                 method.sub();
             }
         }.store();

         return false;
     }

     /**
      * Helper class for binary arithmetic ops
      */
     private abstract class BinaryArith {

         protected abstract void op();

         protected void evaluate(final BinaryNode node) {
             loadBinaryOperands(node);
             op();
             method.store(node.getSymbol());
         }
     }

     @Override
     public boolean enterBIT_AND(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.and();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterBIT_OR(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.or();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterBIT_XOR(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.xor();
             }
         }.evaluate(binaryNode);

         return false;
     }

     private boolean enterComma(final BinaryNode binaryNode) {
         final Expression lhs = binaryNode.lhs();
         final Expression rhs = binaryNode.rhs();

         load(lhs);
         load(rhs);
         method.store(binaryNode.getSymbol());

         return false;
     }

     @Override
     public boolean enterCOMMARIGHT(final BinaryNode binaryNode) {
         return enterComma(binaryNode);
     }

     @Override
     public boolean enterCOMMALEFT(final BinaryNode binaryNode) {
         return enterComma(binaryNode);
     }

     @Override
     public boolean enterDIV(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.div();
             }
         }.evaluate(binaryNode);

         return false;
     }

     private boolean enterCmp(final Expression lhs, final Expression rhs, final Condition cond, final Type type, final Symbol symbol) {
         final Type lhsType = lhs.getType();
         final Type rhsType = rhs.getType();

         final Type widest = Type.widest(lhsType, rhsType);
         assert widest.isNumeric() || widest.isBoolean() : widest;

         loadBinaryOperands(lhs, rhs, widest);
         final Label trueLabel  = new Label("trueLabel");
         final Label afterLabel = new Label("skip");

         method.conditionalJump(cond, trueLabel);

         method.load(Boolean.FALSE);
         method._goto(afterLabel);
         method.label(trueLabel);
         method.load(Boolean.TRUE);
         method.label(afterLabel);

         method.convert(type);
         method.store(symbol);

         return false;
     }

     private boolean enterCmp(final BinaryNode binaryNode, final Condition cond) {
         return enterCmp(binaryNode.lhs(), binaryNode.rhs(), cond, binaryNode.getType(), binaryNode.getSymbol());
     }

     @Override
     public boolean enterEQ(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.EQ);
     }

     @Override
     public boolean enterEQ_STRICT(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.EQ);
     }

     @Override
     public boolean enterGE(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.GE);
     }

     @Override
     public boolean enterGT(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.GT);
     }

     @Override
     public boolean enterLE(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.LE);
     }

     @Override
     public boolean enterLT(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.LT);
     }

     @Override
     public boolean enterMOD(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.rem();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterMUL(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.mul();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterNE(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.NE);
     }

     @Override
     public boolean enterNE_STRICT(final BinaryNode binaryNode) {
         return enterCmp(binaryNode, Condition.NE);
     }

     @Override
     public boolean enterOR(final BinaryNode binaryNode) {
         return enterAND_OR(binaryNode);
     }

     @Override
     public boolean enterSAR(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.sar();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterSHL(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.shl();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterSHR(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void evaluate(final BinaryNode node) {
                 loadBinaryOperands(node.lhs(), node.rhs(), Type.INT);
                 op();
                 method.store(node.getSymbol());
             }
             @Override
             protected void op() {
                 method.shr();
                 method.convert(Type.LONG).load(JSType.MAX_UINT).and();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterSUB(final BinaryNode binaryNode) {
         new BinaryArith() {
             @Override
             protected void op() {
                 method.sub();
             }
         }.evaluate(binaryNode);

         return false;
     }

     @Override
     public boolean enterTernaryNode(final TernaryNode ternaryNode) {
         final Expression test      = ternaryNode.getTest();
         final Expression trueExpr  = ternaryNode.getTrueExpression();
         final Expression falseExpr = ternaryNode.getFalseExpression();

         final Symbol symbol     = ternaryNode.getSymbol();
         final Label  falseLabel = new Label("ternary_false");
         final Label  exitLabel  = new Label("ternary_exit");

         Type widest = Type.widest(ternaryNode.getType(), Type.widest(trueExpr.getType(), falseExpr.getType()));
         if (trueExpr.getType().isArray() || falseExpr.getType().isArray()) { //loadArray creates a Java array type on the stack, calls global allocate, which creates a native array type
             widest = Type.OBJECT;
         }

         load(test, Type.BOOLEAN);
         // we still keep the conversion here as the AccessSpecializer can have separated the types, e.g. var y = x ? x=55 : 17
         // will left as (Object)x=55 : (Object)17 by Lower. Then the first term can be {I}x=55 of type int, which breaks the
         // symmetry for the temporary slot for this TernaryNode. This is evidence that we assign types and explicit conversions
         // too early, or Apply the AccessSpecializer too late. We are mostly probably looking for a separate type pass to
         // do this property. Then we never need any conversions in CodeGenerator
         method.ifeq(falseLabel);
         load(trueExpr, widest);
         method._goto(exitLabel);
         method.label(falseLabel);
         load(falseExpr, widest);
         method.label(exitLabel);
         method.store(symbol);

         return false;
     }

     /**
      * Generate all shared scope calls generated during codegen.
      */
     protected void generateScopeCalls() {
         for (final SharedScopeCall scopeAccess : lc.getScopeCalls()) {
             scopeAccess.generateScopeCall();
         }
     }

     /**
      * Debug code used to print symbols
      *
      * @param block the block we are in
      * @param ident identifier for block or function where applicable
      */
     @SuppressWarnings("resource")
     private void printSymbols(final Block block, final String ident) {
         if (!compiler.getEnv()._print_symbols) {
             return;
         }

         final PrintWriter out = compiler.getEnv().getErr();
         out.println("[BLOCK in '" + ident + "']");
         if (!block.printSymbols(out)) {
             out.println("<no symbols>");
         }
         out.println();
     }


     /**
      * The difference between a store and a self modifying store is that
      * the latter may load part of the target on the stack, e.g. the base
      * of an AccessNode or the base and index of an IndexNode. These are used
      * both as target and as an extra source. Previously it was problematic
      * for self modifying stores if the target/lhs didn't belong to one
      * of three trivial categories: IdentNode, AcessNodes, IndexNodes. In that
      * case it was evaluated and tagged as "resolved", which meant at the second
      * time the lhs of this store was read (e.g. in a = a (second) + b for a += b,
      * it would be evaluated to a nop in the scope and cause stack underflow
      *
      * see NASHORN-703
      *
      * @param <T>
      */
     private abstract class SelfModifyingStore<T extends Expression> extends Store<T> {
         protected SelfModifyingStore(final T assignNode, final Expression target) {
             super(assignNode, target);
         }

         @Override
         protected boolean isSelfModifying() {
             return true;
         }
     }

     /**
      * Helper class to generate stores
      */
     private abstract class Store<T extends Expression> {

         /** An assignment node, e.g. x += y */
         protected final T assignNode;

         /** The target node to store to, e.g. x */
         private final Expression target;

         /** How deep on the stack do the arguments go if this generates an indy call */
         private int depth;

         /** If we have too many arguments, we need temporary storage, this is stored in 'quick' */
         private Symbol quick;

         /**
          * Constructor
          *
          * @param assignNode the node representing the whole assignment
          * @param target     the target node of the assignment (destination)
          */
         protected Store(final T assignNode, final Expression target) {
             this.assignNode = assignNode;
             this.target = target;
         }

         /**
          * Constructor
          *
          * @param assignNode the node representing the whole assignment
          */
         protected Store(final T assignNode) {
             this(assignNode, assignNode);
         }

         /**
          * Is this a self modifying store operation, e.g. *= or ++
          * @return true if self modifying store
          */
         protected boolean isSelfModifying() {
             return false;
         }

         private void prologue() {
             final Symbol targetSymbol = target.getSymbol();
             final Symbol scopeSymbol  = lc.getCurrentFunction().compilerConstant(SCOPE);

             /**
              * This loads the parts of the target, e.g base and index. they are kept
              * on the stack throughout the store and used at the end to execute it
              */

             target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
                 @Override
                 public boolean enterIdentNode(final IdentNode node) {
                     if (targetSymbol.isScope()) {
                         method.load(scopeSymbol);
                         depth++;
                     }
                     return false;
                 }

                 private void enterBaseNode() {
                     assert target instanceof BaseNode : "error - base node " + target + " must be instanceof BaseNode";
                     final BaseNode   baseNode = (BaseNode)target;
                     final Expression base     = baseNode.getBase();

                     load(base, Type.OBJECT);
                     depth += Type.OBJECT.getSlots();

                     if (isSelfModifying()) {
                         method.dup();
                     }
                 }

                 @Override
                 public boolean enterAccessNode(final AccessNode node) {
                     enterBaseNode();
                     return false;
                 }

                 @Override
                 public boolean enterIndexNode(final IndexNode node) {
                     enterBaseNode();

                     final Expression index = node.getIndex();
                     if (!index.getType().isNumeric()) {
                         // could be boolean here as well
                         load(index, Type.OBJECT);
                     } else {
                         load(index);
                     }
                     depth += index.getType().getSlots();

                     if (isSelfModifying()) {
                         //convert "base base index" to "base index base index"
                         method.dup(1);
                     }

                     return false;
                 }

             });
         }

         private Symbol quickSymbol(final Type type) {
             return quickSymbol(type, QUICK_PREFIX.symbolName());
         }

         /**
          * Quick symbol generates an extra local variable, always using the same
          * slot, one that is available after the end of the frame.
          *
          * @param type the type of the symbol
          * @param prefix the prefix for the variable name for the symbol
          *
          * @return the quick symbol
          */
         private Symbol quickSymbol(final Type type, final String prefix) {
             final String name = lc.getCurrentFunction().uniqueName(prefix);
             final Symbol symbol = new Symbol(name, IS_TEMP | IS_INTERNAL);

             symbol.setType(type);

             symbol.setSlot(lc.quickSlot(symbol));

             return symbol;
         }

         // store the result that "lives on" after the op, e.g. "i" in i++ postfix.
         protected void storeNonDiscard() {
             if (lc.getCurrentDiscard() == assignNode) {
                 assert assignNode.isAssignment();
                 lc.popDiscard();
                 return;
             }

             final Symbol symbol = assignNode.getSymbol();
             if (symbol.hasSlot()) {
                 method.dup().store(symbol);
                 return;
             }

             if (method.dup(depth) == null) {
                 method.dup();
                 this.quick = quickSymbol(method.peekType());
                 method.store(quick);
             }
         }

         private void epilogue() {
             /**
              * Take the original target args from the stack and use them
              * together with the value to be stored to emit the store code
              *
              * The case that targetSymbol is in scope (!hasSlot) and we actually
              * need to do a conversion on non-equivalent types exists, but is
              * very rare. See for example test/script/basic/access-specializer.js
              */
             target.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
                 @Override
                 protected boolean enterDefault(Node node) {
                     throw new AssertionError("Unexpected node " + node + " in store epilogue");
                 }

                 @Override
                 public boolean enterIdentNode(final IdentNode node) {
                     final Symbol symbol = node.getSymbol();
                     assert symbol != null;
                     if (symbol.isScope()) {
                         if (isFastScope(symbol)) {
                             storeFastScopeVar(symbol, CALLSITE_SCOPE | getCallSiteFlags());
                         } else {
                             method.dynamicSet(node.getName(), CALLSITE_SCOPE | getCallSiteFlags());
                         }
                     } else {
                         method.convert(node.getType());
                         method.store(symbol);
                     }
                     return false;

                 }

                 @Override
                 public boolean enterAccessNode(final AccessNode node) {
                     method.dynamicSet(node.getProperty().getName(), getCallSiteFlags());
                     return false;
                 }

                 @Override
                 public boolean enterIndexNode(final IndexNode node) {
                     method.dynamicSetIndex(getCallSiteFlags());
                     return false;
                 }
             });


             // whatever is on the stack now is the final answer
         }

         protected abstract void evaluate();

         void store() {
             prologue();
             evaluate(); // leaves an operation of whatever the operationType was on the stack
             storeNonDiscard();
             epilogue();
             if (quick != null) {
                 method.load(quick);
             }
         }
     }

     private void newFunctionObject(final FunctionNode functionNode, final FunctionNode originalFunctionNode) {
         assert lc.peek() == functionNode;
         // We don't emit a ScriptFunction on stack for:
         // 1. the outermost compiled function (as there's no code being generated in its outer context that'd need it
         //    as a callee), and
         // 2. for functions that are immediately called upon definition and they don't need a callee, e.g. (function(){})().
         //    Such immediately-called functions are invoked using INVOKESTATIC (see enterFunctionNode() of the embedded
         //    visitor of enterCallNode() for details), and if they don't need a callee, they don't have it on their
         //    static method's parameter list.
         if (lc.getOutermostFunction() == functionNode ||
                 (!functionNode.needsCallee()) && lc.isFunctionDefinedInCurrentCall(originalFunctionNode)) {
             return;
         }

         // Generate the object class and property map in case this function is ever used as constructor
         final String      className          = SCRIPTFUNCTION_IMPL_OBJECT;
         final int         fieldCount         = ObjectClassGenerator.getPaddedFieldCount(functionNode.countThisProperties());
         final String      allocatorClassName = Compiler.binaryName(ObjectClassGenerator.getClassName(fieldCount));
         final PropertyMap allocatorMap       = PropertyMap.newMap(null, 0, fieldCount, 0);

         method._new(className).dup();
         loadConstant(new RecompilableScriptFunctionData(functionNode, compiler.getCodeInstaller(), allocatorClassName, allocatorMap));

         if (functionNode.isLazy() || functionNode.needsParentScope()) {
             method.loadCompilerConstant(SCOPE);
         } else {
             method.loadNull();
         }
         method.invoke(constructorNoLookup(className, RecompilableScriptFunctionData.class, ScriptObject.class));
     }

     // calls on Global class.
     private MethodEmitter globalInstance() {
         return method.invokestatic(GLOBAL_OBJECT, "instance", "()L" + GLOBAL_OBJECT + ';');
     }

     private MethodEmitter globalObjectPrototype() {
         return method.invokestatic(GLOBAL_OBJECT, "objectPrototype", methodDescriptor(ScriptObject.class));
     }

     private MethodEmitter globalAllocateArguments() {
         return method.invokestatic(GLOBAL_OBJECT, "allocateArguments", methodDescriptor(ScriptObject.class, Object[].class, Object.class, int.class));
     }

     private MethodEmitter globalNewRegExp() {
         return method.invokestatic(GLOBAL_OBJECT, "newRegExp", methodDescriptor(Object.class, String.class, String.class));
     }

     private MethodEmitter globalRegExpCopy() {
         return method.invokestatic(GLOBAL_OBJECT, "regExpCopy", methodDescriptor(Object.class, Object.class));
     }

     private MethodEmitter globalAllocateArray(final ArrayType type) {
         //make sure the native array is treated as an array type
         return method.invokestatic(GLOBAL_OBJECT, "allocate", "(" + type.getDescriptor() + ")Ljdk/nashorn/internal/objects/NativeArray;");
     }

     private MethodEmitter globalIsEval() {
         return method.invokestatic(GLOBAL_OBJECT, "isEval", methodDescriptor(boolean.class, Object.class));
     }

     private MethodEmitter globalCheckObjectCoercible() {
         return method.invokestatic(GLOBAL_OBJECT, "checkObjectCoercible", methodDescriptor(void.class, Object.class));
     }

     private MethodEmitter globalDirectEval() {
         return method.invokestatic(GLOBAL_OBJECT, "directEval",
                 methodDescriptor(Object.class, Object.class, Object.class, Object.class, Object.class, Object.class));
     }
 }