Mercurial > jdk8-mips64-public > nashorn / changeset

     1.1 --- a/bin/verbose_octane.sh	Fri Apr 19 18:23:00 2013 +0530
     1.2 +++ b/bin/verbose_octane.sh	Fri Apr 19 16:11:16 2013 +0200
     1.3 @@ -26,7 +26,7 @@
     1.4      ITERS=7
     1.5  fi
     1.6  NASHORN_JAR=dist/nashorn.jar
     1.7 -JVM_FLAGS="-XX:+UnlockDiagnosticVMOptions -Dnashorn.unstable.relink.threshold=8 -Xms2G -Xmx2G -XX:+TieredCompilation -server -jar ${NASHORN_JAR}"
     1.8 +JVM_FLAGS="-Djava.ext.dirs=`dirname $0`/../dist:$JAVA_HOME/jre/lib/ext -XX:+UnlockDiagnosticVMOptions -Dnashorn.unstable.relink.threshold=8 -Xms2G -Xmx2G -XX:+TieredCompilation -server -jar ${NASHORN_JAR}"
     1.9  JVM_FLAGS7="-Xbootclasspath/p:${NASHORN_JAR} ${JVM_FLAGS}"
    1.10  OCTANE_ARGS="--verbose --iterations ${ITERS}"
    1.11  

     2.1 --- a/src/jdk/nashorn/api/scripting/NashornScriptEngine.java	Fri Apr 19 18:23:00 2013 +0530
     2.2 +++ b/src/jdk/nashorn/api/scripting/NashornScriptEngine.java	Fri Apr 19 16:11:16 2013 +0200
     2.3 @@ -397,10 +397,7 @@
     2.4              }
     2.5  
     2.6              setContextVariables(ctxt);
     2.7 -            final Object val = ctxt.getAttribute(ScriptEngine.FILENAME);
     2.8 -            final String fileName = (val != null) ? val.toString() : "<eval>";
     2.9 -            Object res = ScriptRuntime.apply(script, ctxtGlobal);
    2.10 -            return ScriptObjectMirror.translateUndefined(ScriptObjectMirror.wrap(res, ctxtGlobal));
    2.11 +            return ScriptObjectMirror.translateUndefined(ScriptObjectMirror.wrap(ScriptRuntime.apply(script, ctxtGlobal), ctxtGlobal));
    2.12          } catch (final Exception e) {
    2.13              throwAsScriptException(e);
    2.14              throw new AssertionError("should not reach here");

     3.1 --- a/src/jdk/nashorn/internal/codegen/Attr.java	Fri Apr 19 18:23:00 2013 +0530
     3.2 +++ b/src/jdk/nashorn/internal/codegen/Attr.java	Fri Apr 19 16:11:16 2013 +0200
     3.3 @@ -25,14 +25,16 @@
     3.4  
     3.5  package jdk.nashorn.internal.codegen;
     3.6  
     3.7 +import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS;
     3.8  import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE;
     3.9  import static jdk.nashorn.internal.codegen.CompilerConstants.EXCEPTION_PREFIX;
    3.10  import static jdk.nashorn.internal.codegen.CompilerConstants.ITERATOR_PREFIX;
    3.11 +import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;
    3.12  import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
    3.13 -import static jdk.nashorn.internal.codegen.CompilerConstants.SCRIPT_RETURN;
    3.14  import static jdk.nashorn.internal.codegen.CompilerConstants.SWITCH_TAG_PREFIX;
    3.15  import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
    3.16  import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
    3.17 +import static jdk.nashorn.internal.ir.Symbol.IS_FUNCTION_SELF;
    3.18  import static jdk.nashorn.internal.ir.Symbol.IS_GLOBAL;
    3.19  import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;
    3.20  import static jdk.nashorn.internal.ir.Symbol.IS_LET;
    3.21 @@ -42,18 +44,20 @@
    3.22  import static jdk.nashorn.internal.ir.Symbol.IS_VAR;
    3.23  import static jdk.nashorn.internal.ir.Symbol.KINDMASK;
    3.24  
    3.25 +import java.util.ArrayDeque;
    3.26  import java.util.ArrayList;
    3.27 +import java.util.Deque;
    3.28  import java.util.HashSet;
    3.29 +import java.util.IdentityHashMap;
    3.30  import java.util.Iterator;
    3.31  import java.util.List;
    3.32 -import java.util.ListIterator;
    3.33 +import java.util.Map;
    3.34  import java.util.Set;
    3.35  import jdk.nashorn.internal.codegen.types.Type;
    3.36  import jdk.nashorn.internal.ir.AccessNode;
    3.37  import jdk.nashorn.internal.ir.BinaryNode;
    3.38  import jdk.nashorn.internal.ir.Block;
    3.39  import jdk.nashorn.internal.ir.CallNode;
    3.40 -import jdk.nashorn.internal.ir.CallNode.EvalArgs;
    3.41  import jdk.nashorn.internal.ir.CaseNode;
    3.42  import jdk.nashorn.internal.ir.CatchNode;
    3.43  import jdk.nashorn.internal.ir.ForNode;
    3.44 @@ -62,6 +66,7 @@
    3.45  import jdk.nashorn.internal.ir.IdentNode;
    3.46  import jdk.nashorn.internal.ir.IndexNode;
    3.47  import jdk.nashorn.internal.ir.LexicalContext;
    3.48 +import jdk.nashorn.internal.ir.LexicalContextNode;
    3.49  import jdk.nashorn.internal.ir.LiteralNode;
    3.50  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
    3.51  import jdk.nashorn.internal.ir.Node;
    3.52 @@ -86,7 +91,6 @@
    3.53  import jdk.nashorn.internal.runtime.JSType;
    3.54  import jdk.nashorn.internal.runtime.Property;
    3.55  import jdk.nashorn.internal.runtime.PropertyMap;
    3.56 -import jdk.nashorn.internal.runtime.ScriptFunction;
    3.57  import jdk.nashorn.internal.runtime.ScriptObject;
    3.58  
    3.59  /**
    3.60 @@ -105,21 +109,24 @@
    3.61   */
    3.62  
    3.63  final class Attr extends NodeOperatorVisitor {
    3.64 +
    3.65      /**
    3.66       * Local definitions in current block (to discriminate from function
    3.67       * declarations always defined in the function scope. This is for
    3.68       * "can be undefined" analysis.
    3.69       */
    3.70 -    private Set<String> localDefs;
    3.71 +    private final Deque<Set<String>> localDefs;
    3.72  
    3.73      /**
    3.74       * Local definitions in current block to guard against cases like
    3.75       * NASHORN-467 when things can be undefined as they are used before
    3.76       * their local var definition. *sigh* JavaScript...
    3.77       */
    3.78 -    private Set<String> localUses;
    3.79 +    private final Deque<Set<String>> localUses;
    3.80  
    3.81 -    private final LexicalContext lexicalContext = new LexicalContext();
    3.82 +    private final Deque<Type> returnTypes;
    3.83 +
    3.84 +    private final Map<Symbol, FunctionNode> selfSymbolToFunction = new IdentityHashMap<>();
    3.85  
    3.86      private static final DebugLogger LOG   = new DebugLogger("attr");
    3.87      private static final boolean     DEBUG = LOG.isEnabled();
    3.88 @@ -128,10 +135,13 @@
    3.89       * Constructor.
    3.90       */
    3.91      Attr() {
    3.92 +        localDefs = new ArrayDeque<>();
    3.93 +        localUses = new ArrayDeque<>();
    3.94 +        returnTypes = new ArrayDeque<>();
    3.95      }
    3.96  
    3.97      @Override
    3.98 -    protected Node enterDefault(final Node node) {
    3.99 +    protected boolean enterDefault(final Node node) {
   3.100          return start(node);
   3.101      }
   3.102  
   3.103 @@ -142,217 +152,44 @@
   3.104  
   3.105      @Override
   3.106      public Node leaveAccessNode(final AccessNode accessNode) {
   3.107 -        newTemporary(Type.OBJECT, accessNode);  //While Object type is assigned here, Access Specialization in FinalizeTypes may narrow this
   3.108 +        ensureSymbol(Type.OBJECT, accessNode);  //While Object type is assigned here, Access Specialization in FinalizeTypes may narrow this
   3.109          end(accessNode);
   3.110          return accessNode;
   3.111      }
   3.112  
   3.113 -    @Override
   3.114 -    public Node enterBlock(final Block block) {
   3.115 -        lexicalContext.push(block);
   3.116 -        start(block);
   3.117 +    private void enterFunctionBody() {
   3.118  
   3.119 -        final Set<String> savedLocalDefs = localDefs;
   3.120 -        final Set<String> savedLocalUses = localUses;
   3.121 -
   3.122 -        block.setFrame(getCurrentFunctionNode().pushFrame());
   3.123 -
   3.124 -        try {
   3.125 -            // a block starts out by copying the local defs and local uses
   3.126 -            // from the outer level. But we need the copies, as when we
   3.127 -            // leave the block the def and use sets given upon entry must
   3.128 -            // be restored
   3.129 -            localDefs = new HashSet<>(savedLocalDefs);
   3.130 -            localUses = new HashSet<>(savedLocalUses);
   3.131 -
   3.132 -            block.visitStatements(this);
   3.133 -        } finally {
   3.134 -            localDefs = savedLocalDefs;
   3.135 -            localUses = savedLocalUses;
   3.136 -
   3.137 -            getCurrentFunctionNode().popFrame();
   3.138 +        final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
   3.139 +        final Block body = getLexicalContext().getCurrentBlock();
   3.140 +        initCallee(body);
   3.141 +        initThis(body);
   3.142 +        if (functionNode.isVarArg()) {
   3.143 +            initVarArg(body, functionNode.needsArguments());
   3.144          }
   3.145  
   3.146 -        end(block);
   3.147 -
   3.148 -        lexicalContext.pop(block);
   3.149 -        return null;
   3.150 -    }
   3.151 -
   3.152 -    @Override
   3.153 -    public Node enterCallNode(final CallNode callNode) {
   3.154 -        start(callNode);
   3.155 -
   3.156 -        callNode.getFunction().accept(this);
   3.157 -
   3.158 -        final List<Node> acceptedArgs = new ArrayList<>(callNode.getArgs().size());
   3.159 -        for (final Node arg : callNode.getArgs()) {
   3.160 -            LOG.info("Doing call arg " + arg);
   3.161 -            acceptedArgs.add(arg.accept(this));
   3.162 -        }
   3.163 -        callNode.setArgs(acceptedArgs);
   3.164 -
   3.165 -        final EvalArgs evalArgs = callNode.getEvalArgs();
   3.166 -        if (evalArgs != null) {
   3.167 -            evalArgs.setCode(evalArgs.getCode().accept(this));
   3.168 -
   3.169 -            final IdentNode thisNode = new IdentNode(getCurrentFunctionNode().getThisNode());
   3.170 -            assert thisNode.getSymbol() != null; //should copy attributed symbol and that's it
   3.171 -            evalArgs.setThis(thisNode);
   3.172 -        }
   3.173 -
   3.174 -        newTemporary(callNode.getType(), callNode); // access specialization in FinalizeTypes may narrow it further later
   3.175 -
   3.176 -        end(callNode);
   3.177 -
   3.178 -        return null;
   3.179 -    }
   3.180 -
   3.181 -    @Override
   3.182 -    public Node enterCatchNode(final CatchNode catchNode) {
   3.183 -        final IdentNode exception = catchNode.getException();
   3.184 -        final Block     block     = getCurrentBlock();
   3.185 -
   3.186 -        start(catchNode);
   3.187 -
   3.188 -        // define block-local exception variable
   3.189 -        final Symbol def = defineSymbol(block, exception.getName(), IS_VAR | IS_LET, exception);
   3.190 -        newType(def, Type.OBJECT);
   3.191 -        addLocalDef(exception.getName());
   3.192 -
   3.193 -        return catchNode;
   3.194 -    }
   3.195 -
   3.196 -    /**
   3.197 -     * Declare the definition of a new symbol.
   3.198 -     *
   3.199 -     * @param name         Name of symbol.
   3.200 -     * @param symbolFlags  Symbol flags.
   3.201 -     * @param node         Defining Node.
   3.202 -     *
   3.203 -     * @return Symbol for given name or null for redefinition.
   3.204 -     */
   3.205 -    private Symbol defineSymbol(final Block block, final String name, final int symbolFlags, final Node node) {
   3.206 -        int    flags  = symbolFlags;
   3.207 -        Symbol symbol = findSymbol(block, name); // Locate symbol.
   3.208 -
   3.209 -        if ((flags & KINDMASK) == IS_GLOBAL) {
   3.210 -            flags |= IS_SCOPE;
   3.211 -        }
   3.212 -
   3.213 -        final FunctionNode function = lexicalContext.getFunction(block);
   3.214 -        if (symbol != null) {
   3.215 -            // Symbol was already defined. Check if it needs to be redefined.
   3.216 -            if ((flags & KINDMASK) == IS_PARAM) {
   3.217 -                if (!isLocal(function, symbol)) {
   3.218 -                    // Not defined in this function. Create a new definition.
   3.219 -                    symbol = null;
   3.220 -                } else if (symbol.isParam()) {
   3.221 -                    // Duplicate parameter. Null return will force an error.
   3.222 -                    assert false : "duplicate parameter";
   3.223 -                    return null;
   3.224 -                }
   3.225 -            } else if ((flags & KINDMASK) == IS_VAR) {
   3.226 -                if ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET) {
   3.227 -                    assert !((flags & IS_LET) == IS_LET && symbol.getBlock() == block) : "duplicate let variable in block";
   3.228 -                    // Always create a new definition.
   3.229 -                    symbol = null;
   3.230 -                } else {
   3.231 -                    // Not defined in this function. Create a new definition.
   3.232 -                    if (!isLocal(function, symbol) || symbol.less(IS_VAR)) {
   3.233 -                        symbol = null;
   3.234 -                    }
   3.235 -                }
   3.236 -            }
   3.237 -        }
   3.238 -
   3.239 -        if (symbol == null) {
   3.240 -            // If not found, then create a new one.
   3.241 -            Block symbolBlock;
   3.242 -
   3.243 -            // Determine where to create it.
   3.244 -            if ((flags & Symbol.KINDMASK) == IS_VAR && ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET)) {
   3.245 -                symbolBlock = block;
   3.246 -            } else {
   3.247 -                symbolBlock = function;
   3.248 -            }
   3.249 -
   3.250 -            // Create and add to appropriate block.
   3.251 -            symbol = new Symbol(name, flags, node, symbolBlock);
   3.252 -            symbolBlock.putSymbol(name, symbol);
   3.253 -
   3.254 -            if ((flags & Symbol.KINDMASK) != IS_GLOBAL) {
   3.255 -                symbolBlock.getFrame().addSymbol(symbol);
   3.256 -                symbol.setNeedsSlot(true);
   3.257 -            }
   3.258 -        } else if (symbol.less(flags)) {
   3.259 -            symbol.setFlags(flags);
   3.260 -        }
   3.261 -
   3.262 -        if (node != null) {
   3.263 -            node.setSymbol(symbol);
   3.264 -        }
   3.265 -
   3.266 -        return symbol;
   3.267 -    }
   3.268 -
   3.269 -    @Override
   3.270 -    public Node enterFunctionNode(final FunctionNode functionNode) {
   3.271 -        start(functionNode, false);
   3.272 -        if (functionNode.isLazy()) {
   3.273 -            LOG.info("LAZY: " + functionNode.getName() + " => Promoting to OBJECT");
   3.274 -            newTemporary(lexicalContext.getCurrentFunction(), Type.OBJECT, functionNode);
   3.275 -            functionNode.setReturnType(Type.OBJECT);
   3.276 -            end(functionNode);
   3.277 -            return null;
   3.278 -        }
   3.279 -
   3.280 -        lexicalContext.push(functionNode);
   3.281 -
   3.282 -        clearLocalDefs();
   3.283 -        clearLocalUses();
   3.284 -
   3.285 -        functionNode.setFrame(functionNode.pushFrame());
   3.286 -
   3.287 -        initCallee(functionNode);
   3.288 -        initThis(functionNode);
   3.289 -        if (functionNode.isVarArg()) {
   3.290 -            initVarArg(functionNode);
   3.291 -        }
   3.292 -
   3.293 -        initParameters(functionNode);
   3.294 -        initScope(functionNode);
   3.295 -        initReturn(functionNode);
   3.296 -
   3.297 -        // Add all nested declared functions as symbols in this function
   3.298 -        for (final FunctionNode nestedFunction : functionNode.getDeclaredFunctions()) {
   3.299 -            final IdentNode ident = nestedFunction.getIdent();
   3.300 -            if (ident != null) {
   3.301 -                assert nestedFunction.isDeclared();
   3.302 -                final Symbol functionSymbol = defineSymbol(functionNode, ident.getName(), IS_VAR, nestedFunction);
   3.303 -                newType(functionSymbol, Type.typeFor(ScriptFunction.class));
   3.304 -            }
   3.305 -        }
   3.306 +        initParameters(functionNode, body);
   3.307 +        initScope(body);
   3.308 +        initReturn(body);
   3.309  
   3.310          if (functionNode.isProgram()) {
   3.311 -            initFromPropertyMap(functionNode);
   3.312 +            initFromPropertyMap(body);
   3.313          }
   3.314  
   3.315          // Add function name as local symbol
   3.316          if (!functionNode.isDeclared() && !functionNode.isProgram()) {
   3.317 -            if(functionNode.getSymbol() != null) {
   3.318 +            if (functionNode.getSymbol() != null) {
   3.319                  // a temporary left over from an earlier pass when the function was lazy
   3.320                  assert functionNode.getSymbol().isTemp();
   3.321                  // remove it
   3.322                  functionNode.setSymbol(null);
   3.323              }
   3.324              final Symbol selfSymbol;
   3.325 -            if(functionNode.isAnonymous()) {
   3.326 -                selfSymbol = newTemporary(functionNode, Type.OBJECT, functionNode);
   3.327 +            if (functionNode.isAnonymous()) {
   3.328 +                selfSymbol = ensureSymbol(functionNode, Type.OBJECT, functionNode);
   3.329              } else {
   3.330 -                selfSymbol = defineSymbol(functionNode, functionNode.getIdent().getName(), IS_VAR, functionNode);
   3.331 +                selfSymbol = defineSymbol(body, functionNode.getIdent().getName(), IS_VAR | IS_FUNCTION_SELF, functionNode);
   3.332                  newType(selfSymbol, Type.OBJECT);
   3.333 -                selfSymbol.setNode(functionNode);
   3.334 +                selfSymbolToFunction.put(selfSymbol, functionNode);
   3.335              }
   3.336          }
   3.337  
   3.338 @@ -373,73 +210,243 @@
   3.339           * @see NASHORN-73
   3.340           */
   3.341  
   3.342 -        final List<Symbol> declaredSymbols = new ArrayList<>();
   3.343          // This visitor will assign symbol to all declared variables, except function declarations (which are taken care
   3.344          // in a separate step above) and "var" declarations in for loop initializers.
   3.345 -        functionNode.accept(new NodeOperatorVisitor() {
   3.346 +        body.accept(new NodeOperatorVisitor() {
   3.347              @Override
   3.348 -            public Node enterFunctionNode(FunctionNode nestedFn) {
   3.349 -                // Don't descend into nested functions
   3.350 -                return nestedFn == functionNode ? nestedFn : null;
   3.351 +            public boolean enterFunctionNode(final FunctionNode nestedFn) {
   3.352 +                return false;
   3.353              }
   3.354 +
   3.355              @Override
   3.356 -            public Node enterVarNode(VarNode varNode) {
   3.357 -                if(varNode.isStatement() && !varNode.isFunctionDeclaration()) {
   3.358 +            public boolean enterVarNode(final VarNode varNode) {
   3.359 +
   3.360 +                // any declared symbols that aren't visited need to be typed as well, hence the list
   3.361 +
   3.362 +                if (varNode.isStatement()) {
   3.363 +
   3.364                      final IdentNode ident = varNode.getName();
   3.365 -                    // any declared symbols that aren't visited need to be typed as well, hence the list
   3.366 -                    declaredSymbols.add(defineSymbol(functionNode, ident.getName(), IS_VAR, new IdentNode(ident)));
   3.367 +                    final Symbol symbol = defineSymbol(body, ident.getName(), IS_VAR, new IdentNode(ident));
   3.368 +                    functionNode.addDeclaredSymbol(symbol);
   3.369 +                    if (varNode.isFunctionDeclaration()) {
   3.370 +                        newType(symbol, FunctionNode.FUNCTION_TYPE);
   3.371 +                    }
   3.372                  }
   3.373 -                return null;
   3.374 +                return false;
   3.375              }
   3.376          });
   3.377 +    }
   3.378  
   3.379 -        visitFunctionStatements(functionNode);
   3.380 +    @Override
   3.381 +    public boolean enterBlock(final Block block) {
   3.382 +        start(block);
   3.383 +
   3.384 +        if (getLexicalContext().isFunctionBody()) {
   3.385 +            enterFunctionBody();
   3.386 +        }
   3.387 +        pushLocalsBlock();
   3.388 +
   3.389 +        return true;
   3.390 +    }
   3.391 +
   3.392 +    @Override
   3.393 +    public Node leaveBlock(final Block block) {
   3.394 +        popLocals();
   3.395 +        return end(block);
   3.396 +    }
   3.397 +
   3.398 +    @Override
   3.399 +    public Node leaveCallNode(final CallNode callNode) {
   3.400 +        ensureSymbol(callNode.getType(), callNode);
   3.401 +        return end(callNode);
   3.402 +    }
   3.403 +
   3.404 +    @Override
   3.405 +    public boolean enterCallNode(final CallNode callNode) {
   3.406 +        return start(callNode);
   3.407 +    }
   3.408 +
   3.409 +    @Override
   3.410 +    public boolean enterCatchNode(final CatchNode catchNode) {
   3.411 +        final IdentNode exception = catchNode.getException();
   3.412 +        final Block     block     = getLexicalContext().getCurrentBlock();
   3.413 +
   3.414 +        start(catchNode);
   3.415 +
   3.416 +        // define block-local exception variable
   3.417 +        final Symbol def = defineSymbol(block, exception.getName(), IS_VAR | IS_LET, exception);
   3.418 +        newType(def, Type.OBJECT);
   3.419 +        addLocalDef(exception.getName());
   3.420 +
   3.421 +        return true;
   3.422 +    }
   3.423 +
   3.424 +    /**
   3.425 +     * Declare the definition of a new symbol.
   3.426 +     *
   3.427 +     * @param name         Name of symbol.
   3.428 +     * @param symbolFlags  Symbol flags.
   3.429 +     * @param node         Defining Node.
   3.430 +     *
   3.431 +     * @return Symbol for given name or null for redefinition.
   3.432 +     */
   3.433 +    private Symbol defineSymbol(final Block block, final String name, final int symbolFlags, final Node node) {
   3.434 +        int    flags  = symbolFlags;
   3.435 +        Symbol symbol = findSymbol(block, name); // Locate symbol.
   3.436 +
   3.437 +        if ((flags & KINDMASK) == IS_GLOBAL) {
   3.438 +            flags |= IS_SCOPE;
   3.439 +        }
   3.440 +
   3.441 +        final FunctionNode function = getLexicalContext().getFunction(block);
   3.442 +        if (symbol != null) {
   3.443 +            // Symbol was already defined. Check if it needs to be redefined.
   3.444 +            if ((flags & KINDMASK) == IS_PARAM) {
   3.445 +                if (!isLocal(function, symbol)) {
   3.446 +                    // Not defined in this function. Create a new definition.
   3.447 +                    symbol = null;
   3.448 +                } else if (symbol.isParam()) {
   3.449 +                    // Duplicate parameter. Null return will force an error.
   3.450 +                    assert false : "duplicate parameter";
   3.451 +                    return null;
   3.452 +                }
   3.453 +            } else if ((flags & KINDMASK) == IS_VAR) {
   3.454 +                if ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET) {
   3.455 +                    // Always create a new definition.
   3.456 +                    symbol = null;
   3.457 +                } else {
   3.458 +                    // Not defined in this function. Create a new definition.
   3.459 +                    if (!isLocal(function, symbol) || symbol.less(IS_VAR)) {
   3.460 +                        symbol = null;
   3.461 +                    }
   3.462 +                }
   3.463 +            }
   3.464 +        }
   3.465 +
   3.466 +        if (symbol == null) {
   3.467 +            // If not found, then create a new one.
   3.468 +            Block symbolBlock;
   3.469 +
   3.470 +            // Determine where to create it.
   3.471 +            if ((flags & Symbol.KINDMASK) == IS_VAR && ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET)) {
   3.472 +                symbolBlock = block; //internal vars are always defined in the block closest to them
   3.473 +            } else {
   3.474 +                symbolBlock = getLexicalContext().getFunctionBody(function);
   3.475 +            }
   3.476 +
   3.477 +            // Create and add to appropriate block.
   3.478 +            symbol = new Symbol(name, flags);
   3.479 +            symbolBlock.putSymbol(name, symbol);
   3.480 +
   3.481 +            if ((flags & Symbol.KINDMASK) != IS_GLOBAL) {
   3.482 +                symbol.setNeedsSlot(true);
   3.483 +            }
   3.484 +        } else if (symbol.less(flags)) {
   3.485 +            symbol.setFlags(flags);
   3.486 +        }
   3.487 +
   3.488 +        if (node != null) {
   3.489 +            node.setSymbol(symbol);
   3.490 +        }
   3.491 +
   3.492 +        return symbol;
   3.493 +    }
   3.494 +
   3.495 +    @Override
   3.496 +    public boolean enterFunctionNode(final FunctionNode functionNode) {
   3.497 +        start(functionNode, false);
   3.498 +
   3.499 +        if (functionNode.isDeclared()) {
   3.500 +            final Iterator<Block> blocks = getLexicalContext().getBlocks();
   3.501 +            if (blocks.hasNext()) {
   3.502 +                defineSymbol(
   3.503 +                    blocks.next(),
   3.504 +                    functionNode.getIdent().getName(),
   3.505 +                    IS_VAR,
   3.506 +                    functionNode);
   3.507 +            } else {
   3.508 +                // Q: What's an outermost function in a lexical context that is not a program?
   3.509 +                // A: It's a function being compiled lazily!
   3.510 +                assert getLexicalContext().getOutermostFunction() == functionNode && !functionNode.isProgram();
   3.511 +            }
   3.512 +        }
   3.513 +
   3.514 +        if (functionNode.isLazy()) {
   3.515 +            LOG.info("LAZY: ", functionNode.getName(), " => Promoting to OBJECT");
   3.516 +            ensureSymbol(getLexicalContext().getCurrentFunction(), Type.OBJECT, functionNode);
   3.517 +            end(functionNode);
   3.518 +            return false;
   3.519 +        }
   3.520 +
   3.521 +        returnTypes.push(functionNode.getReturnType());
   3.522 +        pushLocalsFunction();
   3.523 +        return true;
   3.524 +    }
   3.525 +
   3.526 +    @Override
   3.527 +    public Node leaveFunctionNode(final FunctionNode functionNode) {
   3.528 +        FunctionNode newFunctionNode = functionNode;
   3.529 +
   3.530 +        final LexicalContext lc = getLexicalContext();
   3.531  
   3.532          //unknown parameters are promoted to object type.
   3.533 -        finalizeParameters(functionNode);
   3.534 -        finalizeTypes(functionNode);
   3.535 -        for (final Symbol symbol : declaredSymbols) {
   3.536 +        finalizeParameters(newFunctionNode);
   3.537 +        finalizeTypes(newFunctionNode);
   3.538 +        for (final Symbol symbol : newFunctionNode.getDeclaredSymbols()) {
   3.539              if (symbol.getSymbolType().isUnknown()) {
   3.540                  symbol.setType(Type.OBJECT);
   3.541                  symbol.setCanBeUndefined();
   3.542              }
   3.543          }
   3.544  
   3.545 -        if (functionNode.getReturnType().isUnknown()) {
   3.546 -            LOG.info("Unknown return type promoted to object");
   3.547 -            functionNode.setReturnType(Type.OBJECT);
   3.548 +        final Block body = newFunctionNode.getBody();
   3.549 +
   3.550 +        if (newFunctionNode.hasLazyChildren()) {
   3.551 +            //the final body has already been assigned as we have left the function node block body by now
   3.552 +            objectifySymbols(body);
   3.553          }
   3.554  
   3.555 -        if (functionNode.getSelfSymbolInit() != null) {
   3.556 -            LOG.info("Accepting self symbol init " + functionNode.getSelfSymbolInit() + " for " + functionNode.getName());
   3.557 -            final Node init = functionNode.getSelfSymbolInit();
   3.558 +        if (body.getFlag(Block.NEEDS_SELF_SYMBOL)) {
   3.559 +            final IdentNode callee = compilerConstant(CALLEE);
   3.560 +            final VarNode selfInit =
   3.561 +                new VarNode(
   3.562 +                    newFunctionNode.getSource(),
   3.563 +                    newFunctionNode.getToken(),
   3.564 +                    newFunctionNode.getFinish(),
   3.565 +                    newFunctionNode.getIdent(),
   3.566 +                    callee);
   3.567 +
   3.568 +            LOG.info("Accepting self symbol init ", selfInit, " for ", newFunctionNode.getName());
   3.569 +
   3.570              final List<Node> newStatements = new ArrayList<>();
   3.571 -            newStatements.add(init);
   3.572 -            newStatements.addAll(functionNode.getStatements());
   3.573 -            functionNode.setStatements(newStatements);
   3.574 -            functionNode.setNeedsSelfSymbol(functionNode.getSelfSymbolInit().accept(this));
   3.575 +            newStatements.add(selfInit);
   3.576 +            assert callee.getSymbol() != null && callee.getSymbol().hasSlot();
   3.577 +
   3.578 +            final IdentNode name       = selfInit.getName();
   3.579 +            final Symbol    nameSymbol = body.getExistingSymbol(name.getName());
   3.580 +
   3.581 +            assert nameSymbol != null;
   3.582 +
   3.583 +            name.setSymbol(nameSymbol);
   3.584 +            selfInit.setSymbol(nameSymbol);
   3.585 +
   3.586 +            newStatements.addAll(body.getStatements());
   3.587 +            newFunctionNode = newFunctionNode.setBody(lc, body.setStatements(lc, newStatements));
   3.588          }
   3.589  
   3.590 -        if (functionNode.hasLazyChildren()) {
   3.591 -            objectifySymbols(functionNode);
   3.592 +        if (returnTypes.peek().isUnknown()) {
   3.593 +            LOG.info("Unknown return type promoted to object");
   3.594 +            newFunctionNode = newFunctionNode.setReturnType(lc, Type.OBJECT);
   3.595          }
   3.596 +        final Type returnType = returnTypes.pop();
   3.597 +        newFunctionNode = newFunctionNode.setReturnType(lc, returnType.isUnknown() ? Type.OBJECT : returnType);
   3.598 +        newFunctionNode = newFunctionNode.setState(lc, CompilationState.ATTR);
   3.599  
   3.600 -        functionNode.popFrame();
   3.601 +        popLocals();
   3.602  
   3.603 -        functionNode.setState(CompilationState.ATTR);
   3.604 +        end(newFunctionNode, false);
   3.605  
   3.606 -        end(functionNode, false);
   3.607 -        lexicalContext.pop(functionNode);
   3.608 -
   3.609 -        return null;
   3.610 -    }
   3.611 -
   3.612 -    private void visitFunctionStatements(final FunctionNode functionNode) {
   3.613 -        final List<Node> newStatements = new ArrayList<>(functionNode.getStatements());
   3.614 -        for(ListIterator<Node> stmts = newStatements.listIterator(); stmts.hasNext();) {
   3.615 -            stmts.set(stmts.next().accept(this));
   3.616 -        }
   3.617 -        functionNode.setStatements(newStatements);
   3.618 +        return newFunctionNode; //.setFlag(lc, lc.getFlags(functionNode));
   3.619      }
   3.620  
   3.621      @Override
   3.622 @@ -450,7 +457,7 @@
   3.623      }
   3.624  
   3.625      @Override
   3.626 -    public Node enterIdentNode(final IdentNode identNode) {
   3.627 +    public boolean enterIdentNode(final IdentNode identNode) {
   3.628          final String name = identNode.getName();
   3.629  
   3.630          start(identNode);
   3.631 @@ -458,31 +465,28 @@
   3.632          if (identNode.isPropertyName()) {
   3.633              // assign a pseudo symbol to property name
   3.634              final Symbol pseudoSymbol = pseudoSymbol(name);
   3.635 -            LOG.info("IdentNode is property name -> assigning pseudo symbol " + pseudoSymbol);
   3.636 +            LOG.info("IdentNode is property name -> assigning pseudo symbol ", pseudoSymbol);
   3.637              LOG.unindent();
   3.638              identNode.setSymbol(pseudoSymbol);
   3.639 -            return null;
   3.640 +            return false;
   3.641          }
   3.642  
   3.643 -        final Block  block     = getCurrentBlock();
   3.644 -        final Symbol oldSymbol = identNode.getSymbol();
   3.645 +        final LexicalContext lc        = getLexicalContext();
   3.646 +        final Block          block     = lc.getCurrentBlock();
   3.647 +        final Symbol         oldSymbol = identNode.getSymbol();
   3.648  
   3.649          Symbol symbol = findSymbol(block, name);
   3.650  
   3.651          //If an existing symbol with the name is found, use that otherwise, declare a new one
   3.652          if (symbol != null) {
   3.653 -            LOG.info("Existing symbol = " + symbol);
   3.654 -            if (isFunctionExpressionSelfReference(symbol)) {
   3.655 -                final FunctionNode functionNode = (FunctionNode)symbol.getNode();
   3.656 -                assert functionNode.getCalleeNode() != null;
   3.657 -
   3.658 -                final VarNode var = new VarNode(functionNode.getSource(), functionNode.getToken(), functionNode.getFinish(), functionNode.getIdent(), functionNode.getCalleeNode());
   3.659 -                //newTemporary(Type.OBJECT, var); //ScriptFunction? TODO
   3.660 -
   3.661 -                functionNode.setNeedsSelfSymbol(var);
   3.662 -            }
   3.663 -
   3.664 -            if (!identNode.isInitializedHere()) { // NASHORN-448
   3.665 +            LOG.info("Existing symbol = ", symbol);
   3.666 +            if (symbol.isFunctionSelf()) {
   3.667 +                final FunctionNode functionNode = lc.getDefiningFunction(symbol);
   3.668 +                assert functionNode != null;
   3.669 +                assert lc.getFunctionBody(functionNode).getExistingSymbol(CALLEE.symbolName()) != null;
   3.670 +                lc.setFlag(functionNode.getBody(), Block.NEEDS_SELF_SYMBOL);
   3.671 +                newType(symbol, FunctionNode.FUNCTION_TYPE);
   3.672 +            } else if (!identNode.isInitializedHere()) { // NASHORN-448
   3.673                  // here is a use outside the local def scope
   3.674                  if (!isLocalDef(name)) {
   3.675                      newType(symbol, Type.OBJECT);
   3.676 @@ -492,25 +496,19 @@
   3.677  
   3.678              identNode.setSymbol(symbol);
   3.679              // non-local: we need to put symbol in scope (if it isn't already)
   3.680 -            if (!isLocal(getCurrentFunctionNode(), symbol) && !symbol.isScope()) {
   3.681 -                symbol.setIsScope();
   3.682 +            if (!isLocal(lc.getCurrentFunction(), symbol) && !symbol.isScope()) {
   3.683 +                Symbol.setSymbolIsScope(lc, symbol);
   3.684              }
   3.685          } else {
   3.686 -            LOG.info("No symbol exists. Declare undefined: " + symbol);
   3.687 -            symbol = useSymbol(block, name, identNode);
   3.688 +            LOG.info("No symbol exists. Declare undefined: ", symbol);
   3.689 +            symbol = defineSymbol(block, name, IS_GLOBAL, identNode);
   3.690              // we have never seen this before, it can be undefined
   3.691              newType(symbol, Type.OBJECT); // TODO unknown -we have explicit casts anyway?
   3.692              symbol.setCanBeUndefined();
   3.693 -            symbol.setIsScope();
   3.694 +            Symbol.setSymbolIsScope(lc, symbol);
   3.695          }
   3.696  
   3.697 -        assert symbol != null;
   3.698 -        if(symbol.isGlobal()) {
   3.699 -            setUsesGlobalSymbol();
   3.700 -        } else if(symbol.isScope()) {
   3.701 -            final Iterator<Block> blocks = lexicalContext.getBlocks();
   3.702 -            blocks.next().setUsesScopeSymbol(symbol, blocks);
   3.703 -        }
   3.704 +        setBlockScope(name, symbol);
   3.705  
   3.706          if (symbol != oldSymbol && !identNode.isInitializedHere()) {
   3.707              symbol.increaseUseCount();
   3.708 @@ -519,7 +517,37 @@
   3.709  
   3.710          end(identNode);
   3.711  
   3.712 -        return null;
   3.713 +        return false;
   3.714 +    }
   3.715 +
   3.716 +    private void setBlockScope(final String name, final Symbol symbol) {
   3.717 +        assert symbol != null;
   3.718 +        if (symbol.isGlobal()) {
   3.719 +            setUsesGlobalSymbol();
   3.720 +            return;
   3.721 +        }
   3.722 +
   3.723 +        if (symbol.isScope()) {
   3.724 +            final LexicalContext lc = getLexicalContext();
   3.725 +
   3.726 +            Block scopeBlock = null;
   3.727 +            for (final Iterator<LexicalContextNode> contextNodeIter = getLexicalContext().getAllNodes(); contextNodeIter.hasNext(); ) {
   3.728 +                final LexicalContextNode node = contextNodeIter.next();
   3.729 +                if (node instanceof Block) {
   3.730 +                    if (((Block)node).getExistingSymbol(name) != null) {
   3.731 +                        scopeBlock = (Block)node;
   3.732 +                        break;
   3.733 +                    }
   3.734 +                } else if (node instanceof FunctionNode) {
   3.735 +                    lc.setFlag(node, FunctionNode.USES_ANCESTOR_SCOPE);
   3.736 +                }
   3.737 +            }
   3.738 +
   3.739 +            if (scopeBlock != null) {
   3.740 +                assert getLexicalContext().contains(scopeBlock);
   3.741 +                lc.setFlag(scopeBlock, Block.NEEDS_SCOPE);
   3.742 +            }
   3.743 +        }
   3.744      }
   3.745  
   3.746      /**
   3.747 @@ -528,35 +556,12 @@
   3.748       * @see #needsParentScope()
   3.749       */
   3.750      private void setUsesGlobalSymbol() {
   3.751 -        for(final Iterator<FunctionNode> fns = lexicalContext.getFunctions(); fns.hasNext();) {
   3.752 -            fns.next().setUsesAncestorScope();
   3.753 +        for (final Iterator<FunctionNode> fns = getLexicalContext().getFunctions(); fns.hasNext();) {
   3.754 +            getLexicalContext().setFlag(fns.next(), FunctionNode.USES_ANCESTOR_SCOPE);
   3.755          }
   3.756      }
   3.757  
   3.758      /**
   3.759 -     * Declare the use of a symbol in a block.
   3.760 -     *
   3.761 -     * @param block block in which the symbol is used
   3.762 -     * @param name Name of symbol.
   3.763 -     * @param node Using node
   3.764 -     *
   3.765 -     * @return Symbol for given name.
   3.766 -     */
   3.767 -    private Symbol useSymbol(final Block block, final String name, final Node node) {
   3.768 -        Symbol symbol = findSymbol(block, name);
   3.769 -
   3.770 -        if (symbol == null) {
   3.771 -            // If not found, declare as a free var.
   3.772 -            symbol = defineSymbol(block, name, IS_GLOBAL, node);
   3.773 -        } else {
   3.774 -            node.setSymbol(symbol);
   3.775 -        }
   3.776 -
   3.777 -        return symbol;
   3.778 -    }
   3.779 -
   3.780 -
   3.781 -    /**
   3.782       * Search for symbol in the lexical context starting from the given block.
   3.783       * @param name Symbol name.
   3.784       * @return Found symbol or null if not found.
   3.785 @@ -564,7 +569,7 @@
   3.786      private Symbol findSymbol(final Block block, final String name) {
   3.787          // Search up block chain to locate symbol.
   3.788  
   3.789 -        for(final Iterator<Block> blocks = lexicalContext.getBlocks(block); blocks.hasNext();) {
   3.790 +        for(final Iterator<Block> blocks = getLexicalContext().getBlocks(block); blocks.hasNext();) {
   3.791              // Find name.
   3.792              final Symbol symbol = blocks.next().getExistingSymbol(name);
   3.793              // If found then we are good.
   3.794 @@ -577,13 +582,13 @@
   3.795  
   3.796      @Override
   3.797      public Node leaveIndexNode(final IndexNode indexNode) {
   3.798 -        newTemporary(Type.OBJECT, indexNode); //TODO
   3.799 +        ensureSymbol(Type.OBJECT, indexNode); //TODO
   3.800          return indexNode;
   3.801      }
   3.802  
   3.803      @SuppressWarnings("rawtypes")
   3.804      @Override
   3.805 -    public Node enterLiteralNode(final LiteralNode literalNode) {
   3.806 +    public boolean enterLiteralNode(final LiteralNode literalNode) {
   3.807          try {
   3.808              start(literalNode);
   3.809              assert !literalNode.isTokenType(TokenType.THIS) : "tokentype for " + literalNode + " is this"; //guard against old dead code case. literal nodes should never inherit tokens
   3.810 @@ -604,26 +609,33 @@
   3.811                  assert !(literalNode.getValue() instanceof Node) : "literals with Node values not supported";
   3.812              }
   3.813  
   3.814 -            getCurrentFunctionNode().newLiteral(literalNode);
   3.815 +            getLexicalContext().getCurrentFunction().newLiteral(literalNode);
   3.816          } finally {
   3.817              end(literalNode);
   3.818          }
   3.819 -        return null;
   3.820 +
   3.821 +        return false;
   3.822 +    }
   3.823 +
   3.824 +    @Override
   3.825 +    public boolean enterObjectNode(final ObjectNode objectNode) {
   3.826 +        return start(objectNode);
   3.827      }
   3.828  
   3.829      @Override
   3.830      public Node leaveObjectNode(final ObjectNode objectNode) {
   3.831 -        newTemporary(Type.OBJECT, objectNode);
   3.832 -        end(objectNode);
   3.833 -        return objectNode;
   3.834 +        ensureSymbol(Type.OBJECT, objectNode);
   3.835 +        return end(objectNode);
   3.836      }
   3.837  
   3.838 +    //TODO is this correct why not leave?
   3.839      @Override
   3.840 -    public Node enterPropertyNode(final PropertyNode propertyNode) {
   3.841 +    public boolean enterPropertyNode(final PropertyNode propertyNode) {
   3.842          // assign a pseudo symbol to property name, see NASHORN-710
   3.843 +        start(propertyNode);
   3.844          propertyNode.setSymbol(new Symbol(propertyNode.getKeyName(), 0, Type.OBJECT));
   3.845          end(propertyNode);
   3.846 -        return propertyNode;
   3.847 +        return true;
   3.848      }
   3.849  
   3.850      @Override
   3.851 @@ -636,8 +648,10 @@
   3.852              if (expr.getType().isUnknown() && symbol.isParam()) {
   3.853                  symbol.setType(Type.OBJECT);
   3.854              }
   3.855 -            getCurrentFunctionNode().setReturnType(Type.widest(getCurrentFunctionNode().getReturnType(), symbol.getSymbolType()));
   3.856 -            LOG.info("Returntype is now " + getCurrentFunctionNode().getReturnType());
   3.857 +
   3.858 +            final Type returnType = Type.widest(returnTypes.pop(), symbol.getSymbolType());
   3.859 +            returnTypes.push(returnType);
   3.860 +            LOG.info("Returntype is now ", returnType);
   3.861          }
   3.862  
   3.863          end(returnNode);
   3.864 @@ -649,25 +663,29 @@
   3.865      public Node leaveSwitchNode(final SwitchNode switchNode) {
   3.866          Type type = Type.UNKNOWN;
   3.867  
   3.868 +        final List<CaseNode> newCases = new ArrayList<>();
   3.869          for (final CaseNode caseNode : switchNode.getCases()) {
   3.870              final Node test = caseNode.getTest();
   3.871 +
   3.872 +            CaseNode newCaseNode = caseNode;
   3.873              if (test != null) {
   3.874                  if (test instanceof LiteralNode) {
   3.875                      //go down to integers if we can
   3.876                      final LiteralNode<?> lit = (LiteralNode<?>)test;
   3.877                      if (lit.isNumeric() && !(lit.getValue() instanceof Integer)) {
   3.878                          if (JSType.isRepresentableAsInt(lit.getNumber())) {
   3.879 -                            caseNode.setTest(LiteralNode.newInstance(lit, lit.getInt32()).accept(this));
   3.880 +                            newCaseNode = caseNode.setTest(LiteralNode.newInstance(lit, lit.getInt32()).accept(this));
   3.881                          }
   3.882                      }
   3.883                  } else {
   3.884                      // the "all integer" case that CodeGenerator optimizes for currently assumes literals only
   3.885                      type = Type.OBJECT;
   3.886 -                    break;
   3.887                  }
   3.888  
   3.889 -                type = Type.widest(type, caseNode.getTest().getType());
   3.890 +                type = Type.widest(type, newCaseNode.getTest().getType());
   3.891              }
   3.892 +
   3.893 +            newCases.add(newCaseNode);
   3.894          }
   3.895  
   3.896          //only optimize for all integers
   3.897 @@ -675,11 +693,11 @@
   3.898              type = Type.OBJECT;
   3.899          }
   3.900  
   3.901 -        switchNode.setTag(newInternal(getCurrentFunctionNode().uniqueName(SWITCH_TAG_PREFIX.tag()), type));
   3.902 +        switchNode.setTag(newInternal(getLexicalContext().getCurrentFunction().uniqueName(SWITCH_TAG_PREFIX.symbolName()), type));
   3.903  
   3.904          end(switchNode);
   3.905  
   3.906 -        return switchNode;
   3.907 +        return switchNode.setCases(getLexicalContext(), newCases);
   3.908      }
   3.909  
   3.910      @Override
   3.911 @@ -696,25 +714,25 @@
   3.912      }
   3.913  
   3.914      @Override
   3.915 -    public Node enterVarNode(final VarNode varNode) {
   3.916 +    public boolean enterVarNode(final VarNode varNode) {
   3.917          start(varNode);
   3.918  
   3.919          final IdentNode ident = varNode.getName();
   3.920          final String    name  = ident.getName();
   3.921  
   3.922 -        final Symbol symbol = defineSymbol(getCurrentBlock(), name, IS_VAR, ident);
   3.923 +        final Symbol symbol = defineSymbol(getLexicalContext().getCurrentBlock(), name, IS_VAR, ident);
   3.924          assert symbol != null;
   3.925  
   3.926 -        LOG.info("VarNode " + varNode + " set symbol " + symbol);
   3.927 +        LOG.info("VarNode ", varNode, " set symbol ", symbol);
   3.928          varNode.setSymbol(symbol);
   3.929  
   3.930          // NASHORN-467 - use before definition of vars - conservative
   3.931 -        if (localUses.contains(ident.getName())) {
   3.932 +        if (isLocalUse(ident.getName())) {
   3.933              newType(symbol, Type.OBJECT);
   3.934              symbol.setCanBeUndefined();
   3.935          }
   3.936  
   3.937 -        return varNode;
   3.938 +        return true;
   3.939      }
   3.940  
   3.941      @Override
   3.942 @@ -734,7 +752,7 @@
   3.943          addLocalDef(name);
   3.944  
   3.945          final Symbol  symbol   = varNode.getSymbol();
   3.946 -        final boolean isScript = lexicalContext.getFunction(symbol.getBlock()).isProgram(); //see NASHORN-56
   3.947 +        final boolean isScript = getLexicalContext().getDefiningFunction(symbol).isProgram(); //see NASHORN-56
   3.948          if ((init.getType().isNumeric() || init.getType().isBoolean()) && !isScript) {
   3.949              // Forbid integers as local vars for now as we have no way to treat them as undefined
   3.950              newType(symbol, init.getType());
   3.951 @@ -751,14 +769,14 @@
   3.952  
   3.953      @Override
   3.954      public Node leaveADD(final UnaryNode unaryNode) {
   3.955 -        newTemporary(arithType(), unaryNode);
   3.956 +        ensureSymbol(arithType(), unaryNode);
   3.957          end(unaryNode);
   3.958          return unaryNode;
   3.959      }
   3.960  
   3.961      @Override
   3.962      public Node leaveBIT_NOT(final UnaryNode unaryNode) {
   3.963 -        newTemporary(Type.INT, unaryNode);
   3.964 +        ensureSymbol(Type.INT, unaryNode);
   3.965          end(unaryNode);
   3.966          return unaryNode;
   3.967      }
   3.968 @@ -766,30 +784,29 @@
   3.969      @Override
   3.970      public Node leaveDECINC(final UnaryNode unaryNode) {
   3.971          // @see assignOffset
   3.972 -        ensureAssignmentSlots(getCurrentFunctionNode(), unaryNode.rhs());
   3.973 +        ensureAssignmentSlots(getLexicalContext().getCurrentFunction(), unaryNode.rhs());
   3.974          final Type type = arithType();
   3.975          newType(unaryNode.rhs().getSymbol(), type);
   3.976 -        newTemporary(type, unaryNode);
   3.977 +        ensureSymbol(type, unaryNode);
   3.978          end(unaryNode);
   3.979          return unaryNode;
   3.980      }
   3.981  
   3.982      @Override
   3.983      public Node leaveDELETE(final UnaryNode unaryNode) {
   3.984 -        final FunctionNode   currentFunctionNode = getCurrentFunctionNode();
   3.985 -        final boolean        strictMode          = currentFunctionNode.isStrictMode();
   3.986 +        final FunctionNode   currentFunctionNode = getLexicalContext().getCurrentFunction();
   3.987 +        final boolean        strictMode          = currentFunctionNode.isStrict();
   3.988          final Node           rhs                 = unaryNode.rhs();
   3.989          final Node           strictFlagNode      = LiteralNode.newInstance(unaryNode, strictMode).accept(this);
   3.990  
   3.991          Request request = Request.DELETE;
   3.992 -        final RuntimeNode runtimeNode;
   3.993          final List<Node> args = new ArrayList<>();
   3.994  
   3.995          if (rhs instanceof IdentNode) {
   3.996              // If this is a declared variable or a function parameter, delete always fails (except for globals).
   3.997              final String name = ((IdentNode)rhs).getName();
   3.998  
   3.999 -            final boolean failDelete = strictMode || rhs.getSymbol().isParam() || (rhs.getSymbol().isVar() && !rhs.getSymbol().isTopLevel());
  3.1000 +            final boolean failDelete = strictMode || rhs.getSymbol().isParam() || (rhs.getSymbol().isVar() && !isProgramLevelSymbol(name));
  3.1001  
  3.1002              if (failDelete && rhs.getSymbol().isThis()) {
  3.1003                  return LiteralNode.newInstance(unaryNode, true).accept(this);
  3.1004 @@ -797,7 +814,7 @@
  3.1005              final Node literalNode = LiteralNode.newInstance(unaryNode, name).accept(this);
  3.1006  
  3.1007              if (!failDelete) {
  3.1008 -                args.add(currentFunctionNode.getScopeNode());
  3.1009 +                args.add(compilerConstant(SCOPE));
  3.1010              }
  3.1011              args.add(literalNode);
  3.1012              args.add(strictFlagNode);
  3.1013 @@ -825,42 +842,62 @@
  3.1014              return LiteralNode.newInstance(unaryNode, true).accept(this);
  3.1015          }
  3.1016  
  3.1017 -        runtimeNode = new RuntimeNode(unaryNode, request, args);
  3.1018 -        assert runtimeNode.getSymbol() == unaryNode.getSymbol(); //clone constructor should do this
  3.1019 +        final RuntimeNode runtimeNode = new RuntimeNode(unaryNode, request, args);
  3.1020 +        assert runtimeNode.getSymbol() == unaryNode.getSymbol(); //unary parent constructor should do this
  3.1021  
  3.1022          return leaveRuntimeNode(runtimeNode);
  3.1023      }
  3.1024  
  3.1025 +    /**
  3.1026 +     * Is the symbol denoted by the specified name in the current lexical context defined in the program level
  3.1027 +     * @param name the name of the symbol
  3.1028 +     * @return true if the symbol denoted by the specified name in the current lexical context defined in the program level.
  3.1029 +     */
  3.1030 +    private boolean isProgramLevelSymbol(final String name) {
  3.1031 +        for(final Iterator<Block> it = getLexicalContext().getBlocks(); it.hasNext();) {
  3.1032 +            final Block next = it.next();
  3.1033 +            if(next.getExistingSymbol(name) != null) {
  3.1034 +                return next == getLexicalContext().getFunctionBody(getLexicalContext().getOutermostFunction());
  3.1035 +            }
  3.1036 +        }
  3.1037 +        throw new AssertionError("Couldn't find symbol " + name + " in the context");
  3.1038 +    }
  3.1039 +
  3.1040      @Override
  3.1041      public Node leaveNEW(final UnaryNode unaryNode) {
  3.1042 -        newTemporary(Type.OBJECT, unaryNode);
  3.1043 +        ensureSymbol(Type.OBJECT, unaryNode);
  3.1044          end(unaryNode);
  3.1045          return unaryNode;
  3.1046      }
  3.1047  
  3.1048      @Override
  3.1049      public Node leaveNOT(final UnaryNode unaryNode) {
  3.1050 -        newTemporary(Type.BOOLEAN, unaryNode);
  3.1051 +        ensureSymbol(Type.BOOLEAN, unaryNode);
  3.1052          end(unaryNode);
  3.1053          return unaryNode;
  3.1054      }
  3.1055  
  3.1056 +    private IdentNode compilerConstant(CompilerConstants cc) {
  3.1057 +        final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
  3.1058 +        final IdentNode node = new IdentNode(functionNode.getSource(), functionNode.getToken(), functionNode.getFinish(), cc.symbolName());
  3.1059 +        node.setSymbol(functionNode.compilerConstant(cc));
  3.1060 +        return node;
  3.1061 +    }
  3.1062 +
  3.1063      @Override
  3.1064      public Node leaveTYPEOF(final UnaryNode unaryNode) {
  3.1065 -        final Node rhs    = unaryNode.rhs();
  3.1066 -
  3.1067 -        RuntimeNode runtimeNode;
  3.1068 +        final Node rhs = unaryNode.rhs();
  3.1069  
  3.1070          List<Node> args = new ArrayList<>();
  3.1071          if (rhs instanceof IdentNode && !rhs.getSymbol().isParam() && !rhs.getSymbol().isVar()) {
  3.1072 -            args.add(getCurrentFunctionNode().getScopeNode());
  3.1073 +            args.add(compilerConstant(SCOPE));
  3.1074              args.add(LiteralNode.newInstance(rhs, ((IdentNode)rhs).getName()).accept(this)); //null
  3.1075          } else {
  3.1076              args.add(rhs);
  3.1077              args.add(LiteralNode.newInstance(unaryNode).accept(this)); //null, do not reuse token of identifier rhs, it can be e.g. 'this'
  3.1078          }
  3.1079  
  3.1080 -        runtimeNode = new RuntimeNode(unaryNode, Request.TYPEOF, args);
  3.1081 +        RuntimeNode runtimeNode = new RuntimeNode(unaryNode, Request.TYPEOF, args);
  3.1082          assert runtimeNode.getSymbol() == unaryNode.getSymbol();
  3.1083  
  3.1084          runtimeNode = (RuntimeNode)leaveRuntimeNode(runtimeNode);
  3.1085 @@ -872,21 +909,20 @@
  3.1086  
  3.1087      @Override
  3.1088      public Node leaveRuntimeNode(final RuntimeNode runtimeNode) {
  3.1089 -        newTemporary(runtimeNode.getRequest().getReturnType(), runtimeNode);
  3.1090 +        ensureSymbol(runtimeNode.getRequest().getReturnType(), runtimeNode);
  3.1091          return runtimeNode;
  3.1092      }
  3.1093  
  3.1094      @Override
  3.1095      public Node leaveSUB(final UnaryNode unaryNode) {
  3.1096 -        newTemporary(arithType(), unaryNode);
  3.1097 +        ensureSymbol(arithType(), unaryNode);
  3.1098          end(unaryNode);
  3.1099          return unaryNode;
  3.1100      }
  3.1101  
  3.1102      @Override
  3.1103      public Node leaveVOID(final UnaryNode unaryNode) {
  3.1104 -        final RuntimeNode runtimeNode = new RuntimeNode(unaryNode, Request.VOID);
  3.1105 -        runtimeNode.accept(this);
  3.1106 +        final RuntimeNode runtimeNode = (RuntimeNode)new RuntimeNode(unaryNode, Request.VOID).accept(this);
  3.1107          assert runtimeNode.getSymbol().getSymbolType().isObject();
  3.1108          end(unaryNode);
  3.1109          return runtimeNode;
  3.1110 @@ -903,7 +939,7 @@
  3.1111  
  3.1112          ensureTypeNotUnknown(lhs);
  3.1113          ensureTypeNotUnknown(rhs);
  3.1114 -        newTemporary(Type.widest(lhs.getType(), rhs.getType()), binaryNode);
  3.1115 +        ensureSymbol(Type.widest(lhs.getType(), rhs.getType()), binaryNode);
  3.1116  
  3.1117          end(binaryNode);
  3.1118  
  3.1119 @@ -912,7 +948,7 @@
  3.1120  
  3.1121      @Override
  3.1122      public Node leaveAND(final BinaryNode binaryNode) {
  3.1123 -        newTemporary(Type.OBJECT, binaryNode);
  3.1124 +        ensureSymbol(Type.OBJECT, binaryNode);
  3.1125          end(binaryNode);
  3.1126          return binaryNode;
  3.1127      }
  3.1128 @@ -921,39 +957,40 @@
  3.1129       * This is a helper called before an assignment.
  3.1130       * @param binaryNode assignment node
  3.1131       */
  3.1132 -    private Node enterAssignmentNode(final BinaryNode binaryNode) {
  3.1133 +    private boolean enterAssignmentNode(final BinaryNode binaryNode) {
  3.1134          start(binaryNode);
  3.1135  
  3.1136          final Node lhs = binaryNode.lhs();
  3.1137  
  3.1138          if (lhs instanceof IdentNode) {
  3.1139 -            final Block     block = getCurrentBlock();
  3.1140 -            final IdentNode ident = (IdentNode)lhs;
  3.1141 -            final String    name  = ident.getName();
  3.1142 +            final LexicalContext lc    = getLexicalContext();
  3.1143 +            final Block          block = lc.getCurrentBlock();
  3.1144 +            final IdentNode      ident = (IdentNode)lhs;
  3.1145 +            final String         name  = ident.getName();
  3.1146  
  3.1147 -            Symbol symbol = findSymbol(getCurrentBlock(), name);
  3.1148 +            Symbol symbol = findSymbol(block, name);
  3.1149  
  3.1150              if (symbol == null) {
  3.1151                  symbol = defineSymbol(block, name, IS_GLOBAL, ident);
  3.1152                  binaryNode.setSymbol(symbol);
  3.1153 -            } else if (!isLocal(getCurrentFunctionNode(), symbol)) {
  3.1154 -                symbol.setIsScope();
  3.1155 +            } else if (!isLocal(lc.getCurrentFunction(), symbol)) {
  3.1156 +                Symbol.setSymbolIsScope(lc, symbol);
  3.1157              }
  3.1158  
  3.1159              addLocalDef(name);
  3.1160          }
  3.1161  
  3.1162 -        return binaryNode;
  3.1163 +        return true;
  3.1164      }
  3.1165  
  3.1166      private boolean isLocal(FunctionNode function, Symbol symbol) {
  3.1167 -        final Block block = symbol.getBlock();
  3.1168 -        // some temp symbols have no block, so can be assumed local
  3.1169 -        return block == null || lexicalContext.getFunction(block) == function;
  3.1170 +        final FunctionNode definingFn = getLexicalContext().getDefiningFunction(symbol);
  3.1171 +        // Temp symbols are not assigned to a block, so their defining fn is null; those can be assumed local
  3.1172 +        return definingFn == null || definingFn == function;
  3.1173      }
  3.1174  
  3.1175      @Override
  3.1176 -    public Node enterASSIGN(final BinaryNode binaryNode) {
  3.1177 +    public boolean enterASSIGN(final BinaryNode binaryNode) {
  3.1178          return enterAssignmentNode(binaryNode);
  3.1179      }
  3.1180  
  3.1181 @@ -963,7 +1000,7 @@
  3.1182      }
  3.1183  
  3.1184      @Override
  3.1185 -    public Node enterASSIGN_ADD(final BinaryNode binaryNode) {
  3.1186 +    public boolean enterASSIGN_ADD(final BinaryNode binaryNode) {
  3.1187          return enterAssignmentNode(binaryNode);
  3.1188      }
  3.1189  
  3.1190 @@ -978,7 +1015,7 @@
  3.1191      }
  3.1192  
  3.1193      @Override
  3.1194 -    public Node enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
  3.1195 +    public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
  3.1196          return enterAssignmentNode(binaryNode);
  3.1197      }
  3.1198  
  3.1199 @@ -988,7 +1025,7 @@
  3.1200      }
  3.1201  
  3.1202      @Override
  3.1203 -    public Node enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
  3.1204 +    public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
  3.1205          return enterAssignmentNode(binaryNode);
  3.1206      }
  3.1207  
  3.1208 @@ -998,7 +1035,7 @@
  3.1209      }
  3.1210  
  3.1211      @Override
  3.1212 -    public Node enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
  3.1213 +    public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
  3.1214          return enterAssignmentNode(binaryNode);
  3.1215      }
  3.1216  
  3.1217 @@ -1008,7 +1045,7 @@
  3.1218      }
  3.1219  
  3.1220      @Override
  3.1221 -    public Node enterASSIGN_DIV(final BinaryNode binaryNode) {
  3.1222 +    public boolean enterASSIGN_DIV(final BinaryNode binaryNode) {
  3.1223          return enterAssignmentNode(binaryNode);
  3.1224      }
  3.1225  
  3.1226 @@ -1018,7 +1055,7 @@
  3.1227      }
  3.1228  
  3.1229      @Override
  3.1230 -    public Node enterASSIGN_MOD(final BinaryNode binaryNode) {
  3.1231 +    public boolean enterASSIGN_MOD(final BinaryNode binaryNode) {
  3.1232          return enterAssignmentNode(binaryNode);
  3.1233      }
  3.1234  
  3.1235 @@ -1028,7 +1065,7 @@
  3.1236      }
  3.1237  
  3.1238      @Override
  3.1239 -    public Node enterASSIGN_MUL(final BinaryNode binaryNode) {
  3.1240 +    public boolean enterASSIGN_MUL(final BinaryNode binaryNode) {
  3.1241          return enterAssignmentNode(binaryNode);
  3.1242      }
  3.1243  
  3.1244 @@ -1038,7 +1075,7 @@
  3.1245      }
  3.1246  
  3.1247      @Override
  3.1248 -    public Node enterASSIGN_SAR(final BinaryNode binaryNode) {
  3.1249 +    public boolean enterASSIGN_SAR(final BinaryNode binaryNode) {
  3.1250          return enterAssignmentNode(binaryNode);
  3.1251      }
  3.1252  
  3.1253 @@ -1048,7 +1085,7 @@
  3.1254      }
  3.1255  
  3.1256      @Override
  3.1257 -    public Node enterASSIGN_SHL(final BinaryNode binaryNode) {
  3.1258 +    public boolean enterASSIGN_SHL(final BinaryNode binaryNode) {
  3.1259          return enterAssignmentNode(binaryNode);
  3.1260      }
  3.1261  
  3.1262 @@ -1058,7 +1095,7 @@
  3.1263      }
  3.1264  
  3.1265      @Override
  3.1266 -    public Node enterASSIGN_SHR(final BinaryNode binaryNode) {
  3.1267 +    public boolean enterASSIGN_SHR(final BinaryNode binaryNode) {
  3.1268          return enterAssignmentNode(binaryNode);
  3.1269      }
  3.1270  
  3.1271 @@ -1068,7 +1105,7 @@
  3.1272      }
  3.1273  
  3.1274      @Override
  3.1275 -    public Node enterASSIGN_SUB(final BinaryNode binaryNode) {
  3.1276 +    public boolean enterASSIGN_SUB(final BinaryNode binaryNode) {
  3.1277          return enterAssignmentNode(binaryNode);
  3.1278      }
  3.1279  
  3.1280 @@ -1094,13 +1131,13 @@
  3.1281  
  3.1282      @Override
  3.1283      public Node leaveCOMMARIGHT(final BinaryNode binaryNode) {
  3.1284 -        newTemporary(binaryNode.rhs().getType(), binaryNode);
  3.1285 +        ensureSymbol(binaryNode.rhs().getType(), binaryNode);
  3.1286          return binaryNode;
  3.1287      }
  3.1288  
  3.1289      @Override
  3.1290      public Node leaveCOMMALEFT(final BinaryNode binaryNode) {
  3.1291 -        newTemporary(binaryNode.lhs().getType(), binaryNode);
  3.1292 +        ensureSymbol(binaryNode.lhs().getType(), binaryNode);
  3.1293          return binaryNode;
  3.1294      }
  3.1295  
  3.1296 @@ -1113,7 +1150,7 @@
  3.1297          final Node lhs = binaryNode.lhs();
  3.1298          final Node rhs = binaryNode.rhs();
  3.1299  
  3.1300 -        newTemporary(Type.BOOLEAN, binaryNode);
  3.1301 +        ensureSymbol(Type.BOOLEAN, binaryNode);
  3.1302          ensureTypeNotUnknown(lhs);
  3.1303          ensureTypeNotUnknown(rhs);
  3.1304  
  3.1305 @@ -1131,7 +1168,7 @@
  3.1306  
  3.1307          //newType(binaryNode.lhs().getSymbol(), operandType);
  3.1308          //newType(binaryNode.rhs().getSymbol(), operandType);
  3.1309 -        newTemporary(destType, binaryNode);
  3.1310 +        ensureSymbol(destType, binaryNode);
  3.1311          return binaryNode;
  3.1312      }
  3.1313  
  3.1314 @@ -1216,7 +1253,7 @@
  3.1315  
  3.1316      @Override
  3.1317      public Node leaveOR(final BinaryNode binaryNode) {
  3.1318 -        newTemporary(Type.OBJECT, binaryNode);
  3.1319 +        ensureSymbol(Type.OBJECT, binaryNode);
  3.1320          end(binaryNode);
  3.1321          return binaryNode;
  3.1322      }
  3.1323 @@ -1244,7 +1281,7 @@
  3.1324      @Override
  3.1325      public Node leaveForNode(final ForNode forNode) {
  3.1326          if (forNode.isForIn()) {
  3.1327 -            forNode.setIterator(newInternal(getCurrentFunctionNode().uniqueName(ITERATOR_PREFIX.tag()), Type.OBJECT)); //NASHORN-73
  3.1328 +            forNode.setIterator(newInternal(getLexicalContext().getCurrentFunction().uniqueName(ITERATOR_PREFIX.symbolName()), Type.OBJECT)); //NASHORN-73
  3.1329              /*
  3.1330               * Iterators return objects, so we need to widen the scope of the
  3.1331               * init variable if it, for example, has been assigned double type
  3.1332 @@ -1267,65 +1304,50 @@
  3.1333          ensureTypeNotUnknown(rhs);
  3.1334  
  3.1335          final Type type = Type.widest(lhs.getType(), rhs.getType());
  3.1336 -        newTemporary(type, ternaryNode);
  3.1337 +        ensureSymbol(type, ternaryNode);
  3.1338  
  3.1339          end(ternaryNode);
  3.1340 +        assert ternaryNode.getSymbol() != null;
  3.1341  
  3.1342          return ternaryNode;
  3.1343      }
  3.1344  
  3.1345 -    private void initThis(final FunctionNode functionNode) {
  3.1346 -        final Symbol thisSymbol = defineSymbol(functionNode, THIS.tag(), IS_PARAM | IS_THIS, null);
  3.1347 +    private void initThis(final Block block) {
  3.1348 +        final Symbol thisSymbol = defineSymbol(block, THIS.symbolName(), IS_PARAM | IS_THIS, null);
  3.1349          newType(thisSymbol, Type.OBJECT);
  3.1350          thisSymbol.setNeedsSlot(true);
  3.1351 -        functionNode.getThisNode().setSymbol(thisSymbol);
  3.1352 -        LOG.info("Initialized scope symbol: " + thisSymbol);
  3.1353      }
  3.1354  
  3.1355 -    private void initScope(final FunctionNode functionNode) {
  3.1356 -        final Symbol scopeSymbol = defineSymbol(functionNode, SCOPE.tag(), IS_VAR | IS_INTERNAL, null);
  3.1357 +    private void initScope(final Block block) {
  3.1358 +        final Symbol scopeSymbol = defineSymbol(block, SCOPE.symbolName(), IS_VAR | IS_INTERNAL, null);
  3.1359          newType(scopeSymbol, Type.typeFor(ScriptObject.class));
  3.1360          scopeSymbol.setNeedsSlot(true);
  3.1361 -        functionNode.getScopeNode().setSymbol(scopeSymbol);
  3.1362 -        LOG.info("Initialized scope symbol: " + scopeSymbol);
  3.1363      }
  3.1364  
  3.1365 -    private void initReturn(final FunctionNode functionNode) {
  3.1366 -        final Symbol returnSymbol = defineSymbol(functionNode, SCRIPT_RETURN.tag(), IS_VAR | IS_INTERNAL, null);
  3.1367 +    private void initReturn(final Block block) {
  3.1368 +        final Symbol returnSymbol = defineSymbol(block, RETURN.symbolName(), IS_VAR | IS_INTERNAL, null);
  3.1369          newType(returnSymbol, Type.OBJECT);
  3.1370          returnSymbol.setNeedsSlot(true);
  3.1371 -        functionNode.getResultNode().setSymbol(returnSymbol);
  3.1372 -        LOG.info("Initialized return symbol: " + returnSymbol);
  3.1373          //return symbol is always object as it's the __return__ thing. What returnType is is another matter though
  3.1374      }
  3.1375  
  3.1376 -    private void initVarArg(final FunctionNode functionNode) {
  3.1377 -        if (functionNode.isVarArg()) {
  3.1378 -            final Symbol varArgsSymbol = defineSymbol(functionNode, VARARGS.tag(), IS_PARAM | IS_INTERNAL, null);
  3.1379 -            varArgsSymbol.setTypeOverride(Type.OBJECT_ARRAY);
  3.1380 -            varArgsSymbol.setNeedsSlot(true);
  3.1381 -            functionNode.getVarArgsNode().setSymbol(varArgsSymbol);
  3.1382 -            LOG.info("Initialized varargs symbol: " + varArgsSymbol);
  3.1383 +    private void initVarArg(final Block block, final boolean needsArguments) {
  3.1384 +        final Symbol varArgsSymbol = defineSymbol(block, VARARGS.symbolName(), IS_PARAM | IS_INTERNAL, null);
  3.1385 +        varArgsSymbol.setTypeOverride(Type.OBJECT_ARRAY);
  3.1386 +        varArgsSymbol.setNeedsSlot(true);
  3.1387  
  3.1388 -            if (functionNode.needsArguments()) {
  3.1389 -                final String    argumentsName   = functionNode.getArgumentsNode().getName();
  3.1390 -                final Symbol    argumentsSymbol = defineSymbol(functionNode, argumentsName, IS_VAR | IS_INTERNAL, null);
  3.1391 -                newType(argumentsSymbol, Type.typeFor(ScriptObject.class));
  3.1392 -                argumentsSymbol.setNeedsSlot(true);
  3.1393 -                functionNode.getArgumentsNode().setSymbol(argumentsSymbol);
  3.1394 -                addLocalDef(argumentsName);
  3.1395 -                LOG.info("Initialized vararg varArgsSymbol=" + varArgsSymbol + " argumentsSymbol=" + argumentsSymbol);
  3.1396 -            }
  3.1397 +        if (needsArguments) {
  3.1398 +            final Symbol    argumentsSymbol = defineSymbol(block, ARGUMENTS.symbolName(), IS_VAR | IS_INTERNAL, null);
  3.1399 +            newType(argumentsSymbol, Type.typeFor(ScriptObject.class));
  3.1400 +            argumentsSymbol.setNeedsSlot(true);
  3.1401 +            addLocalDef(ARGUMENTS.symbolName());
  3.1402          }
  3.1403      }
  3.1404  
  3.1405 -    private void initCallee(final FunctionNode functionNode) {
  3.1406 -        assert functionNode.getCalleeNode() != null : functionNode + " has no callee";
  3.1407 -        final Symbol calleeSymbol = defineSymbol(functionNode, CALLEE.tag(), IS_PARAM | IS_INTERNAL, null);
  3.1408 -        newType(calleeSymbol, Type.typeFor(ScriptFunction.class));
  3.1409 +    private void initCallee(final Block block) {
  3.1410 +        final Symbol calleeSymbol = defineSymbol(block, CALLEE.symbolName(), IS_PARAM | IS_INTERNAL, null);
  3.1411 +        newType(calleeSymbol, FunctionNode.FUNCTION_TYPE);
  3.1412          calleeSymbol.setNeedsSlot(true);
  3.1413 -        functionNode.getCalleeNode().setSymbol(calleeSymbol);
  3.1414 -        LOG.info("Initialized callee symbol " + calleeSymbol);
  3.1415      }
  3.1416  
  3.1417      /**
  3.1418 @@ -1334,25 +1356,19 @@
  3.1419       *
  3.1420       * @param functionNode the function node
  3.1421       */
  3.1422 -    private void initParameters(final FunctionNode functionNode) {
  3.1423 -        //If a function is specialized, we don't need to tag either it return
  3.1424 -        // type or its parameters with the widest (OBJECT) type for safety.
  3.1425 -        functionNode.setReturnType(Type.UNKNOWN);
  3.1426 -
  3.1427 +    private void initParameters(final FunctionNode functionNode, final Block body) {
  3.1428          for (final IdentNode param : functionNode.getParameters()) {
  3.1429              addLocalDef(param.getName());
  3.1430 -            final Symbol paramSymbol = defineSymbol(functionNode, param.getName(), IS_PARAM, param);
  3.1431 +            final Symbol paramSymbol = defineSymbol(body, param.getName(), IS_PARAM, param);
  3.1432              if (paramSymbol != null) {
  3.1433                  final Type callSiteParamType = functionNode.getSpecializedType(param);
  3.1434                  if (callSiteParamType != null) {
  3.1435 -                    LOG.info("Param " + paramSymbol + " has a callsite type " + callSiteParamType + ". Using that.");
  3.1436 -
  3.1437 -                    System.err.println("Param " + param + " has a callsite type " + callSiteParamType + ". Using that.");
  3.1438 +                    LOG.info("Param ", paramSymbol, " has a callsite type ", callSiteParamType, ". Using that.");
  3.1439                  }
  3.1440                  newType(paramSymbol, callSiteParamType == null ? Type.UNKNOWN : callSiteParamType);
  3.1441              }
  3.1442  
  3.1443 -            LOG.info("Initialized param " + paramSymbol);
  3.1444 +            LOG.info("Initialized param ", paramSymbol);
  3.1445          }
  3.1446      }
  3.1447  
  3.1448 @@ -1378,7 +1394,7 @@
  3.1449              // this function, we can tell the runtime system that no matter what the
  3.1450              // call site is, use this information. TODO
  3.1451              if (!paramSymbol.getSymbolType().isObject()) {
  3.1452 -                LOG.finest("Parameter " + ident + " could profit from specialization to " + paramSymbol.getSymbolType());
  3.1453 +                LOG.finest("Parameter ", ident, " could profit from specialization to ", paramSymbol.getSymbolType());
  3.1454              }
  3.1455  
  3.1456              newType(paramSymbol, Type.widest(type, paramSymbol.getSymbolType()));
  3.1457 @@ -1392,19 +1408,18 @@
  3.1458  
  3.1459      /**
  3.1460       * Move any properties from a global map into the scope of this method
  3.1461 -     * @param functionNode the function node for which to init scope vars
  3.1462 +     * @param block the function node body for which to init scope vars
  3.1463       */
  3.1464 -    private void initFromPropertyMap(final FunctionNode functionNode) {
  3.1465 +    private void initFromPropertyMap(final Block block) {
  3.1466          // For a script, add scope symbols as defined in the property map
  3.1467 -        assert functionNode.isProgram();
  3.1468  
  3.1469          final PropertyMap map = Context.getGlobalMap();
  3.1470  
  3.1471          for (final Property property : map.getProperties()) {
  3.1472              final String key    = property.getKey();
  3.1473 -            final Symbol symbol = defineSymbol(functionNode, key, IS_GLOBAL, null);
  3.1474 +            final Symbol symbol = defineSymbol(block, key, IS_GLOBAL, null);
  3.1475              newType(symbol, Type.OBJECT);
  3.1476 -            LOG.info("Added global symbol from property map " + symbol);
  3.1477 +            LOG.info("Added global symbol from property map ", symbol);
  3.1478          }
  3.1479      }
  3.1480  
  3.1481 @@ -1412,7 +1427,7 @@
  3.1482  
  3.1483          final Symbol symbol = node.getSymbol();
  3.1484  
  3.1485 -        LOG.info("Ensure type not unknown for: " + symbol);
  3.1486 +        LOG.info("Ensure type not unknown for: ", symbol);
  3.1487  
  3.1488          /*
  3.1489           * Note that not just unknowns, but params need to be blown
  3.1490 @@ -1452,7 +1467,7 @@
  3.1491      }
  3.1492  
  3.1493      private Symbol exceptionSymbol() {
  3.1494 -        return newInternal(getCurrentFunctionNode().uniqueName(EXCEPTION_PREFIX.tag()), Type.typeFor(ECMAException.class));
  3.1495 +        return newInternal(getLexicalContext().getCurrentFunction().uniqueName(EXCEPTION_PREFIX.symbolName()), Type.typeFor(ECMAException.class));
  3.1496      }
  3.1497  
  3.1498      /**
  3.1499 @@ -1512,15 +1527,15 @@
  3.1500                      }
  3.1501                      Type from = node.getType();
  3.1502                      if (!Type.areEquivalent(from, to) && Type.widest(from, to) == to) {
  3.1503 -                        LOG.fine("Had to post pass widen '" + node + "' " + Debug.id(node) + " from " + node.getType() + " to " + to);
  3.1504 +                        LOG.fine("Had to post pass widen '", node, "' " + Debug.id(node), " from ", node.getType(), " to ", to);
  3.1505                          newType(node.getSymbol(), to);
  3.1506                          changed.add(node);
  3.1507                      }
  3.1508                  }
  3.1509  
  3.1510                  @Override
  3.1511 -                public Node enterFunctionNode(final FunctionNode node) {
  3.1512 -                    return node.isLazy() ? null : node;
  3.1513 +                public boolean enterFunctionNode(final FunctionNode node) {
  3.1514 +                    return !node.isLazy();
  3.1515                  }
  3.1516  
  3.1517                  /**
  3.1518 @@ -1574,7 +1589,7 @@
  3.1519          } else {
  3.1520              type = Type.OBJECT; //force lhs to be an object if not numeric assignment, e.g. strings too.
  3.1521          }
  3.1522 -        newTemporary(type, binaryNode);
  3.1523 +        ensureSymbol(type, binaryNode);
  3.1524          newType(lhs.getSymbol(), type);
  3.1525          end(binaryNode);
  3.1526          return binaryNode;
  3.1527 @@ -1589,32 +1604,25 @@
  3.1528          final Node lhs = binaryNode.lhs();
  3.1529  
  3.1530          newType(lhs.getSymbol(), destType); //may not narrow if dest is already wider than destType
  3.1531 -        newTemporary(destType, binaryNode); //for OP= nodes, the node can carry a narrower types than its lhs rhs. This is perfectly fine
  3.1532 +        ensureSymbol(destType, binaryNode); //for OP= nodes, the node can carry a narrower types than its lhs rhs. This is perfectly fine
  3.1533  
  3.1534 -        ensureAssignmentSlots(getCurrentFunctionNode(), binaryNode);
  3.1535 +        ensureAssignmentSlots(getLexicalContext().getCurrentFunction(), binaryNode);
  3.1536  
  3.1537          end(binaryNode);
  3.1538          return binaryNode;
  3.1539      }
  3.1540  
  3.1541 -    private static boolean isFunctionExpressionSelfReference(final Symbol symbol) {
  3.1542 -        if (symbol.isVar() && symbol.getNode() == symbol.getBlock() && symbol.getNode() instanceof FunctionNode) {
  3.1543 -            return ((FunctionNode)symbol.getNode()).getIdent().getName().equals(symbol.getName());
  3.1544 -        }
  3.1545 -        return false;
  3.1546 +    private Symbol ensureSymbol(final FunctionNode functionNode, final Type type, final Node node) {
  3.1547 +        LOG.info("New TEMPORARY added to ", functionNode.getName(), " type=", type);
  3.1548 +        return functionNode.ensureSymbol(getLexicalContext().getCurrentBlock(), type, node);
  3.1549      }
  3.1550  
  3.1551 -    private static Symbol newTemporary(final FunctionNode functionNode, final Type type, final Node node) {
  3.1552 -        LOG.info("New TEMPORARY added to " + functionNode.getName() + " type=" + type);
  3.1553 -        return functionNode.newTemporary(type, node);
  3.1554 -    }
  3.1555 -
  3.1556 -    private Symbol newTemporary(final Type type, final Node node) {
  3.1557 -        return newTemporary(getCurrentFunctionNode(), type, node);
  3.1558 +    private Symbol ensureSymbol(final Type type, final Node node) {
  3.1559 +        return ensureSymbol(getLexicalContext().getCurrentFunction(), type, node);
  3.1560      }
  3.1561  
  3.1562      private Symbol newInternal(final String name, final Type type) {
  3.1563 -        final Symbol iter = defineSymbol(getCurrentFunctionNode(), name, IS_VAR | IS_INTERNAL, null);
  3.1564 +        final Symbol iter = defineSymbol(getLexicalContext().getCurrentBlock(), name, IS_VAR | IS_INTERNAL, null);
  3.1565          iter.setType(type); // NASHORN-73
  3.1566          return iter;
  3.1567      }
  3.1568 @@ -1624,40 +1632,51 @@
  3.1569          symbol.setType(type);
  3.1570  
  3.1571          if (symbol.getSymbolType() != oldType) {
  3.1572 -            LOG.info("New TYPE " + type + " for " + symbol + " (was " + oldType + ")");
  3.1573 +            LOG.info("New TYPE ", type, " for ", symbol," (was ", oldType, ")");
  3.1574          }
  3.1575  
  3.1576          if (symbol.isParam()) {
  3.1577              symbol.setType(type);
  3.1578 -            LOG.info("Param type change " + symbol);
  3.1579 +            LOG.info("Param type change ", symbol);
  3.1580          }
  3.1581      }
  3.1582  
  3.1583 -    private void clearLocalDefs() {
  3.1584 -        localDefs = new HashSet<>();
  3.1585 +    private void pushLocalsFunction() {
  3.1586 +        localDefs.push(new HashSet<String>());
  3.1587 +        localUses.push(new HashSet<String>());
  3.1588 +    }
  3.1589 +
  3.1590 +    private void pushLocalsBlock() {
  3.1591 +        localDefs.push(localDefs.isEmpty() ? new HashSet<String>() : new HashSet<>(localDefs.peek()));
  3.1592 +        localUses.push(localUses.isEmpty() ? new HashSet<String>() : new HashSet<>(localUses.peek()));
  3.1593 +    }
  3.1594 +
  3.1595 +    private void popLocals() {
  3.1596 +        localDefs.pop();
  3.1597 +        localUses.pop();
  3.1598      }
  3.1599  
  3.1600      private boolean isLocalDef(final String name) {
  3.1601 -        return localDefs.contains(name);
  3.1602 +        return localDefs.peek().contains(name);
  3.1603      }
  3.1604  
  3.1605      private void addLocalDef(final String name) {
  3.1606 -        LOG.info("Adding local def of symbol: '" + name + "'");
  3.1607 -        localDefs.add(name);
  3.1608 +        LOG.info("Adding local def of symbol: '", name, "'");
  3.1609 +        localDefs.peek().add(name);
  3.1610      }
  3.1611  
  3.1612      private void removeLocalDef(final String name) {
  3.1613 -        LOG.info("Removing local def of symbol: '" + name + "'");
  3.1614 -        localDefs.remove(name);
  3.1615 +        LOG.info("Removing local def of symbol: '", name, "'");
  3.1616 +        localDefs.peek().remove(name);
  3.1617      }
  3.1618  
  3.1619 -    private void clearLocalUses() {
  3.1620 -        localUses = new HashSet<>();
  3.1621 +    private boolean isLocalUse(final String name) {
  3.1622 +        return localUses.peek().contains(name);
  3.1623      }
  3.1624  
  3.1625      private void addLocalUse(final String name) {
  3.1626 -        LOG.info("Adding local use of symbol: '" + name + "'");
  3.1627 -        localUses.add(name);
  3.1628 +        LOG.info("Adding local use of symbol: '", name, "'");
  3.1629 +        localUses.peek().add(name);
  3.1630      }
  3.1631  
  3.1632      /**
  3.1633 @@ -1665,30 +1684,28 @@
  3.1634       * This is done when the function contains unevaluated black boxes such as
  3.1635       * lazy sub-function nodes that have not been compiled.
  3.1636       *
  3.1637 -     * @param functionNode function node in whose scope symbols should conservatively be made objects
  3.1638 +     * @param body body for the function node we are leaving
  3.1639       */
  3.1640 -    private static void objectifySymbols(final FunctionNode functionNode) {
  3.1641 -        functionNode.accept(new NodeVisitor() {
  3.1642 +    private static void objectifySymbols(final Block body) {
  3.1643 +        body.accept(new NodeVisitor() {
  3.1644              private void toObject(final Block block) {
  3.1645                  for (final Iterator<Symbol> iter = block.symbolIterator(); iter.hasNext();) {
  3.1646                      final Symbol symbol = iter.next();
  3.1647 -                    newType(symbol, Type.OBJECT);
  3.1648 +                    if (!symbol.isTemp()) {
  3.1649 +                        newType(symbol, Type.OBJECT);
  3.1650 +                    }
  3.1651                  }
  3.1652              }
  3.1653  
  3.1654              @Override
  3.1655 -            public Node enterBlock(final Block block) {
  3.1656 +            public boolean enterBlock(final Block block) {
  3.1657                  toObject(block);
  3.1658 -                return block;
  3.1659 +                return true;
  3.1660              }
  3.1661  
  3.1662              @Override
  3.1663 -            public Node enterFunctionNode(final FunctionNode node) {
  3.1664 -                toObject(node);
  3.1665 -                if (node.isLazy()) {
  3.1666 -                    return null;
  3.1667 -                }
  3.1668 -                return node;
  3.1669 +            public boolean enterFunctionNode(final FunctionNode node) {
  3.1670 +                return false;
  3.1671              }
  3.1672          });
  3.1673      }
  3.1674 @@ -1702,11 +1719,11 @@
  3.1675          return cn.substring(lastDot + 1);
  3.1676      }
  3.1677  
  3.1678 -    private Node start(final Node node) {
  3.1679 +    private boolean start(final Node node) {
  3.1680          return start(node, true);
  3.1681      }
  3.1682  
  3.1683 -    private Node start(final Node node, final boolean printNode) {
  3.1684 +    private boolean start(final Node node, final boolean printNode) {
  3.1685          if (DEBUG) {
  3.1686              final StringBuilder sb = new StringBuilder();
  3.1687  
  3.1688 @@ -1715,13 +1732,13 @@
  3.1689                  append("] ").
  3.1690                  append(printNode ? node.toString() : "").
  3.1691                  append(" in '").
  3.1692 -                append(getCurrentFunctionNode().getName()).
  3.1693 +                append(getLexicalContext().getCurrentFunction().getName()).
  3.1694                  append("'");
  3.1695 -            LOG.info(sb.toString());
  3.1696 +            LOG.info(sb);
  3.1697              LOG.indent();
  3.1698          }
  3.1699  
  3.1700 -        return node;
  3.1701 +        return true;
  3.1702      }
  3.1703  
  3.1704      private Node end(final Node node) {
  3.1705 @@ -1737,7 +1754,7 @@
  3.1706                  append("] ").
  3.1707                  append(printNode ? node.toString() : "").
  3.1708                  append(" in '").
  3.1709 -                append(getCurrentFunctionNode().getName());
  3.1710 +                append(getLexicalContext().getCurrentFunction().getName());
  3.1711  
  3.1712              if (node.getSymbol() == null) {
  3.1713                  sb.append(" <NO SYMBOL>");
  3.1714 @@ -1746,7 +1763,7 @@
  3.1715              }
  3.1716  
  3.1717              LOG.unindent();
  3.1718 -            LOG.info(sb.toString());
  3.1719 +            LOG.info(sb);
  3.1720          }
  3.1721  
  3.1722          return node;

     4.1 --- a/src/jdk/nashorn/internal/codegen/ClassEmitter.java	Fri Apr 19 18:23:00 2013 +0530
     4.2 +++ b/src/jdk/nashorn/internal/codegen/ClassEmitter.java	Fri Apr 19 16:11:16 2013 +0200
     4.3 @@ -58,12 +58,14 @@
     4.4  import java.util.EnumSet;
     4.5  import java.util.HashSet;
     4.6  import java.util.Set;
     4.7 +
     4.8  import jdk.internal.org.objectweb.asm.ClassReader;
     4.9  import jdk.internal.org.objectweb.asm.ClassWriter;
    4.10  import jdk.internal.org.objectweb.asm.MethodVisitor;
    4.11  import jdk.internal.org.objectweb.asm.util.TraceClassVisitor;
    4.12  import jdk.nashorn.internal.codegen.types.Type;
    4.13  import jdk.nashorn.internal.ir.FunctionNode;
    4.14 +import jdk.nashorn.internal.ir.SplitNode;
    4.15  import jdk.nashorn.internal.runtime.PropertyMap;
    4.16  import jdk.nashorn.internal.runtime.ScriptEnvironment;
    4.17  import jdk.nashorn.internal.runtime.ScriptObject;
    4.18 @@ -219,14 +221,14 @@
    4.19      private void defineCommonStatics(final boolean strictMode) {
    4.20          // source - used to store the source data (text) for this script.  Shared across
    4.21          // compile units.  Set externally by the compiler.
    4.22 -        field(EnumSet.of(Flag.PRIVATE, Flag.STATIC), SOURCE.tag(), Source.class);
    4.23 +        field(EnumSet.of(Flag.PRIVATE, Flag.STATIC), SOURCE.symbolName(), Source.class);
    4.24  
    4.25          // constants - used to the constants array for this script.  Shared across
    4.26          // compile units.  Set externally by the compiler.
    4.27 -        field(EnumSet.of(Flag.PRIVATE, Flag.STATIC), CONSTANTS.tag(), Object[].class);
    4.28 +        field(EnumSet.of(Flag.PRIVATE, Flag.STATIC), CONSTANTS.symbolName(), Object[].class);
    4.29  
    4.30          // strictMode - was this script compiled in strict mode.  Set externally by the compiler.
    4.31 -        field(EnumSet.of(Flag.PUBLIC, Flag.STATIC, Flag.FINAL), STRICT_MODE.tag(), boolean.class, strictMode);
    4.32 +        field(EnumSet.of(Flag.PUBLIC, Flag.STATIC, Flag.FINAL), STRICT_MODE.symbolName(), boolean.class, strictMode);
    4.33      }
    4.34  
    4.35      /**
    4.36 @@ -238,9 +240,9 @@
    4.37  
    4.38          if (constantMethodNeeded.contains(String.class)) {
    4.39              // $getString - get the ith entry from the constants table and cast to String.
    4.40 -            final MethodEmitter getStringMethod = method(EnumSet.of(Flag.PRIVATE, Flag.STATIC), GET_STRING.tag(), String.class, int.class);
    4.41 +            final MethodEmitter getStringMethod = method(EnumSet.of(Flag.PRIVATE, Flag.STATIC), GET_STRING.symbolName(), String.class, int.class);
    4.42              getStringMethod.begin();
    4.43 -            getStringMethod.getStatic(unitClassName, CONSTANTS.tag(), CONSTANTS.descriptor())
    4.44 +            getStringMethod.getStatic(unitClassName, CONSTANTS.symbolName(), CONSTANTS.descriptor())
    4.45                          .load(Type.INT, 0)
    4.46                          .arrayload()
    4.47                          .checkcast(String.class)
    4.48 @@ -250,7 +252,7 @@
    4.49  
    4.50          if (constantMethodNeeded.contains(PropertyMap.class)) {
    4.51              // $getMap - get the ith entry from the constants table and cast to PropertyMap.
    4.52 -            final MethodEmitter getMapMethod = method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), GET_MAP.tag(), PropertyMap.class, int.class);
    4.53 +            final MethodEmitter getMapMethod = method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), GET_MAP.symbolName(), PropertyMap.class, int.class);
    4.54              getMapMethod.begin();
    4.55              getMapMethod.loadConstants()
    4.56                          .load(Type.INT, 0)
    4.57 @@ -260,7 +262,7 @@
    4.58              getMapMethod.end();
    4.59  
    4.60              // $setMap - overwrite an existing map.
    4.61 -            final MethodEmitter setMapMethod = method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), SET_MAP.tag(), void.class, int.class, PropertyMap.class);
    4.62 +            final MethodEmitter setMapMethod = method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), SET_MAP.symbolName(), void.class, int.class, PropertyMap.class);
    4.63              setMapMethod.begin();
    4.64              setMapMethod.loadConstants()
    4.65                          .load(Type.INT, 0)
    4.66 @@ -289,7 +291,7 @@
    4.67          final MethodEmitter getArrayMethod = method(EnumSet.of(Flag.PRIVATE, Flag.STATIC), methodName, cls, int.class);
    4.68  
    4.69          getArrayMethod.begin();
    4.70 -        getArrayMethod.getStatic(unitClassName, CONSTANTS.tag(), CONSTANTS.descriptor())
    4.71 +        getArrayMethod.getStatic(unitClassName, CONSTANTS.symbolName(), CONSTANTS.descriptor())
    4.72                        .load(Type.INT, 0)
    4.73                        .arrayload()
    4.74                        .checkcast(cls)
    4.75 @@ -307,7 +309,7 @@
    4.76       */
    4.77      static String getArrayMethodName(final Class<?> cls) {
    4.78          assert cls.isArray();
    4.79 -        return GET_ARRAY_PREFIX.tag() + cls.getComponentType().getSimpleName() + GET_ARRAY_SUFFIX.tag();
    4.80 +        return GET_ARRAY_PREFIX.symbolName() + cls.getComponentType().getSimpleName() + GET_ARRAY_SUFFIX.symbolName();
    4.81      }
    4.82  
    4.83      /**
    4.84 @@ -409,6 +411,10 @@
    4.85          methodsStarted.remove(method);
    4.86      }
    4.87  
    4.88 +    SplitMethodEmitter method(final SplitNode splitNode, final String methodName, final Class<?> rtype, final Class<?>... ptypes) {
    4.89 +        return new SplitMethodEmitter(this, methodVisitor(EnumSet.of(Flag.PUBLIC, Flag.STATIC), methodName, rtype, ptypes), splitNode);
    4.90 +    }
    4.91 +
    4.92      /**
    4.93       * Add a new method to the class - defaults to public method
    4.94       *
    4.95 @@ -433,7 +439,7 @@
    4.96       * @return method emitter to use for weaving this method
    4.97       */
    4.98      MethodEmitter method(final EnumSet<Flag> methodFlags, final String methodName, final Class<?> rtype, final Class<?>... ptypes) {
    4.99 -        return new MethodEmitter(this, cw.visitMethod(Flag.getValue(methodFlags), methodName, methodDescriptor(rtype, ptypes), null, null));
   4.100 +        return new MethodEmitter(this, methodVisitor(methodFlags, methodName, rtype, ptypes));
   4.101      }
   4.102  
   4.103      /**
   4.104 @@ -484,7 +490,7 @@
   4.105       * @return method emitter to use for weaving <clinit>
   4.106       */
   4.107      MethodEmitter clinit() {
   4.108 -        return method(EnumSet.of(Flag.STATIC), CLINIT.tag(), void.class);
   4.109 +        return method(EnumSet.of(Flag.STATIC), CLINIT.symbolName(), void.class);
   4.110      }
   4.111  
   4.112      /**
   4.113 @@ -493,7 +499,7 @@
   4.114       * @return method emitter to use for weaving <init>()V
   4.115       */
   4.116      MethodEmitter init() {
   4.117 -        return method(INIT.tag(), void.class);
   4.118 +        return method(INIT.symbolName(), void.class);
   4.119      }
   4.120  
   4.121      /**
   4.122 @@ -503,7 +509,7 @@
   4.123       * @return method emitter to use for weaving <init>()V
   4.124       */
   4.125      MethodEmitter init(final Class<?>... ptypes) {
   4.126 -        return method(INIT.tag(), void.class, ptypes);
   4.127 +        return method(INIT.symbolName(), void.class, ptypes);
   4.128      }
   4.129  
   4.130      /**
   4.131 @@ -515,7 +521,7 @@
   4.132       * @return method emitter to use for weaving <init>(...)V
   4.133       */
   4.134      MethodEmitter init(final EnumSet<Flag> flags, final Class<?>... ptypes) {
   4.135 -        return method(flags, INIT.tag(), void.class, ptypes);
   4.136 +        return method(flags, INIT.symbolName(), void.class, ptypes);
   4.137      }
   4.138  
   4.139      /**
   4.140 @@ -628,4 +634,9 @@
   4.141              return v;
   4.142          }
   4.143      }
   4.144 +
   4.145 +    private MethodVisitor methodVisitor(EnumSet<Flag> flags, final String methodName, final Class<?> rtype, final Class<?>... ptypes) {
   4.146 +        return cw.visitMethod(Flag.getValue(flags), methodName, methodDescriptor(rtype, ptypes), null, null);
   4.147 +    }
   4.148 +
   4.149  }

     5.1 --- a/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Fri Apr 19 18:23:00 2013 +0530
     5.2 +++ b/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Fri Apr 19 16:11:16 2013 +0200
     5.3 @@ -27,14 +27,18 @@
     5.4  
     5.5  import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.PRIVATE;
     5.6  import static jdk.nashorn.internal.codegen.ClassEmitter.Flag.STATIC;
     5.7 +import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS;
     5.8 +import static jdk.nashorn.internal.codegen.CompilerConstants.CALLEE;
     5.9  import static jdk.nashorn.internal.codegen.CompilerConstants.GET_MAP;
    5.10  import static jdk.nashorn.internal.codegen.CompilerConstants.GET_STRING;
    5.11 -import static jdk.nashorn.internal.codegen.CompilerConstants.LEAF;
    5.12  import static jdk.nashorn.internal.codegen.CompilerConstants.QUICK_PREFIX;
    5.13  import static jdk.nashorn.internal.codegen.CompilerConstants.REGEX_PREFIX;
    5.14 +import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;
    5.15  import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
    5.16  import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_ARRAY_ARG;
    5.17  import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_PREFIX;
    5.18 +import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
    5.19 +import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
    5.20  import static jdk.nashorn.internal.codegen.CompilerConstants.constructorNoLookup;
    5.21  import static jdk.nashorn.internal.codegen.CompilerConstants.interfaceCallNoLookup;
    5.22  import static jdk.nashorn.internal.codegen.CompilerConstants.methodDescriptor;
    5.23 @@ -48,8 +52,10 @@
    5.24  import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_STRICT;
    5.25  
    5.26  import java.io.PrintWriter;
    5.27 +import java.util.ArrayDeque;
    5.28  import java.util.ArrayList;
    5.29  import java.util.Arrays;
    5.30 +import java.util.Deque;
    5.31  import java.util.EnumSet;
    5.32  import java.util.HashMap;
    5.33  import java.util.Iterator;
    5.34 @@ -67,11 +73,11 @@
    5.35  import jdk.nashorn.internal.ir.BinaryNode;
    5.36  import jdk.nashorn.internal.ir.Block;
    5.37  import jdk.nashorn.internal.ir.BreakNode;
    5.38 +import jdk.nashorn.internal.ir.BreakableNode;
    5.39  import jdk.nashorn.internal.ir.CallNode;
    5.40  import jdk.nashorn.internal.ir.CaseNode;
    5.41  import jdk.nashorn.internal.ir.CatchNode;
    5.42  import jdk.nashorn.internal.ir.ContinueNode;
    5.43 -import jdk.nashorn.internal.ir.DoWhileNode;
    5.44  import jdk.nashorn.internal.ir.EmptyNode;
    5.45  import jdk.nashorn.internal.ir.ExecuteNode;
    5.46  import jdk.nashorn.internal.ir.ForNode;
    5.47 @@ -85,6 +91,7 @@
    5.48  import jdk.nashorn.internal.ir.LiteralNode;
    5.49  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
    5.50  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
    5.51 +import jdk.nashorn.internal.ir.LoopNode;
    5.52  import jdk.nashorn.internal.ir.Node;
    5.53  import jdk.nashorn.internal.ir.ObjectNode;
    5.54  import jdk.nashorn.internal.ir.PropertyNode;
    5.55 @@ -107,6 +114,7 @@
    5.56  import jdk.nashorn.internal.parser.Lexer.RegexToken;
    5.57  import jdk.nashorn.internal.parser.TokenType;
    5.58  import jdk.nashorn.internal.runtime.Context;
    5.59 +import jdk.nashorn.internal.runtime.Debug;
    5.60  import jdk.nashorn.internal.runtime.DebugLogger;
    5.61  import jdk.nashorn.internal.runtime.ECMAException;
    5.62  import jdk.nashorn.internal.runtime.Property;
    5.63 @@ -157,14 +165,29 @@
    5.64      /** How many regexp fields have been emitted */
    5.65      private int regexFieldCount;
    5.66  
    5.67 -    /** Used for temporary signaling between enterCallNode and enterFunctionNode to handle the special case of calling
    5.68 -     * a just-defined anonymous function expression. */
    5.69 -    private boolean functionNodeIsCallee;
    5.70 -
    5.71      /** Map of shared scope call sites */
    5.72      private final Map<SharedScopeCall, SharedScopeCall> scopeCalls = new HashMap<>();
    5.73  
    5.74 -    private final LexicalContext lexicalContext = new LexicalContext();
    5.75 +    /** Compile unit stack - every time we start a sub method (e.g. a split) we push one */
    5.76 +    private final Deque<CompileUnit> compileUnits = new ArrayDeque<>();
    5.77 +
    5.78 +    /** Method emitter stack - every time we start a sub method (e.g. a split) we push one */
    5.79 +    private final Deque<MethodEmitter> methodEmitters = new ArrayDeque<>();
    5.80 +
    5.81 +    /** The discard stack - whenever we enter a discard node we keep track of its return value status -
    5.82 +     *  i.e. should we keep it or throw it away */
    5.83 +    private final Deque<Node> discard = new ArrayDeque<>();
    5.84 +
    5.85 +    // A stack tracking the next free local variable slot in the blocks. There's one entry for every block
    5.86 +    // currently on the lexical context stack.
    5.87 +    private int[] nextFreeSlots = new int[16];
    5.88 +    private int nextFreeSlotsSize = 0;
    5.89 +
    5.90 +    /** Current method emitter */
    5.91 +    private MethodEmitter method;
    5.92 +
    5.93 +    /** Current compile unit */
    5.94 +    private CompileUnit unit;
    5.95  
    5.96      /** When should we stop caching regexp expressions in fields to limit bytecode size? */
    5.97      private static final int MAX_REGEX_FIELDS = 2 * 1024;
    5.98 @@ -188,7 +211,37 @@
    5.99       * @return the correct flags for a call site in the current function
   5.100       */
   5.101      int getCallSiteFlags() {
   5.102 -        return getCurrentFunctionNode().isStrictMode() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags;
   5.103 +        return getLexicalContext().getCurrentFunction().isStrict() ? callSiteFlags | CALLSITE_STRICT : callSiteFlags;
   5.104 +    }
   5.105 +
   5.106 +    private void pushMethodEmitter(final MethodEmitter newMethod) {
   5.107 +        methodEmitters.push(newMethod);
   5.108 +        this.method = newMethod;
   5.109 +    }
   5.110 +
   5.111 +    private void popMethodEmitter(final MethodEmitter oldMethod) {
   5.112 +        assert methodEmitters.peek() == oldMethod;
   5.113 +        methodEmitters.pop();
   5.114 +        if (!methodEmitters.isEmpty()) {
   5.115 +            this.method = methodEmitters.peek();
   5.116 +        } else {
   5.117 +            this.method = null;
   5.118 +        }
   5.119 +    }
   5.120 +
   5.121 +    private void push(final CompileUnit newUnit) {
   5.122 +        compileUnits.push(newUnit);
   5.123 +        this.unit = newUnit;
   5.124 +    }
   5.125 +
   5.126 +    private void pop(final CompileUnit oldUnit) {
   5.127 +        assert compileUnits.peek() == oldUnit;
   5.128 +        compileUnits.pop();
   5.129 +        if (!compileUnits.isEmpty()) {
   5.130 +            this.unit = compileUnits.peek();
   5.131 +        } else {
   5.132 +            this.unit = null;
   5.133 +        }
   5.134      }
   5.135  
   5.136      /**
   5.137 @@ -217,7 +270,7 @@
   5.138              assert identNode.getSymbol().isScope() : identNode + " is not in scope!";
   5.139  
   5.140              final int flags = CALLSITE_SCOPE | getCallSiteFlags();
   5.141 -            method.loadScope();
   5.142 +            method.loadCompilerConstant(SCOPE);
   5.143  
   5.144              if (isFastScope(symbol)) {
   5.145                  // Only generate shared scope getter for fast-scope symbols so we know we can dial in correct scope.
   5.146 @@ -237,11 +290,11 @@
   5.147       * @return true if fast scope
   5.148       */
   5.149      private boolean isFastScope(final Symbol symbol) {
   5.150 -        if (!symbol.isScope() || !symbol.getBlock().needsScope()) {
   5.151 +        if (!symbol.isScope() || !getLexicalContext().getDefiningBlock(symbol).needsScope()) {
   5.152              return false;
   5.153          }
   5.154          // Allow fast scope access if no function contains with or eval
   5.155 -        for(final Iterator<FunctionNode> it = lexicalContext.getFunctions(getCurrentFunctionNode()); it.hasNext();) {
   5.156 +        for (final Iterator<FunctionNode> it = getLexicalContext().getFunctions(); it.hasNext();) {
   5.157              final FunctionNode func = it.next();
   5.158              if (func.hasWith() || func.hasEval()) {
   5.159                  return false;
   5.160 @@ -251,7 +304,7 @@
   5.161      }
   5.162  
   5.163      private MethodEmitter loadSharedScopeVar(final Type valueType, final Symbol symbol, final int flags) {
   5.164 -        method.load(isFastScope(symbol) ? getScopeProtoDepth(getCurrentBlock(), symbol) : -1);
   5.165 +        method.load(isFastScope(symbol) ? getScopeProtoDepth(getLexicalContext().getCurrentBlock(), symbol) : -1);
   5.166          final SharedScopeCall scopeCall = getScopeGet(valueType, symbol, flags | CALLSITE_FAST_SCOPE);
   5.167          scopeCall.generateInvoke(method);
   5.168          return method;
   5.169 @@ -271,10 +324,10 @@
   5.170  
   5.171      private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) {
   5.172          int depth = 0;
   5.173 -        final Block definingBlock = symbol.getBlock();
   5.174 -        for(final Iterator<Block> blocks = lexicalContext.getBlocks(startingBlock); blocks.hasNext();) {
   5.175 +        final String name = symbol.getName();
   5.176 +        for(final Iterator<Block> blocks = getLexicalContext().getBlocks(startingBlock); blocks.hasNext();) {
   5.177              final Block currentBlock = blocks.next();
   5.178 -            if (currentBlock == definingBlock) {
   5.179 +            if (currentBlock.getExistingSymbol(name) == symbol) {
   5.180                  return depth;
   5.181              }
   5.182              if (currentBlock.needsScope()) {
   5.183 @@ -285,9 +338,9 @@
   5.184      }
   5.185  
   5.186      private void loadFastScopeProto(final Symbol symbol, final boolean swap) {
   5.187 -        final int depth = getScopeProtoDepth(getCurrentBlock(), symbol);
   5.188 +        final int depth = getScopeProtoDepth(getLexicalContext().getCurrentBlock(), symbol);
   5.189          assert depth != -1;
   5.190 -        if(depth > 0) {
   5.191 +        if (depth > 0) {
   5.192              if (swap) {
   5.193                  method.swap();
   5.194              }
   5.195 @@ -328,46 +381,46 @@
   5.196           */
   5.197          final CodeGenerator codegen = this;
   5.198  
   5.199 -        node.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
   5.200 +        node.accept(new NodeVisitor() {
   5.201              @Override
   5.202 -            public Node enterIdentNode(final IdentNode identNode) {
   5.203 +            public boolean enterIdentNode(final IdentNode identNode) {
   5.204                  loadIdent(identNode);
   5.205 -                return null;
   5.206 +                return false;
   5.207              }
   5.208  
   5.209              @Override
   5.210 -            public Node enterAccessNode(final AccessNode accessNode) {
   5.211 +            public boolean enterAccessNode(final AccessNode accessNode) {
   5.212                  if (!baseAlreadyOnStack) {
   5.213                      load(accessNode.getBase()).convert(Type.OBJECT);
   5.214                  }
   5.215                  assert method.peekType().isObject();
   5.216                  method.dynamicGet(node.getType(), accessNode.getProperty().getName(), getCallSiteFlags(), accessNode.isFunction());
   5.217 -                return null;
   5.218 +                return false;
   5.219              }
   5.220  
   5.221              @Override
   5.222 -            public Node enterIndexNode(final IndexNode indexNode) {
   5.223 +            public boolean enterIndexNode(final IndexNode indexNode) {
   5.224                  if (!baseAlreadyOnStack) {
   5.225                      load(indexNode.getBase()).convert(Type.OBJECT);
   5.226                      load(indexNode.getIndex());
   5.227                  }
   5.228                  method.dynamicGetIndex(node.getType(), getCallSiteFlags(), indexNode.isFunction());
   5.229 -                return null;
   5.230 +                return false;
   5.231              }
   5.232  
   5.233              @Override
   5.234 -            public Node enterFunctionNode(FunctionNode functionNode) {
   5.235 +            public boolean enterFunctionNode(FunctionNode functionNode) {
   5.236                  // function nodes will always leave a constructed function object on stack, no need to load the symbol
   5.237                  // separately as in enterDefault()
   5.238                  functionNode.accept(codegen);
   5.239 -                return null;
   5.240 +                return false;
   5.241              }
   5.242  
   5.243              @Override
   5.244 -            public Node enterDefault(final Node otherNode) {
   5.245 +            public boolean enterDefault(final Node otherNode) {
   5.246                  otherNode.accept(codegen); // generate code for whatever we are looking at.
   5.247                  method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there)
   5.248 -                return null;
   5.249 +                return false;
   5.250              }
   5.251          });
   5.252  
   5.253 @@ -375,14 +428,9 @@
   5.254      }
   5.255  
   5.256      @Override
   5.257 -    public Node enterAccessNode(final AccessNode accessNode) {
   5.258 -        if (accessNode.testResolved()) {
   5.259 -            return null;
   5.260 -        }
   5.261 -
   5.262 +    public boolean enterAccessNode(final AccessNode accessNode) {
   5.263          load(accessNode);
   5.264 -
   5.265 -        return null;
   5.266 +        return false;
   5.267      }
   5.268  
   5.269      /**
   5.270 @@ -407,7 +455,7 @@
   5.271              final boolean isInternal = symbol.isParam() || symbol.isInternal() || symbol.isThis() || !symbol.canBeUndefined();
   5.272  
   5.273              if (symbol.hasSlot() && !isInternal) {
   5.274 -                assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + getCurrentFunctionNode();
   5.275 +                assert symbol.getSymbolType().isNumber() || symbol.getSymbolType().isObject() : "no potentially undefined narrower local vars than doubles are allowed: " + symbol + " in " + getLexicalContext().getCurrentFunction();
   5.276                  if (symbol.getSymbolType().isNumber()) {
   5.277                      numbers.add(symbol);
   5.278                  } else if (symbol.getSymbolType().isObject()) {
   5.279 @@ -441,22 +489,20 @@
   5.280       * @param block block containing symbols.
   5.281       */
   5.282      private void symbolInfo(final Block block) {
   5.283 -        for (final Symbol symbol : block.getFrame().getSymbols()) {
   5.284 -            method.localVariable(symbol, block.getEntryLabel(), block.getBreakLabel());
   5.285 +        for (final Iterator<Symbol> iter = block.symbolIterator(); iter.hasNext(); ) {
   5.286 +            final Symbol symbol = iter.next();
   5.287 +            if (symbol.hasSlot()) {
   5.288 +                method.localVariable(symbol, block.getEntryLabel(), block.getBreakLabel());
   5.289 +            }
   5.290          }
   5.291      }
   5.292  
   5.293      @Override
   5.294 -    public Node enterBlock(final Block block) {
   5.295 -        if (block.testResolved()) {
   5.296 -            return null;
   5.297 -        }
   5.298 -        lexicalContext.push(block);
   5.299 -
   5.300 +    public boolean enterBlock(final Block block) {
   5.301          method.label(block.getEntryLabel());
   5.302          initLocals(block);
   5.303  
   5.304 -        return block;
   5.305 +        return true;
   5.306      }
   5.307  
   5.308      @Override
   5.309 @@ -464,10 +510,10 @@
   5.310          method.label(block.getBreakLabel());
   5.311          symbolInfo(block);
   5.312  
   5.313 -        if (block.needsScope()) {
   5.314 +        if (block.needsScope() && !block.isTerminal()) {
   5.315              popBlockScope(block);
   5.316          }
   5.317 -        lexicalContext.pop(block);
   5.318 +        --nextFreeSlotsSize;
   5.319          return block;
   5.320      }
   5.321  
   5.322 @@ -477,34 +523,30 @@
   5.323          final Label skipLabel     = new Label("skip_catch");
   5.324  
   5.325          /* pop scope a la try-finally */
   5.326 -        method.loadScope();
   5.327 +        method.loadCompilerConstant(SCOPE);
   5.328          method.invoke(ScriptObject.GET_PROTO);
   5.329 -        method.storeScope();
   5.330 +        method.storeCompilerConstant(SCOPE);
   5.331          method._goto(skipLabel);
   5.332          method.label(exitLabel);
   5.333  
   5.334          method._catch(recoveryLabel);
   5.335 -        method.loadScope();
   5.336 +        method.loadCompilerConstant(SCOPE);
   5.337          method.invoke(ScriptObject.GET_PROTO);
   5.338 -        method.storeScope();
   5.339 +        method.storeCompilerConstant(SCOPE);
   5.340          method.athrow();
   5.341          method.label(skipLabel);
   5.342          method._try(block.getEntryLabel(), exitLabel, recoveryLabel, Throwable.class);
   5.343      }
   5.344  
   5.345      @Override
   5.346 -    public Node enterBreakNode(final BreakNode breakNode) {
   5.347 -        if (breakNode.testResolved()) {
   5.348 -            return null;
   5.349 -        }
   5.350 -
   5.351 -        for (int i = 0; i < breakNode.getScopeNestingLevel(); i++) {
   5.352 +    public boolean enterBreakNode(final BreakNode breakNode) {
   5.353 +        final BreakableNode breakFrom = getLexicalContext().getBreakable(breakNode.getLabel());
   5.354 +        for (int i = 0; i < getLexicalContext().getScopeNestingLevelTo(breakFrom); i++) {
   5.355              closeWith();
   5.356          }
   5.357 -
   5.358 -        method.splitAwareGoto(breakNode.getTargetLabel());
   5.359 -
   5.360 -        return null;
   5.361 +        method.splitAwareGoto(getLexicalContext(), breakFrom.getBreakLabel());
   5.362 +
   5.363 +        return false;
   5.364      }
   5.365  
   5.366      private int loadArgs(final List<Node> args) {
   5.367 @@ -541,21 +583,17 @@
   5.368      }
   5.369  
   5.370      @Override
   5.371 -    public Node enterCallNode(final CallNode callNode) {
   5.372 -        if (callNode.testResolved()) {
   5.373 -            return null;
   5.374 -        }
   5.375 -
   5.376 +    public boolean enterCallNode(final CallNode callNode) {
   5.377          final List<Node>   args            = callNode.getArgs();
   5.378          final Node         function        = callNode.getFunction();
   5.379 -        final Block        currentBlock    = getCurrentBlock();
   5.380 -
   5.381 -        function.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
   5.382 +        final Block        currentBlock    = getLexicalContext().getCurrentBlock();
   5.383 +
   5.384 +        function.accept(new NodeVisitor() {
   5.385  
   5.386              private void sharedScopeCall(final IdentNode identNode, final int flags) {
   5.387                  final Symbol symbol = identNode.getSymbol();
   5.388                  int    scopeCallFlags = flags;
   5.389 -                method.loadScope();
   5.390 +                method.loadCompilerConstant(SCOPE);
   5.391                  if (isFastScope(symbol)) {
   5.392                      method.load(getScopeProtoDepth(currentBlock, symbol));
   5.393                      scopeCallFlags |= CALLSITE_FAST_SCOPE;
   5.394 @@ -591,7 +629,7 @@
   5.395                  // We don't need ScriptFunction object for 'eval'
   5.396                  method.pop();
   5.397  
   5.398 -                method.loadScope(); // Load up self (scope).
   5.399 +                method.loadCompilerConstant(SCOPE); // Load up self (scope).
   5.400  
   5.401                  final CallNode.EvalArgs evalArgs = callNode.getEvalArgs();
   5.402                  // load evaluated code
   5.403 @@ -618,7 +656,7 @@
   5.404              }
   5.405  
   5.406              @Override
   5.407 -            public Node enterIdentNode(final IdentNode node) {
   5.408 +            public boolean enterIdentNode(final IdentNode node) {
   5.409                  final Symbol symbol = node.getSymbol();
   5.410  
   5.411                  if (symbol.isScope()) {
   5.412 @@ -637,16 +675,16 @@
   5.413                      } else {
   5.414                          sharedScopeCall(node, flags);
   5.415                      }
   5.416 -                    assert method.peekType().equals(callNode.getType());
   5.417 +                    assert method.peekType().equals(callNode.getType()) : method.peekType() + "!=" + callNode.getType();
   5.418                  } else {
   5.419                      enterDefault(node);
   5.420                  }
   5.421  
   5.422 -                return null;
   5.423 +                return false;
   5.424              }
   5.425  
   5.426              @Override
   5.427 -            public Node enterAccessNode(final AccessNode node) {
   5.428 +            public boolean enterAccessNode(final AccessNode node) {
   5.429                  load(node.getBase());
   5.430                  method.convert(Type.OBJECT);
   5.431                  method.dup();
   5.432 @@ -655,35 +693,34 @@
   5.433                  method.dynamicCall(callNode.getType(), 2 + loadArgs(args), getCallSiteFlags());
   5.434                  assert method.peekType().equals(callNode.getType());
   5.435  
   5.436 -                return null;
   5.437 +                return false;
   5.438              }
   5.439  
   5.440              @Override
   5.441 -            public Node enterFunctionNode(final FunctionNode callee) {
   5.442 +            public boolean enterFunctionNode(final FunctionNode origCallee) {
   5.443 +                // NOTE: visiting the callee will leave a constructed ScriptFunction object on the stack if
   5.444 +                // callee.needsCallee() == true
   5.445 +                final FunctionNode callee = (FunctionNode)origCallee.accept(CodeGenerator.this);
   5.446 +
   5.447                  final boolean      isVarArg = callee.isVarArg();
   5.448                  final int          argCount = isVarArg ? -1 : callee.getParameters().size();
   5.449  
   5.450                  final String signature = new FunctionSignature(true, callee.needsCallee(), callee.getReturnType(), isVarArg ? null : callee.getParameters()).toString();
   5.451  
   5.452 -                if (callee.needsCallee()) {
   5.453 -                    newFunctionObject(callee);
   5.454 -                }
   5.455 -
   5.456 -                if (callee.isStrictMode()) { // self is undefined
   5.457 +                if (callee.isStrict()) { // self is undefined
   5.458                      method.loadUndefined(Type.OBJECT);
   5.459                  } else { // get global from scope (which is the self)
   5.460                      globalInstance();
   5.461                  }
   5.462                  loadArgs(args, signature, isVarArg, argCount);
   5.463 +                assert callee.getCompileUnit() != null : "no compile unit for " + callee.getName() + " " + Debug.id(callee) + " " + callNode;
   5.464                  method.invokestatic(callee.getCompileUnit().getUnitClassName(), callee.getName(), signature);
   5.465                  assert method.peekType().equals(callee.getReturnType()) : method.peekType() + " != " + callee.getReturnType();
   5.466 -                functionNodeIsCallee = true;
   5.467 -                callee.accept(CodeGenerator.this);
   5.468 -                return null;
   5.469 +                return false;
   5.470              }
   5.471  
   5.472              @Override
   5.473 -            public Node enterIndexNode(final IndexNode node) {
   5.474 +            public boolean enterIndexNode(final IndexNode node) {
   5.475                  load(node.getBase());
   5.476                  method.convert(Type.OBJECT);
   5.477                  method.dup();
   5.478 @@ -697,11 +734,11 @@
   5.479                  method.dynamicCall(callNode.getType(), 2 + loadArgs(args), getCallSiteFlags());
   5.480                  assert method.peekType().equals(callNode.getType());
   5.481  
   5.482 -                return null;
   5.483 +                return false;
   5.484              }
   5.485  
   5.486              @Override
   5.487 -            protected Node enterDefault(final Node node) {
   5.488 +            protected boolean enterDefault(final Node node) {
   5.489                  // Load up function.
   5.490                  load(function);
   5.491                  method.convert(Type.OBJECT); //TODO, e.g. booleans can be used as functions
   5.492 @@ -709,58 +746,41 @@
   5.493                  method.dynamicCall(callNode.getType(), 2 + loadArgs(args), getCallSiteFlags() | CALLSITE_SCOPE);
   5.494                  assert method.peekType().equals(callNode.getType());
   5.495  
   5.496 -                return null;
   5.497 +                return false;
   5.498              }
   5.499          });
   5.500  
   5.501          method.store(callNode.getSymbol());
   5.502  
   5.503 -        return null;
   5.504 +        return false;
   5.505      }
   5.506  
   5.507      @Override
   5.508 -    public Node enterContinueNode(final ContinueNode continueNode) {
   5.509 -        if (continueNode.testResolved()) {
   5.510 -            return null;
   5.511 -        }
   5.512 -
   5.513 -        for (int i = 0; i < continueNode.getScopeNestingLevel(); i++) {
   5.514 +    public boolean enterContinueNode(final ContinueNode continueNode) {
   5.515 +        final LoopNode continueTo = getLexicalContext().getContinueTo(continueNode.getLabel());
   5.516 +        for (int i = 0; i < getLexicalContext().getScopeNestingLevelTo(continueTo); i++) {
   5.517              closeWith();
   5.518          }
   5.519 -
   5.520 -        method.splitAwareGoto(continueNode.getTargetLabel());
   5.521 -
   5.522 -        return null;
   5.523 +        method.splitAwareGoto(getLexicalContext(), continueTo.getContinueLabel());
   5.524 +
   5.525 +        return false;
   5.526      }
   5.527  
   5.528      @Override
   5.529 -    public Node enterDoWhileNode(final DoWhileNode doWhileNode) {
   5.530 -        return enterWhileNode(doWhileNode);
   5.531 +    public boolean enterEmptyNode(final EmptyNode emptyNode) {
   5.532 +        return false;
   5.533      }
   5.534  
   5.535      @Override
   5.536 -    public Node enterEmptyNode(final EmptyNode emptyNode) {
   5.537 -        return null;
   5.538 -    }
   5.539 -
   5.540 -    @Override
   5.541 -    public Node enterExecuteNode(final ExecuteNode executeNode) {
   5.542 -        if (executeNode.testResolved()) {
   5.543 -            return null;
   5.544 -        }
   5.545 -
   5.546 +    public boolean enterExecuteNode(final ExecuteNode executeNode) {
   5.547          final Node expression = executeNode.getExpression();
   5.548          expression.accept(this);
   5.549  
   5.550 -        return null;
   5.551 +        return false;
   5.552      }
   5.553  
   5.554      @Override
   5.555 -    public Node enterForNode(final ForNode forNode) {
   5.556 -        if (forNode.testResolved()) {
   5.557 -            return null;
   5.558 -        }
   5.559 -
   5.560 +    public boolean enterForNode(final ForNode forNode) {
   5.561          final Node  test   = forNode.getTest();
   5.562          final Block body   = forNode.getBody();
   5.563          final Node  modify = forNode.getModify();
   5.564 @@ -790,6 +810,10 @@
   5.565  
   5.566              new Store<Node>(init) {
   5.567                  @Override
   5.568 +                protected void storeNonDiscard() {
   5.569 +                    return;
   5.570 +                }
   5.571 +                @Override
   5.572                  protected void evaluate() {
   5.573                      method.load(iter);
   5.574                      method.invoke(interfaceCallNoLookup(Iterator.class, "next", Object.class));
   5.575 @@ -829,7 +853,19 @@
   5.576              method.label(breakLabel);
   5.577          }
   5.578  
   5.579 -        return null;
   5.580 +        return false;
   5.581 +    }
   5.582 +
   5.583 +    private static int assignSlots(final Block block, final int firstSlot) {
   5.584 +        int nextSlot = firstSlot;
   5.585 +        for (final Iterator<Symbol> iter = block.symbolIterator(); iter.hasNext(); ) {
   5.586 +            final Symbol next = iter.next();
   5.587 +            if (next.hasSlot()) {
   5.588 +                next.setSlot(nextSlot);
   5.589 +                nextSlot += next.slotCount();
   5.590 +            }
   5.591 +        }
   5.592 +        return nextSlot;
   5.593      }
   5.594  
   5.595      /**
   5.596 @@ -838,21 +874,26 @@
   5.597       * @param block block with local vars.
   5.598       */
   5.599      private void initLocals(final Block block) {
   5.600 -        final FunctionNode function       = lexicalContext.getFunction(block);
   5.601 -        final boolean      isFunctionNode = block == function;
   5.602 -
   5.603 -        /*
   5.604 -         * Get the symbols from the frame and realign the frame so that all
   5.605 -         * slots get correct numbers. The slot numbering is not fixed until
   5.606 -         * after initLocals has been run
   5.607 -         */
   5.608 -        final Frame        frame   = block.getFrame();
   5.609 -        final List<Symbol> symbols = frame.getSymbols();
   5.610 -
   5.611 -        /* Fix the predefined slots so they have numbers >= 0, like varargs. */
   5.612 -        frame.realign();
   5.613 -
   5.614 -        if (isFunctionNode) {
   5.615 +        final boolean isFunctionBody = getLexicalContext().isFunctionBody();
   5.616 +
   5.617 +        final int nextFreeSlot;
   5.618 +        if (isFunctionBody) {
   5.619 +            // On entry to function, start with slot 0
   5.620 +            nextFreeSlot = 0;
   5.621 +        } else {
   5.622 +            // Otherwise, continue from previous block's first free slot
   5.623 +            nextFreeSlot = nextFreeSlots[nextFreeSlotsSize - 1];
   5.624 +        }
   5.625 +        if(nextFreeSlotsSize == nextFreeSlots.length) {
   5.626 +            final int[] newNextFreeSlots = new int[nextFreeSlotsSize * 2];
   5.627 +            System.arraycopy(nextFreeSlots, 0, newNextFreeSlots, 0, nextFreeSlotsSize);
   5.628 +            nextFreeSlots = newNextFreeSlots;
   5.629 +        }
   5.630 +        nextFreeSlots[nextFreeSlotsSize++] = assignSlots(block, nextFreeSlot);
   5.631 +
   5.632 +        final FunctionNode function = getLexicalContext().getCurrentFunction();
   5.633 +        if (isFunctionBody) {
   5.634 +            /* Fix the predefined slots so they have numbers >= 0, like varargs. */
   5.635              if (function.needsParentScope()) {
   5.636                  initParentScope();
   5.637              }
   5.638 @@ -876,14 +917,18 @@
   5.639              final List<String> nameList = new ArrayList<>();
   5.640              final List<Symbol> locals   = new ArrayList<>();
   5.641  
   5.642 -
   5.643              // Initalize symbols and values
   5.644              final List<Symbol> newSymbols = new ArrayList<>();
   5.645              final List<Symbol> values     = new ArrayList<>();
   5.646  
   5.647              final boolean hasArguments = function.needsArguments();
   5.648 -            for (final Symbol symbol : symbols) {
   5.649 -                if (symbol.isInternal() || symbol.isThis()) {
   5.650 +
   5.651 +            final Iterator<Symbol> symbols = block.symbolIterator();
   5.652 +
   5.653 +            while (symbols.hasNext()) {
   5.654 +                final Symbol symbol = symbols.next();
   5.655 +
   5.656 +                if (symbol.isInternal() || symbol.isThis() || symbol.isTemp()) {
   5.657                      continue;
   5.658                  }
   5.659  
   5.660 @@ -907,9 +952,6 @@
   5.661                  }
   5.662              }
   5.663  
   5.664 -            /* Correct slot numbering again */
   5.665 -            frame.realign();
   5.666 -
   5.667              // we may have locals that need to be initialized
   5.668              initSymbols(locals);
   5.669  
   5.670 @@ -931,7 +973,7 @@
   5.671                  @Override
   5.672                  protected void loadScope(MethodEmitter m) {
   5.673                      if(function.needsParentScope()) {
   5.674 -                        m.loadScope();
   5.675 +                        m.loadCompilerConstant(SCOPE);
   5.676                      } else {
   5.677                          m.loadNull();
   5.678                      }
   5.679 @@ -940,118 +982,102 @@
   5.680              foc.makeObject(method);
   5.681  
   5.682              // runScript(): merge scope into global
   5.683 -            if (isFunctionNode && function.isProgram()) {
   5.684 +            if (isFunctionBody && function.isProgram()) {
   5.685                  method.invoke(ScriptRuntime.MERGE_SCOPE);
   5.686              }
   5.687  
   5.688 -            method.storeScope();
   5.689 +            method.storeCompilerConstant(SCOPE);
   5.690          } else {
   5.691              // Since we don't have a scope, parameters didn't get assigned array indices by the FieldObjectCreator, so
   5.692              // we need to assign them separately here.
   5.693              int nextParam = 0;
   5.694 -            if (isFunctionNode && function.isVarArg()) {
   5.695 +            if (isFunctionBody && function.isVarArg()) {
   5.696                  for (final IdentNode param : function.getParameters()) {
   5.697                      param.getSymbol().setFieldIndex(nextParam++);
   5.698                  }
   5.699              }
   5.700 +
   5.701 +            final Iterator<Symbol> iter = block.symbolIterator();
   5.702 +            final List<Symbol> symbols = new ArrayList<>();
   5.703 +            while (iter.hasNext()) {
   5.704 +                symbols.add(iter.next());
   5.705 +            }
   5.706              initSymbols(symbols);
   5.707          }
   5.708  
   5.709          // Debugging: print symbols? @see --print-symbols flag
   5.710 -        printSymbols(block, (isFunctionNode ? "Function " : "Block in ") + (function.getIdent() == null ? "<anonymous>" : function.getIdent().getName()));
   5.711 +        printSymbols(block, (isFunctionBody ? "Function " : "Block in ") + (function.getIdent() == null ? "<anonymous>" : function.getIdent().getName()));
   5.712      }
   5.713  
   5.714      private void initArguments(final FunctionNode function) {
   5.715 -        method.loadVarArgs();
   5.716 +        method.loadCompilerConstant(VARARGS);
   5.717          if(function.needsCallee()) {
   5.718 -            method.loadCallee();
   5.719 +            method.loadCompilerConstant(CALLEE);
   5.720          } else {
   5.721              // If function is strict mode, "arguments.callee" is not populated, so we don't necessarily need the
   5.722              // caller.
   5.723 -            assert function.isStrictMode();
   5.724 +            assert function.isStrict();
   5.725              method.loadNull();
   5.726          }
   5.727          method.load(function.getParameters().size());
   5.728          globalAllocateArguments();
   5.729 -        method.storeArguments();
   5.730 +        method.storeCompilerConstant(ARGUMENTS);
   5.731      }
   5.732  
   5.733      private void initParentScope() {
   5.734 -        method.loadCallee();
   5.735 +        method.loadCompilerConstant(CALLEE);
   5.736          method.invoke(ScriptFunction.GET_SCOPE);
   5.737 -        method.storeScope();
   5.738 +        method.storeCompilerConstant(SCOPE);
   5.739      }
   5.740  
   5.741      @Override
   5.742 -    public Node enterFunctionNode(final FunctionNode functionNode) {
   5.743 -        final boolean isCallee = functionNodeIsCallee;
   5.744 -        functionNodeIsCallee = false;
   5.745 -
   5.746 -        if (functionNode.testResolved()) {
   5.747 -            return null;
   5.748 +    public boolean enterFunctionNode(final FunctionNode functionNode) {
   5.749 +        if (functionNode.isLazy()) {
   5.750 +            // Must do it now; can't postpone it until leaveFunctionNode()
   5.751 +            newFunctionObject(functionNode, functionNode);
   5.752 +            return false;
   5.753          }
   5.754  
   5.755 -        if(!(isCallee || functionNode == compiler.getFunctionNode())) {
   5.756 -            newFunctionObject(functionNode);
   5.757 -        }
   5.758 -
   5.759 -        if (functionNode.isLazy()) {
   5.760 -            return null;
   5.761 -        }
   5.762 -
   5.763 -        LOG.info("=== BEGIN " + functionNode.getName());
   5.764 -        lexicalContext.push(functionNode);
   5.765 -
   5.766 -        setCurrentCompileUnit(functionNode.getCompileUnit());
   5.767 -        assert getCurrentCompileUnit() != null;
   5.768 -
   5.769 -        setCurrentMethodEmitter(getCurrentCompileUnit().getClassEmitter().method(functionNode));
   5.770 -        functionNode.setMethodEmitter(method);
   5.771 +        LOG.info("=== BEGIN ", functionNode.getName());
   5.772 +
   5.773 +        assert functionNode.getCompileUnit() != null : "no compile unit for " + functionNode.getName() + " " + Debug.id(functionNode);
   5.774 +        push(functionNode.getCompileUnit());
   5.775 +        assert !compileUnits.isEmpty();
   5.776 +
   5.777 +        pushMethodEmitter(unit.getClassEmitter().method(functionNode));
   5.778          // Mark end for variable tables.
   5.779          method.begin();
   5.780 -        method.label(functionNode.getEntryLabel());
   5.781 -
   5.782 -        initLocals(functionNode);
   5.783 -        functionNode.setState(CompilationState.EMITTED);
   5.784 -
   5.785 -        return functionNode;
   5.786 +
   5.787 +        return true;
   5.788      }
   5.789  
   5.790      @Override
   5.791      public Node leaveFunctionNode(final FunctionNode functionNode) {
   5.792 -        // Mark end for variable tables.
   5.793 -        method.label(functionNode.getBreakLabel());
   5.794 -
   5.795 -        if (!functionNode.needsScope()) {
   5.796 -            method.markerVariable(LEAF.tag(), functionNode.getEntryLabel(), functionNode.getBreakLabel());
   5.797 -        }
   5.798 -
   5.799 -        symbolInfo(functionNode);
   5.800          try {
   5.801              method.end(); // wrap up this method
   5.802 +            pop(functionNode.getCompileUnit());
   5.803 +            popMethodEmitter(method);
   5.804 +            LOG.info("=== END ", functionNode.getName());
   5.805 +
   5.806 +            final FunctionNode newFunctionNode = functionNode.setState(getLexicalContext(), CompilationState.EMITTED);
   5.807 +
   5.808 +            newFunctionObject(newFunctionNode, functionNode);
   5.809 +            return newFunctionNode;
   5.810          } catch (final Throwable t) {
   5.811              Context.printStackTrace(t);
   5.812              final VerifyError e = new VerifyError("Code generation bug in \"" + functionNode.getName() + "\": likely stack misaligned: " + t + " " + functionNode.getSource().getName());
   5.813              e.initCause(t);
   5.814              throw e;
   5.815          }
   5.816 -
   5.817 -        lexicalContext.pop(functionNode);
   5.818 -        LOG.info("=== END " + functionNode.getName());
   5.819 -        return functionNode;
   5.820      }
   5.821  
   5.822      @Override
   5.823 -    public Node enterIdentNode(final IdentNode identNode) {
   5.824 -        return null;
   5.825 +    public boolean enterIdentNode(final IdentNode identNode) {
   5.826 +        return false;
   5.827      }
   5.828  
   5.829      @Override
   5.830 -    public Node enterIfNode(final IfNode ifNode) {
   5.831 -        if (ifNode.testResolved()) {
   5.832 -            return null;
   5.833 -        }
   5.834 -
   5.835 +    public boolean enterIfNode(final IfNode ifNode) {
   5.836          final Node  test = ifNode.getTest();
   5.837          final Block pass = ifNode.getPass();
   5.838          final Block fail = ifNode.getFail();
   5.839 @@ -1082,30 +1108,21 @@
   5.840              method.label(afterLabel);
   5.841          }
   5.842  
   5.843 -        return null;
   5.844 +        return false;
   5.845      }
   5.846  
   5.847      @Override
   5.848 -    public Node enterIndexNode(final IndexNode indexNode) {
   5.849 -        if (indexNode.testResolved()) {
   5.850 -            return null;
   5.851 -        }
   5.852 -
   5.853 +    public boolean enterIndexNode(final IndexNode indexNode) {
   5.854          load(indexNode);
   5.855 -
   5.856 -        return null;
   5.857 +        return false;
   5.858      }
   5.859  
   5.860      @Override
   5.861 -    public Node enterLineNumberNode(final LineNumberNode lineNumberNode) {
   5.862 -        if (lineNumberNode.testResolved()) {
   5.863 -            return null;
   5.864 -        }
   5.865 -
   5.866 -        final Label label = new Label("line:" + lineNumberNode.getLineNumber() + " (" + getCurrentFunctionNode().getName() + ")");
   5.867 +    public boolean enterLineNumberNode(final LineNumberNode lineNumberNode) {
   5.868 +        final Label label = new Label("line:" + lineNumberNode.getLineNumber() + " (" + getLexicalContext().getCurrentFunction().getName() + ")");
   5.869          method.label(label);
   5.870          method.lineNumber(lineNumberNode.getLineNumber(), label);
   5.871 -        return null;
   5.872 +        return false;
   5.873      }
   5.874  
   5.875      /**
   5.876 @@ -1131,43 +1148,43 @@
   5.877          final Type elementType = arrayType.getElementType();
   5.878  
   5.879          if (units != null) {
   5.880 -            final CompileUnit   savedCompileUnit = getCurrentCompileUnit();
   5.881 -            final MethodEmitter savedMethod      = getCurrentMethodEmitter();
   5.882 -
   5.883 -            try {
   5.884 -                for (final ArrayUnit unit : units) {
   5.885 -                    setCurrentCompileUnit(unit.getCompileUnit());
   5.886 -
   5.887 -                    final String className = getCurrentCompileUnit().getUnitClassName();
   5.888 -                    final String name      = getCurrentFunctionNode().uniqueName(SPLIT_PREFIX.tag());
   5.889 -                    final String signature = methodDescriptor(type, Object.class, ScriptFunction.class, ScriptObject.class, type);
   5.890 -
   5.891 -                    setCurrentMethodEmitter(getCurrentCompileUnit().getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature));
   5.892 -                    method.setFunctionNode(getCurrentFunctionNode());
   5.893 -                    method.begin();
   5.894 -
   5.895 -                    fixScopeSlot();
   5.896 -
   5.897 -                    method.load(arrayType, SPLIT_ARRAY_ARG.slot());
   5.898 -
   5.899 -                    for (int i = unit.getLo(); i < unit.getHi(); i++) {
   5.900 -                        storeElement(nodes, elementType, postsets[i]);
   5.901 -                    }
   5.902 -
   5.903 -                    method._return();
   5.904 -                    method.end();
   5.905 -
   5.906 -                    savedMethod.loadThis();
   5.907 -                    savedMethod.swap();
   5.908 -                    savedMethod.loadCallee();
   5.909 -                    savedMethod.swap();
   5.910 -                    savedMethod.loadScope();
   5.911 -                    savedMethod.swap();
   5.912 -                    savedMethod.invokestatic(className, name, signature);
   5.913 +            final MethodEmitter savedMethod = method;
   5.914 +
   5.915 +            for (final ArrayUnit arrayUnit : units) {
   5.916 +                push(arrayUnit.getCompileUnit());
   5.917 +
   5.918 +                final String className = unit.getUnitClassName();
   5.919 +                final String name      = getLexicalContext().getCurrentFunction().uniqueName(SPLIT_PREFIX.symbolName());
   5.920 +                final String signature = methodDescriptor(type, Object.class, ScriptFunction.class, ScriptObject.class, type);
   5.921 +
   5.922 +                final MethodEmitter me = unit.getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature);
   5.923 +                pushMethodEmitter(me);
   5.924 +
   5.925 +                method.setFunctionNode(getLexicalContext().getCurrentFunction());
   5.926 +                method.begin();
   5.927 +
   5.928 +                fixScopeSlot();
   5.929 +
   5.930 +                method.load(arrayType, SPLIT_ARRAY_ARG.slot());
   5.931 +
   5.932 +                for (int i = arrayUnit.getLo(); i < arrayUnit.getHi(); i++) {
   5.933 +                    storeElement(nodes, elementType, postsets[i]);
   5.934                  }
   5.935 -            } finally {
   5.936 -                setCurrentCompileUnit(savedCompileUnit);
   5.937 -                setCurrentMethodEmitter(savedMethod);
   5.938 +
   5.939 +                method._return();
   5.940 +                method.end();
   5.941 +                popMethodEmitter(me);
   5.942 +
   5.943 +                assert method == savedMethod;
   5.944 +                method.loadCompilerConstant(THIS);
   5.945 +                method.swap();
   5.946 +                method.loadCompilerConstant(CALLEE);
   5.947 +                method.swap();
   5.948 +                method.loadCompilerConstant(SCOPE);
   5.949 +                method.swap();
   5.950 +                method.invokestatic(className, name, signature);
   5.951 +
   5.952 +                pop(unit);
   5.953              }
   5.954  
   5.955              return method;
   5.956 @@ -1217,12 +1234,12 @@
   5.957       * @param string string to load
   5.958       */
   5.959      void loadConstant(final String string) {
   5.960 -        final String       unitClassName = getCurrentCompileUnit().getUnitClassName();
   5.961 -        final ClassEmitter classEmitter  = getCurrentCompileUnit().getClassEmitter();
   5.962 +        final String       unitClassName = unit.getUnitClassName();
   5.963 +        final ClassEmitter classEmitter  = unit.getClassEmitter();
   5.964          final int          index         = compiler.getConstantData().add(string);
   5.965  
   5.966          method.load(index);
   5.967 -        method.invokestatic(unitClassName, GET_STRING.tag(), methodDescriptor(String.class, int.class));
   5.968 +        method.invokestatic(unitClassName, GET_STRING.symbolName(), methodDescriptor(String.class, int.class));
   5.969          classEmitter.needGetConstantMethod(String.class);
   5.970      }
   5.971  
   5.972 @@ -1233,14 +1250,14 @@
   5.973       * @param object object to load
   5.974       */
   5.975      void loadConstant(final Object object) {
   5.976 -        final String       unitClassName = getCurrentCompileUnit().getUnitClassName();
   5.977 -        final ClassEmitter classEmitter  = getCurrentCompileUnit().getClassEmitter();
   5.978 +        final String       unitClassName = unit.getUnitClassName();
   5.979 +        final ClassEmitter classEmitter  = unit.getClassEmitter();
   5.980          final int          index         = compiler.getConstantData().add(object);
   5.981          final Class<?>     cls           = object.getClass();
   5.982  
   5.983          if (cls == PropertyMap.class) {
   5.984              method.load(index);
   5.985 -            method.invokestatic(unitClassName, GET_MAP.tag(), methodDescriptor(PropertyMap.class, int.class));
   5.986 +            method.invokestatic(unitClassName, GET_MAP.symbolName(), methodDescriptor(PropertyMap.class, int.class));
   5.987              classEmitter.needGetConstantMethod(PropertyMap.class);
   5.988          } else if (cls.isArray()) {
   5.989              method.load(index);
   5.990 @@ -1303,14 +1320,14 @@
   5.991              return loadRegexToken(regexToken);
   5.992          }
   5.993          // emit field
   5.994 -        final String       regexName    = getCurrentFunctionNode().uniqueName(REGEX_PREFIX.tag());
   5.995 -        final ClassEmitter classEmitter = getCurrentCompileUnit().getClassEmitter();
   5.996 +        final String       regexName    = getLexicalContext().getCurrentFunction().uniqueName(REGEX_PREFIX.symbolName());
   5.997 +        final ClassEmitter classEmitter = unit.getClassEmitter();
   5.998  
   5.999          classEmitter.field(EnumSet.of(PRIVATE, STATIC), regexName, Object.class);
  5.1000          regexFieldCount++;
  5.1001  
  5.1002          // get field, if null create new regex, finally clone regex object
  5.1003 -        method.getStatic(getCurrentCompileUnit().getUnitClassName(), regexName, typeDescriptor(Object.class));
  5.1004 +        method.getStatic(unit.getUnitClassName(), regexName, typeDescriptor(Object.class));
  5.1005          method.dup();
  5.1006          final Label cachedLabel = new Label("cached");
  5.1007          method.ifnonnull(cachedLabel);
  5.1008 @@ -1318,7 +1335,7 @@
  5.1009          method.pop();
  5.1010          loadRegexToken(regexToken);
  5.1011          method.dup();
  5.1012 -        method.putStatic(getCurrentCompileUnit().getUnitClassName(), regexName, typeDescriptor(Object.class));
  5.1013 +        method.putStatic(unit.getUnitClassName(), regexName, typeDescriptor(Object.class));
  5.1014  
  5.1015          method.label(cachedLabel);
  5.1016          globalRegExpCopy();
  5.1017 @@ -1328,18 +1345,14 @@
  5.1018  
  5.1019      @SuppressWarnings("rawtypes")
  5.1020      @Override
  5.1021 -    public Node enterLiteralNode(final LiteralNode literalNode) {
  5.1022 +    public boolean enterLiteralNode(final LiteralNode literalNode) {
  5.1023          assert literalNode.getSymbol() != null : literalNode + " has no symbol";
  5.1024          load(literalNode).store(literalNode.getSymbol());
  5.1025 -        return null;
  5.1026 +        return false;
  5.1027      }
  5.1028  
  5.1029      @Override
  5.1030 -    public Node enterObjectNode(final ObjectNode objectNode) {
  5.1031 -        if (objectNode.testResolved()) {
  5.1032 -            return null;
  5.1033 -        }
  5.1034 -
  5.1035 +    public boolean enterObjectNode(final ObjectNode objectNode) {
  5.1036          final List<Node> elements = objectNode.getElements();
  5.1037          final int        size     = elements.size();
  5.1038  
  5.1039 @@ -1404,14 +1417,14 @@
  5.1040  
  5.1041          if (!hasGettersSetters) {
  5.1042              method.store(objectNode.getSymbol());
  5.1043 -            return null;
  5.1044 +            return false;
  5.1045          }
  5.1046  
  5.1047          for (final Node element : elements) {
  5.1048              final PropertyNode propertyNode = (PropertyNode)element;
  5.1049              final Object       key          = propertyNode.getKey();
  5.1050 -            final FunctionNode getter       = (FunctionNode)propertyNode.getGetter();
  5.1051 -            final FunctionNode setter       = (FunctionNode)propertyNode.getSetter();
  5.1052 +            final FunctionNode getter       = propertyNode.getGetter();
  5.1053 +            final FunctionNode setter       = propertyNode.getSetter();
  5.1054  
  5.1055              if (getter == null && setter == null) {
  5.1056                  continue;
  5.1057 @@ -1436,35 +1449,25 @@
  5.1058  
  5.1059          method.store(objectNode.getSymbol());
  5.1060  
  5.1061 -        return null;
  5.1062 +        return false;
  5.1063      }
  5.1064  
  5.1065      @Override
  5.1066 -    public Node enterReturnNode(final ReturnNode returnNode) {
  5.1067 -        if (returnNode.testResolved()) {
  5.1068 -            return null;
  5.1069 -        }
  5.1070 -
  5.1071 -        // Set the split return flag in the scope if this is a split method fragment.
  5.1072 -        if (method.getSplitNode() != null) {
  5.1073 -            assert method.getSplitNode().hasReturn() : "unexpected return in split node";
  5.1074 -
  5.1075 -            method.loadScope();
  5.1076 -            method.checkcast(Scope.class);
  5.1077 -            method.load(0);
  5.1078 -            method.invoke(Scope.SET_SPLIT_STATE);
  5.1079 -        }
  5.1080 +    public boolean enterReturnNode(final ReturnNode returnNode) {
  5.1081 +        method.registerReturn();
  5.1082 +
  5.1083 +        final Type returnType = getLexicalContext().getCurrentFunction().getReturnType();
  5.1084  
  5.1085          final Node expression = returnNode.getExpression();
  5.1086          if (expression != null) {
  5.1087              load(expression);
  5.1088          } else {
  5.1089 -            method.loadUndefined(getCurrentFunctionNode().getReturnType());
  5.1090 +            method.loadUndefined(returnType);
  5.1091          }
  5.1092  
  5.1093 -        method._return(getCurrentFunctionNode().getReturnType());
  5.1094 -
  5.1095 -        return null;
  5.1096 +        method._return(returnType);
  5.1097 +
  5.1098 +        return false;
  5.1099      }
  5.1100  
  5.1101      private static boolean isNullLiteral(final Node node) {
  5.1102 @@ -1542,19 +1545,20 @@
  5.1103          }
  5.1104  
  5.1105          assert args.size() == 2;
  5.1106 -        final Node lhs = args.get(0);
  5.1107 -        final Node rhs = args.get(1);
  5.1108 -
  5.1109          final Type returnType = node.getType();
  5.1110 -        load(lhs);
  5.1111 -        load(rhs);
  5.1112 +
  5.1113 +        load(args.get(0));
  5.1114 +        load(args.get(1));
  5.1115  
  5.1116          Request finalRequest = request;
  5.1117  
  5.1118 +        //if the request is a comparison, i.e. one that can be reversed
  5.1119 +        //it keeps its semantic, but make sure that the object comes in
  5.1120 +        //last
  5.1121          final Request reverse = Request.reverse(request);
  5.1122 -        if (method.peekType().isObject() && reverse != null) {
  5.1123 -            if (!method.peekType(1).isObject()) {
  5.1124 -                method.swap();
  5.1125 +        if (method.peekType().isObject() && reverse != null) { //rhs is object
  5.1126 +            if (!method.peekType(1).isObject()) { //lhs is not object
  5.1127 +                method.swap(); //prefer object as lhs
  5.1128                  finalRequest = reverse;
  5.1129              }
  5.1130          }
  5.1131 @@ -1581,11 +1585,7 @@
  5.1132      }
  5.1133  
  5.1134      @Override
  5.1135 -    public Node enterRuntimeNode(final RuntimeNode runtimeNode) {
  5.1136 -        if (runtimeNode.testResolved()) {
  5.1137 -            return null;
  5.1138 -        }
  5.1139 -
  5.1140 +    public boolean enterRuntimeNode(final RuntimeNode runtimeNode) {
  5.1141          /*
  5.1142           * First check if this should be something other than a runtime node
  5.1143           * AccessSpecializer might have changed the type
  5.1144 @@ -1624,7 +1624,7 @@
  5.1145                  method.add();
  5.1146                  method.convert(type);
  5.1147                  method.store(symbol);
  5.1148 -                return null;
  5.1149 +                return false;
  5.1150              default:
  5.1151                  // it's ok to send this one on with only primitive arguments, maybe INSTANCEOF(true, true) or similar
  5.1152                  // assert false : runtimeNode + " has all primitive arguments. This is an inconsistent state";
  5.1153 @@ -1636,11 +1636,11 @@
  5.1154          final List<Node> args = runtimeNode.getArgs();
  5.1155  
  5.1156          if (nullCheck(runtimeNode, args, new FunctionSignature(false, false, runtimeNode.getType(), args).toString())) {
  5.1157 -            return null;
  5.1158 +            return false;
  5.1159          }
  5.1160  
  5.1161          if (!runtimeNode.isFinal() && specializationCheck(runtimeNode.getRequest(), runtimeNode, args)) {
  5.1162 -            return null;
  5.1163 +            return false;
  5.1164          }
  5.1165  
  5.1166          for (final Node arg : runtimeNode.getArgs()) {
  5.1167 @@ -1658,129 +1658,146 @@
  5.1168          method.convert(runtimeNode.getType());
  5.1169          method.store(runtimeNode.getSymbol());
  5.1170  
  5.1171 -        return null;
  5.1172 +        return false;
  5.1173      }
  5.1174  
  5.1175      @Override
  5.1176 -    public Node enterSplitNode(final SplitNode splitNode) {
  5.1177 -        if (splitNode.testResolved()) {
  5.1178 -            return null;
  5.1179 -        }
  5.1180 -
  5.1181 +    public boolean enterSplitNode(final SplitNode splitNode) {
  5.1182          final CompileUnit splitCompileUnit = splitNode.getCompileUnit();
  5.1183  
  5.1184 -        final FunctionNode fn   = getCurrentFunctionNode();
  5.1185 +        final FunctionNode fn   = getLexicalContext().getCurrentFunction();
  5.1186          final String className  = splitCompileUnit.getUnitClassName();
  5.1187          final String name       = splitNode.getName();
  5.1188  
  5.1189 -        final Class<?>   rtype  = fn.getReturnType().getTypeClass();
  5.1190 -        final boolean needsArguments = fn.needsArguments();
  5.1191 -        final Class<?>[] ptypes = needsArguments ?
  5.1192 +        final Class<?>   rtype          = fn.getReturnType().getTypeClass();
  5.1193 +        final boolean    needsArguments = fn.needsArguments();
  5.1194 +        final Class<?>[] ptypes         = needsArguments ?
  5.1195                  new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class, Object.class} :
  5.1196                  new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class};
  5.1197  
  5.1198 -        setCurrentCompileUnit(splitCompileUnit);
  5.1199 -        splitNode.setCompileUnit(splitCompileUnit);
  5.1200 +        final MethodEmitter caller = method;
  5.1201 +        push(splitCompileUnit);
  5.1202  
  5.1203          final Call splitCall = staticCallNoLookup(
  5.1204              className,
  5.1205              name,
  5.1206              methodDescriptor(rtype, ptypes));
  5.1207  
  5.1208 -        setCurrentMethodEmitter(
  5.1209 -            splitCompileUnit.getClassEmitter().method(
  5.1210 -                EnumSet.of(Flag.PUBLIC, Flag.STATIC),
  5.1211 -                name,
  5.1212 -                rtype,
  5.1213 -                ptypes));
  5.1214 +        final MethodEmitter splitEmitter =
  5.1215 +                splitCompileUnit.getClassEmitter().method(
  5.1216 +                        splitNode,
  5.1217 +                        name,
  5.1218 +                        rtype,
  5.1219 +                        ptypes);
  5.1220 +
  5.1221 +        pushMethodEmitter(splitEmitter);
  5.1222  
  5.1223          method.setFunctionNode(fn);
  5.1224 -        method.setSplitNode(splitNode);
  5.1225 -        splitNode.setMethodEmitter(method);
  5.1226 -
  5.1227 -        final MethodEmitter caller = splitNode.getCaller();
  5.1228 -        if(fn.needsCallee()) {
  5.1229 -            caller.loadCallee();
  5.1230 +
  5.1231 +        if (fn.needsCallee()) {
  5.1232 +            caller.loadCompilerConstant(CALLEE);
  5.1233          } else {
  5.1234              caller.loadNull();
  5.1235          }
  5.1236 -        caller.loadThis();
  5.1237 -        caller.loadScope();
  5.1238 +        caller.loadCompilerConstant(THIS);
  5.1239 +        caller.loadCompilerConstant(SCOPE);
  5.1240          if (needsArguments) {
  5.1241 -            caller.loadArguments();
  5.1242 +            caller.loadCompilerConstant(ARGUMENTS);
  5.1243          }
  5.1244          caller.invoke(splitCall);
  5.1245 -        caller.storeResult();
  5.1246 +        caller.storeCompilerConstant(RETURN);
  5.1247  
  5.1248          method.begin();
  5.1249  
  5.1250          method.loadUndefined(fn.getReturnType());
  5.1251 -        method.storeResult();
  5.1252 +        method.storeCompilerConstant(RETURN);
  5.1253  
  5.1254          fixScopeSlot();
  5.1255  
  5.1256 -        return splitNode;
  5.1257 +        return true;
  5.1258      }
  5.1259  
  5.1260      private void fixScopeSlot() {
  5.1261 -        if (getCurrentFunctionNode().getScopeNode().getSymbol().getSlot() != SCOPE.slot()) {
  5.1262 +        if (getLexicalContext().getCurrentFunction().compilerConstant(SCOPE).getSlot() != SCOPE.slot()) {
  5.1263              // TODO hack to move the scope to the expected slot (that's needed because split methods reuse the same slots as the root method)
  5.1264              method.load(Type.typeFor(ScriptObject.class), SCOPE.slot());
  5.1265 -            method.storeScope();
  5.1266 +            method.storeCompilerConstant(SCOPE);
  5.1267          }
  5.1268      }
  5.1269  
  5.1270      @Override
  5.1271      public Node leaveSplitNode(final SplitNode splitNode) {
  5.1272 +        assert method instanceof SplitMethodEmitter;
  5.1273 +        final boolean     hasReturn = method.hasReturn();
  5.1274 +        final List<Label> targets   = method.getExternalTargets();
  5.1275 +
  5.1276          try {
  5.1277              // Wrap up this method.
  5.1278 -            method.loadResult();
  5.1279 -            method._return(getCurrentFunctionNode().getReturnType());
  5.1280 +
  5.1281 +            method.loadCompilerConstant(RETURN);
  5.1282 +            method._return(getLexicalContext().getCurrentFunction().getReturnType());
  5.1283              method.end();
  5.1284 +
  5.1285 +            pop(splitNode.getCompileUnit());
  5.1286 +            popMethodEmitter(method);
  5.1287 +
  5.1288          } catch (final Throwable t) {
  5.1289              Context.printStackTrace(t);
  5.1290 -            final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + getCurrentFunctionNode().getSource().getName());
  5.1291 +            final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + getLexicalContext().getCurrentFunction().getSource().getName());
  5.1292              e.initCause(t);
  5.1293              throw e;
  5.1294          }
  5.1295  
  5.1296          // Handle return from split method if there was one.
  5.1297 -        final MethodEmitter caller      = splitNode.getCaller();
  5.1298 -        final List<Label>   targets     = splitNode.getExternalTargets();
  5.1299 -        final int           targetCount = targets.size();
  5.1300 -
  5.1301 -        if (splitNode.hasReturn() || targetCount > 0) {
  5.1302 -
  5.1303 -            caller.loadScope();
  5.1304 -            caller.checkcast(Scope.class);
  5.1305 -            caller.invoke(Scope.GET_SPLIT_STATE);
  5.1306 -
  5.1307 -            // Split state is -1 for no split state, 0 for return, 1..n+1 for break/continue
  5.1308 -            final Label   breakLabel = new Label("no_split_state");
  5.1309 -            final int     low        = splitNode.hasReturn() ? 0 : 1;
  5.1310 -            final int     labelCount = targetCount + 1 - low;
  5.1311 -            final Label[] labels     = new Label[labelCount];
  5.1312 +        final MethodEmitter caller = method;
  5.1313 +        final int     targetCount = targets.size();
  5.1314 +
  5.1315 +        //no external jump targets or return in switch node
  5.1316 +        if (!hasReturn && targets.isEmpty()) {
  5.1317 +            return splitNode;
  5.1318 +        }
  5.1319 +
  5.1320 +        caller.loadCompilerConstant(SCOPE);
  5.1321 +        caller.checkcast(Scope.class);
  5.1322 +        caller.invoke(Scope.GET_SPLIT_STATE);
  5.1323 +
  5.1324 +        final Label breakLabel = new Label("no_split_state");
  5.1325 +        // Split state is -1 for no split state, 0 for return, 1..n+1 for break/continue
  5.1326 +
  5.1327 +        //the common case is that we don't need a switch
  5.1328 +        if (targetCount == 0) {
  5.1329 +            assert hasReturn;
  5.1330 +            caller.ifne(breakLabel);
  5.1331 +            //has to be zero
  5.1332 +            caller.label(new Label("split_return"));
  5.1333 +            method.loadCompilerConstant(RETURN);
  5.1334 +            caller._return(getLexicalContext().getCurrentFunction().getReturnType());
  5.1335 +            caller.label(breakLabel);
  5.1336 +        } else {
  5.1337 +            assert !targets.isEmpty();
  5.1338 +
  5.1339 +            final int     low         = hasReturn ? 0 : 1;
  5.1340 +            final int     labelCount  = targetCount + 1 - low;
  5.1341 +            final Label[] labels      = new Label[labelCount];
  5.1342  
  5.1343              for (int i = 0; i < labelCount; i++) {
  5.1344 -                labels[i] = new Label("split_state_" + i);
  5.1345 +                labels[i] = new Label(i == 0 ? "split_return" : "split_" + targets.get(i - 1));
  5.1346              }
  5.1347 -
  5.1348              caller.tableswitch(low, targetCount, breakLabel, labels);
  5.1349              for (int i = low; i <= targetCount; i++) {
  5.1350                  caller.label(labels[i - low]);
  5.1351                  if (i == 0) {
  5.1352 -                    caller.loadResult();
  5.1353 -                    caller._return(getCurrentFunctionNode().getReturnType());
  5.1354 +                    caller.loadCompilerConstant(RETURN);
  5.1355 +                    caller._return(getLexicalContext().getCurrentFunction().getReturnType());
  5.1356                  } else {
  5.1357                      // Clear split state.
  5.1358 -                    caller.loadScope();
  5.1359 +                    caller.loadCompilerConstant(SCOPE);
  5.1360                      caller.checkcast(Scope.class);
  5.1361                      caller.load(-1);
  5.1362                      caller.invoke(Scope.SET_SPLIT_STATE);
  5.1363 -                    caller.splitAwareGoto(targets.get(i - 1));
  5.1364 +                    caller.splitAwareGoto(getLexicalContext(), targets.get(i - 1));
  5.1365                  }
  5.1366              }
  5.1367 -
  5.1368              caller.label(breakLabel);
  5.1369          }
  5.1370  
  5.1371 @@ -1788,11 +1805,7 @@
  5.1372      }
  5.1373  
  5.1374      @Override
  5.1375 -    public Node enterSwitchNode(final SwitchNode switchNode) {
  5.1376 -        if (switchNode.testResolved()) {
  5.1377 -            return null;
  5.1378 -        }
  5.1379 -
  5.1380 +    public boolean enterSwitchNode(final SwitchNode switchNode) {
  5.1381          final Node           expression  = switchNode.getExpression();
  5.1382          final Symbol         tag         = switchNode.getTag();
  5.1383          final boolean        allInteger  = tag.getSymbolType().isInteger();
  5.1384 @@ -1810,7 +1823,7 @@
  5.1385  
  5.1386          if (cases.isEmpty()) {
  5.1387              method.label(breakLabel);
  5.1388 -            return null;
  5.1389 +            return false;
  5.1390          }
  5.1391  
  5.1392          if (allInteger) {
  5.1393 @@ -1916,15 +1929,11 @@
  5.1394              method.label(breakLabel);
  5.1395          }
  5.1396  
  5.1397 -        return null;
  5.1398 +        return false;
  5.1399      }
  5.1400  
  5.1401      @Override
  5.1402 -    public Node enterThrowNode(final ThrowNode throwNode) {
  5.1403 -        if (throwNode.testResolved()) {
  5.1404 -            return null;
  5.1405 -        }
  5.1406 -
  5.1407 +    public boolean enterThrowNode(final ThrowNode throwNode) {
  5.1408          method._new(ECMAException.class).dup();
  5.1409  
  5.1410          final Node   expression = throwNode.getExpression();
  5.1411 @@ -1943,15 +1952,11 @@
  5.1412  
  5.1413          method.athrow();
  5.1414  
  5.1415 -        return null;
  5.1416 +        return false;
  5.1417      }
  5.1418  
  5.1419      @Override
  5.1420 -    public Node enterTryNode(final TryNode tryNode) {
  5.1421 -        if (tryNode.testResolved()) {
  5.1422 -            return null;
  5.1423 -        }
  5.1424 -
  5.1425 +    public boolean enterTryNode(final TryNode tryNode) {
  5.1426          final Block       body        = tryNode.getBody();
  5.1427          final List<Block> catchBlocks = tryNode.getCatchBlocks();
  5.1428          final Symbol      symbol      = tryNode.getException();
  5.1429 @@ -1974,74 +1979,68 @@
  5.1430          method.store(symbol);
  5.1431  
  5.1432          for (int i = 0; i < catchBlocks.size(); i++) {
  5.1433 -            final Block saveBlock = getCurrentBlock();
  5.1434              final Block catchBlock = catchBlocks.get(i);
  5.1435  
  5.1436 -            setCurrentBlock(catchBlock);
  5.1437 -
  5.1438 -            try {
  5.1439 -                enterBlock(catchBlock);
  5.1440 -
  5.1441 -                final CatchNode catchNode          = (CatchNode)catchBlocks.get(i).getStatements().get(0);
  5.1442 -                final IdentNode exception          = catchNode.getException();
  5.1443 -                final Node      exceptionCondition = catchNode.getExceptionCondition();
  5.1444 -                final Block     catchBody          = catchNode.getBody();
  5.1445 -
  5.1446 -                if (catchNode.isSyntheticRethrow()) {
  5.1447 -                    // Generate catch body (inlined finally) and rethrow exception
  5.1448 -                    catchBody.accept(this);
  5.1449 +            //TODO this is very ugly - try not to call enter/leave methods directly
  5.1450 +            //better to use the implicit lexical context scoping given by the visitor's
  5.1451 +            //accept method.
  5.1452 +            getLexicalContext().push(catchBlock);
  5.1453 +            enterBlock(catchBlock);
  5.1454 +
  5.1455 +            final CatchNode catchNode          = (CatchNode)catchBlocks.get(i).getStatements().get(0);
  5.1456 +            final IdentNode exception          = catchNode.getException();
  5.1457 +            final Node      exceptionCondition = catchNode.getExceptionCondition();
  5.1458 +            final Block     catchBody          = catchNode.getBody();
  5.1459 +
  5.1460 +            new Store<IdentNode>(exception) {
  5.1461 +                @Override
  5.1462 +                protected void storeNonDiscard() {
  5.1463 +                    return;
  5.1464 +                }
  5.1465 +                @Override
  5.1466 +                protected void evaluate() {
  5.1467 +                    /*
  5.1468 +                     * If caught object is an instance of ECMAException, then
  5.1469 +                     * bind obj.thrown to the script catch var. Or else bind the
  5.1470 +                     * caught object itself to the script catch var.
  5.1471 +                     */
  5.1472 +                    final Label notEcmaException = new Label("no_ecma_exception");
  5.1473 +
  5.1474 +                    method.load(symbol).dup()._instanceof(ECMAException.class).ifeq(notEcmaException);
  5.1475 +                    method.checkcast(ECMAException.class); //TODO is this necessary?
  5.1476 +                    method.getField(ECMAException.THROWN);
  5.1477 +                    method.label(notEcmaException);
  5.1478 +                }
  5.1479 +            }.store();
  5.1480 +
  5.1481 +            final Label next;
  5.1482 +
  5.1483 +            if (exceptionCondition != null) {
  5.1484 +                next = new Label("next");
  5.1485 +                load(exceptionCondition).convert(Type.BOOLEAN).ifeq(next);
  5.1486 +            } else {
  5.1487 +                next = null;
  5.1488 +            }
  5.1489 +
  5.1490 +            catchBody.accept(this);
  5.1491 +
  5.1492 +            if (i + 1 != catchBlocks.size() && !catchBody.hasTerminalFlags()) {
  5.1493 +                method._goto(skip);
  5.1494 +            }
  5.1495 +
  5.1496 +            if (next != null) {
  5.1497 +                if (i + 1 == catchBlocks.size()) {
  5.1498 +                    // no next catch block - rethrow if condition failed
  5.1499 +                    method._goto(skip);
  5.1500 +                    method.label(next);
  5.1501                      method.load(symbol).athrow();
  5.1502 -                    lexicalContext.pop(catchBlock);
  5.1503 -                    continue;
  5.1504 +                } else {
  5.1505 +                    method.label(next);
  5.1506                  }
  5.1507 -
  5.1508 -                new Store<IdentNode>(exception) {
  5.1509 -                    @Override
  5.1510 -                    protected void evaluate() {
  5.1511 -                        /*
  5.1512 -                         * If caught object is an instance of ECMAException, then
  5.1513 -                         * bind obj.thrown to the script catch var. Or else bind the
  5.1514 -                         * caught object itself to the script catch var.
  5.1515 -                         */
  5.1516 -                        final Label notEcmaException = new Label("no_ecma_exception");
  5.1517 -
  5.1518 -                        method.load(symbol).dup()._instanceof(ECMAException.class).ifeq(notEcmaException);
  5.1519 -                        method.checkcast(ECMAException.class); //TODO is this necessary?
  5.1520 -                        method.getField(ECMAException.THROWN);
  5.1521 -                        method.label(notEcmaException);
  5.1522 -                    }
  5.1523 -                }.store();
  5.1524 -
  5.1525 -                final Label next;
  5.1526 -
  5.1527 -                if (exceptionCondition != null) {
  5.1528 -                    next = new Label("next");
  5.1529 -                    load(exceptionCondition).convert(Type.BOOLEAN).ifeq(next);
  5.1530 -                } else {
  5.1531 -                    next = null;
  5.1532 -                }
  5.1533 -
  5.1534 -                catchBody.accept(this);
  5.1535 -
  5.1536 -                if (i + 1 != catchBlocks.size() && !catchBody.hasTerminalFlags()) {
  5.1537 -                    method._goto(skip);
  5.1538 -                }
  5.1539 -
  5.1540 -                if (next != null) {
  5.1541 -                    if (i + 1 == catchBlocks.size()) {
  5.1542 -                        // no next catch block - rethrow if condition failed
  5.1543 -                        method._goto(skip);
  5.1544 -                        method.label(next);
  5.1545 -                        method.load(symbol).athrow();
  5.1546 -                    } else {
  5.1547 -                        method.label(next);
  5.1548 -                    }
  5.1549 -                }
  5.1550 -
  5.1551 -                leaveBlock(catchBlock);
  5.1552 -            } finally {
  5.1553 -                setCurrentBlock(saveBlock);
  5.1554              }
  5.1555 +
  5.1556 +            leaveBlock(catchBlock);
  5.1557 +            getLexicalContext().pop(catchBlock);
  5.1558          }
  5.1559  
  5.1560          method.label(skip);
  5.1561 @@ -2049,15 +2048,15 @@
  5.1562  
  5.1563          // Finally body is always inlined elsewhere so it doesn't need to be emitted
  5.1564  
  5.1565 -        return null;
  5.1566 +        return false;
  5.1567      }
  5.1568  
  5.1569      @Override
  5.1570 -    public Node enterVarNode(final VarNode varNode) {
  5.1571 +    public boolean enterVarNode(final VarNode varNode) {
  5.1572          final Node init = varNode.getInit();
  5.1573  
  5.1574 -        if (varNode.testResolved() || init == null) {
  5.1575 -            return null;
  5.1576 +        if (init == null) {
  5.1577 +            return false;
  5.1578          }
  5.1579  
  5.1580          final Symbol varSymbol = varNode.getSymbol();
  5.1581 @@ -2067,7 +2066,7 @@
  5.1582  
  5.1583          final boolean needsScope = varSymbol.isScope();
  5.1584          if (needsScope) {
  5.1585 -            method.loadScope();
  5.1586 +            method.loadCompilerConstant(SCOPE);
  5.1587          }
  5.1588          load(init);
  5.1589  
  5.1590 @@ -2087,22 +2086,18 @@
  5.1591              method.store(varSymbol);
  5.1592          }
  5.1593  
  5.1594 -        return null;
  5.1595 +        return false;
  5.1596      }
  5.1597  
  5.1598      @Override
  5.1599 -    public Node enterWhileNode(final WhileNode whileNode) {
  5.1600 -        if (whileNode.testResolved()) {
  5.1601 -            return null;
  5.1602 -        }
  5.1603 -
  5.1604 +    public boolean enterWhileNode(final WhileNode whileNode) {
  5.1605          final Node  test          = whileNode.getTest();
  5.1606          final Block body          = whileNode.getBody();
  5.1607          final Label breakLabel    = whileNode.getBreakLabel();
  5.1608          final Label continueLabel = whileNode.getContinueLabel();
  5.1609          final Label loopLabel     = new Label("loop");
  5.1610  
  5.1611 -        if (!(whileNode instanceof DoWhileNode)) {
  5.1612 +        if (!whileNode.isDoWhile()) {
  5.1613              method._goto(continueLabel);
  5.1614          }
  5.1615  
  5.1616 @@ -2114,21 +2109,17 @@
  5.1617              method.label(breakLabel);
  5.1618          }
  5.1619  
  5.1620 -        return null;
  5.1621 +        return false;
  5.1622      }
  5.1623  
  5.1624      private void closeWith() {
  5.1625 -        method.loadScope();
  5.1626 +        method.loadCompilerConstant(SCOPE);
  5.1627          method.invoke(ScriptRuntime.CLOSE_WITH);
  5.1628 -        method.storeScope();
  5.1629 +        method.storeCompilerConstant(SCOPE);
  5.1630      }
  5.1631  
  5.1632      @Override
  5.1633 -    public Node enterWithNode(final WithNode withNode) {
  5.1634 -        if (withNode.testResolved()) {
  5.1635 -            return null;
  5.1636 -        }
  5.1637 -
  5.1638 +    public boolean enterWithNode(final WithNode withNode) {
  5.1639          final Node expression = withNode.getExpression();
  5.1640          final Node body       = withNode.getBody();
  5.1641  
  5.1642 @@ -2139,13 +2130,13 @@
  5.1643  
  5.1644          method.label(tryLabel);
  5.1645  
  5.1646 -        method.loadScope();
  5.1647 +        method.loadCompilerConstant(SCOPE);
  5.1648          load(expression);
  5.1649  
  5.1650          assert expression.getType().isObject() : "with expression needs to be object: " + expression;
  5.1651  
  5.1652          method.invoke(ScriptRuntime.OPEN_WITH);
  5.1653 -        method.storeScope();
  5.1654 +        method.storeCompilerConstant(SCOPE);
  5.1655  
  5.1656          body.accept(this);
  5.1657  
  5.1658 @@ -2164,40 +2155,27 @@
  5.1659  
  5.1660          method._try(tryLabel, endLabel, catchLabel);
  5.1661  
  5.1662 -        return null;
  5.1663 +        return false;
  5.1664      }
  5.1665  
  5.1666      @Override
  5.1667 -    public Node enterADD(final UnaryNode unaryNode) {
  5.1668 -        if (unaryNode.testResolved()) {
  5.1669 -            return null;
  5.1670 -        }
  5.1671 -
  5.1672 +    public boolean enterADD(final UnaryNode unaryNode) {
  5.1673          load(unaryNode.rhs());
  5.1674          assert unaryNode.rhs().getType().isNumber();
  5.1675          method.store(unaryNode.getSymbol());
  5.1676  
  5.1677 -        return null;
  5.1678 +        return false;
  5.1679      }
  5.1680  
  5.1681      @Override
  5.1682 -    public Node enterBIT_NOT(final UnaryNode unaryNode) {
  5.1683 -        if (unaryNode.testResolved()) {
  5.1684 -            return null;
  5.1685 -        }
  5.1686 -
  5.1687 +    public boolean enterBIT_NOT(final UnaryNode unaryNode) {
  5.1688          load(unaryNode.rhs()).convert(Type.INT).load(-1).xor().store(unaryNode.getSymbol());
  5.1689 -
  5.1690 -        return null;
  5.1691 +        return false;
  5.1692      }
  5.1693  
  5.1694      // do this better with convert calls to method. TODO
  5.1695      @Override
  5.1696 -    public Node enterCONVERT(final UnaryNode unaryNode) {
  5.1697 -        if (unaryNode.testResolved()) {
  5.1698 -            return null;
  5.1699 -        }
  5.1700 -
  5.1701 +    public boolean enterCONVERT(final UnaryNode unaryNode) {
  5.1702          final Node rhs = unaryNode.rhs();
  5.1703          final Type to  = unaryNode.getType();
  5.1704  
  5.1705 @@ -2230,15 +2208,11 @@
  5.1706  
  5.1707          method.store(unaryNode.getSymbol());
  5.1708  
  5.1709 -        return null;
  5.1710 +        return false;
  5.1711      }
  5.1712  
  5.1713      @Override
  5.1714 -    public Node enterDECINC(final UnaryNode unaryNode) {
  5.1715 -        if (unaryNode.testResolved()) {
  5.1716 -            return null;
  5.1717 -        }
  5.1718 -
  5.1719 +    public boolean enterDECINC(final UnaryNode unaryNode) {
  5.1720          final Node      rhs         = unaryNode.rhs();
  5.1721          final Type      type        = unaryNode.getType();
  5.1722          final TokenType tokenType   = unaryNode.tokenType();
  5.1723 @@ -2282,32 +2256,28 @@
  5.1724              }
  5.1725          }.store();
  5.1726  
  5.1727 -        return null;
  5.1728 +        return false;
  5.1729      }
  5.1730  
  5.1731      @Override
  5.1732 -    public Node enterDISCARD(final UnaryNode unaryNode) {
  5.1733 -        if (unaryNode.testResolved()) {
  5.1734 -            return null;
  5.1735 +    public boolean enterDISCARD(final UnaryNode unaryNode) {
  5.1736 +        final Node rhs = unaryNode.rhs();
  5.1737 +
  5.1738 +       // System.err.println("**** Enter discard " + unaryNode);
  5.1739 +        discard.push(rhs);
  5.1740 +        load(rhs);
  5.1741 +
  5.1742 +        if (discard.peek() == rhs) {
  5.1743 +            assert !rhs.isAssignment();
  5.1744 +            method.pop();
  5.1745 +            discard.pop();
  5.1746          }
  5.1747 -
  5.1748 -        final Node rhs = unaryNode.rhs();
  5.1749 -
  5.1750 -        load(rhs);
  5.1751 -
  5.1752 -        if (rhs.shouldDiscard()) {
  5.1753 -            method.pop();
  5.1754 -        }
  5.1755 -
  5.1756 -        return null;
  5.1757 +       // System.err.println("**** Leave discard " + unaryNode);
  5.1758 +        return false;
  5.1759      }
  5.1760  
  5.1761      @Override
  5.1762 -    public Node enterNEW(final UnaryNode unaryNode) {
  5.1763 -        if (unaryNode.testResolved()) {
  5.1764 -            return null;
  5.1765 -        }
  5.1766 -
  5.1767 +    public boolean enterNEW(final UnaryNode unaryNode) {
  5.1768          final CallNode callNode = (CallNode)unaryNode.rhs();
  5.1769          final List<Node> args   = callNode.getArgs();
  5.1770  
  5.1771 @@ -2317,15 +2287,11 @@
  5.1772          method.dynamicNew(1 + loadArgs(args), getCallSiteFlags());
  5.1773          method.store(unaryNode.getSymbol());
  5.1774  
  5.1775 -        return null;
  5.1776 +        return false;
  5.1777      }
  5.1778  
  5.1779      @Override
  5.1780 -    public Node enterNOT(final UnaryNode unaryNode) {
  5.1781 -        if (unaryNode.testResolved()) {
  5.1782 -            return null;
  5.1783 -        }
  5.1784 -
  5.1785 +    public boolean enterNOT(final UnaryNode unaryNode) {
  5.1786          final Node rhs = unaryNode.rhs();
  5.1787  
  5.1788          load(rhs);
  5.1789 @@ -2342,18 +2308,14 @@
  5.1790          method.label(afterLabel);
  5.1791          method.store(unaryNode.getSymbol());
  5.1792  
  5.1793 -        return null;
  5.1794 +        return false;
  5.1795      }
  5.1796  
  5.1797      @Override
  5.1798 -    public Node enterSUB(final UnaryNode unaryNode) {
  5.1799 -        if (unaryNode.testResolved()) {
  5.1800 -            return null;
  5.1801 -        }
  5.1802 -
  5.1803 +    public boolean enterSUB(final UnaryNode unaryNode) {
  5.1804          load(unaryNode.rhs()).neg().store(unaryNode.getSymbol());
  5.1805  
  5.1806 -        return null;
  5.1807 +        return false;
  5.1808      }
  5.1809  
  5.1810      private Node enterNumericAdd(final Node lhs, final Node rhs, final Type type, final Symbol symbol) {
  5.1811 @@ -2366,11 +2328,7 @@
  5.1812      }
  5.1813  
  5.1814      @Override
  5.1815 -    public Node enterADD(final BinaryNode binaryNode) {
  5.1816 -        if (binaryNode.testResolved()) {
  5.1817 -            return null;
  5.1818 -        }
  5.1819 -
  5.1820 +    public boolean enterADD(final BinaryNode binaryNode) {
  5.1821          final Node lhs = binaryNode.lhs();
  5.1822          final Node rhs = binaryNode.rhs();
  5.1823  
  5.1824 @@ -2384,14 +2342,10 @@
  5.1825              method.store(binaryNode.getSymbol());
  5.1826          }
  5.1827  
  5.1828 -        return null;
  5.1829 +        return false;
  5.1830      }
  5.1831  
  5.1832 -    private Node enterAND_OR(final BinaryNode binaryNode) {
  5.1833 -        if (binaryNode.testResolved()) {
  5.1834 -            return null;
  5.1835 -        }
  5.1836 -
  5.1837 +    private boolean enterAND_OR(final BinaryNode binaryNode) {
  5.1838          final Node lhs = binaryNode.lhs();
  5.1839          final Node rhs = binaryNode.rhs();
  5.1840  
  5.1841 @@ -2410,20 +2364,16 @@
  5.1842          method.label(skip);
  5.1843          method.store(binaryNode.getSymbol());
  5.1844  
  5.1845 -        return null;
  5.1846 +        return false;
  5.1847      }
  5.1848  
  5.1849      @Override
  5.1850 -    public Node enterAND(final BinaryNode binaryNode) {
  5.1851 +    public boolean enterAND(final BinaryNode binaryNode) {
  5.1852          return enterAND_OR(binaryNode);
  5.1853      }
  5.1854  
  5.1855      @Override
  5.1856 -    public Node enterASSIGN(final BinaryNode binaryNode) {
  5.1857 -        if (binaryNode.testResolved()) {
  5.1858 -            return null;
  5.1859 -        }
  5.1860 -
  5.1861 +    public boolean enterASSIGN(final BinaryNode binaryNode) {
  5.1862          final Node lhs = binaryNode.lhs();
  5.1863          final Node rhs = binaryNode.rhs();
  5.1864  
  5.1865 @@ -2442,7 +2392,7 @@
  5.1866              }
  5.1867          }.store();
  5.1868  
  5.1869 -        return null;
  5.1870 +        return false;
  5.1871      }
  5.1872  
  5.1873      /**
  5.1874 @@ -2473,14 +2423,6 @@
  5.1875              this.opType = opType;
  5.1876          }
  5.1877  
  5.1878 -        @Override
  5.1879 -        public void store() {
  5.1880 -            if (assignNode.testResolved()) {
  5.1881 -                return;
  5.1882 -            }
  5.1883 -            super.store();
  5.1884 -        }
  5.1885 -
  5.1886          protected abstract void op();
  5.1887  
  5.1888          @Override
  5.1889 @@ -2493,35 +2435,43 @@
  5.1890      }
  5.1891  
  5.1892      @Override
  5.1893 -    public Node enterASSIGN_ADD(final BinaryNode binaryNode) {
  5.1894 +    public boolean enterASSIGN_ADD(final BinaryNode binaryNode) {
  5.1895          assert RuntimeNode.Request.ADD.canSpecialize();
  5.1896 +        final Type lhsType = binaryNode.lhs().getType();
  5.1897 +        final Type rhsType = binaryNode.rhs().getType();
  5.1898          final boolean specialize = binaryNode.getType() == Type.OBJECT;
  5.1899  
  5.1900          new AssignOp(binaryNode) {
  5.1901 -            @Override
  5.1902 -            protected boolean isSelfModifying() {
  5.1903 -                return !specialize;
  5.1904 -            }
  5.1905  
  5.1906              @Override
  5.1907              protected void op() {
  5.1908 -                method.add();
  5.1909 +                if (specialize) {
  5.1910 +                    method.dynamicRuntimeCall(
  5.1911 +                            new SpecializedRuntimeNode(
  5.1912 +                                Request.ADD,
  5.1913 +                                new Type[] {
  5.1914 +                                    lhsType,
  5.1915 +                                    rhsType,
  5.1916 +                                },
  5.1917 +                                Type.OBJECT).getInitialName(),
  5.1918 +                            Type.OBJECT,
  5.1919 +                            Request.ADD);
  5.1920 +                } else {
  5.1921 +                    method.add();
  5.1922 +                }
  5.1923              }
  5.1924  
  5.1925              @Override
  5.1926              protected void evaluate() {
  5.1927 -                if (specialize && specializationCheck(Request.ADD, assignNode, Arrays.asList(assignNode.lhs(), assignNode.rhs()))) {
  5.1928 -                    return;
  5.1929 -                }
  5.1930                  super.evaluate();
  5.1931              }
  5.1932          }.store();
  5.1933  
  5.1934 -        return null;
  5.1935 +        return false;
  5.1936      }
  5.1937  
  5.1938      @Override
  5.1939 -    public Node enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
  5.1940 +    public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
  5.1941          new AssignOp(Type.INT, binaryNode) {
  5.1942              @Override
  5.1943              protected void op() {
  5.1944 @@ -2529,11 +2479,11 @@
  5.1945              }
  5.1946          }.store();
  5.1947  
  5.1948 -        return null;
  5.1949 +        return false;
  5.1950      }
  5.1951  
  5.1952      @Override
  5.1953 -    public Node enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
  5.1954 +    public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
  5.1955          new AssignOp(Type.INT, binaryNode) {
  5.1956              @Override
  5.1957              protected void op() {
  5.1958 @@ -2541,11 +2491,11 @@
  5.1959              }
  5.1960          }.store();
  5.1961  
  5.1962 -        return null;
  5.1963 +        return false;
  5.1964      }
  5.1965  
  5.1966      @Override
  5.1967 -    public Node enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
  5.1968 +    public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
  5.1969          new AssignOp(Type.INT, binaryNode) {
  5.1970              @Override
  5.1971              protected void op() {
  5.1972 @@ -2553,11 +2503,11 @@
  5.1973              }
  5.1974          }.store();
  5.1975  
  5.1976 -        return null;
  5.1977 +        return false;
  5.1978      }
  5.1979  
  5.1980      @Override
  5.1981 -    public Node enterASSIGN_DIV(final BinaryNode binaryNode) {
  5.1982 +    public boolean enterASSIGN_DIV(final BinaryNode binaryNode) {
  5.1983          new AssignOp(binaryNode) {
  5.1984              @Override
  5.1985              protected void op() {
  5.1986 @@ -2565,11 +2515,11 @@
  5.1987              }
  5.1988          }.store();
  5.1989  
  5.1990 -        return null;
  5.1991 +        return false;
  5.1992      }
  5.1993  
  5.1994      @Override
  5.1995 -    public Node enterASSIGN_MOD(final BinaryNode binaryNode) {
  5.1996 +    public boolean enterASSIGN_MOD(final BinaryNode binaryNode) {
  5.1997          new AssignOp(binaryNode) {
  5.1998              @Override
  5.1999              protected void op() {
  5.2000 @@ -2577,11 +2527,11 @@
  5.2001              }
  5.2002          }.store();
  5.2003  
  5.2004 -        return null;
  5.2005 +        return false;
  5.2006      }
  5.2007  
  5.2008      @Override
  5.2009 -    public Node enterASSIGN_MUL(final BinaryNode binaryNode) {
  5.2010 +    public boolean enterASSIGN_MUL(final BinaryNode binaryNode) {
  5.2011          new AssignOp(binaryNode) {
  5.2012              @Override
  5.2013              protected void op() {
  5.2014 @@ -2589,11 +2539,11 @@
  5.2015              }
  5.2016          }.store();
  5.2017  
  5.2018 -        return null;
  5.2019 +        return false;
  5.2020      }
  5.2021  
  5.2022      @Override
  5.2023 -    public Node enterASSIGN_SAR(final BinaryNode binaryNode) {
  5.2024 +    public boolean enterASSIGN_SAR(final BinaryNode binaryNode) {
  5.2025          new AssignOp(Type.INT, binaryNode) {
  5.2026              @Override
  5.2027              protected void op() {
  5.2028 @@ -2601,11 +2551,11 @@
  5.2029              }
  5.2030          }.store();
  5.2031  
  5.2032 -        return null;
  5.2033 +        return false;
  5.2034      }
  5.2035  
  5.2036      @Override
  5.2037 -    public Node enterASSIGN_SHL(final BinaryNode binaryNode) {
  5.2038 +    public boolean enterASSIGN_SHL(final BinaryNode binaryNode) {
  5.2039          new AssignOp(Type.INT, binaryNode) {
  5.2040              @Override
  5.2041              protected void op() {
  5.2042 @@ -2613,11 +2563,11 @@
  5.2043              }
  5.2044          }.store();
  5.2045  
  5.2046 -        return null;
  5.2047 +        return false;
  5.2048      }
  5.2049  
  5.2050      @Override
  5.2051 -    public Node enterASSIGN_SHR(final BinaryNode binaryNode) {
  5.2052 +    public boolean enterASSIGN_SHR(final BinaryNode binaryNode) {
  5.2053          new AssignOp(Type.INT, binaryNode) {
  5.2054              @Override
  5.2055              protected void op() {
  5.2056 @@ -2626,11 +2576,11 @@
  5.2057              }
  5.2058          }.store();
  5.2059  
  5.2060 -        return null;
  5.2061 +        return false;
  5.2062      }
  5.2063  
  5.2064      @Override
  5.2065 -    public Node enterASSIGN_SUB(final BinaryNode binaryNode) {
  5.2066 +    public boolean enterASSIGN_SUB(final BinaryNode binaryNode) {
  5.2067          new AssignOp(binaryNode) {
  5.2068              @Override
  5.2069              protected void op() {
  5.2070 @@ -2638,7 +2588,7 @@
  5.2071              }
  5.2072          }.store();
  5.2073  
  5.2074 -        return null;
  5.2075 +        return false;
  5.2076      }
  5.2077  
  5.2078      /**
  5.2079 @@ -2649,9 +2599,6 @@
  5.2080          protected abstract void op();
  5.2081  
  5.2082          protected void evaluate(final BinaryNode node) {
  5.2083 -            if (node.testResolved()) {
  5.2084 -                return;
  5.2085 -            }
  5.2086              load(node.lhs());
  5.2087              load(node.rhs());
  5.2088              op();
  5.2089 @@ -2660,7 +2607,7 @@
  5.2090      }
  5.2091  
  5.2092      @Override
  5.2093 -    public Node enterBIT_AND(final BinaryNode binaryNode) {
  5.2094 +    public boolean enterBIT_AND(final BinaryNode binaryNode) {
  5.2095          new BinaryArith() {
  5.2096              @Override
  5.2097              protected void op() {
  5.2098 @@ -2668,11 +2615,11 @@
  5.2099              }
  5.2100          }.evaluate(binaryNode);
  5.2101  
  5.2102 -        return null;
  5.2103 +        return false;
  5.2104      }
  5.2105  
  5.2106      @Override
  5.2107 -    public Node enterBIT_OR(final BinaryNode binaryNode) {
  5.2108 +    public boolean enterBIT_OR(final BinaryNode binaryNode) {
  5.2109          new BinaryArith() {
  5.2110              @Override
  5.2111              protected void op() {
  5.2112 @@ -2680,11 +2627,11 @@
  5.2113              }
  5.2114          }.evaluate(binaryNode);
  5.2115  
  5.2116 -        return null;
  5.2117 +        return false;
  5.2118      }
  5.2119  
  5.2120      @Override
  5.2121 -    public Node enterBIT_XOR(final BinaryNode binaryNode) {
  5.2122 +    public boolean enterBIT_XOR(final BinaryNode binaryNode) {
  5.2123          new BinaryArith() {
  5.2124              @Override
  5.2125              protected void op() {
  5.2126 @@ -2692,14 +2639,10 @@
  5.2127              }
  5.2128          }.evaluate(binaryNode);
  5.2129  
  5.2130 -        return null;
  5.2131 +        return false;
  5.2132      }
  5.2133  
  5.2134 -    private Node enterComma(final BinaryNode binaryNode) {
  5.2135 -        if (binaryNode.testResolved()) {
  5.2136 -            return null;
  5.2137 -        }
  5.2138 -
  5.2139 +    private boolean enterComma(final BinaryNode binaryNode) {
  5.2140          final Node lhs = binaryNode.lhs();
  5.2141          final Node rhs = binaryNode.rhs();
  5.2142  
  5.2143 @@ -2707,21 +2650,21 @@
  5.2144          load(rhs);
  5.2145          method.store(binaryNode.getSymbol());
  5.2146  
  5.2147 -        return null;
  5.2148 +        return false;
  5.2149      }
  5.2150  
  5.2151      @Override
  5.2152 -    public Node enterCOMMARIGHT(final BinaryNode binaryNode) {
  5.2153 +    public boolean enterCOMMARIGHT(final BinaryNode binaryNode) {
  5.2154          return enterComma(binaryNode);
  5.2155      }
  5.2156  
  5.2157      @Override
  5.2158 -    public Node enterCOMMALEFT(final BinaryNode binaryNode) {
  5.2159 +    public boolean enterCOMMALEFT(final BinaryNode binaryNode) {
  5.2160          return enterComma(binaryNode);
  5.2161      }
  5.2162  
  5.2163      @Override
  5.2164 -    public Node enterDIV(final BinaryNode binaryNode) {
  5.2165 +    public boolean enterDIV(final BinaryNode binaryNode) {
  5.2166          new BinaryArith() {
  5.2167              @Override
  5.2168              protected void op() {
  5.2169 @@ -2729,10 +2672,10 @@
  5.2170              }
  5.2171          }.evaluate(binaryNode);
  5.2172  
  5.2173 -        return null;
  5.2174 +        return false;
  5.2175      }
  5.2176  
  5.2177 -    private Node enterCmp(final Node lhs, final Node rhs, final Condition cond, final Type type, final Symbol symbol) {
  5.2178 +    private boolean enterCmp(final Node lhs, final Node rhs, final Condition cond, final Type type, final Symbol symbol) {
  5.2179          final Type lhsType = lhs.getType();
  5.2180          final Type rhsType = rhs.getType();
  5.2181  
  5.2182 @@ -2758,48 +2701,45 @@
  5.2183          method.convert(type);
  5.2184          method.store(symbol);
  5.2185  
  5.2186 -        return null;
  5.2187 +        return false;
  5.2188      }
  5.2189  
  5.2190 -    private Node enterCmp(final BinaryNode binaryNode, final Condition cond) {
  5.2191 -        if (binaryNode.testResolved()) {
  5.2192 -            return null;
  5.2193 -        }
  5.2194 +    private boolean enterCmp(final BinaryNode binaryNode, final Condition cond) {
  5.2195          return enterCmp(binaryNode.lhs(), binaryNode.rhs(), cond, binaryNode.getType(), binaryNode.getSymbol());
  5.2196      }
  5.2197  
  5.2198      @Override
  5.2199 -    public Node enterEQ(final BinaryNode binaryNode) {
  5.2200 +    public boolean enterEQ(final BinaryNode binaryNode) {
  5.2201          return enterCmp(binaryNode, Condition.EQ);
  5.2202      }
  5.2203  
  5.2204      @Override
  5.2205 -    public Node enterEQ_STRICT(final BinaryNode binaryNode) {
  5.2206 +    public boolean enterEQ_STRICT(final BinaryNode binaryNode) {
  5.2207          return enterCmp(binaryNode, Condition.EQ);
  5.2208      }
  5.2209  
  5.2210      @Override
  5.2211 -    public Node enterGE(final BinaryNode binaryNode) {
  5.2212 +    public boolean enterGE(final BinaryNode binaryNode) {
  5.2213          return enterCmp(binaryNode, Condition.GE);
  5.2214      }
  5.2215  
  5.2216      @Override
  5.2217 -    public Node enterGT(final BinaryNode binaryNode) {
  5.2218 +    public boolean enterGT(final BinaryNode binaryNode) {
  5.2219          return enterCmp(binaryNode, Condition.GT);
  5.2220      }
  5.2221  
  5.2222      @Override
  5.2223 -    public Node enterLE(final BinaryNode binaryNode) {
  5.2224 +    public boolean enterLE(final BinaryNode binaryNode) {
  5.2225          return enterCmp(binaryNode, Condition.LE);
  5.2226      }
  5.2227  
  5.2228      @Override
  5.2229 -    public Node enterLT(final BinaryNode binaryNode) {
  5.2230 +    public boolean enterLT(final BinaryNode binaryNode) {
  5.2231          return enterCmp(binaryNode, Condition.LT);
  5.2232      }
  5.2233  
  5.2234      @Override
  5.2235 -    public Node enterMOD(final BinaryNode binaryNode) {
  5.2236 +    public boolean enterMOD(final BinaryNode binaryNode) {
  5.2237          new BinaryArith() {
  5.2238              @Override
  5.2239              protected void op() {
  5.2240 @@ -2807,11 +2747,11 @@
  5.2241              }
  5.2242          }.evaluate(binaryNode);
  5.2243  
  5.2244 -        return null;
  5.2245 +        return false;
  5.2246      }
  5.2247  
  5.2248      @Override
  5.2249 -    public Node enterMUL(final BinaryNode binaryNode) {
  5.2250 +    public boolean enterMUL(final BinaryNode binaryNode) {
  5.2251          new BinaryArith() {
  5.2252              @Override
  5.2253              protected void op() {
  5.2254 @@ -2819,26 +2759,26 @@
  5.2255              }
  5.2256          }.evaluate(binaryNode);
  5.2257  
  5.2258 -        return null;
  5.2259 +        return false;
  5.2260      }
  5.2261  
  5.2262      @Override
  5.2263 -    public Node enterNE(final BinaryNode binaryNode) {
  5.2264 +    public boolean enterNE(final BinaryNode binaryNode) {
  5.2265          return enterCmp(binaryNode, Condition.NE);
  5.2266      }
  5.2267  
  5.2268      @Override
  5.2269 -    public Node enterNE_STRICT(final BinaryNode binaryNode) {
  5.2270 +    public boolean enterNE_STRICT(final BinaryNode binaryNode) {
  5.2271          return enterCmp(binaryNode, Condition.NE);
  5.2272      }
  5.2273  
  5.2274      @Override
  5.2275 -    public Node enterOR(final BinaryNode binaryNode) {
  5.2276 +    public boolean enterOR(final BinaryNode binaryNode) {
  5.2277          return enterAND_OR(binaryNode);
  5.2278      }
  5.2279  
  5.2280      @Override
  5.2281 -    public Node enterSAR(final BinaryNode binaryNode) {
  5.2282 +    public boolean enterSAR(final BinaryNode binaryNode) {
  5.2283          new BinaryArith() {
  5.2284              @Override
  5.2285              protected void op() {
  5.2286 @@ -2846,11 +2786,11 @@
  5.2287              }
  5.2288          }.evaluate(binaryNode);
  5.2289  
  5.2290 -        return null;
  5.2291 +        return false;
  5.2292      }
  5.2293  
  5.2294      @Override
  5.2295 -    public Node enterSHL(final BinaryNode binaryNode) {
  5.2296 +    public boolean enterSHL(final BinaryNode binaryNode) {
  5.2297          new BinaryArith() {
  5.2298              @Override
  5.2299              protected void op() {
  5.2300 @@ -2858,11 +2798,11 @@
  5.2301              }
  5.2302          }.evaluate(binaryNode);
  5.2303  
  5.2304 -        return null;
  5.2305 +        return false;
  5.2306      }
  5.2307  
  5.2308      @Override
  5.2309 -    public Node enterSHR(final BinaryNode binaryNode) {
  5.2310 +    public boolean enterSHR(final BinaryNode binaryNode) {
  5.2311          new BinaryArith() {
  5.2312              @Override
  5.2313              protected void op() {
  5.2314 @@ -2871,11 +2811,11 @@
  5.2315              }
  5.2316          }.evaluate(binaryNode);
  5.2317  
  5.2318 -        return null;
  5.2319 +        return false;
  5.2320      }
  5.2321  
  5.2322      @Override
  5.2323 -    public Node enterSUB(final BinaryNode binaryNode) {
  5.2324 +    public boolean enterSUB(final BinaryNode binaryNode) {
  5.2325          new BinaryArith() {
  5.2326              @Override
  5.2327              protected void op() {
  5.2328 @@ -2883,18 +2823,11 @@
  5.2329              }
  5.2330          }.evaluate(binaryNode);
  5.2331  
  5.2332 -        return null;
  5.2333 +        return false;
  5.2334      }
  5.2335  
  5.2336 -    /*
  5.2337 -     * Ternary visits.
  5.2338 -     */
  5.2339      @Override
  5.2340 -    public Node enterTernaryNode(final TernaryNode ternaryNode) {
  5.2341 -        if (ternaryNode.testResolved()) {
  5.2342 -            return null;
  5.2343 -        }
  5.2344 -
  5.2345 +    public boolean enterTernaryNode(final TernaryNode ternaryNode) {
  5.2346          final Node lhs   = ternaryNode.lhs();
  5.2347          final Node rhs   = ternaryNode.rhs();
  5.2348          final Node third = ternaryNode.third();
  5.2349 @@ -2926,7 +2859,7 @@
  5.2350          method.label(exitLabel);
  5.2351          method.store(symbol);
  5.2352  
  5.2353 -        return null;
  5.2354 +        return false;
  5.2355      }
  5.2356  
  5.2357      /**
  5.2358 @@ -2955,7 +2888,7 @@
  5.2359          if (scopeCalls.containsKey(scopeCall)) {
  5.2360              return scopeCalls.get(scopeCall);
  5.2361          }
  5.2362 -        scopeCall.setClassAndName(getCurrentCompileUnit(), getCurrentFunctionNode().uniqueName("scopeCall"));
  5.2363 +        scopeCall.setClassAndName(unit, getLexicalContext().getCurrentFunction().uniqueName("scopeCall"));
  5.2364          scopeCalls.put(scopeCall, scopeCall);
  5.2365          return scopeCall;
  5.2366      }
  5.2367 @@ -2974,7 +2907,7 @@
  5.2368          if (scopeCalls.containsKey(scopeCall)) {
  5.2369              return scopeCalls.get(scopeCall);
  5.2370          }
  5.2371 -        scopeCall.setClassAndName(getCurrentCompileUnit(), getCurrentFunctionNode().uniqueName("scopeCall"));
  5.2372 +        scopeCall.setClassAndName(unit, getLexicalContext().getCurrentFunction().uniqueName("scopeCall"));
  5.2373          scopeCalls.put(scopeCall, scopeCall);
  5.2374          return scopeCall;
  5.2375      }
  5.2376 @@ -3037,9 +2970,6 @@
  5.2377          /** The target node to store to, e.g. x */
  5.2378          private final Node target;
  5.2379  
  5.2380 -        /** Should the result always be discarded, no matter what? */
  5.2381 -        private final boolean alwaysDiscard;
  5.2382 -
  5.2383          /** How deep on the stack do the arguments go if this generates an indy call */
  5.2384          private int depth;
  5.2385  
  5.2386 @@ -3055,7 +2985,6 @@
  5.2387          protected Store(final T assignNode, final Node target) {
  5.2388              this.assignNode = assignNode;
  5.2389              this.target = target;
  5.2390 -            this.alwaysDiscard = assignNode == target;
  5.2391          }
  5.2392  
  5.2393          /**
  5.2394 @@ -3077,21 +3006,21 @@
  5.2395  
  5.2396          private void prologue() {
  5.2397              final Symbol targetSymbol = target.getSymbol();
  5.2398 -            final Symbol scopeSymbol  = getCurrentFunctionNode().getScopeNode().getSymbol();
  5.2399 +            final Symbol scopeSymbol  = getLexicalContext().getCurrentFunction().compilerConstant(SCOPE);
  5.2400  
  5.2401              /**
  5.2402               * This loads the parts of the target, e.g base and index. they are kept
  5.2403               * on the stack throughout the store and used at the end to execute it
  5.2404               */
  5.2405  
  5.2406 -            target.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
  5.2407 +            target.accept(new NodeVisitor() {
  5.2408                  @Override
  5.2409 -                public Node enterIdentNode(final IdentNode node) {
  5.2410 +                public boolean enterIdentNode(final IdentNode node) {
  5.2411                      if (targetSymbol.isScope()) {
  5.2412                          method.load(scopeSymbol);
  5.2413                          depth++;
  5.2414                      }
  5.2415 -                    return null;
  5.2416 +                    return false;
  5.2417                  }
  5.2418  
  5.2419                  private void enterBaseNode() {
  5.2420 @@ -3109,13 +3038,13 @@
  5.2421                  }
  5.2422  
  5.2423                  @Override
  5.2424 -                public Node enterAccessNode(final AccessNode node) {
  5.2425 +                public boolean enterAccessNode(final AccessNode node) {
  5.2426                      enterBaseNode();
  5.2427 -                    return null;
  5.2428 +                    return false;
  5.2429                  }
  5.2430  
  5.2431                  @Override
  5.2432 -                public Node enterIndexNode(final IndexNode node) {
  5.2433 +                public boolean enterIndexNode(final IndexNode node) {
  5.2434                      enterBaseNode();
  5.2435  
  5.2436                      final Node index = node.getIndex();
  5.2437 @@ -3131,14 +3060,14 @@
  5.2438                          method.dup(1);
  5.2439                      }
  5.2440  
  5.2441 -                    return null;
  5.2442 +                    return false;
  5.2443                  }
  5.2444  
  5.2445              });
  5.2446          }
  5.2447  
  5.2448          private Symbol quickSymbol(final Type type) {
  5.2449 -            return quickSymbol(type, QUICK_PREFIX.tag());
  5.2450 +            return quickSymbol(type, QUICK_PREFIX.symbolName());
  5.2451          }
  5.2452  
  5.2453          /**
  5.2454 @@ -3151,22 +3080,28 @@
  5.2455           * @return the quick symbol
  5.2456           */
  5.2457          private Symbol quickSymbol(final Type type, final String prefix) {
  5.2458 -            final String name = getCurrentFunctionNode().uniqueName(prefix);
  5.2459 -            final Symbol symbol = new Symbol(name, IS_TEMP | IS_INTERNAL, null, null);
  5.2460 +            final String name = getLexicalContext().getCurrentFunction().uniqueName(prefix);
  5.2461 +            final Symbol symbol = new Symbol(name, IS_TEMP | IS_INTERNAL);
  5.2462  
  5.2463              symbol.setType(type);
  5.2464 -            symbol.setSlot(getCurrentBlock().getFrame().getSlotCount());
  5.2465 +            final int quickSlot = nextFreeSlots[nextFreeSlotsSize - 1];
  5.2466 +            nextFreeSlots[nextFreeSlotsSize - 1] = quickSlot + symbol.slotCount();
  5.2467 +            symbol.setSlot(quickSlot);
  5.2468  
  5.2469              return symbol;
  5.2470          }
  5.2471  
  5.2472          // store the result that "lives on" after the op, e.g. "i" in i++ postfix.
  5.2473          protected void storeNonDiscard() {
  5.2474 -            if (assignNode.shouldDiscard() || alwaysDiscard) {
  5.2475 -                assignNode.setDiscard(false);
  5.2476 +            if (discard.peek() == assignNode) {
  5.2477 +                assert assignNode.isAssignment();
  5.2478 +                discard.pop();
  5.2479                  return;
  5.2480              }
  5.2481  
  5.2482 +            //System.err.println("Store with out discard that shouldn't just return " + assignNode);
  5.2483 +            //new Throwable().printStackTrace();
  5.2484 +
  5.2485              final Symbol symbol = assignNode.getSymbol();
  5.2486              if (symbol.hasSlot()) {
  5.2487                  method.dup().store(symbol);
  5.2488 @@ -3191,22 +3126,22 @@
  5.2489               */
  5.2490              method.convert(target.getType());
  5.2491  
  5.2492 -            target.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
  5.2493 +            target.accept(new NodeVisitor() {
  5.2494                  @Override
  5.2495 -                protected Node enterDefault(Node node) {
  5.2496 +                protected boolean enterDefault(Node node) {
  5.2497                      throw new AssertionError("Unexpected node " + node + " in store epilogue");
  5.2498                  }
  5.2499  
  5.2500                  @Override
  5.2501 -                public Node enterUnaryNode(final UnaryNode node) {
  5.2502 -                    if(node.tokenType() == TokenType.CONVERT && node.getSymbol() != null) {
  5.2503 +                public boolean enterUnaryNode(final UnaryNode node) {
  5.2504 +                    if (node.tokenType() == TokenType.CONVERT && node.getSymbol() != null) {
  5.2505                          method.convert(node.rhs().getType());
  5.2506                      }
  5.2507 -                    return node;
  5.2508 +                    return true;
  5.2509                  }
  5.2510  
  5.2511                  @Override
  5.2512 -                public Node enterIdentNode(final IdentNode node) {
  5.2513 +                public boolean enterIdentNode(final IdentNode node) {
  5.2514                      final Symbol symbol = node.getSymbol();
  5.2515                      assert symbol != null;
  5.2516                      if (symbol.isScope()) {
  5.2517 @@ -3218,20 +3153,20 @@
  5.2518                      } else {
  5.2519                          method.store(symbol);
  5.2520                      }
  5.2521 -                    return null;
  5.2522 +                    return false;
  5.2523  
  5.2524                  }
  5.2525  
  5.2526                  @Override
  5.2527 -                public Node enterAccessNode(final AccessNode node) {
  5.2528 +                public boolean enterAccessNode(final AccessNode node) {
  5.2529                      method.dynamicSet(node.getProperty().getType(), node.getProperty().getName(), getCallSiteFlags());
  5.2530 -                    return null;
  5.2531 +                    return false;
  5.2532                  }
  5.2533  
  5.2534                  @Override
  5.2535 -                public Node enterIndexNode(final IndexNode node) {
  5.2536 +                public boolean enterIndexNode(final IndexNode node) {
  5.2537                      method.dynamicSetIndex(getCallSiteFlags());
  5.2538 -                    return null;
  5.2539 +                    return false;
  5.2540                  }
  5.2541              });
  5.2542  
  5.2543 @@ -3250,10 +3185,23 @@
  5.2544                  method.load(quick);
  5.2545              }
  5.2546          }
  5.2547 -
  5.2548      }
  5.2549  
  5.2550 -    private void newFunctionObject(final FunctionNode functionNode) {
  5.2551 +    private void newFunctionObject(final FunctionNode functionNode, final FunctionNode originalFunctionNode) {
  5.2552 +        final LexicalContext lc = getLexicalContext();
  5.2553 +        assert lc.peek() == functionNode;
  5.2554 +        // We don't emit a ScriptFunction on stack for:
  5.2555 +        // 1. the outermost compiled function (as there's no code being generated in its outer context that'd need it
  5.2556 +        //    as a callee), and
  5.2557 +        // 2. for functions that are immediately called upon definition and they don't need a callee, e.g. (function(){})().
  5.2558 +        //    Such immediately-called functions are invoked using INVOKESTATIC (see enterFunctionNode() of the embedded
  5.2559 +        //    visitor of enterCallNode() for details), and if they don't need a callee, they don't have it on their
  5.2560 +        //    static method's parameter list.
  5.2561 +        if(lc.getOutermostFunction() == functionNode ||
  5.2562 +                (!functionNode.needsCallee()) && lc.isFunctionDefinedInCurrentCall(originalFunctionNode)) {
  5.2563 +            return;
  5.2564 +        }
  5.2565 +
  5.2566          final boolean isLazy  = functionNode.isLazy();
  5.2567  
  5.2568          new ObjectCreator(this, new ArrayList<String>(), new ArrayList<Symbol>(), false, false) {
  5.2569 @@ -3265,7 +3213,7 @@
  5.2570                  loadConstant(new RecompilableScriptFunctionData(functionNode, compiler.getCodeInstaller(), Compiler.binaryName(getClassName()), makeMap()));
  5.2571  
  5.2572                  if (isLazy || functionNode.needsParentScope()) {
  5.2573 -                    m.loadScope();
  5.2574 +                    m.loadCompilerConstant(SCOPE);
  5.2575                  } else {
  5.2576                      m.loadNull();
  5.2577                  }