Mercurial > jdk8-mips64-public > nashorn / changeset

     1.1 --- a/make/project.properties	Tue Mar 19 11:03:24 2013 -0300
     1.2 +++ b/make/project.properties	Sat Mar 23 00:58:39 2013 +0100
     1.3 @@ -210,7 +210,7 @@
     1.4  # add '-Dtest.js.outofprocess' to run each test in a new sub-process
     1.5  run.test.jvmargs.main=-server -Xmx${run.test.xmx} -XX:-TieredCompilation -esa -ea -Dnashorn.debug=true -Dfile.encoding=UTF-8
     1.6  #-XX:+HeapDumpOnOutOfMemoryError -XX:-UseCompressedKlassPointers -XX:+PrintHeapAtGC -XX:ClassMetaspaceSize=300M  
     1.7 -run.test.jvmargs.octane.main=-Xms${run.test.xms} ${run.test.jvmargs}
     1.8 +run.test.jvmargs.octane.main=-Xms${run.test.xms} ${run.test.jvmargs.main}
     1.9  
    1.10  run.test.jvmsecurityargs=-Xverify:all -Djava.security.properties=${basedir}/make/java.security.override -Djava.security.manager -Djava.security.policy=${basedir}/build/nashorn.policy
    1.11  

     2.1 --- a/src/jdk/nashorn/internal/codegen/Attr.java	Tue Mar 19 11:03:24 2013 -0300
     2.2 +++ b/src/jdk/nashorn/internal/codegen/Attr.java	Sat Mar 23 00:58:39 2013 +0100
     2.3 @@ -37,14 +37,16 @@
     2.4  import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;
     2.5  import static jdk.nashorn.internal.ir.Symbol.IS_LET;
     2.6  import static jdk.nashorn.internal.ir.Symbol.IS_PARAM;
     2.7 +import static jdk.nashorn.internal.ir.Symbol.IS_SCOPE;
     2.8  import static jdk.nashorn.internal.ir.Symbol.IS_THIS;
     2.9  import static jdk.nashorn.internal.ir.Symbol.IS_VAR;
    2.10 +import static jdk.nashorn.internal.ir.Symbol.KINDMASK;
    2.11  
    2.12  import java.util.ArrayList;
    2.13  import java.util.HashSet;
    2.14  import java.util.Iterator;
    2.15 -import java.util.LinkedList;
    2.16  import java.util.List;
    2.17 +import java.util.ListIterator;
    2.18  import java.util.Set;
    2.19  import jdk.nashorn.internal.codegen.types.Type;
    2.20  import jdk.nashorn.internal.ir.AccessNode;
    2.21 @@ -52,19 +54,19 @@
    2.22  import jdk.nashorn.internal.ir.Block;
    2.23  import jdk.nashorn.internal.ir.CallNode;
    2.24  import jdk.nashorn.internal.ir.CallNode.EvalArgs;
    2.25 -import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    2.26  import jdk.nashorn.internal.ir.CaseNode;
    2.27  import jdk.nashorn.internal.ir.CatchNode;
    2.28  import jdk.nashorn.internal.ir.ForNode;
    2.29  import jdk.nashorn.internal.ir.FunctionNode;
    2.30 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    2.31  import jdk.nashorn.internal.ir.IdentNode;
    2.32  import jdk.nashorn.internal.ir.IndexNode;
    2.33 +import jdk.nashorn.internal.ir.LexicalContext;
    2.34  import jdk.nashorn.internal.ir.LiteralNode;
    2.35  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
    2.36  import jdk.nashorn.internal.ir.Node;
    2.37  import jdk.nashorn.internal.ir.ObjectNode;
    2.38  import jdk.nashorn.internal.ir.PropertyNode;
    2.39 -import jdk.nashorn.internal.ir.ReferenceNode;
    2.40  import jdk.nashorn.internal.ir.ReturnNode;
    2.41  import jdk.nashorn.internal.ir.RuntimeNode;
    2.42  import jdk.nashorn.internal.ir.RuntimeNode.Request;
    2.43 @@ -117,6 +119,8 @@
    2.44       */
    2.45      private Set<String> localUses;
    2.46  
    2.47 +    private final LexicalContext lexicalContext = new LexicalContext();
    2.48 +
    2.49      private static final DebugLogger LOG   = new DebugLogger("attr");
    2.50      private static final boolean     DEBUG = LOG.isEnabled();
    2.51  
    2.52 @@ -137,14 +141,15 @@
    2.53      }
    2.54  
    2.55      @Override
    2.56 -    public Node leave(final AccessNode accessNode) {
    2.57 +    public Node leaveAccessNode(final AccessNode accessNode) {
    2.58          newTemporary(Type.OBJECT, accessNode);  //While Object type is assigned here, Access Specialization in FinalizeTypes may narrow this
    2.59          end(accessNode);
    2.60          return accessNode;
    2.61      }
    2.62  
    2.63      @Override
    2.64 -    public Node enter(final Block block) {
    2.65 +    public Node enterBlock(final Block block) {
    2.66 +        lexicalContext.push(block);
    2.67          start(block);
    2.68  
    2.69          final Set<String> savedLocalDefs = localDefs;
    2.70 @@ -160,9 +165,7 @@
    2.71              localDefs = new HashSet<>(savedLocalDefs);
    2.72              localUses = new HashSet<>(savedLocalUses);
    2.73  
    2.74 -            for (final Node statement : block.getStatements()) {
    2.75 -                statement.accept(this);
    2.76 -            }
    2.77 +            block.visitStatements(this);
    2.78          } finally {
    2.79              localDefs = savedLocalDefs;
    2.80              localUses = savedLocalUses;
    2.81 @@ -172,11 +175,12 @@
    2.82  
    2.83          end(block);
    2.84  
    2.85 +        lexicalContext.pop(block);
    2.86          return null;
    2.87      }
    2.88  
    2.89      @Override
    2.90 -    public Node enter(final CallNode callNode) {
    2.91 +    public Node enterCallNode(final CallNode callNode) {
    2.92          start(callNode);
    2.93  
    2.94          callNode.getFunction().accept(this);
    2.95 @@ -197,8 +201,7 @@
    2.96              evalArgs.setThis(thisNode);
    2.97          }
    2.98  
    2.99 -        newTemporary(Type.OBJECT, callNode); // object type here, access specialization in FinalizeTypes may narrow it later
   2.100 -        newType(callNode.getFunction().getSymbol(), Type.OBJECT);
   2.101 +        newTemporary(callNode.getType(), callNode); // access specialization in FinalizeTypes may narrow it further later
   2.102  
   2.103          end(callNode);
   2.104  
   2.105 @@ -206,29 +209,106 @@
   2.106      }
   2.107  
   2.108      @Override
   2.109 -    public Node enter(final CatchNode catchNode) {
   2.110 +    public Node enterCatchNode(final CatchNode catchNode) {
   2.111          final IdentNode exception = catchNode.getException();
   2.112          final Block     block     = getCurrentBlock();
   2.113  
   2.114          start(catchNode);
   2.115  
   2.116          // define block-local exception variable
   2.117 -        final Symbol def = block.defineSymbol(exception.getName(), IS_VAR | IS_LET, exception);
   2.118 +        final Symbol def = defineSymbol(block, exception.getName(), IS_VAR | IS_LET, exception);
   2.119          newType(def, Type.OBJECT);
   2.120          addLocalDef(exception.getName());
   2.121  
   2.122          return catchNode;
   2.123      }
   2.124  
   2.125 +    /**
   2.126 +     * Declare the definition of a new symbol.
   2.127 +     *
   2.128 +     * @param name         Name of symbol.
   2.129 +     * @param symbolFlags  Symbol flags.
   2.130 +     * @param node         Defining Node.
   2.131 +     *
   2.132 +     * @return Symbol for given name or null for redefinition.
   2.133 +     */
   2.134 +    private Symbol defineSymbol(final Block block, final String name, final int symbolFlags, final Node node) {
   2.135 +        int    flags  = symbolFlags;
   2.136 +        Symbol symbol = findSymbol(block, name); // Locate symbol.
   2.137 +
   2.138 +        if ((flags & KINDMASK) == IS_GLOBAL) {
   2.139 +            flags |= IS_SCOPE;
   2.140 +        }
   2.141 +
   2.142 +        final FunctionNode function = lexicalContext.getFunction(block);
   2.143 +        if (symbol != null) {
   2.144 +            // Symbol was already defined. Check if it needs to be redefined.
   2.145 +            if ((flags & KINDMASK) == IS_PARAM) {
   2.146 +                if (!isLocal(function, symbol)) {
   2.147 +                    // Not defined in this function. Create a new definition.
   2.148 +                    symbol = null;
   2.149 +                } else if (symbol.isParam()) {
   2.150 +                    // Duplicate parameter. Null return will force an error.
   2.151 +                    assert false : "duplicate parameter";
   2.152 +                    return null;
   2.153 +                }
   2.154 +            } else if ((flags & KINDMASK) == IS_VAR) {
   2.155 +                if ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET) {
   2.156 +                    assert !((flags & IS_LET) == IS_LET && symbol.getBlock() == block) : "duplicate let variable in block";
   2.157 +                    // Always create a new definition.
   2.158 +                    symbol = null;
   2.159 +                } else {
   2.160 +                    // Not defined in this function. Create a new definition.
   2.161 +                    if (!isLocal(function, symbol) || symbol.less(IS_VAR)) {
   2.162 +                        symbol = null;
   2.163 +                    }
   2.164 +                }
   2.165 +            }
   2.166 +        }
   2.167 +
   2.168 +        if (symbol == null) {
   2.169 +            // If not found, then create a new one.
   2.170 +            Block symbolBlock;
   2.171 +
   2.172 +            // Determine where to create it.
   2.173 +            if ((flags & Symbol.KINDMASK) == IS_VAR && ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET)) {
   2.174 +                symbolBlock = block;
   2.175 +            } else {
   2.176 +                symbolBlock = function;
   2.177 +            }
   2.178 +
   2.179 +            // Create and add to appropriate block.
   2.180 +            symbol = new Symbol(name, flags, node, symbolBlock);
   2.181 +            symbolBlock.putSymbol(name, symbol);
   2.182 +
   2.183 +            if ((flags & Symbol.KINDMASK) != IS_GLOBAL) {
   2.184 +                symbolBlock.getFrame().addSymbol(symbol);
   2.185 +                symbol.setNeedsSlot(true);
   2.186 +            }
   2.187 +        } else if (symbol.less(flags)) {
   2.188 +            symbol.setFlags(flags);
   2.189 +        }
   2.190 +
   2.191 +        if (node != null) {
   2.192 +            node.setSymbol(symbol);
   2.193 +        }
   2.194 +
   2.195 +        return symbol;
   2.196 +    }
   2.197 +
   2.198      @Override
   2.199 -    public Node enter(final FunctionNode functionNode) {
   2.200 +    public Node enterFunctionNode(final FunctionNode functionNode) {
   2.201          start(functionNode, false);
   2.202          if (functionNode.isLazy()) {
   2.203 -            LOG.info("LAZY: " + functionNode.getName());
   2.204 +            LOG.info("LAZY: " + functionNode.getName() + " => Promoting to OBJECT");
   2.205 +            newTemporary(lexicalContext.getCurrentFunction(), Type.OBJECT, functionNode);
   2.206 +            functionNode.setReturnType(Type.OBJECT);
   2.207              end(functionNode);
   2.208              return null;
   2.209          }
   2.210  
   2.211 +        lexicalContext.push(functionNode);
   2.212 +
   2.213          clearLocalDefs();
   2.214          clearLocalUses();
   2.215  
   2.216 @@ -244,24 +324,36 @@
   2.217          initScope(functionNode);
   2.218          initReturn(functionNode);
   2.219  
   2.220 -        // Add all nested functions as symbols in this function
   2.221 -        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {
   2.222 +        // Add all nested declared functions as symbols in this function
   2.223 +        for (final FunctionNode nestedFunction : functionNode.getDeclaredFunctions()) {
   2.224              final IdentNode ident = nestedFunction.getIdent();
   2.225 -            if (ident != null && nestedFunction.isStatement()) {
   2.226 -                final Symbol functionSymbol = functionNode.defineSymbol(ident.getName(), IS_VAR, nestedFunction);
   2.227 +            if (ident != null) {
   2.228 +                assert nestedFunction.isDeclared();
   2.229 +                final Symbol functionSymbol = defineSymbol(functionNode, ident.getName(), IS_VAR, nestedFunction);
   2.230                  newType(functionSymbol, Type.typeFor(ScriptFunction.class));
   2.231              }
   2.232          }
   2.233  
   2.234 -        if (functionNode.isScript()) {
   2.235 +        if (functionNode.isProgram()) {
   2.236              initFromPropertyMap(functionNode);
   2.237          }
   2.238  
   2.239          // Add function name as local symbol
   2.240 -        if (!functionNode.isStatement() && !functionNode.isAnonymous() && !functionNode.isScript()) {
   2.241 -            final Symbol selfSymbol = functionNode.defineSymbol(functionNode.getIdent().getName(), IS_VAR, functionNode);
   2.242 -            newType(selfSymbol, Type.OBJECT);
   2.243 -            selfSymbol.setNode(functionNode);
   2.244 +        if (!functionNode.isDeclared() && !functionNode.isProgram()) {
   2.245 +            if(functionNode.getSymbol() != null) {
   2.246 +                // a temporary left over from an earlier pass when the function was lazy
   2.247 +                assert functionNode.getSymbol().isTemp();
   2.248 +                // remove it
   2.249 +                functionNode.setSymbol(null);
   2.250 +            }
   2.251 +            final Symbol selfSymbol;
   2.252 +            if(functionNode.isAnonymous()) {
   2.253 +                selfSymbol = newTemporary(functionNode, Type.OBJECT, functionNode);
   2.254 +            } else {
   2.255 +                selfSymbol = defineSymbol(functionNode, functionNode.getIdent().getName(), IS_VAR, functionNode);
   2.256 +                newType(selfSymbol, Type.OBJECT);
   2.257 +                selfSymbol.setNode(functionNode);
   2.258 +            }
   2.259          }
   2.260  
   2.261          /*
   2.262 @@ -282,32 +374,26 @@
   2.263           */
   2.264  
   2.265          final List<Symbol> declaredSymbols = new ArrayList<>();
   2.266 -        for (final VarNode decl : functionNode.getDeclarations()) {
   2.267 -            final IdentNode ident = decl.getName();
   2.268 -            // any declared symbols that aren't visited need to be typed as well, hence the list
   2.269 -            declaredSymbols.add(functionNode.defineSymbol(ident.getName(), IS_VAR, new IdentNode(ident)));
   2.270 -        }
   2.271 +        // This visitor will assign symbol to all declared variables, except function declarations (which are taken care
   2.272 +        // in a separate step above) and "var" declarations in for loop initializers.
   2.273 +        functionNode.accept(new NodeOperatorVisitor() {
   2.274 +            @Override
   2.275 +            public Node enterFunctionNode(FunctionNode nestedFn) {
   2.276 +                // Don't descend into nested functions
   2.277 +                return nestedFn == functionNode ? nestedFn : null;
   2.278 +            }
   2.279 +            @Override
   2.280 +            public Node enterVarNode(VarNode varNode) {
   2.281 +                if(varNode.isStatement() && !varNode.isFunctionDeclaration()) {
   2.282 +                    final IdentNode ident = varNode.getName();
   2.283 +                    // any declared symbols that aren't visited need to be typed as well, hence the list
   2.284 +                    declaredSymbols.add(defineSymbol(functionNode, ident.getName(), IS_VAR, new IdentNode(ident)));
   2.285 +                }
   2.286 +                return null;
   2.287 +            }
   2.288 +        });
   2.289  
   2.290 -        // Every nested function needs a definition in the outer function with its name. Add these.
   2.291 -        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {
   2.292 -            final VarNode varNode = nestedFunction.getFunctionVarNode();
   2.293 -            if (varNode != null) {
   2.294 -                varNode.accept(this);
   2.295 -                assert varNode.isFunctionVarNode() : varNode + " should be function var node";
   2.296 -            }
   2.297 -        }
   2.298 -
   2.299 -        for (final Node statement : functionNode.getStatements()) {
   2.300 -            if (statement instanceof VarNode && ((VarNode)statement).isFunctionVarNode()) {
   2.301 -                continue; //var nodes have already been processed, skip or they will generate additional defs/uses and false "can be undefined"
   2.302 -            }
   2.303 -            statement.accept(this);
   2.304 -        }
   2.305 -
   2.306 -        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {
   2.307 -            LOG.info("Going into nested function " + functionNode.getName() + " -> " + nestedFunction.getName());
   2.308 -            nestedFunction.accept(this);
   2.309 -        }
   2.310 +        visitFunctionStatements(functionNode);
   2.311  
   2.312          //unknown parameters are promoted to object type.
   2.313          finalizeParameters(functionNode);
   2.314 @@ -343,10 +429,19 @@
   2.315          functionNode.setState(CompilationState.ATTR);
   2.316  
   2.317          end(functionNode, false);
   2.318 +        lexicalContext.pop(functionNode);
   2.319  
   2.320          return null;
   2.321      }
   2.322  
   2.323 +    private void visitFunctionStatements(final FunctionNode functionNode) {
   2.324 +        final List<Node> newStatements = new ArrayList<>(functionNode.getStatements());
   2.325 +        for(ListIterator<Node> stmts = newStatements.listIterator(); stmts.hasNext();) {
   2.326 +            stmts.set(stmts.next().accept(this));
   2.327 +        }
   2.328 +        functionNode.setStatements(newStatements);
   2.329 +    }
   2.330 +
   2.331      @Override
   2.332      public Node leaveCONVERT(final UnaryNode unaryNode) {
   2.333          assert false : "There should be no convert operators in IR during Attribution";
   2.334 @@ -355,7 +450,7 @@
   2.335      }
   2.336  
   2.337      @Override
   2.338 -    public Node enter(final IdentNode identNode) {
   2.339 +    public Node enterIdentNode(final IdentNode identNode) {
   2.340          final String name = identNode.getName();
   2.341  
   2.342          start(identNode);
   2.343 @@ -372,7 +467,7 @@
   2.344          final Block  block     = getCurrentBlock();
   2.345          final Symbol oldSymbol = identNode.getSymbol();
   2.346  
   2.347 -        Symbol symbol = block.findSymbol(name);
   2.348 +        Symbol symbol = findSymbol(block, name);
   2.349  
   2.350          //If an existing symbol with the name is found, use that otherwise, declare a new one
   2.351          if (symbol != null) {
   2.352 @@ -396,22 +491,13 @@
   2.353              }
   2.354  
   2.355              identNode.setSymbol(symbol);
   2.356 -            if (!getCurrentFunctionNode().isLocal(symbol)) {
   2.357 -                // non-local: we need to put symbol in scope (if it isn't already)
   2.358 -                if (!symbol.isScope()) {
   2.359 -                    final List<Block> lookupBlocks = findLookupBlocksHelper(getCurrentFunctionNode(), symbol.findFunction());
   2.360 -                    for (final Block lookupBlock : lookupBlocks) {
   2.361 -                        final Symbol refSymbol = lookupBlock.findSymbol(name);
   2.362 -                        if (refSymbol != null) { // See NASHORN-837, function declaration in lexical scope: try {} catch (x){ function f() { use(x) } } f()
   2.363 -                            LOG.finest("Found a ref symbol that must be scope " + refSymbol);
   2.364 -                            refSymbol.setIsScope();
   2.365 -                        }
   2.366 -                    }
   2.367 -                }
   2.368 +            // non-local: we need to put symbol in scope (if it isn't already)
   2.369 +            if (!isLocal(getCurrentFunctionNode(), symbol) && !symbol.isScope()) {
   2.370 +                symbol.setIsScope();
   2.371              }
   2.372          } else {
   2.373              LOG.info("No symbol exists. Declare undefined: " + symbol);
   2.374 -            symbol = block.useSymbol(name, identNode);
   2.375 +            symbol = useSymbol(block, name, identNode);
   2.376              // we have never seen this before, it can be undefined
   2.377              newType(symbol, Type.OBJECT); // TODO unknown -we have explicit casts anyway?
   2.378              symbol.setCanBeUndefined();
   2.379 @@ -420,9 +506,10 @@
   2.380  
   2.381          assert symbol != null;
   2.382          if(symbol.isGlobal()) {
   2.383 -            getCurrentFunctionNode().setUsesGlobalSymbol();
   2.384 +            setUsesGlobalSymbol();
   2.385          } else if(symbol.isScope()) {
   2.386 -            getCurrentFunctionNode().setUsesScopeSymbol(symbol);
   2.387 +            final Iterator<Block> blocks = lexicalContext.getBlocks();
   2.388 +            blocks.next().setUsesScopeSymbol(symbol, blocks);
   2.389          }
   2.390  
   2.391          if (symbol != oldSymbol && !identNode.isInitializedHere()) {
   2.392 @@ -435,15 +522,68 @@
   2.393          return null;
   2.394      }
   2.395  
   2.396 +    /**
   2.397 +     * Marks the current function as one using any global symbol. The function and all its parent functions will all be
   2.398 +     * marked as needing parent scope.
   2.399 +     * @see #needsParentScope()
   2.400 +     */
   2.401 +    private void setUsesGlobalSymbol() {
   2.402 +        for(final Iterator<FunctionNode> fns = lexicalContext.getFunctions(); fns.hasNext();) {
   2.403 +            fns.next().setUsesAncestorScope();
   2.404 +        }
   2.405 +    }
   2.406 +
   2.407 +    /**
   2.408 +     * Declare the use of a symbol in a block.
   2.409 +     *
   2.410 +     * @param block block in which the symbol is used
   2.411 +     * @param name Name of symbol.
   2.412 +     * @param node Using node
   2.413 +     *
   2.414 +     * @return Symbol for given name.
   2.415 +     */
   2.416 +    private Symbol useSymbol(final Block block, final String name, final Node node) {
   2.417 +        Symbol symbol = findSymbol(block, name);
   2.418 +
   2.419 +        if (symbol == null) {
   2.420 +            // If not found, declare as a free var.
   2.421 +            symbol = defineSymbol(block, name, IS_GLOBAL, node);
   2.422 +        } else {
   2.423 +            node.setSymbol(symbol);
   2.424 +        }
   2.425 +
   2.426 +        return symbol;
   2.427 +    }
   2.428 +
   2.429 +
   2.430 +    /**
   2.431 +     * Search for symbol in the lexical context starting from the given block.
   2.432 +     * @param name Symbol name.
   2.433 +     * @return Found symbol or null if not found.
   2.434 +     */
   2.435 +    private Symbol findSymbol(final Block block, final String name) {
   2.436 +        // Search up block chain to locate symbol.
   2.437 +
   2.438 +        for(final Iterator<Block> blocks = lexicalContext.getBlocks(block); blocks.hasNext();) {
   2.439 +            // Find name.
   2.440 +            final Symbol symbol = blocks.next().getExistingSymbol(name);
   2.441 +            // If found then we are good.
   2.442 +            if(symbol != null) {
   2.443 +                return symbol;
   2.444 +            }
   2.445 +        }
   2.446 +        return null;
   2.447 +    }
   2.448 +
   2.449      @Override
   2.450 -    public Node leave(final IndexNode indexNode) {
   2.451 +    public Node leaveIndexNode(final IndexNode indexNode) {
   2.452          newTemporary(Type.OBJECT, indexNode); //TORO
   2.453          return indexNode;
   2.454      }
   2.455  
   2.456      @SuppressWarnings("rawtypes")
   2.457      @Override
   2.458 -    public Node enter(final LiteralNode literalNode) {
   2.459 +    public Node enterLiteralNode(final LiteralNode literalNode) {
   2.460          try {
   2.461              start(literalNode);
   2.462              assert !literalNode.isTokenType(TokenType.THIS) : "tokentype for " + literalNode + " is this"; //guard against old dead code case. literal nodes should never inherit tokens
   2.463 @@ -472,14 +612,14 @@
   2.464      }
   2.465  
   2.466      @Override
   2.467 -    public Node leave(final ObjectNode objectNode) {
   2.468 +    public Node leaveObjectNode(final ObjectNode objectNode) {
   2.469          newTemporary(Type.OBJECT, objectNode);
   2.470          end(objectNode);
   2.471          return objectNode;
   2.472      }
   2.473  
   2.474      @Override
   2.475 -    public Node enter(final PropertyNode propertyNode) {
   2.476 +    public Node enterPropertyNode(final PropertyNode propertyNode) {
   2.477          // assign a pseudo symbol to property name, see NASHORN-710
   2.478          propertyNode.setSymbol(new Symbol(propertyNode.getKeyName(), 0, Type.OBJECT));
   2.479          end(propertyNode);
   2.480 @@ -487,31 +627,7 @@
   2.481      }
   2.482  
   2.483      @Override
   2.484 -    public Node enter(final ReferenceNode referenceNode) {
   2.485 -        final FunctionNode functionNode = referenceNode.getReference();
   2.486 -        if (functionNode != null) {
   2.487 -            functionNode.addReferencingParentBlock(getCurrentBlock());
   2.488 -        }
   2.489 -        return referenceNode;
   2.490 -    }
   2.491 -
   2.492 -    @Override
   2.493 -    public Node leave(final ReferenceNode referenceNode) {
   2.494 -        newTemporary(Type.OBJECT, referenceNode); //reference node type is always an object, i.e. the scriptFunction. the function return type varies though
   2.495 -
   2.496 -        final FunctionNode functionNode = referenceNode.getReference();
   2.497 -        //assert !functionNode.getType().isUnknown() || functionNode.isLazy() : functionNode.getType();
   2.498 -        if (functionNode.isLazy()) {
   2.499 -            LOG.info("Lazy function node call reference: " + functionNode.getName() + " => Promoting to OBJECT");
   2.500 -            functionNode.setReturnType(Type.OBJECT);
   2.501 -        }
   2.502 -        end(referenceNode);
   2.503 -
   2.504 -        return referenceNode;
   2.505 -    }
   2.506 -
   2.507 -    @Override
   2.508 -    public Node leave(final ReturnNode returnNode) {
   2.509 +    public Node leaveReturnNode(final ReturnNode returnNode) {
   2.510          final Node expr = returnNode.getExpression();
   2.511  
   2.512          if (expr != null) {
   2.513 @@ -530,7 +646,7 @@
   2.514      }
   2.515  
   2.516      @Override
   2.517 -    public Node leave(final SwitchNode switchNode) {
   2.518 +    public Node leaveSwitchNode(final SwitchNode switchNode) {
   2.519          Type type = Type.UNKNOWN;
   2.520  
   2.521          for (final CaseNode caseNode : switchNode.getCases()) {
   2.522 @@ -567,7 +683,7 @@
   2.523      }
   2.524  
   2.525      @Override
   2.526 -    public Node leave(final TryNode tryNode) {
   2.527 +    public Node leaveTryNode(final TryNode tryNode) {
   2.528          tryNode.setException(exceptionSymbol());
   2.529  
   2.530          if (tryNode.getFinallyBody() != null) {
   2.531 @@ -580,13 +696,13 @@
   2.532      }
   2.533  
   2.534      @Override
   2.535 -    public Node enter(final VarNode varNode) {
   2.536 +    public Node enterVarNode(final VarNode varNode) {
   2.537          start(varNode);
   2.538  
   2.539          final IdentNode ident = varNode.getName();
   2.540          final String    name  = ident.getName();
   2.541  
   2.542 -        final Symbol symbol = getCurrentBlock().defineSymbol(name, IS_VAR, ident);
   2.543 +        final Symbol symbol = defineSymbol(getCurrentBlock(), name, IS_VAR, ident);
   2.544          assert symbol != null;
   2.545  
   2.546          LOG.info("VarNode " + varNode + " set symbol " + symbol);
   2.547 @@ -598,23 +714,15 @@
   2.548              symbol.setCanBeUndefined();
   2.549          }
   2.550  
   2.551 -        if (varNode.getInit() != null) {
   2.552 -            varNode.getInit().accept(this);
   2.553 -        }
   2.554 -
   2.555          return varNode;
   2.556      }
   2.557  
   2.558      @Override
   2.559 -    public Node leave(final VarNode varNode) {
   2.560 +    public Node leaveVarNode(final VarNode varNode) {
   2.561          final Node      init  = varNode.getInit();
   2.562          final IdentNode ident = varNode.getName();
   2.563          final String    name  = ident.getName();
   2.564  
   2.565 -        if (init != null) {
   2.566 -            addLocalDef(name);
   2.567 -        }
   2.568 -
   2.569          if (init == null) {
   2.570              // var x; with no init will be treated like a use of x by
   2.571              // visit(IdentNode) unless we remove the name
   2.572 @@ -623,8 +731,10 @@
   2.573              return varNode;
   2.574          }
   2.575  
   2.576 +        addLocalDef(name);
   2.577 +
   2.578          final Symbol  symbol   = varNode.getSymbol();
   2.579 -        final boolean isScript = symbol.getBlock().getFunction().isScript(); //see NASHORN-56
   2.580 +        final boolean isScript = lexicalContext.getFunction(symbol.getBlock()).isProgram(); //see NASHORN-56
   2.581          if ((init.getType().isNumeric() || init.getType().isBoolean()) && !isScript) {
   2.582              // Forbid integers as local vars for now as we have no way to treat them as undefined
   2.583              newType(symbol, init.getType());
   2.584 @@ -718,11 +828,9 @@
   2.585          runtimeNode = new RuntimeNode(unaryNode, request, args);
   2.586          assert runtimeNode.getSymbol() == unaryNode.getSymbol(); //clone constructor should do this
   2.587  
   2.588 -        runtimeNode.accept(this);
   2.589 -        return runtimeNode;
   2.590 +        return leaveRuntimeNode(runtimeNode);
   2.591      }
   2.592  
   2.593 -
   2.594      @Override
   2.595      public Node leaveNEW(final UnaryNode unaryNode) {
   2.596          newTemporary(Type.OBJECT, unaryNode);
   2.597 @@ -755,7 +863,7 @@
   2.598          runtimeNode = new RuntimeNode(unaryNode, Request.TYPEOF, args);
   2.599          assert runtimeNode.getSymbol() == unaryNode.getSymbol();
   2.600  
   2.601 -        runtimeNode.accept(this);
   2.602 +        runtimeNode = (RuntimeNode)leaveRuntimeNode(runtimeNode);
   2.603  
   2.604          end(unaryNode);
   2.605  
   2.606 @@ -763,7 +871,7 @@
   2.607      }
   2.608  
   2.609      @Override
   2.610 -    public Node leave(final RuntimeNode runtimeNode) {
   2.611 +    public Node leaveRuntimeNode(final RuntimeNode runtimeNode) {
   2.612          newTemporary(runtimeNode.getRequest().getReturnType(), runtimeNode);
   2.613          return runtimeNode;
   2.614      }
   2.615 @@ -823,12 +931,12 @@
   2.616              final IdentNode ident = (IdentNode)lhs;
   2.617              final String    name  = ident.getName();
   2.618  
   2.619 -            Symbol symbol = getCurrentBlock().findSymbol(name);
   2.620 +            Symbol symbol = findSymbol(getCurrentBlock(), name);
   2.621  
   2.622              if (symbol == null) {
   2.623 -                symbol = block.defineSymbol(name, IS_GLOBAL, ident);
   2.624 +                symbol = defineSymbol(block, name, IS_GLOBAL, ident);
   2.625                  binaryNode.setSymbol(symbol);
   2.626 -            } else if (!getCurrentFunctionNode().isLocal(symbol)) {
   2.627 +            } else if (!isLocal(getCurrentFunctionNode(), symbol)) {
   2.628                  symbol.setIsScope();
   2.629              }
   2.630  
   2.631 @@ -838,6 +946,12 @@
   2.632          return binaryNode;
   2.633      }
   2.634  
   2.635 +    private boolean isLocal(FunctionNode function, Symbol symbol) {
   2.636 +        final Block block = symbol.getBlock();
   2.637 +        // some temp symbols have no block, so can be assumed local
   2.638 +        return block == null || lexicalContext.getFunction(block) == function;
   2.639 +    }
   2.640 +
   2.641      @Override
   2.642      public Node enterASSIGN(final BinaryNode binaryNode) {
   2.643          return enterAssignmentNode(binaryNode);
   2.644 @@ -995,7 +1109,7 @@
   2.645          return leaveBinaryArithmetic(binaryNode);
   2.646      }
   2.647  
   2.648 -    private Node leaveCmp(final BinaryNode binaryNode, final RuntimeNode.Request request) {
   2.649 +    private Node leaveCmp(final BinaryNode binaryNode) {
   2.650          final Node lhs = binaryNode.lhs();
   2.651          final Node rhs = binaryNode.rhs();
   2.652  
   2.653 @@ -1033,37 +1147,38 @@
   2.654  
   2.655      @Override
   2.656      public Node leaveEQ(final BinaryNode binaryNode) {
   2.657 -        return leaveCmp(binaryNode, Request.EQ);
   2.658 +        return leaveCmp(binaryNode);
   2.659      }
   2.660  
   2.661      @Override
   2.662      public Node leaveEQ_STRICT(final BinaryNode binaryNode) {
   2.663 -        return leaveCmp(binaryNode, Request.EQ_STRICT);
   2.664 +        return leaveCmp(binaryNode);
   2.665      }
   2.666  
   2.667      @Override
   2.668      public Node leaveGE(final BinaryNode binaryNode) {
   2.669 -        return leaveCmp(binaryNode, Request.GE);
   2.670 +        return leaveCmp(binaryNode);
   2.671      }
   2.672  
   2.673      @Override
   2.674      public Node leaveGT(final BinaryNode binaryNode) {
   2.675 -        return leaveCmp(binaryNode, Request.GT);
   2.676 +        return leaveCmp(binaryNode);
   2.677      }
   2.678  
   2.679      @Override
   2.680      public Node leaveIN(final BinaryNode binaryNode) {
   2.681 -        try {
   2.682 -            return new RuntimeNode(binaryNode, Request.IN).accept(this);
   2.683 -        } finally {
   2.684 -            end(binaryNode);
   2.685 -        }
   2.686 +        return leaveBinaryRuntimeOperator(binaryNode, Request.IN);
   2.687      }
   2.688  
   2.689      @Override
   2.690      public Node leaveINSTANCEOF(final BinaryNode binaryNode) {
   2.691 +        return leaveBinaryRuntimeOperator(binaryNode, Request.INSTANCEOF);
   2.692 +    }
   2.693 +
   2.694 +    private Node leaveBinaryRuntimeOperator(final BinaryNode binaryNode, final Request request) {
   2.695          try {
   2.696 -            return new RuntimeNode(binaryNode, Request.INSTANCEOF).accept(this);
   2.697 +            // Don't do a full RuntimeNode.accept, as we don't want to double-visit the binary node operands
   2.698 +            return leaveRuntimeNode(new RuntimeNode(binaryNode, request));
   2.699          } finally {
   2.700              end(binaryNode);
   2.701          }
   2.702 @@ -1071,12 +1186,12 @@
   2.703  
   2.704      @Override
   2.705      public Node leaveLE(final BinaryNode binaryNode) {
   2.706 -        return leaveCmp(binaryNode, Request.LE);
   2.707 +        return leaveCmp(binaryNode);
   2.708      }
   2.709  
   2.710      @Override
   2.711      public Node leaveLT(final BinaryNode binaryNode) {
   2.712 -        return leaveCmp(binaryNode, Request.LT);
   2.713 +        return leaveCmp(binaryNode);
   2.714      }
   2.715  
   2.716      @Override
   2.717 @@ -1091,12 +1206,12 @@
   2.718  
   2.719      @Override
   2.720      public Node leaveNE(final BinaryNode binaryNode) {
   2.721 -        return leaveCmp(binaryNode, Request.NE);
   2.722 +        return leaveCmp(binaryNode);
   2.723      }
   2.724  
   2.725      @Override
   2.726      public Node leaveNE_STRICT(final BinaryNode binaryNode) {
   2.727 -        return leaveCmp(binaryNode, Request.NE_STRICT);
   2.728 +        return leaveCmp(binaryNode);
   2.729      }
   2.730  
   2.731      @Override
   2.732 @@ -1127,9 +1242,9 @@
   2.733      }
   2.734  
   2.735      @Override
   2.736 -    public Node leave(final ForNode forNode) {
   2.737 +    public Node leaveForNode(final ForNode forNode) {
   2.738          if (forNode.isForIn()) {
   2.739 -            forNode.setIterator(newInternal(getCurrentFunctionNode(), getCurrentFunctionNode().uniqueName(ITERATOR_PREFIX.tag()), Type.OBJECT)); //NASHORN-73
   2.740 +            forNode.setIterator(newInternal(getCurrentFunctionNode().uniqueName(ITERATOR_PREFIX.tag()), Type.OBJECT)); //NASHORN-73
   2.741              /*
   2.742               * Iterators return objects, so we need to widen the scope of the
   2.743               * init variable if it, for example, has been assigned double type
   2.744 @@ -1144,7 +1259,7 @@
   2.745      }
   2.746  
   2.747      @Override
   2.748 -    public Node leave(final TernaryNode ternaryNode) {
   2.749 +    public Node leaveTernaryNode(final TernaryNode ternaryNode) {
   2.750          final Node lhs  = ternaryNode.rhs();
   2.751          final Node rhs  = ternaryNode.third();
   2.752  
   2.753 @@ -1159,24 +1274,24 @@
   2.754          return ternaryNode;
   2.755      }
   2.756  
   2.757 -    private static void initThis(final FunctionNode functionNode) {
   2.758 -        final Symbol thisSymbol = functionNode.defineSymbol(THIS.tag(), IS_PARAM | IS_THIS, null);
   2.759 +    private void initThis(final FunctionNode functionNode) {
   2.760 +        final Symbol thisSymbol = defineSymbol(functionNode, THIS.tag(), IS_PARAM | IS_THIS, null);
   2.761          newType(thisSymbol, Type.OBJECT);
   2.762          thisSymbol.setNeedsSlot(true);
   2.763          functionNode.getThisNode().setSymbol(thisSymbol);
   2.764          LOG.info("Initialized scope symbol: " + thisSymbol);
   2.765      }
   2.766  
   2.767 -    private static void initScope(final FunctionNode functionNode) {
   2.768 -        final Symbol scopeSymbol = functionNode.defineSymbol(SCOPE.tag(), IS_VAR | IS_INTERNAL, null);
   2.769 +    private void initScope(final FunctionNode functionNode) {
   2.770 +        final Symbol scopeSymbol = defineSymbol(functionNode, SCOPE.tag(), IS_VAR | IS_INTERNAL, null);
   2.771          newType(scopeSymbol, Type.typeFor(ScriptObject.class));
   2.772          scopeSymbol.setNeedsSlot(true);
   2.773          functionNode.getScopeNode().setSymbol(scopeSymbol);
   2.774          LOG.info("Initialized scope symbol: " + scopeSymbol);
   2.775      }
   2.776  
   2.777 -    private static void initReturn(final FunctionNode functionNode) {
   2.778 -        final Symbol returnSymbol = functionNode.defineSymbol(SCRIPT_RETURN.tag(), IS_VAR | IS_INTERNAL, null);
   2.779 +    private void initReturn(final FunctionNode functionNode) {
   2.780 +        final Symbol returnSymbol = defineSymbol(functionNode, SCRIPT_RETURN.tag(), IS_VAR | IS_INTERNAL, null);
   2.781          newType(returnSymbol, Type.OBJECT);
   2.782          returnSymbol.setNeedsSlot(true);
   2.783          functionNode.getResultNode().setSymbol(returnSymbol);
   2.784 @@ -1186,7 +1301,7 @@
   2.785  
   2.786      private void initVarArg(final FunctionNode functionNode) {
   2.787          if (functionNode.isVarArg()) {
   2.788 -            final Symbol varArgsSymbol = functionNode.defineSymbol(VARARGS.tag(), IS_PARAM | IS_INTERNAL, null);
   2.789 +            final Symbol varArgsSymbol = defineSymbol(functionNode, VARARGS.tag(), IS_PARAM | IS_INTERNAL, null);
   2.790              varArgsSymbol.setTypeOverride(Type.OBJECT_ARRAY);
   2.791              varArgsSymbol.setNeedsSlot(true);
   2.792              functionNode.getVarArgsNode().setSymbol(varArgsSymbol);
   2.793 @@ -1194,7 +1309,7 @@
   2.794  
   2.795              if (functionNode.needsArguments()) {
   2.796                  final String    argumentsName   = functionNode.getArgumentsNode().getName();
   2.797 -                final Symbol    argumentsSymbol = functionNode.defineSymbol(argumentsName, IS_VAR | IS_INTERNAL, null);
   2.798 +                final Symbol    argumentsSymbol = defineSymbol(functionNode, argumentsName, IS_VAR | IS_INTERNAL, null);
   2.799                  newType(argumentsSymbol, Type.typeFor(ScriptObject.class));
   2.800                  argumentsSymbol.setNeedsSlot(true);
   2.801                  functionNode.getArgumentsNode().setSymbol(argumentsSymbol);
   2.802 @@ -1204,9 +1319,9 @@
   2.803          }
   2.804      }
   2.805  
   2.806 -    private static void initCallee(final FunctionNode functionNode) {
   2.807 +    private void initCallee(final FunctionNode functionNode) {
   2.808          assert functionNode.getCalleeNode() != null : functionNode + " has no callee";
   2.809 -        final Symbol calleeSymbol = functionNode.defineSymbol(CALLEE.tag(), IS_PARAM | IS_INTERNAL, null);
   2.810 +        final Symbol calleeSymbol = defineSymbol(functionNode, CALLEE.tag(), IS_PARAM | IS_INTERNAL, null);
   2.811          newType(calleeSymbol, Type.typeFor(ScriptFunction.class));
   2.812          calleeSymbol.setNeedsSlot(true);
   2.813          functionNode.getCalleeNode().setSymbol(calleeSymbol);
   2.814 @@ -1226,7 +1341,7 @@
   2.815  
   2.816          for (final IdentNode param : functionNode.getParameters()) {
   2.817              addLocalDef(param.getName());
   2.818 -            final Symbol paramSymbol = functionNode.defineSymbol(param.getName(), IS_PARAM, param);
   2.819 +            final Symbol paramSymbol = defineSymbol(functionNode, param.getName(), IS_PARAM, param);
   2.820              if (paramSymbol != null) {
   2.821                  final Type callSiteParamType = functionNode.getSpecializedType(param);
   2.822                  if (callSiteParamType != null) {
   2.823 @@ -1279,15 +1394,15 @@
   2.824       * Move any properties from a global map into the scope of this method
   2.825       * @param functionNode the function node for which to init scope vars
   2.826       */
   2.827 -    private static void initFromPropertyMap(final FunctionNode functionNode) {
   2.828 +    private void initFromPropertyMap(final FunctionNode functionNode) {
   2.829          // For a script, add scope symbols as defined in the property map
   2.830 -        assert functionNode.isScript();
   2.831 +        assert functionNode.isProgram();
   2.832  
   2.833          final PropertyMap map = Context.getGlobalMap();
   2.834  
   2.835          for (final Property property : map.getProperties()) {
   2.836              final String key    = property.getKey();
   2.837 -            final Symbol symbol = functionNode.defineSymbol(key, IS_GLOBAL, null);
   2.838 +            final Symbol symbol = defineSymbol(functionNode, key, IS_GLOBAL, null);
   2.839              newType(symbol, Type.OBJECT);
   2.840              LOG.info("Added global symbol from property map " + symbol);
   2.841          }
   2.842 @@ -1354,7 +1469,7 @@
   2.843      private static void ensureAssignmentSlots(final FunctionNode functionNode, final Node assignmentDest) {
   2.844          assignmentDest.accept(new NodeVisitor() {
   2.845              @Override
   2.846 -            public Node leave(final IndexNode indexNode) {
   2.847 +            public Node leaveIndexNode(final IndexNode indexNode) {
   2.848                  final Node index = indexNode.getIndex();
   2.849                  index.getSymbol().setNeedsSlot(!index.getSymbol().isConstant());
   2.850                  return indexNode;
   2.851 @@ -1399,7 +1514,7 @@
   2.852                  }
   2.853  
   2.854                  @Override
   2.855 -                public Node enter(final FunctionNode node) {
   2.856 +                public Node enterFunctionNode(final FunctionNode node) {
   2.857                      return node.isLazy() ? null : node;
   2.858                  }
   2.859  
   2.860 @@ -1419,7 +1534,7 @@
   2.861                   */
   2.862                  @SuppressWarnings("fallthrough")
   2.863                  @Override
   2.864 -                public Node leave(final BinaryNode binaryNode) {
   2.865 +                public Node leaveBinaryNode(final BinaryNode binaryNode) {
   2.866                      final Type widest = Type.widest(binaryNode.lhs().getType(), binaryNode.rhs().getType());
   2.867                      switch (binaryNode.tokenType()) {
   2.868                      default:
   2.869 @@ -1477,22 +1592,6 @@
   2.870          return binaryNode;
   2.871      }
   2.872  
   2.873 -    private static List<Block> findLookupBlocksHelper(final FunctionNode currentFunction, final FunctionNode topFunction) {
   2.874 -        if (currentFunction.findParentFunction() == topFunction) {
   2.875 -            final List<Block> blocks = new LinkedList<>();
   2.876 -
   2.877 -            blocks.add(currentFunction.getParent());
   2.878 -            blocks.addAll(currentFunction.getReferencingParentBlocks());
   2.879 -            return blocks;
   2.880 -        }
   2.881 -        /*
   2.882 -         * assumption: all parent blocks of an inner function will always be in the same outer function;
   2.883 -         * therefore we can simply skip through intermediate functions.
   2.884 -         * @see FunctionNode#addReferencingParentBlock(Block)
   2.885 -         */
   2.886 -        return findLookupBlocksHelper(currentFunction.findParentFunction(), topFunction);
   2.887 -    }
   2.888 -
   2.889      private static boolean isFunctionExpressionSelfReference(final Symbol symbol) {
   2.890          if (symbol.isVar() && symbol.getNode() == symbol.getBlock() && symbol.getNode() instanceof FunctionNode) {
   2.891              return ((FunctionNode)symbol.getNode()).getIdent().getName().equals(symbol.getName());
   2.892 @@ -1509,16 +1608,12 @@
   2.893          return newTemporary(getCurrentFunctionNode(), type, node);
   2.894      }
   2.895  
   2.896 -    private Symbol newInternal(final FunctionNode functionNode, final String name, final Type type) {
   2.897 -        final Symbol iter = getCurrentFunctionNode().defineSymbol(name, IS_VAR | IS_INTERNAL, null);
   2.898 +    private Symbol newInternal(final String name, final Type type) {
   2.899 +        final Symbol iter = defineSymbol(getCurrentFunctionNode(), name, IS_VAR | IS_INTERNAL, null);
   2.900          iter.setType(type); // NASHORN-73
   2.901          return iter;
   2.902      }
   2.903  
   2.904 -    private Symbol newInternal(final String name, final Type type) {
   2.905 -        return newInternal(getCurrentFunctionNode(), name, type);
   2.906 -    }
   2.907 -
   2.908      private static void newType(final Symbol symbol, final Type type) {
   2.909          final Type oldType = symbol.getSymbolType();
   2.910          symbol.setType(type);
   2.911 @@ -1577,13 +1672,13 @@
   2.912              }
   2.913  
   2.914              @Override
   2.915 -            public Node enter(final Block block) {
   2.916 +            public Node enterBlock(final Block block) {
   2.917                  toObject(block);
   2.918                  return block;
   2.919              }
   2.920  
   2.921              @Override
   2.922 -            public Node enter(final FunctionNode node) {
   2.923 +            public Node enterFunctionNode(final FunctionNode node) {
   2.924                  toObject(node);
   2.925                  if (node.isLazy()) {
   2.926                      return null;

     3.1 --- a/src/jdk/nashorn/internal/codegen/ClassEmitter.java	Tue Mar 19 11:03:24 2013 -0300
     3.2 +++ b/src/jdk/nashorn/internal/codegen/ClassEmitter.java	Sat Mar 23 00:58:39 2013 +0100
     3.3 @@ -195,6 +195,14 @@
     3.4      }
     3.5  
     3.6      /**
     3.7 +     * Returns the name of the compile unit class name.
     3.8 +     * @return the name of the compile unit class name.
     3.9 +     */
    3.10 +    String getUnitClassName() {
    3.11 +        return unitClassName;
    3.12 +    }
    3.13 +
    3.14 +    /**
    3.15       * Convert a binary name to a package/class name.
    3.16       *
    3.17       * @param name Binary name.
    3.18 @@ -244,7 +252,7 @@
    3.19              // $getMap - get the ith entry from the constants table and cast to PropertyMap.
    3.20              final MethodEmitter getMapMethod = method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), GET_MAP.tag(), PropertyMap.class, int.class);
    3.21              getMapMethod.begin();
    3.22 -            getMapMethod.loadConstants(unitClassName)
    3.23 +            getMapMethod.loadConstants()
    3.24                          .load(Type.INT, 0)
    3.25                          .arrayload()
    3.26                          .checkcast(PropertyMap.class)
    3.27 @@ -254,7 +262,7 @@
    3.28              // $setMap - overwrite an existing map.
    3.29              final MethodEmitter setMapMethod = method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), SET_MAP.tag(), void.class, int.class, PropertyMap.class);
    3.30              setMapMethod.begin();
    3.31 -            setMapMethod.loadConstants(unitClassName)
    3.32 +            setMapMethod.loadConstants()
    3.33                          .load(Type.INT, 0)
    3.34                          .load(Type.OBJECT, 1)
    3.35                          .arraystore();

     4.1 --- a/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Tue Mar 19 11:03:24 2013 -0300
     4.2 +++ b/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Sat Mar 23 00:58:39 2013 +0100
     4.3 @@ -76,18 +76,18 @@
     4.4  import jdk.nashorn.internal.ir.ExecuteNode;
     4.5  import jdk.nashorn.internal.ir.ForNode;
     4.6  import jdk.nashorn.internal.ir.FunctionNode;
     4.7 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
     4.8  import jdk.nashorn.internal.ir.IdentNode;
     4.9  import jdk.nashorn.internal.ir.IfNode;
    4.10  import jdk.nashorn.internal.ir.IndexNode;
    4.11 +import jdk.nashorn.internal.ir.LexicalContext;
    4.12  import jdk.nashorn.internal.ir.LineNumberNode;
    4.13  import jdk.nashorn.internal.ir.LiteralNode;
    4.14 -import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    4.15  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
    4.16  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
    4.17  import jdk.nashorn.internal.ir.Node;
    4.18  import jdk.nashorn.internal.ir.ObjectNode;
    4.19  import jdk.nashorn.internal.ir.PropertyNode;
    4.20 -import jdk.nashorn.internal.ir.ReferenceNode;
    4.21  import jdk.nashorn.internal.ir.ReturnNode;
    4.22  import jdk.nashorn.internal.ir.RuntimeNode;
    4.23  import jdk.nashorn.internal.ir.RuntimeNode.Request;
    4.24 @@ -107,6 +107,7 @@
    4.25  import jdk.nashorn.internal.parser.Lexer.RegexToken;
    4.26  import jdk.nashorn.internal.parser.TokenType;
    4.27  import jdk.nashorn.internal.runtime.Context;
    4.28 +import jdk.nashorn.internal.runtime.DebugLogger;
    4.29  import jdk.nashorn.internal.runtime.ECMAException;
    4.30  import jdk.nashorn.internal.runtime.Property;
    4.31  import jdk.nashorn.internal.runtime.PropertyMap;
    4.32 @@ -156,12 +157,20 @@
    4.33      /** How many regexp fields have been emitted */
    4.34      private int regexFieldCount;
    4.35  
    4.36 +    /** Used for temporary signaling between enterCallNode and enterFunctionNode to handle the special case of calling
    4.37 +     * a just-defined anonymous function expression. */
    4.38 +    private boolean functionNodeIsCallee;
    4.39 +
    4.40      /** Map of shared scope call sites */
    4.41      private final Map<SharedScopeCall, SharedScopeCall> scopeCalls = new HashMap<>();
    4.42  
    4.43 +    private final LexicalContext lexicalContext = new LexicalContext();
    4.44 +
    4.45      /** When should we stop caching regexp expressions in fields to limit bytecode size? */
    4.46      private static final int MAX_REGEX_FIELDS = 2 * 1024;
    4.47  
    4.48 +    private static final DebugLogger LOG   = new DebugLogger("codegen", "nashorn.codegen.debug");
    4.49 +
    4.50      /**
    4.51       * Constructor.
    4.52       *
    4.53 @@ -210,7 +219,7 @@
    4.54              final int flags = CALLSITE_SCOPE | getCallSiteFlags();
    4.55              method.loadScope();
    4.56  
    4.57 -            if (symbol.isFastScope(getCurrentFunctionNode())) {
    4.58 +            if (isFastScope(symbol)) {
    4.59                  // Only generate shared scope getter for fast-scope symbols so we know we can dial in correct scope.
    4.60                  if (symbol.getUseCount() > SharedScopeCall.FAST_SCOPE_GET_THRESHOLD) {
    4.61                      return loadSharedScopeVar(identNode.getType(), symbol, flags);
    4.62 @@ -221,8 +230,28 @@
    4.63          }
    4.64      }
    4.65  
    4.66 +    /**
    4.67 +     * Check if this symbol can be accessed directly with a putfield or getfield or dynamic load
    4.68 +     *
    4.69 +     * @param function function to check for fast scope
    4.70 +     * @return true if fast scope
    4.71 +     */
    4.72 +    private boolean isFastScope(final Symbol symbol) {
    4.73 +        if (!symbol.isScope() || !symbol.getBlock().needsScope()) {
    4.74 +            return false;
    4.75 +        }
    4.76 +        // Allow fast scope access if no function contains with or eval
    4.77 +        for(final Iterator<FunctionNode> it = lexicalContext.getFunctions(getCurrentFunctionNode()); it.hasNext();) {
    4.78 +            final FunctionNode func = it.next();
    4.79 +            if (func.hasWith() || func.hasEval()) {
    4.80 +                return false;
    4.81 +            }
    4.82 +        }
    4.83 +        return true;
    4.84 +    }
    4.85 +
    4.86      private MethodEmitter loadSharedScopeVar(final Type valueType, final Symbol symbol, final int flags) {
    4.87 -        method.load(symbol.isFastScope(getCurrentFunctionNode()) ? getScopeProtoDepth(getCurrentBlock(), symbol) : -1);
    4.88 +        method.load(isFastScope(symbol) ? getScopeProtoDepth(getCurrentBlock(), symbol) : -1);
    4.89          final SharedScopeCall scopeCall = getScopeGet(valueType, symbol, flags | CALLSITE_FAST_SCOPE);
    4.90          scopeCall.generateInvoke(method);
    4.91          return method;
    4.92 @@ -240,30 +269,18 @@
    4.93          return method;
    4.94      }
    4.95  
    4.96 -    private static int getScopeProtoDepth(final Block currentBlock, final Symbol symbol) {
    4.97 -        if (currentBlock == symbol.getBlock()) {
    4.98 -            return 0;
    4.99 -        }
   4.100 -
   4.101 -        final int   delta       = currentBlock.needsScope() ? 1 : 0;
   4.102 -        final Block parentBlock = currentBlock.getParent();
   4.103 -
   4.104 -        if (parentBlock != null) {
   4.105 -            final int result = getScopeProtoDepth(parentBlock, symbol);
   4.106 -            if (result != -1) {
   4.107 -                return delta + result;
   4.108 +    private int getScopeProtoDepth(final Block startingBlock, final Symbol symbol) {
   4.109 +        int depth = 0;
   4.110 +        final Block definingBlock = symbol.getBlock();
   4.111 +        for(final Iterator<Block> blocks = lexicalContext.getBlocks(startingBlock); blocks.hasNext();) {
   4.112 +            final Block currentBlock = blocks.next();
   4.113 +            if (currentBlock == definingBlock) {
   4.114 +                return depth;
   4.115 +            }
   4.116 +            if (currentBlock.needsScope()) {
   4.117 +                ++depth;
   4.118              }
   4.119          }
   4.120 -
   4.121 -        if (currentBlock instanceof FunctionNode) {
   4.122 -            for (final Block lookupBlock : ((FunctionNode)currentBlock).getReferencingParentBlocks()) {
   4.123 -                final int result = getScopeProtoDepth(lookupBlock, symbol);
   4.124 -                if (result != -1) {
   4.125 -                    return delta + result;
   4.126 -                }
   4.127 -            }
   4.128 -        }
   4.129 -
   4.130          return -1;
   4.131      }
   4.132  
   4.133 @@ -313,13 +330,13 @@
   4.134  
   4.135          node.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
   4.136              @Override
   4.137 -            public Node enter(final IdentNode identNode) {
   4.138 +            public Node enterIdentNode(final IdentNode identNode) {
   4.139                  loadIdent(identNode);
   4.140                  return null;
   4.141              }
   4.142  
   4.143              @Override
   4.144 -            public Node enter(final AccessNode accessNode) {
   4.145 +            public Node enterAccessNode(final AccessNode accessNode) {
   4.146                  if (!baseAlreadyOnStack) {
   4.147                      load(accessNode.getBase()).convert(Type.OBJECT);
   4.148                  }
   4.149 @@ -329,7 +346,7 @@
   4.150              }
   4.151  
   4.152              @Override
   4.153 -            public Node enter(final IndexNode indexNode) {
   4.154 +            public Node enterIndexNode(final IndexNode indexNode) {
   4.155                  if (!baseAlreadyOnStack) {
   4.156                      load(indexNode.getBase()).convert(Type.OBJECT);
   4.157                      load(indexNode.getIndex());
   4.158 @@ -339,6 +356,14 @@
   4.159              }
   4.160  
   4.161              @Override
   4.162 +            public Node enterFunctionNode(FunctionNode functionNode) {
   4.163 +                // function nodes will always leave a constructed function object on stack, no need to load the symbol
   4.164 +                // separately as in enterDefault()
   4.165 +                functionNode.accept(codegen);
   4.166 +                return null;
   4.167 +            }
   4.168 +
   4.169 +            @Override
   4.170              public Node enterDefault(final Node otherNode) {
   4.171                  otherNode.accept(codegen); // generate code for whatever we are looking at.
   4.172                  method.load(symbol); // load the final symbol to the stack (or nop if no slot, then result is already there)
   4.173 @@ -350,7 +375,7 @@
   4.174      }
   4.175  
   4.176      @Override
   4.177 -    public Node enter(final AccessNode accessNode) {
   4.178 +    public Node enterAccessNode(final AccessNode accessNode) {
   4.179          if (accessNode.testResolved()) {
   4.180              return null;
   4.181          }
   4.182 @@ -422,10 +447,11 @@
   4.183      }
   4.184  
   4.185      @Override
   4.186 -    public Node enter(final Block block) {
   4.187 +    public Node enterBlock(final Block block) {
   4.188          if (block.testResolved()) {
   4.189              return null;
   4.190          }
   4.191 +        lexicalContext.push(block);
   4.192  
   4.193          method.label(block.getEntryLabel());
   4.194          initLocals(block);
   4.195 @@ -434,14 +460,14 @@
   4.196      }
   4.197  
   4.198      @Override
   4.199 -    public Node leave(final Block block) {
   4.200 +    public Node leaveBlock(final Block block) {
   4.201          method.label(block.getBreakLabel());
   4.202          symbolInfo(block);
   4.203  
   4.204          if (block.needsScope()) {
   4.205              popBlockScope(block);
   4.206          }
   4.207 -
   4.208 +        lexicalContext.pop(block);
   4.209          return block;
   4.210      }
   4.211  
   4.212 @@ -467,7 +493,7 @@
   4.213      }
   4.214  
   4.215      @Override
   4.216 -    public Node enter(final BreakNode breakNode) {
   4.217 +    public Node enterBreakNode(final BreakNode breakNode) {
   4.218          if (breakNode.testResolved()) {
   4.219              return null;
   4.220          }
   4.221 @@ -515,14 +541,13 @@
   4.222      }
   4.223  
   4.224      @Override
   4.225 -    public Node enter(final CallNode callNode) {
   4.226 +    public Node enterCallNode(final CallNode callNode) {
   4.227          if (callNode.testResolved()) {
   4.228              return null;
   4.229          }
   4.230  
   4.231          final List<Node>   args            = callNode.getArgs();
   4.232          final Node         function        = callNode.getFunction();
   4.233 -        final FunctionNode currentFunction = getCurrentFunctionNode();
   4.234          final Block        currentBlock    = getCurrentBlock();
   4.235  
   4.236          function.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
   4.237 @@ -531,7 +556,7 @@
   4.238                  final Symbol symbol = identNode.getSymbol();
   4.239                  int    scopeCallFlags = flags;
   4.240                  method.loadScope();
   4.241 -                if (symbol.isFastScope(currentFunction)) {
   4.242 +                if (isFastScope(symbol)) {
   4.243                      method.load(getScopeProtoDepth(currentBlock, symbol));
   4.244                      scopeCallFlags |= CALLSITE_FAST_SCOPE;
   4.245                  } else {
   4.246 @@ -593,7 +618,7 @@
   4.247              }
   4.248  
   4.249              @Override
   4.250 -            public Node enter(final IdentNode node) {
   4.251 +            public Node enterIdentNode(final IdentNode node) {
   4.252                  final Symbol symbol = node.getSymbol();
   4.253  
   4.254                  if (symbol.isScope()) {
   4.255 @@ -606,7 +631,7 @@
   4.256                      if (callNode.isEval()) {
   4.257                          evalCall(node, flags);
   4.258                      } else if (useCount <= SharedScopeCall.FAST_SCOPE_CALL_THRESHOLD
   4.259 -                            || (!symbol.isFastScope(currentFunction) && useCount <= SharedScopeCall.SLOW_SCOPE_CALL_THRESHOLD)
   4.260 +                            || (!isFastScope(symbol) && useCount <= SharedScopeCall.SLOW_SCOPE_CALL_THRESHOLD)
   4.261                              || callNode.inWithBlock()) {
   4.262                          scopeCall(node, flags);
   4.263                      } else {
   4.264 @@ -621,7 +646,7 @@
   4.265              }
   4.266  
   4.267              @Override
   4.268 -            public Node enter(final AccessNode node) {
   4.269 +            public Node enterAccessNode(final AccessNode node) {
   4.270                  load(node.getBase());
   4.271                  method.convert(Type.OBJECT);
   4.272                  method.dup();
   4.273 @@ -634,8 +659,7 @@
   4.274              }
   4.275  
   4.276              @Override
   4.277 -            public Node enter(final ReferenceNode node) {
   4.278 -                final FunctionNode callee   = node.getReference();
   4.279 +            public Node enterFunctionNode(final FunctionNode callee) {
   4.280                  final boolean      isVarArg = callee.isVarArg();
   4.281                  final int          argCount = isVarArg ? -1 : callee.getParameters().size();
   4.282  
   4.283 @@ -653,12 +677,13 @@
   4.284                  loadArgs(args, signature, isVarArg, argCount);
   4.285                  method.invokestatic(callee.getCompileUnit().getUnitClassName(), callee.getName(), signature);
   4.286                  assert method.peekType().equals(callee.getReturnType()) : method.peekType() + " != " + callee.getReturnType();
   4.287 -
   4.288 +                functionNodeIsCallee = true;
   4.289 +                callee.accept(CodeGenerator.this);
   4.290                  return null;
   4.291              }
   4.292  
   4.293              @Override
   4.294 -            public Node enter(final IndexNode node) {
   4.295 +            public Node enterIndexNode(final IndexNode node) {
   4.296                  load(node.getBase());
   4.297                  method.convert(Type.OBJECT);
   4.298                  method.dup();
   4.299 @@ -694,7 +719,7 @@
   4.300      }
   4.301  
   4.302      @Override
   4.303 -    public Node enter(final ContinueNode continueNode) {
   4.304 +    public Node enterContinueNode(final ContinueNode continueNode) {
   4.305          if (continueNode.testResolved()) {
   4.306              return null;
   4.307          }
   4.308 @@ -709,17 +734,17 @@
   4.309      }
   4.310  
   4.311      @Override
   4.312 -    public Node enter(final DoWhileNode doWhileNode) {
   4.313 -        return enter((WhileNode)doWhileNode);
   4.314 +    public Node enterDoWhileNode(final DoWhileNode doWhileNode) {
   4.315 +        return enterWhileNode(doWhileNode);
   4.316      }
   4.317  
   4.318      @Override
   4.319 -    public Node enter(final EmptyNode emptyNode) {
   4.320 +    public Node enterEmptyNode(final EmptyNode emptyNode) {
   4.321          return null;
   4.322      }
   4.323  
   4.324      @Override
   4.325 -    public Node enter(final ExecuteNode executeNode) {
   4.326 +    public Node enterExecuteNode(final ExecuteNode executeNode) {
   4.327          if (executeNode.testResolved()) {
   4.328              return null;
   4.329          }
   4.330 @@ -731,7 +756,7 @@
   4.331      }
   4.332  
   4.333      @Override
   4.334 -    public Node enter(final ForNode forNode) {
   4.335 +    public Node enterForNode(final ForNode forNode) {
   4.336          if (forNode.testResolved()) {
   4.337              return null;
   4.338          }
   4.339 @@ -813,7 +838,7 @@
   4.340       * @param block block with local vars.
   4.341       */
   4.342      private void initLocals(final Block block) {
   4.343 -        final FunctionNode function       = block.getFunction();
   4.344 +        final FunctionNode function       = lexicalContext.getFunction(block);
   4.345          final boolean      isFunctionNode = block == function;
   4.346  
   4.347          /*
   4.348 @@ -915,7 +940,7 @@
   4.349              foc.makeObject(method);
   4.350  
   4.351              // runScript(): merge scope into global
   4.352 -            if (isFunctionNode && function.isScript()) {
   4.353 +            if (isFunctionNode && function.isProgram()) {
   4.354                  method.invoke(ScriptRuntime.MERGE_SCOPE);
   4.355              }
   4.356  
   4.357 @@ -958,19 +983,29 @@
   4.358      }
   4.359  
   4.360      @Override
   4.361 -    public Node enter(final FunctionNode functionNode) {
   4.362 +    public Node enterFunctionNode(final FunctionNode functionNode) {
   4.363 +        final boolean isCallee = functionNodeIsCallee;
   4.364 +        functionNodeIsCallee = false;
   4.365 +
   4.366 +        if (functionNode.testResolved()) {
   4.367 +            return null;
   4.368 +        }
   4.369 +
   4.370 +        if(!(isCallee || functionNode == compiler.getFunctionNode())) {
   4.371 +            newFunctionObject(functionNode);
   4.372 +        }
   4.373 +
   4.374          if (functionNode.isLazy()) {
   4.375              return null;
   4.376          }
   4.377  
   4.378 -        if (functionNode.testResolved()) {
   4.379 -            return null;
   4.380 -        }
   4.381 +        LOG.info("=== BEGIN " + functionNode.getName());
   4.382 +        lexicalContext.push(functionNode);
   4.383  
   4.384          setCurrentCompileUnit(functionNode.getCompileUnit());
   4.385          assert getCurrentCompileUnit() != null;
   4.386  
   4.387 -        method = getCurrentCompileUnit().getClassEmitter().method(functionNode);
   4.388 +        setCurrentMethodEmitter(getCurrentCompileUnit().getClassEmitter().method(functionNode));
   4.389          functionNode.setMethodEmitter(method);
   4.390          // Mark end for variable tables.
   4.391          method.begin();
   4.392 @@ -983,7 +1018,7 @@
   4.393      }
   4.394  
   4.395      @Override
   4.396 -    public Node leave(final FunctionNode functionNode) {
   4.397 +    public Node leaveFunctionNode(final FunctionNode functionNode) {
   4.398          // Mark end for variable tables.
   4.399          method.label(functionNode.getBreakLabel());
   4.400  
   4.401 @@ -1001,16 +1036,18 @@
   4.402              throw e;
   4.403          }
   4.404  
   4.405 +        lexicalContext.pop(functionNode);
   4.406 +        LOG.info("=== END " + functionNode.getName());
   4.407          return functionNode;
   4.408      }
   4.409  
   4.410      @Override
   4.411 -    public Node enter(final IdentNode identNode) {
   4.412 +    public Node enterIdentNode(final IdentNode identNode) {
   4.413          return null;
   4.414      }
   4.415  
   4.416      @Override
   4.417 -    public Node enter(final IfNode ifNode) {
   4.418 +    public Node enterIfNode(final IfNode ifNode) {
   4.419          if (ifNode.testResolved()) {
   4.420              return null;
   4.421          }
   4.422 @@ -1049,7 +1086,7 @@
   4.423      }
   4.424  
   4.425      @Override
   4.426 -    public Node enter(final IndexNode indexNode) {
   4.427 +    public Node enterIndexNode(final IndexNode indexNode) {
   4.428          if (indexNode.testResolved()) {
   4.429              return null;
   4.430          }
   4.431 @@ -1060,7 +1097,7 @@
   4.432      }
   4.433  
   4.434      @Override
   4.435 -    public Node enter(final LineNumberNode lineNumberNode) {
   4.436 +    public Node enterLineNumberNode(final LineNumberNode lineNumberNode) {
   4.437          if (lineNumberNode.testResolved()) {
   4.438              return null;
   4.439          }
   4.440 @@ -1068,7 +1105,6 @@
   4.441          final Label label = new Label("line:" + lineNumberNode.getLineNumber() + " (" + getCurrentFunctionNode().getName() + ")");
   4.442          method.label(label);
   4.443          method.lineNumber(lineNumberNode.getLineNumber(), label);
   4.444 -
   4.445          return null;
   4.446      }
   4.447  
   4.448 @@ -1106,7 +1142,7 @@
   4.449                      final String name      = getCurrentFunctionNode().uniqueName(SPLIT_PREFIX.tag());
   4.450                      final String signature = methodDescriptor(type, Object.class, ScriptFunction.class, ScriptObject.class, type);
   4.451  
   4.452 -                    method = getCurrentCompileUnit().getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature);
   4.453 +                    setCurrentMethodEmitter(getCurrentCompileUnit().getClassEmitter().method(EnumSet.of(Flag.PUBLIC, Flag.STATIC), name, signature));
   4.454                      method.setFunctionNode(getCurrentFunctionNode());
   4.455                      method.begin();
   4.456  
   4.457 @@ -1212,7 +1248,7 @@
   4.458              method.invokestatic(unitClassName, methodName, methodDescriptor(cls, int.class));
   4.459              classEmitter.needGetConstantMethod(cls);
   4.460          } else {
   4.461 -            method.loadConstants(unitClassName).load(index).arrayload();
   4.462 +            method.loadConstants().load(index).arrayload();
   4.463              if (cls != Object.class) {
   4.464                  method.checkcast(cls);
   4.465              }
   4.466 @@ -1292,14 +1328,14 @@
   4.467  
   4.468      @SuppressWarnings("rawtypes")
   4.469      @Override
   4.470 -    public Node enter(final LiteralNode literalNode) {
   4.471 +    public Node enterLiteralNode(final LiteralNode literalNode) {
   4.472          assert literalNode.getSymbol() != null : literalNode + " has no symbol";
   4.473          load(literalNode).store(literalNode.getSymbol());
   4.474          return null;
   4.475      }
   4.476  
   4.477      @Override
   4.478 -    public Node enter(final ObjectNode objectNode) {
   4.479 +    public Node enterObjectNode(final ObjectNode objectNode) {
   4.480          if (objectNode.testResolved()) {
   4.481              return null;
   4.482          }
   4.483 @@ -1372,10 +1408,10 @@
   4.484          }
   4.485  
   4.486          for (final Node element : elements) {
   4.487 -            final PropertyNode  propertyNode = (PropertyNode)element;
   4.488 -            final Object        key          = propertyNode.getKey();
   4.489 -            final ReferenceNode getter       = (ReferenceNode)propertyNode.getGetter();
   4.490 -            final ReferenceNode setter       = (ReferenceNode)propertyNode.getSetter();
   4.491 +            final PropertyNode propertyNode = (PropertyNode)element;
   4.492 +            final Object       key          = propertyNode.getKey();
   4.493 +            final FunctionNode getter       = (FunctionNode)propertyNode.getGetter();
   4.494 +            final FunctionNode setter       = (FunctionNode)propertyNode.getSetter();
   4.495  
   4.496              if (getter == null && setter == null) {
   4.497                  continue;
   4.498 @@ -1404,18 +1440,7 @@
   4.499      }
   4.500  
   4.501      @Override
   4.502 -    public Node enter(final ReferenceNode referenceNode) {
   4.503 -        if (referenceNode.testResolved()) {
   4.504 -            return null;
   4.505 -        }
   4.506 -
   4.507 -        newFunctionObject(referenceNode.getReference());
   4.508 -
   4.509 -        return null;
   4.510 -    }
   4.511 -
   4.512 -    @Override
   4.513 -    public Node enter(final ReturnNode returnNode) {
   4.514 +    public Node enterReturnNode(final ReturnNode returnNode) {
   4.515          if (returnNode.testResolved()) {
   4.516              return null;
   4.517          }
   4.518 @@ -1556,7 +1581,7 @@
   4.519      }
   4.520  
   4.521      @Override
   4.522 -    public Node enter(final RuntimeNode runtimeNode) {
   4.523 +    public Node enterRuntimeNode(final RuntimeNode runtimeNode) {
   4.524          if (runtimeNode.testResolved()) {
   4.525              return null;
   4.526          }
   4.527 @@ -1637,7 +1662,7 @@
   4.528      }
   4.529  
   4.530      @Override
   4.531 -    public Node enter(final SplitNode splitNode) {
   4.532 +    public Node enterSplitNode(final SplitNode splitNode) {
   4.533          if (splitNode.testResolved()) {
   4.534              return null;
   4.535          }
   4.536 @@ -1706,7 +1731,7 @@
   4.537      }
   4.538  
   4.539      @Override
   4.540 -    public Node leave(final SplitNode splitNode) {
   4.541 +    public Node leaveSplitNode(final SplitNode splitNode) {
   4.542          try {
   4.543              // Wrap up this method.
   4.544              method.loadResult();
   4.545 @@ -1763,7 +1788,7 @@
   4.546      }
   4.547  
   4.548      @Override
   4.549 -    public Node enter(final SwitchNode switchNode) {
   4.550 +    public Node enterSwitchNode(final SwitchNode switchNode) {
   4.551          if (switchNode.testResolved()) {
   4.552              return null;
   4.553          }
   4.554 @@ -1895,7 +1920,7 @@
   4.555      }
   4.556  
   4.557      @Override
   4.558 -    public Node enter(final ThrowNode throwNode) {
   4.559 +    public Node enterThrowNode(final ThrowNode throwNode) {
   4.560          if (throwNode.testResolved()) {
   4.561              return null;
   4.562          }
   4.563 @@ -1922,7 +1947,7 @@
   4.564      }
   4.565  
   4.566      @Override
   4.567 -    public Node enter(final TryNode tryNode) {
   4.568 +    public Node enterTryNode(final TryNode tryNode) {
   4.569          if (tryNode.testResolved()) {
   4.570              return null;
   4.571          }
   4.572 @@ -1955,7 +1980,7 @@
   4.573              setCurrentBlock(catchBlock);
   4.574  
   4.575              try {
   4.576 -                enter(catchBlock);
   4.577 +                enterBlock(catchBlock);
   4.578  
   4.579                  final CatchNode catchNode          = (CatchNode)catchBlocks.get(i).getStatements().get(0);
   4.580                  final IdentNode exception          = catchNode.getException();
   4.581 @@ -1966,6 +1991,7 @@
   4.582                      // Generate catch body (inlined finally) and rethrow exception
   4.583                      catchBody.accept(this);
   4.584                      method.load(symbol).athrow();
   4.585 +                    lexicalContext.pop(catchBlock);
   4.586                      continue;
   4.587                  }
   4.588  
   4.589 @@ -2012,7 +2038,7 @@
   4.590                      }
   4.591                  }
   4.592  
   4.593 -                leave(catchBlock);
   4.594 +                leaveBlock(catchBlock);
   4.595              } finally {
   4.596                  setCurrentBlock(saveBlock);
   4.597              }
   4.598 @@ -2027,7 +2053,7 @@
   4.599      }
   4.600  
   4.601      @Override
   4.602 -    public Node enter(final VarNode varNode) {
   4.603 +    public Node enterVarNode(final VarNode varNode) {
   4.604          final Node init = varNode.getInit();
   4.605  
   4.606          if (varNode.testResolved() || init == null) {
   4.607 @@ -2049,7 +2075,7 @@
   4.608              int flags = CALLSITE_SCOPE | getCallSiteFlags();
   4.609              final IdentNode identNode = varNode.getName();
   4.610              final Type type = identNode.getType();
   4.611 -            if (varSymbol.isFastScope(getCurrentFunctionNode())) {
   4.612 +            if (isFastScope(varSymbol)) {
   4.613                  storeFastScopeVar(type, varSymbol, flags);
   4.614              } else {
   4.615                  method.dynamicSet(type, identNode.getName(), flags);
   4.616 @@ -2065,7 +2091,7 @@
   4.617      }
   4.618  
   4.619      @Override
   4.620 -    public Node enter(final WhileNode whileNode) {
   4.621 +    public Node enterWhileNode(final WhileNode whileNode) {
   4.622          if (whileNode.testResolved()) {
   4.623              return null;
   4.624          }
   4.625 @@ -2098,7 +2124,7 @@
   4.626      }
   4.627  
   4.628      @Override
   4.629 -    public Node enter(final WithNode withNode) {
   4.630 +    public Node enterWithNode(final WithNode withNode) {
   4.631          if (withNode.testResolved()) {
   4.632              return null;
   4.633          }
   4.634 @@ -2864,7 +2890,7 @@
   4.635       * Ternary visits.
   4.636       */
   4.637      @Override
   4.638 -    public Node enter(final TernaryNode ternaryNode) {
   4.639 +    public Node enterTernaryNode(final TernaryNode ternaryNode) {
   4.640          if (ternaryNode.testResolved()) {
   4.641              return null;
   4.642          }
   4.643 @@ -3060,7 +3086,7 @@
   4.644  
   4.645              target.accept(new NodeVisitor(getCurrentCompileUnit(), method) {
   4.646                  @Override
   4.647 -                public Node enter(final IdentNode node) {
   4.648 +                public Node enterIdentNode(final IdentNode node) {
   4.649                      if (targetSymbol.isScope()) {
   4.650                          method.load(scopeSymbol);
   4.651                          depth++;
   4.652 @@ -3083,13 +3109,13 @@
   4.653                  }
   4.654  
   4.655                  @Override
   4.656 -                public Node enter(final AccessNode node) {
   4.657 +                public Node enterAccessNode(final AccessNode node) {
   4.658                      enterBaseNode();
   4.659                      return null;
   4.660                  }
   4.661  
   4.662                  @Override
   4.663 -                public Node enter(final IndexNode node) {
   4.664 +                public Node enterIndexNode(final IndexNode node) {
   4.665                      enterBaseNode();
   4.666  
   4.667                      final Node index = node.getIndex();
   4.668 @@ -3155,8 +3181,6 @@
   4.669          }
   4.670  
   4.671          private void epilogue() {
   4.672 -            final FunctionNode currentFunction = getCurrentFunctionNode();
   4.673 -
   4.674              /**
   4.675               * Take the original target args from the stack and use them
   4.676               * together with the value to be stored to emit the store code
   4.677 @@ -3174,7 +3198,7 @@
   4.678                  }
   4.679  
   4.680                  @Override
   4.681 -                public Node enter(final UnaryNode node) {
   4.682 +                public Node enterUnaryNode(final UnaryNode node) {
   4.683                      if(node.tokenType() == TokenType.CONVERT && node.getSymbol() != null) {
   4.684                          method.convert(node.rhs().getType());
   4.685                      }
   4.686 @@ -3182,11 +3206,11 @@
   4.687                  }
   4.688  
   4.689                  @Override
   4.690 -                public Node enter(final IdentNode node) {
   4.691 +                public Node enterIdentNode(final IdentNode node) {
   4.692                      final Symbol symbol = node.getSymbol();
   4.693                      assert symbol != null;
   4.694                      if (symbol.isScope()) {
   4.695 -                        if (symbol.isFastScope(currentFunction)) {
   4.696 +                        if (isFastScope(symbol)) {
   4.697                              storeFastScopeVar(node.getType(), symbol, CALLSITE_SCOPE | getCallSiteFlags());
   4.698                          } else {
   4.699                              method.dynamicSet(node.getType(), node.getName(), CALLSITE_SCOPE | getCallSiteFlags());
   4.700 @@ -3199,13 +3223,13 @@
   4.701                  }
   4.702  
   4.703                  @Override
   4.704 -                public Node enter(final AccessNode node) {
   4.705 +                public Node enterAccessNode(final AccessNode node) {
   4.706                      method.dynamicSet(node.getProperty().getType(), node.getProperty().getName(), getCallSiteFlags());
   4.707                      return null;
   4.708                  }
   4.709  
   4.710                  @Override
   4.711 -                public Node enter(final IndexNode node) {
   4.712 +                public Node enterIndexNode(final IndexNode node) {
   4.713                      method.dynamicSetIndex(getCallSiteFlags());
   4.714                      return null;
   4.715                  }

     5.1 --- a/src/jdk/nashorn/internal/codegen/CompilationPhase.java	Tue Mar 19 11:03:24 2013 -0300
     5.2 +++ b/src/jdk/nashorn/internal/codegen/CompilationPhase.java	Sat Mar 23 00:58:39 2013 +0100
     5.3 @@ -14,16 +14,16 @@
     5.4  import java.util.EnumSet;
     5.5  import java.util.HashSet;
     5.6  import java.util.Set;
     5.7 -
     5.8  import jdk.nashorn.internal.codegen.types.Type;
     5.9  import jdk.nashorn.internal.ir.CallNode;
    5.10  import jdk.nashorn.internal.ir.FunctionNode;
    5.11  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    5.12 +import jdk.nashorn.internal.ir.LexicalContext;
    5.13  import jdk.nashorn.internal.ir.Node;
    5.14 -import jdk.nashorn.internal.ir.ReferenceNode;
    5.15 -import jdk.nashorn.internal.ir.visitor.NodeVisitor;
    5.16  import jdk.nashorn.internal.ir.debug.ASTWriter;
    5.17  import jdk.nashorn.internal.ir.debug.PrintVisitor;
    5.18 +import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
    5.19 +import jdk.nashorn.internal.ir.visitor.NodeVisitor;
    5.20  import jdk.nashorn.internal.runtime.ECMAErrors;
    5.21  import jdk.nashorn.internal.runtime.ScriptEnvironment;
    5.22  import jdk.nashorn.internal.runtime.Timing;
    5.23 @@ -65,17 +65,17 @@
    5.24              outermostFunctionNode.accept(new NodeVisitor() {
    5.25                  // self references are done with invokestatic and thus cannot have trampolines - never lazy
    5.26                  @Override
    5.27 -                public Node enter(final CallNode node) {
    5.28 +                public Node enterCallNode(final CallNode node) {
    5.29                      final Node callee = node.getFunction();
    5.30 -                    if (callee instanceof ReferenceNode) {
    5.31 -                        neverLazy.add(((ReferenceNode)callee).getReference());
    5.32 +                    if (callee instanceof FunctionNode) {
    5.33 +                        neverLazy.add(((FunctionNode)callee));
    5.34                          return null;
    5.35                      }
    5.36                      return node;
    5.37                  }
    5.38  
    5.39                  @Override
    5.40 -                public Node enter(final FunctionNode node) {
    5.41 +                public Node enterFunctionNode(final FunctionNode node) {
    5.42                      if (node == outermostFunctionNode) {
    5.43                          return node;
    5.44                      }
    5.45 @@ -94,15 +94,24 @@
    5.46                  lazy.remove(node);
    5.47              }
    5.48  
    5.49 -            for (final FunctionNode node : lazy) {
    5.50 -                Compiler.LOG.fine("Marking " + node.getName() + " as lazy");
    5.51 -                node.setIsLazy(true);
    5.52 -                final FunctionNode parent = node.findParentFunction();
    5.53 -                if (parent != null) {
    5.54 -                    Compiler.LOG.fine("Marking " + parent.getName() + " as having lazy children - it needs scope for all variables");
    5.55 -                    parent.setHasLazyChildren();
    5.56 +            outermostFunctionNode.accept(new NodeOperatorVisitor() {
    5.57 +                private final LexicalContext lexicalContext = new LexicalContext();
    5.58 +                @Override
    5.59 +                public Node enterFunctionNode(FunctionNode functionNode) {
    5.60 +                    lexicalContext.push(functionNode);
    5.61 +                    if(lazy.contains(functionNode)) {
    5.62 +                        Compiler.LOG.fine("Marking " + functionNode.getName() + " as lazy");
    5.63 +                        functionNode.setIsLazy(true);
    5.64 +                        lexicalContext.getParentFunction(functionNode).setHasLazyChildren();
    5.65 +                    }
    5.66 +                    return functionNode;
    5.67                  }
    5.68 -            }
    5.69 +                @Override
    5.70 +                public Node leaveFunctionNode(FunctionNode functionNode) {
    5.71 +                    lexicalContext.pop(functionNode);
    5.72 +                    return functionNode;
    5.73 +                }
    5.74 +            });
    5.75          }
    5.76  
    5.77          @Override
    5.78 @@ -241,6 +250,16 @@
    5.79                  final CodeGenerator codegen = new CodeGenerator(compiler);
    5.80                  fn.accept(codegen);
    5.81                  codegen.generateScopeCalls();
    5.82 +                fn.accept(new NodeOperatorVisitor() {
    5.83 +                    @Override
    5.84 +                    public Node enterFunctionNode(FunctionNode functionNode) {
    5.85 +                        if(functionNode.isLazy()) {
    5.86 +                            functionNode.resetResolved();
    5.87 +                            return null;
    5.88 +                        }
    5.89 +                        return fn;
    5.90 +                    }
    5.91 +                });
    5.92  
    5.93              } catch (final VerifyError e) {
    5.94                  if (env._verify_code || env._print_code) {

     6.1 --- a/src/jdk/nashorn/internal/codegen/Compiler.java	Tue Mar 19 11:03:24 2013 -0300
     6.2 +++ b/src/jdk/nashorn/internal/codegen/Compiler.java	Sat Mar 23 00:58:39 2013 +0100
     6.3 @@ -46,7 +46,6 @@
     6.4  import java.util.Map.Entry;
     6.5  import java.util.Set;
     6.6  import java.util.logging.Level;
     6.7 -
     6.8  import jdk.internal.dynalink.support.NameCodec;
     6.9  import jdk.nashorn.internal.codegen.ClassEmitter.Flag;
    6.10  import jdk.nashorn.internal.codegen.types.Type;
    6.11 @@ -383,7 +382,7 @@
    6.12  
    6.13          functionNode.accept(new NodeVisitor() {
    6.14              @Override
    6.15 -            public Node enter(final FunctionNode node) {
    6.16 +            public Node enterFunctionNode(final FunctionNode node) {
    6.17                  if (node.isLazy()) {
    6.18                      return null;
    6.19                  }

     7.1 --- a/src/jdk/nashorn/internal/codegen/FinalizeTypes.java	Tue Mar 19 11:03:24 2013 -0300
     7.2 +++ b/src/jdk/nashorn/internal/codegen/FinalizeTypes.java	Sat Mar 23 00:58:39 2013 +0100
     7.3 @@ -34,20 +34,20 @@
     7.4  import jdk.nashorn.internal.ir.Block;
     7.5  import jdk.nashorn.internal.ir.CallNode;
     7.6  import jdk.nashorn.internal.ir.CallNode.EvalArgs;
     7.7 -import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
     7.8  import jdk.nashorn.internal.ir.CaseNode;
     7.9  import jdk.nashorn.internal.ir.CatchNode;
    7.10  import jdk.nashorn.internal.ir.DoWhileNode;
    7.11  import jdk.nashorn.internal.ir.ExecuteNode;
    7.12  import jdk.nashorn.internal.ir.ForNode;
    7.13  import jdk.nashorn.internal.ir.FunctionNode;
    7.14 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    7.15  import jdk.nashorn.internal.ir.IdentNode;
    7.16  import jdk.nashorn.internal.ir.IfNode;
    7.17  import jdk.nashorn.internal.ir.IndexNode;
    7.18 +import jdk.nashorn.internal.ir.LexicalContext;
    7.19  import jdk.nashorn.internal.ir.LiteralNode;
    7.20  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
    7.21  import jdk.nashorn.internal.ir.Node;
    7.22 -import jdk.nashorn.internal.ir.ReferenceNode;
    7.23  import jdk.nashorn.internal.ir.ReturnNode;
    7.24  import jdk.nashorn.internal.ir.RuntimeNode;
    7.25  import jdk.nashorn.internal.ir.RuntimeNode.Request;
    7.26 @@ -85,11 +85,13 @@
    7.27  
    7.28      private static final DebugLogger LOG = new DebugLogger("finalize");
    7.29  
    7.30 +    private final LexicalContext lexicalContext = new LexicalContext();
    7.31 +
    7.32      FinalizeTypes() {
    7.33      }
    7.34  
    7.35      @Override
    7.36 -    public Node leave(final CallNode callNode) {
    7.37 +    public Node leaveCallNode(final CallNode callNode) {
    7.38          final EvalArgs evalArgs = callNode.getEvalArgs();
    7.39          if (evalArgs != null) {
    7.40              evalArgs.setCode(evalArgs.getCode().accept(this));
    7.41 @@ -97,15 +99,14 @@
    7.42  
    7.43          // AccessSpecializer - call return type may change the access for this location
    7.44          final Node function = callNode.getFunction();
    7.45 -        if (function instanceof ReferenceNode) {
    7.46 -            setTypeOverride(callNode, ((ReferenceNode)function).getReference().getType());
    7.47 +        if (function instanceof FunctionNode) {
    7.48 +            return setTypeOverride(callNode, ((FunctionNode)function).getReturnType());
    7.49          }
    7.50          return callNode;
    7.51      }
    7.52  
    7.53      private Node leaveUnary(final UnaryNode unaryNode) {
    7.54 -        unaryNode.setRHS(convert(unaryNode.rhs(), unaryNode.getType()));
    7.55 -        return unaryNode;
    7.56 +        return unaryNode.setRHS(convert(unaryNode.rhs(), unaryNode.getType()));
    7.57      }
    7.58  
    7.59      @Override
    7.60 @@ -126,8 +127,7 @@
    7.61  
    7.62      @Override
    7.63      public Node leaveDECINC(final UnaryNode unaryNode) {
    7.64 -        specialize(unaryNode);
    7.65 -        return unaryNode;
    7.66 +        return specialize(unaryNode).node;
    7.67      }
    7.68  
    7.69      @Override
    7.70 @@ -159,9 +159,7 @@
    7.71              }
    7.72          }
    7.73  
    7.74 -        binaryNode.setLHS(convert(lhs, type));
    7.75 -        binaryNode.setRHS(convert(rhs, type));
    7.76 -        return binaryNode;
    7.77 +        return binaryNode.setLHS(convert(lhs, type)).setRHS(convert(rhs, type));
    7.78      }
    7.79  
    7.80      @Override
    7.81 @@ -171,12 +169,13 @@
    7.82  
    7.83      @Override
    7.84      public Node leaveASSIGN(final BinaryNode binaryNode) {
    7.85 -        Type destType = specialize(binaryNode);
    7.86 +        final SpecializedNode specialized = specialize(binaryNode);
    7.87 +        final BinaryNode specBinaryNode = (BinaryNode)specialized.node;
    7.88 +        Type destType = specialized.type;
    7.89          if (destType == null) {
    7.90 -            destType = binaryNode.getType();
    7.91 +            destType = specBinaryNode.getType();
    7.92          }
    7.93 -        binaryNode.setRHS(convert(binaryNode.rhs(), destType));
    7.94 -        return binaryNode;
    7.95 +        return specBinaryNode.setRHS(convert(specBinaryNode.rhs(), destType));
    7.96      }
    7.97  
    7.98      @Override
    7.99 @@ -255,21 +254,21 @@
   7.100      @Override
   7.101      public Node leaveCOMMALEFT(final BinaryNode binaryNode) {
   7.102          assert binaryNode.getSymbol() != null;
   7.103 -        binaryNode.setRHS(discard(binaryNode.rhs()));
   7.104 +        final BinaryNode newBinaryNode = (BinaryNode)binaryNode.setRHS(discard(binaryNode.rhs()));
   7.105          // AccessSpecializer - the type of lhs, which is the remaining value of this node may have changed
   7.106          // in that case, update the node type as well
   7.107 -        propagateType(binaryNode, binaryNode.lhs().getType());
   7.108 -        return binaryNode;
   7.109 +        propagateType(newBinaryNode, newBinaryNode.lhs().getType());
   7.110 +        return newBinaryNode;
   7.111      }
   7.112  
   7.113      @Override
   7.114      public Node leaveCOMMARIGHT(final BinaryNode binaryNode) {
   7.115          assert binaryNode.getSymbol() != null;
   7.116 -        binaryNode.setLHS(discard(binaryNode.lhs()));
   7.117 +        final BinaryNode newBinaryNode = binaryNode.setLHS(discard(binaryNode.lhs()));
   7.118          // AccessSpecializer - the type of rhs, which is the remaining value of this node may have changed
   7.119          // in that case, update the node type as well
   7.120 -        propagateType(binaryNode, binaryNode.rhs().getType());
   7.121 -        return binaryNode;
   7.122 +        propagateType(newBinaryNode, newBinaryNode.rhs().getType());
   7.123 +        return newBinaryNode;
   7.124      }
   7.125  
   7.126      @Override
   7.127 @@ -355,13 +354,20 @@
   7.128      }
   7.129  
   7.130      @Override
   7.131 -    public Node enter(final Block block) {
   7.132 +    public Node enterBlock(final Block block) {
   7.133 +        lexicalContext.push(block);
   7.134          updateSymbols(block);
   7.135          return block;
   7.136      }
   7.137  
   7.138      @Override
   7.139 -    public Node leave(final CatchNode catchNode) {
   7.140 +    public Node leaveBlock(Block block) {
   7.141 +        lexicalContext.pop(block);
   7.142 +        return super.leaveBlock(block);
   7.143 +    }
   7.144 +
   7.145 +    @Override
   7.146 +    public Node leaveCatchNode(final CatchNode catchNode) {
   7.147          final Node exceptionCondition = catchNode.getExceptionCondition();
   7.148          if (exceptionCondition != null) {
   7.149              catchNode.setExceptionCondition(convert(exceptionCondition, Type.BOOLEAN));
   7.150 @@ -370,23 +376,23 @@
   7.151      }
   7.152  
   7.153      @Override
   7.154 -    public Node enter(final DoWhileNode doWhileNode) {
   7.155 -        return enter((WhileNode)doWhileNode);
   7.156 +    public Node enterDoWhileNode(final DoWhileNode doWhileNode) {
   7.157 +        return enterWhileNode(doWhileNode);
   7.158      }
   7.159  
   7.160      @Override
   7.161 -    public Node leave(final DoWhileNode doWhileNode) {
   7.162 -        return leave((WhileNode)doWhileNode);
   7.163 +    public Node leaveDoWhileNode(final DoWhileNode doWhileNode) {
   7.164 +        return leaveWhileNode(doWhileNode);
   7.165      }
   7.166  
   7.167      @Override
   7.168 -    public Node leave(final ExecuteNode executeNode) {
   7.169 +    public Node leaveExecuteNode(final ExecuteNode executeNode) {
   7.170          executeNode.setExpression(discard(executeNode.getExpression()));
   7.171          return executeNode;
   7.172      }
   7.173  
   7.174      @Override
   7.175 -    public Node leave(final ForNode forNode) {
   7.176 +    public Node leaveForNode(final ForNode forNode) {
   7.177          final Node init   = forNode.getInit();
   7.178          final Node test   = forNode.getTest();
   7.179          final Node modify = forNode.getModify();
   7.180 @@ -414,11 +420,12 @@
   7.181      }
   7.182  
   7.183      @Override
   7.184 -    public Node enter(final FunctionNode functionNode) {
   7.185 +    public Node enterFunctionNode(final FunctionNode functionNode) {
   7.186          if (functionNode.isLazy()) {
   7.187              return null;
   7.188          }
   7.189  
   7.190 +        lexicalContext.push(functionNode);
   7.191          // If the function doesn't need a callee, we ensure its __callee__ symbol doesn't get a slot. We can't do
   7.192          // this earlier, as access to scoped variables, self symbol, etc. in previous phases can all trigger the
   7.193          // need for the callee.
   7.194 @@ -439,14 +446,20 @@
   7.195      }
   7.196  
   7.197      @Override
   7.198 -    public Node leave(final IfNode ifNode) {
   7.199 +    public Node leaveFunctionNode(FunctionNode functionNode) {
   7.200 +        lexicalContext.pop(functionNode);
   7.201 +        return super.leaveFunctionNode(functionNode);
   7.202 +    }
   7.203 +
   7.204 +    @Override
   7.205 +    public Node leaveIfNode(final IfNode ifNode) {
   7.206          ifNode.setTest(convert(ifNode.getTest(), Type.BOOLEAN));
   7.207          return ifNode;
   7.208      }
   7.209  
   7.210      @SuppressWarnings("rawtypes")
   7.211      @Override
   7.212 -    public Node enter(final LiteralNode literalNode) {
   7.213 +    public Node enterLiteralNode(final LiteralNode literalNode) {
   7.214          if (literalNode instanceof ArrayLiteralNode) {
   7.215              final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode)literalNode;
   7.216              final Node[]           array            = arrayLiteralNode.getValue();
   7.217 @@ -464,7 +477,7 @@
   7.218      }
   7.219  
   7.220      @Override
   7.221 -    public Node leave(final ReturnNode returnNode) {
   7.222 +    public Node leaveReturnNode(final ReturnNode returnNode) {
   7.223          final Node expr = returnNode.getExpression();
   7.224          if (expr != null) {
   7.225              returnNode.setExpression(convert(expr, getCurrentFunctionNode().getReturnType()));
   7.226 @@ -473,7 +486,7 @@
   7.227      }
   7.228  
   7.229      @Override
   7.230 -    public Node leave(final RuntimeNode runtimeNode) {
   7.231 +    public Node leaveRuntimeNode(final RuntimeNode runtimeNode) {
   7.232          final List<Node> args = runtimeNode.getArgs();
   7.233          for (final Node arg : args) {
   7.234              assert !arg.getType().isUnknown();
   7.235 @@ -482,7 +495,7 @@
   7.236      }
   7.237  
   7.238      @Override
   7.239 -    public Node leave(final SwitchNode switchNode) {
   7.240 +    public Node leaveSwitchNode(final SwitchNode switchNode) {
   7.241          final Node           expression  = switchNode.getExpression();
   7.242          final List<CaseNode> cases       = switchNode.getCases();
   7.243          final boolean        allInteger  = switchNode.getTag().getSymbolType().isInteger();
   7.244 @@ -501,33 +514,34 @@
   7.245      }
   7.246  
   7.247      @Override
   7.248 -    public Node leave(final TernaryNode ternaryNode) {
   7.249 -        ternaryNode.setLHS(convert(ternaryNode.lhs(), Type.BOOLEAN));
   7.250 -        return ternaryNode;
   7.251 +    public Node leaveTernaryNode(final TernaryNode ternaryNode) {
   7.252 +        return ternaryNode.setLHS(convert(ternaryNode.lhs(), Type.BOOLEAN));
   7.253      }
   7.254  
   7.255      @Override
   7.256 -    public Node leave(final ThrowNode throwNode) {
   7.257 +    public Node leaveThrowNode(final ThrowNode throwNode) {
   7.258          throwNode.setExpression(convert(throwNode.getExpression(), Type.OBJECT));
   7.259          return throwNode;
   7.260      }
   7.261  
   7.262      @Override
   7.263 -    public Node leave(final VarNode varNode) {
   7.264 +    public Node leaveVarNode(final VarNode varNode) {
   7.265          final Node rhs = varNode.getInit();
   7.266          if (rhs != null) {
   7.267 -            Type destType = specialize(varNode);
   7.268 +            final SpecializedNode specialized = specialize(varNode);
   7.269 +            final VarNode specVarNode = (VarNode)specialized.node;
   7.270 +            Type destType = specialized.type;
   7.271              if (destType == null) {
   7.272 -                destType = varNode.getType();
   7.273 +                destType = specVarNode.getType();
   7.274              }
   7.275 -            assert varNode.hasType() : varNode + " doesn't have a type";
   7.276 -            varNode.setInit(convert(rhs, destType));
   7.277 +            assert specVarNode.hasType() : specVarNode + " doesn't have a type";
   7.278 +            return specVarNode.setInit(convert(rhs, destType));
   7.279          }
   7.280          return varNode;
   7.281      }
   7.282  
   7.283      @Override
   7.284 -    public Node leave(final WhileNode whileNode) {
   7.285 +    public Node leaveWhileNode(final WhileNode whileNode) {
   7.286          final Node test = whileNode.getTest();
   7.287          if (test != null) {
   7.288              whileNode.setTest(convert(test, Type.BOOLEAN));
   7.289 @@ -536,7 +550,7 @@
   7.290      }
   7.291  
   7.292      @Override
   7.293 -    public Node leave(final WithNode withNode) {
   7.294 +    public Node leaveWithNode(final WithNode withNode) {
   7.295          withNode.setExpression(convert(withNode.getExpression(), Type.OBJECT));
   7.296          return withNode;
   7.297      }
   7.298 @@ -555,14 +569,14 @@
   7.299       * that scope and slot information is correct for every symbol
   7.300       * @param block block for which to to finalize type info.
   7.301       */
   7.302 -    private static void updateSymbols(final Block block) {
   7.303 +    private void updateSymbols(final Block block) {
   7.304          if (!block.needsScope()) {
   7.305              return; // nothing to do
   7.306          }
   7.307  
   7.308 -        assert !(block instanceof FunctionNode) || block.getFunction() == block;
   7.309 +        final FunctionNode functionNode = lexicalContext.getFunction(block);
   7.310 +        assert !(block instanceof FunctionNode) || functionNode == block;
   7.311  
   7.312 -        final FunctionNode functionNode   = block.getFunction();
   7.313          final List<Symbol> symbols        = block.getFrame().getSymbols();
   7.314          final boolean      allVarsInScope = functionNode.allVarsInScope();
   7.315          final boolean      isVarArg       = functionNode.isVarArg();
   7.316 @@ -631,10 +645,7 @@
   7.317              break;
   7.318          }
   7.319  
   7.320 -        binaryNode.setLHS(convert(lhs, widest));
   7.321 -        binaryNode.setRHS(convert(rhs, widest));
   7.322 -
   7.323 -        return binaryNode;
   7.324 +        return binaryNode.setLHS(convert(lhs, widest)).setRHS(convert(rhs, widest));
   7.325      }
   7.326  
   7.327      /**
   7.328 @@ -656,9 +667,7 @@
   7.329      }
   7.330  
   7.331      private Node leaveBinary(final BinaryNode binaryNode, final Type lhsType, final Type rhsType) {
   7.332 -        binaryNode.setLHS(convert(binaryNode.lhs(), lhsType));
   7.333 -        binaryNode.setRHS(convert(binaryNode.rhs(), rhsType));
   7.334 -        return binaryNode;
   7.335 +        return binaryNode.setLHS(convert(binaryNode.lhs(), lhsType)).setRHS(convert(binaryNode.rhs(), rhsType));
   7.336      }
   7.337  
   7.338      /**
   7.339 @@ -679,7 +688,7 @@
   7.340              }
   7.341  
   7.342              @Override
   7.343 -            public Node enter(final IdentNode identNode) {
   7.344 +            public Node enterIdentNode(final IdentNode identNode) {
   7.345                  if (!exclude.contains(identNode)) {
   7.346                      setCanBePrimitive(identNode.getSymbol());
   7.347                  }
   7.348 @@ -687,26 +696,36 @@
   7.349              }
   7.350  
   7.351              @Override
   7.352 -            public Node enter(final AccessNode accessNode) {
   7.353 +            public Node enterAccessNode(final AccessNode accessNode) {
   7.354                  setCanBePrimitive(accessNode.getProperty().getSymbol());
   7.355                  return null;
   7.356              }
   7.357  
   7.358              @Override
   7.359 -            public Node enter(final IndexNode indexNode) {
   7.360 +            public Node enterIndexNode(final IndexNode indexNode) {
   7.361                  exclude.add(indexNode.getBase()); //prevent array base node to be flagged as primitive, but k in a[k++] is fine
   7.362                  return indexNode;
   7.363              }
   7.364          });
   7.365      }
   7.366  
   7.367 -    private static Type specialize(final Assignment<?> assignment) {
   7.368 +    private static class SpecializedNode {
   7.369 +        final Node node;
   7.370 +        final Type type;
   7.371 +
   7.372 +        SpecializedNode(Node node, Type type) {
   7.373 +            this.node = node;
   7.374 +            this.type = type;
   7.375 +        }
   7.376 +    }
   7.377 +
   7.378 +    private static <T extends Node> SpecializedNode specialize(final Assignment<T> assignment) {
   7.379          final Node node = ((Node)assignment);
   7.380 -        final Node lhs = assignment.getAssignmentDest();
   7.381 +        final T lhs = assignment.getAssignmentDest();
   7.382          final Node rhs = assignment.getAssignmentSource();
   7.383  
   7.384          if (!canHaveCallSiteType(lhs)) {
   7.385 -            return null;
   7.386 +            return new SpecializedNode(node, null);
   7.387          }
   7.388  
   7.389          final Type to;
   7.390 @@ -718,13 +737,13 @@
   7.391  
   7.392          if (!isSupportedCallSiteType(to)) {
   7.393              //meaningless to specialize to boolean or object
   7.394 -            return null;
   7.395 +            return new SpecializedNode(node, null);
   7.396          }
   7.397  
   7.398 -        setTypeOverride(lhs, to);
   7.399 -        propagateType(node, to);
   7.400 +        final Node newNode = assignment.setAssignmentDest(setTypeOverride(lhs, to));
   7.401 +        propagateType(newNode, to);
   7.402  
   7.403 -        return to;
   7.404 +        return new SpecializedNode(newNode, to);
   7.405      }
   7.406  
   7.407  
   7.408 @@ -736,7 +755,7 @@
   7.409       * @return true if node can have a callsite type
   7.410       */
   7.411      private static boolean canHaveCallSiteType(final Node node) {
   7.412 -        return node instanceof TypeOverride && ((TypeOverride)node).canHaveCallSiteType();
   7.413 +        return node instanceof TypeOverride && ((TypeOverride<?>)node).canHaveCallSiteType();
   7.414      }
   7.415  
   7.416      /**
   7.417 @@ -762,7 +781,8 @@
   7.418       * @param node    node for which to change type
   7.419       * @param to      new type
   7.420       */
   7.421 -    private static void setTypeOverride(final Node node, final Type to) {
   7.422 +    @SuppressWarnings("unchecked")
   7.423 +    private static <T extends Node> T setTypeOverride(final T node, final Type to) {
   7.424          final Type from = node.getType();
   7.425          if (!node.getType().equals(to)) {
   7.426              LOG.info("Changing call override type for '" + node + "' from " + node.getType() + " to " + to);
   7.427 @@ -771,7 +791,7 @@
   7.428              }
   7.429          }
   7.430          LOG.info("Type override for lhs in '" + node + "' => " + to);
   7.431 -        ((TypeOverride)node).setType(to);
   7.432 +        return ((TypeOverride<T>)node).setType(to);
   7.433      }
   7.434  
   7.435      /**
   7.436 @@ -816,8 +836,8 @@
   7.437              }
   7.438          } else {
   7.439              if (canHaveCallSiteType(node) && isSupportedCallSiteType(to)) {
   7.440 -                setTypeOverride(node, to);
   7.441 -                return resultNode;
   7.442 +                assert node instanceof TypeOverride;
   7.443 +                return setTypeOverride(node, to);
   7.444              }
   7.445              resultNode = new UnaryNode(node.getSource(), Token.recast(node.getToken(), TokenType.CONVERT), node);
   7.446          }

     8.1 --- a/src/jdk/nashorn/internal/codegen/FoldConstants.java	Tue Mar 19 11:03:24 2013 -0300
     8.2 +++ b/src/jdk/nashorn/internal/codegen/FoldConstants.java	Sat Mar 23 00:58:39 2013 +0100
     8.3 @@ -31,12 +31,12 @@
     8.4  import jdk.nashorn.internal.ir.EmptyNode;
     8.5  import jdk.nashorn.internal.ir.ExecuteNode;
     8.6  import jdk.nashorn.internal.ir.FunctionNode;
     8.7 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
     8.8  import jdk.nashorn.internal.ir.IfNode;
     8.9  import jdk.nashorn.internal.ir.LiteralNode;
    8.10  import jdk.nashorn.internal.ir.Node;
    8.11  import jdk.nashorn.internal.ir.TernaryNode;
    8.12  import jdk.nashorn.internal.ir.UnaryNode;
    8.13 -import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    8.14  import jdk.nashorn.internal.ir.visitor.NodeVisitor;
    8.15  import jdk.nashorn.internal.runtime.DebugLogger;
    8.16  import jdk.nashorn.internal.runtime.JSType;
    8.17 @@ -54,7 +54,7 @@
    8.18      }
    8.19  
    8.20      @Override
    8.21 -    public Node leave(final UnaryNode unaryNode) {
    8.22 +    public Node leaveUnaryNode(final UnaryNode unaryNode) {
    8.23          final LiteralNode<?> literalNode = new UnaryNodeConstantEvaluator(unaryNode).eval();
    8.24          if (literalNode != null) {
    8.25              LOG.info("Unary constant folded " + unaryNode + " to " + literalNode);
    8.26 @@ -64,7 +64,7 @@
    8.27      }
    8.28  
    8.29      @Override
    8.30 -    public Node leave(final BinaryNode binaryNode) {
    8.31 +    public Node leaveBinaryNode(final BinaryNode binaryNode) {
    8.32          final LiteralNode<?> literalNode = new BinaryNodeConstantEvaluator(binaryNode).eval();
    8.33          if (literalNode != null) {
    8.34              LOG.info("Binary constant folded " + binaryNode + " to " + literalNode);
    8.35 @@ -74,7 +74,7 @@
    8.36      }
    8.37  
    8.38      @Override
    8.39 -    public Node enter(final FunctionNode functionNode) {
    8.40 +    public Node enterFunctionNode(final FunctionNode functionNode) {
    8.41          if (functionNode.isLazy()) {
    8.42              return null;
    8.43          }
    8.44 @@ -82,13 +82,13 @@
    8.45      }
    8.46  
    8.47      @Override
    8.48 -    public Node leave(final FunctionNode functionNode) {
    8.49 +    public Node leaveFunctionNode(final FunctionNode functionNode) {
    8.50          functionNode.setState(CompilationState.CONSTANT_FOLDED);
    8.51          return functionNode;
    8.52      }
    8.53  
    8.54      @Override
    8.55 -    public Node leave(final IfNode ifNode) {
    8.56 +    public Node leaveIfNode(final IfNode ifNode) {
    8.57          final Node test = ifNode.getTest();
    8.58          if (test instanceof LiteralNode) {
    8.59              final Block shortCut = ((LiteralNode<?>)test).isTrue() ? ifNode.getPass() : ifNode.getFail();
    8.60 @@ -101,7 +101,7 @@
    8.61      }
    8.62  
    8.63      @Override
    8.64 -    public Node leave(final TernaryNode ternaryNode) {
    8.65 +    public Node leaveTernaryNode(final TernaryNode ternaryNode) {
    8.66          final Node test = ternaryNode.lhs();
    8.67          if (test instanceof LiteralNode) {
    8.68              return ((LiteralNode<?>)test).isTrue() ? ternaryNode.rhs() : ternaryNode.third();

     9.1 --- a/src/jdk/nashorn/internal/codegen/FunctionSignature.java	Tue Mar 19 11:03:24 2013 -0300
     9.2 +++ b/src/jdk/nashorn/internal/codegen/FunctionSignature.java	Sat Mar 23 00:58:39 2013 +0100
     9.3 @@ -155,7 +155,7 @@
     9.4              true,
     9.5              functionNode.needsCallee(),
     9.6              functionNode.getReturnType(),
     9.7 -            (functionNode.isVarArg() && !functionNode.isScript()) ?
     9.8 +            (functionNode.isVarArg() && !functionNode.isProgram()) ?
     9.9                  null :
    9.10                  functionNode.getParameters());
    9.11      }

    10.1 --- a/src/jdk/nashorn/internal/codegen/Lower.java	Tue Mar 19 11:03:24 2013 -0300
    10.2 +++ b/src/jdk/nashorn/internal/codegen/Lower.java	Sat Mar 23 00:58:39 2013 +0100
    10.3 @@ -37,8 +37,8 @@
    10.4  import java.util.ArrayList;
    10.5  import java.util.Arrays;
    10.6  import java.util.Deque;
    10.7 +import java.util.Iterator;
    10.8  import java.util.List;
    10.9 -import jdk.nashorn.internal.ir.AccessNode;
   10.10  import jdk.nashorn.internal.ir.BaseNode;
   10.11  import jdk.nashorn.internal.ir.BinaryNode;
   10.12  import jdk.nashorn.internal.ir.Block;
   10.13 @@ -52,11 +52,12 @@
   10.14  import jdk.nashorn.internal.ir.ExecuteNode;
   10.15  import jdk.nashorn.internal.ir.ForNode;
   10.16  import jdk.nashorn.internal.ir.FunctionNode;
   10.17 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   10.18  import jdk.nashorn.internal.ir.IdentNode;
   10.19  import jdk.nashorn.internal.ir.IfNode;
   10.20 -import jdk.nashorn.internal.ir.IndexNode;
   10.21  import jdk.nashorn.internal.ir.LabelNode;
   10.22  import jdk.nashorn.internal.ir.LabeledNode;
   10.23 +import jdk.nashorn.internal.ir.LexicalContext;
   10.24  import jdk.nashorn.internal.ir.LineNumberNode;
   10.25  import jdk.nashorn.internal.ir.LiteralNode;
   10.26  import jdk.nashorn.internal.ir.Node;
   10.27 @@ -69,7 +70,6 @@
   10.28  import jdk.nashorn.internal.ir.VarNode;
   10.29  import jdk.nashorn.internal.ir.WhileNode;
   10.30  import jdk.nashorn.internal.ir.WithNode;
   10.31 -import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   10.32  import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
   10.33  import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   10.34  import jdk.nashorn.internal.parser.Token;
   10.35 @@ -103,6 +103,8 @@
   10.36  
   10.37      private List<Node> statements;
   10.38  
   10.39 +    private LexicalContext lexicalContext = new LexicalContext();
   10.40 +
   10.41      /**
   10.42       * Constructor.
   10.43       *
   10.44 @@ -114,14 +116,15 @@
   10.45      }
   10.46  
   10.47      @Override
   10.48 -    public Node enter(final Block block) {
   10.49 +    public Node enterBlock(final Block block) {
   10.50          final Node       savedLastStatement = lastStatement;
   10.51          final List<Node> savedStatements    = statements;
   10.52 -
   10.53 +        lexicalContext.push(block);
   10.54          try {
   10.55              this.statements = new ArrayList<>();
   10.56 +            NodeVisitor visitor = this;
   10.57              for (final Node statement : block.getStatements()) {
   10.58 -                statement.accept(this);
   10.59 +                statement.accept(visitor);
   10.60                  /*
   10.61                   * This is slightly unsound, for example if we have a loop with
   10.62                   * a guarded statement like if (x) continue in the body and the
   10.63 @@ -133,7 +136,7 @@
   10.64                   */
   10.65                  if (lastStatement != null && lastStatement.isTerminal()) {
   10.66                      copyTerminal(block, lastStatement);
   10.67 -                    break;
   10.68 +                    visitor = new DeadCodeVarDeclarationVisitor();
   10.69                  }
   10.70              }
   10.71              block.setStatements(statements);
   10.72 @@ -141,18 +144,19 @@
   10.73          } finally {
   10.74              this.statements = savedStatements;
   10.75              this.lastStatement = savedLastStatement;
   10.76 +            lexicalContext.pop(block);
   10.77          }
   10.78  
   10.79          return null;
   10.80      }
   10.81  
   10.82      @Override
   10.83 -    public Node enter(final BreakNode breakNode) {
   10.84 +    public Node enterBreakNode(final BreakNode breakNode) {
   10.85          return enterBreakOrContinue(breakNode);
   10.86      }
   10.87  
   10.88      @Override
   10.89 -    public Node enter(final CallNode callNode) {
   10.90 +    public Node enterCallNode(final CallNode callNode) {
   10.91          final Node function = markerFunction(callNode.getFunction());
   10.92          callNode.setFunction(function);
   10.93          checkEval(callNode); //check if this is an eval call and store the information
   10.94 @@ -160,44 +164,44 @@
   10.95      }
   10.96  
   10.97      @Override
   10.98 -    public Node leave(final CaseNode caseNode) {
   10.99 +    public Node leaveCaseNode(final CaseNode caseNode) {
  10.100          caseNode.copyTerminalFlags(caseNode.getBody());
  10.101          return caseNode;
  10.102      }
  10.103  
  10.104      @Override
  10.105 -    public Node leave(final CatchNode catchNode) {
  10.106 +    public Node leaveCatchNode(final CatchNode catchNode) {
  10.107          catchNode.copyTerminalFlags(catchNode.getBody());
  10.108          addStatement(catchNode);
  10.109          return catchNode;
  10.110      }
  10.111  
  10.112      @Override
  10.113 -    public Node enter(final ContinueNode continueNode) {
  10.114 +    public Node enterContinueNode(final ContinueNode continueNode) {
  10.115          return enterBreakOrContinue(continueNode);
  10.116      }
  10.117  
  10.118      @Override
  10.119 -    public Node enter(final DoWhileNode doWhileNode) {
  10.120 -        return enter((WhileNode)doWhileNode);
  10.121 +    public Node enterDoWhileNode(final DoWhileNode doWhileNode) {
  10.122 +        return enterWhileNode(doWhileNode);
  10.123      }
  10.124  
  10.125      @Override
  10.126 -    public Node leave(final DoWhileNode doWhileNode) {
  10.127 -        return leave((WhileNode)doWhileNode);
  10.128 +    public Node leaveDoWhileNode(final DoWhileNode doWhileNode) {
  10.129 +        return leaveWhileNode(doWhileNode);
  10.130      }
  10.131  
  10.132      @Override
  10.133 -    public Node enter(final EmptyNode emptyNode) {
  10.134 +    public Node enterEmptyNode(final EmptyNode emptyNode) {
  10.135          return null;
  10.136      }
  10.137  
  10.138      @Override
  10.139 -    public Node leave(final ExecuteNode executeNode) {
  10.140 +    public Node leaveExecuteNode(final ExecuteNode executeNode) {
  10.141          final Node expr = executeNode.getExpression();
  10.142  
  10.143 -        if (getCurrentFunctionNode().isScript()) {
  10.144 -            if (!(expr instanceof Block)) {
  10.145 +        if (getCurrentFunctionNode().isProgram()) {
  10.146 +            if (!(expr instanceof Block) || expr instanceof FunctionNode) { // it's not a block, but can be a function
  10.147                  if (!isInternalExpression(expr) && !isEvalResultAssignment(expr)) {
  10.148                      executeNode.setExpression(new BinaryNode(executeNode.getSource(), Token.recast(executeNode.getToken(), TokenType.ASSIGN),
  10.149                              getCurrentFunctionNode().getResultNode(),
  10.150 @@ -213,13 +217,13 @@
  10.151      }
  10.152  
  10.153      @Override
  10.154 -    public Node enter(final ForNode forNode) {
  10.155 +    public Node enterForNode(final ForNode forNode) {
  10.156          nest(forNode);
  10.157          return forNode;
  10.158      }
  10.159  
  10.160      @Override
  10.161 -    public Node leave(final ForNode forNode) {
  10.162 +    public Node leaveForNode(final ForNode forNode) {
  10.163          final Node  test = forNode.getTest();
  10.164          final Block body = forNode.getBody();
  10.165  
  10.166 @@ -247,18 +251,16 @@
  10.167      }
  10.168  
  10.169      @Override
  10.170 -    public Node enter(final FunctionNode functionNode) {
  10.171 +    public Node enterFunctionNode(final FunctionNode functionNode) {
  10.172          LOG.info("START FunctionNode: " + functionNode.getName());
  10.173  
  10.174          if (functionNode.isLazy()) {
  10.175              LOG.info("LAZY: " + functionNode.getName());
  10.176              return null;
  10.177          }
  10.178 -
  10.179 +        lexicalContext.push(functionNode);
  10.180          initFunctionNode(functionNode);
  10.181  
  10.182 -        Node initialEvalResult = LiteralNode.newInstance(functionNode, ScriptRuntime.UNDEFINED);
  10.183 -
  10.184          nest(functionNode);
  10.185  
  10.186          /*
  10.187 @@ -272,60 +274,40 @@
  10.188          statements    = new ArrayList<>();
  10.189          lastStatement = null;
  10.190  
  10.191 -        // for initial eval result is the last declared function
  10.192 -        for (final FunctionNode nestedFunction : functionNode.getFunctions()) {
  10.193 -            final IdentNode ident = nestedFunction.getIdent();
  10.194 -            if (ident != null && nestedFunction.isStatement()) {
  10.195 -                initialEvalResult = new IdentNode(ident);
  10.196 -            }
  10.197 -        }
  10.198 -
  10.199          if (functionNode.needsSelfSymbol()) {
  10.200              //function needs to start with var funcIdent = __callee_;
  10.201              statements.add(functionNode.getSelfSymbolInit().accept(this));
  10.202          }
  10.203  
  10.204 +        NodeVisitor visitor = this;
  10.205          try {
  10.206 -            // Every nested function needs a definition in the outer function with its name. Add these.
  10.207 -            for (final FunctionNode nestedFunction : functionNode.getFunctions()) {
  10.208 -                final VarNode varNode = nestedFunction.getFunctionVarNode();
  10.209 -                if (varNode != null) {
  10.210 -                    final LineNumberNode lineNumberNode = nestedFunction.getFunctionVarLineNumberNode();
  10.211 -                    if (lineNumberNode != null) {
  10.212 -                        lineNumberNode.accept(this);
  10.213 -                    }
  10.214 -                    varNode.accept(this);
  10.215 -                    varNode.setIsFunctionVarNode();
  10.216 +            //do the statements - this fills the block with code
  10.217 +            boolean needsInitialEvalResult = functionNode.isProgram();
  10.218 +            for (final Node statement : functionNode.getStatements()) {
  10.219 +                // If this function is a program, then insert an assignment to the initial eval result after all
  10.220 +                // function declarations.
  10.221 +                if(needsInitialEvalResult && !(statement instanceof LineNumberNode || (statement instanceof VarNode && ((VarNode)statement).isFunctionDeclaration()))) {
  10.222 +                    addInitialEvalResult(functionNode);
  10.223 +                    needsInitialEvalResult = false;
  10.224                  }
  10.225 -            }
  10.226 -
  10.227 -            if (functionNode.isScript()) {
  10.228 -                new ExecuteNode(functionNode.getSource(), functionNode.getFirstToken(), functionNode.getFinish(), initialEvalResult).accept(this);
  10.229 -            }
  10.230 -
  10.231 -            //do the statements - this fills the block with code
  10.232 -            for (final Node statement : functionNode.getStatements()) {
  10.233 -                statement.accept(this);
  10.234 +                statement.accept(visitor);
  10.235                  //If there are unused terminated endpoints in the function, we need
  10.236                  // to add a "return undefined" in those places for correct semantics
  10.237                  LOG.info("Checking lastStatement="+lastStatement+" for terminal flags");
  10.238                  if (lastStatement != null && lastStatement.hasTerminalFlags()) {
  10.239                      copyTerminal(functionNode, lastStatement);
  10.240 -                    break;
  10.241 +                    assert !needsInitialEvalResult;
  10.242 +                    visitor = new DeadCodeVarDeclarationVisitor();
  10.243                  }
  10.244              }
  10.245 -
  10.246 +            if(needsInitialEvalResult) {
  10.247 +                addInitialEvalResult(functionNode);
  10.248 +            }
  10.249              functionNode.setStatements(statements);
  10.250  
  10.251              if (!functionNode.isTerminal()) {
  10.252                  guaranteeReturn(functionNode);
  10.253              }
  10.254 -
  10.255 -            //lower all nested functions
  10.256 -            for (final FunctionNode nestedFunction : functionNode.getFunctions()) {
  10.257 -                nestedFunction.accept(this);
  10.258 -            }
  10.259 -
  10.260          } finally {
  10.261              statements    = savedStatements;
  10.262              lastStatement = savedLastStatement;
  10.263 @@ -333,19 +315,67 @@
  10.264  
  10.265          LOG.info("END FunctionNode: " + functionNode.getName());
  10.266          unnest(functionNode);
  10.267 +        lexicalContext.pop(functionNode);
  10.268  
  10.269          functionNode.setState(CompilationState.LOWERED);
  10.270  
  10.271          return null;
  10.272      }
  10.273  
  10.274 +    /**
  10.275 +     * This visitor is used to go over statements after a terminal statement. Those statements are dead code, but the
  10.276 +     * var declarations in them still have the effect of declaring a local variable on the function level. Therefore,
  10.277 +     * they aren't really dead code and must be preserved. Note that they're only preserved as no-op declarations; their
  10.278 +     * initializers are wiped out as those are, in fact, dead code.
  10.279 +     */
  10.280 +    private class DeadCodeVarDeclarationVisitor extends NodeOperatorVisitor {
  10.281 +        DeadCodeVarDeclarationVisitor() {
  10.282 +        }
  10.283 +
  10.284 +        @Override
  10.285 +        public Node enterVarNode(VarNode varNode) {
  10.286 +            // Can't ever see a function declaration, as this visitor is only ever used after a terminal statement was
  10.287 +            // encountered, and all function declarations precede any terminal statements.
  10.288 +            assert !varNode.isFunctionDeclaration();
  10.289 +            if(varNode.getInit() == null) {
  10.290 +                // No initializer, just pass it to Lower.
  10.291 +                return varNode.accept(Lower.this);
  10.292 +            }
  10.293 +            // Wipe out the initializer and then pass it to Lower.
  10.294 +            return varNode.setInit(null).accept(Lower.this);
  10.295 +        }
  10.296 +    }
  10.297 +
  10.298 +    private void addInitialEvalResult(final FunctionNode functionNode) {
  10.299 +        new ExecuteNode(functionNode.getSource(), functionNode.getFirstToken(), functionNode.getFinish(),
  10.300 +                getInitialEvalResult(functionNode)).accept(this);
  10.301 +    }
  10.302 +
  10.303 +    /**
  10.304 +     * Result of initial result of evaluating a particular program, which is either the last function it declares, or
  10.305 +     * undefined if it doesn't declare any functions.
  10.306 +     * @param program
  10.307 +     * @return the initial result of evaluating the program
  10.308 +     */
  10.309 +    private static Node getInitialEvalResult(final FunctionNode program) {
  10.310 +        IdentNode lastFnName = null;
  10.311 +        for (final FunctionNode fn : program.getDeclaredFunctions()) {
  10.312 +            assert fn.isDeclared();
  10.313 +            final IdentNode fnName = fn.getIdent();
  10.314 +            if(fnName != null) {
  10.315 +                lastFnName = fnName;
  10.316 +            }
  10.317 +        }
  10.318 +        return lastFnName != null ? new IdentNode(lastFnName) : LiteralNode.newInstance(program, ScriptRuntime.UNDEFINED);
  10.319 +    }
  10.320 +
  10.321      @Override
  10.322 -    public Node enter(final IfNode ifNode) {
  10.323 +    public Node enterIfNode(final IfNode ifNode) {
  10.324          return nest(ifNode);
  10.325      }
  10.326  
  10.327      @Override
  10.328 -    public Node leave(final IfNode ifNode) {
  10.329 +    public Node leaveIfNode(final IfNode ifNode) {
  10.330          final Node pass = ifNode.getPass();
  10.331          final Node fail = ifNode.getFail();
  10.332  
  10.333 @@ -360,7 +390,7 @@
  10.334      }
  10.335  
  10.336      @Override
  10.337 -    public Node enter(LabelNode labelNode) {
  10.338 +    public Node enterLabelNode(LabelNode labelNode) {
  10.339          final Block body = labelNode.getBody();
  10.340          body.accept(this);
  10.341          copyTerminal(labelNode, body);
  10.342 @@ -369,13 +399,13 @@
  10.343      }
  10.344  
  10.345      @Override
  10.346 -    public Node enter(final LineNumberNode lineNumberNode) {
  10.347 +    public Node enterLineNumberNode(final LineNumberNode lineNumberNode) {
  10.348          addStatement(lineNumberNode, false); // don't put it in lastStatement cache
  10.349          return null;
  10.350      }
  10.351  
  10.352      @Override
  10.353 -    public Node enter(final ReturnNode returnNode) {
  10.354 +    public Node enterReturnNode(final ReturnNode returnNode) {
  10.355          final TryNode tryNode = returnNode.getTryChain();
  10.356          final Node    expr    = returnNode.getExpression();
  10.357  
  10.358 @@ -413,19 +443,19 @@
  10.359      }
  10.360  
  10.361      @Override
  10.362 -    public Node leave(final ReturnNode returnNode) {
  10.363 +    public Node leaveReturnNode(final ReturnNode returnNode) {
  10.364          addStatement(returnNode); //ReturnNodes are always terminal, marked as such in constructor
  10.365          return returnNode;
  10.366      }
  10.367  
  10.368      @Override
  10.369 -    public Node enter(final SwitchNode switchNode) {
  10.370 +    public Node enterSwitchNode(final SwitchNode switchNode) {
  10.371          nest(switchNode);
  10.372          return switchNode;
  10.373      }
  10.374  
  10.375      @Override
  10.376 -    public Node leave(final SwitchNode switchNode) {
  10.377 +    public Node leaveSwitchNode(final SwitchNode switchNode) {
  10.378          unnest(switchNode);
  10.379  
  10.380          final List<CaseNode> cases       = switchNode.getCases();
  10.381 @@ -446,13 +476,13 @@
  10.382      }
  10.383  
  10.384      @Override
  10.385 -    public Node leave(final ThrowNode throwNode) {
  10.386 +    public Node leaveThrowNode(final ThrowNode throwNode) {
  10.387          addStatement(throwNode); //ThrowNodes are always terminal, marked as such in constructor
  10.388          return throwNode;
  10.389      }
  10.390  
  10.391      @Override
  10.392 -    public Node enter(final TryNode tryNode) {
  10.393 +    public Node enterTryNode(final TryNode tryNode) {
  10.394          final Block  finallyBody = tryNode.getFinallyBody();
  10.395          final long   token       = tryNode.getToken();
  10.396          final int    finish      = tryNode.getFinish();
  10.397 @@ -538,26 +568,19 @@
  10.398  
  10.399              // set outer tryNode's body to innerTryNode
  10.400              final Block outerBody;
  10.401 -            outerBody = new Block(source, token, finish, tryNode.getBody().getParent(), getCurrentFunctionNode());
  10.402 +            outerBody = new Block(source, token, finish);
  10.403              outerBody.setStatements(new ArrayList<Node>(Arrays.asList(innerTryNode)));
  10.404              tryNode.setBody(outerBody);
  10.405              tryNode.setCatchBlocks(null);
  10.406 -
  10.407 -            // now before we go on, we have to fix the block parents
  10.408 -            // (we repair the block tree after the insertion so that all references are intact)
  10.409 -            innerTryNode.getBody().setParent(tryNode.getBody());
  10.410 -            for (final Block block : innerTryNode.getCatchBlocks()) {
  10.411 -                block.setParent(tryNode.getBody());
  10.412 -            }
  10.413          }
  10.414  
  10.415          // create a catch-all that inlines finally and rethrows
  10.416  
  10.417 -        final Block catchBlock      = new Block(source, token, finish, getCurrentBlock(), getCurrentFunctionNode());
  10.418 +        final Block catchBlock      = new Block(source, token, finish);
  10.419          //this catch block should get define symbol
  10.420  
  10.421 -        final Block catchBody       = new Block(source, token, finish, catchBlock, getCurrentFunctionNode());
  10.422 -        final Node  catchAllFinally = finallyBody.clone();
  10.423 +        final Block catchBody       = new Block(source, token, finish);
  10.424 +        final Node  catchAllFinally = finallyBody.copy();
  10.425  
  10.426          catchBody.addStatement(new ExecuteNode(source, finallyBody.getToken(), finallyBody.getFinish(), catchAllFinally));
  10.427          setTerminal(catchBody, true);
  10.428 @@ -584,7 +607,7 @@
  10.429      }
  10.430  
  10.431      @Override
  10.432 -    public Node leave(final TryNode tryNode) {
  10.433 +    public Node leaveTryNode(final TryNode tryNode) {
  10.434          final Block finallyBody   = tryNode.getFinallyBody();
  10.435  
  10.436          boolean allTerminal = tryNode.getBody().isTerminal() && (finallyBody == null || finallyBody.isTerminal());
  10.437 @@ -608,18 +631,18 @@
  10.438      }
  10.439  
  10.440      @Override
  10.441 -    public Node leave(final VarNode varNode) {
  10.442 +    public Node leaveVarNode(final VarNode varNode) {
  10.443          addStatement(varNode);
  10.444          return varNode;
  10.445      }
  10.446  
  10.447      @Override
  10.448 -    public Node enter(final WhileNode whileNode) {
  10.449 +    public Node enterWhileNode(final WhileNode whileNode) {
  10.450          return nest(whileNode);
  10.451      }
  10.452  
  10.453      @Override
  10.454 -    public Node leave(final WhileNode whileNode) {
  10.455 +    public Node leaveWhileNode(final WhileNode whileNode) {
  10.456          final Node test = whileNode.getTest();
  10.457  
  10.458          if (test == null) {
  10.459 @@ -653,7 +676,7 @@
  10.460      }
  10.461  
  10.462      @Override
  10.463 -    public Node leave(final WithNode withNode) {
  10.464 +    public Node leaveWithNode(final WithNode withNode) {
  10.465          if (withNode.getBody().isTerminal()) {
  10.466              setTerminal(withNode,  true);
  10.467          }
  10.468 @@ -682,28 +705,10 @@
  10.469       */
  10.470      private static Node markerFunction(final Node function) {
  10.471          if (function instanceof IdentNode) {
  10.472 -            return new IdentNode((IdentNode)function) {
  10.473 -                @Override
  10.474 -                public boolean isFunction() {
  10.475 -                    return true;
  10.476 -                }
  10.477 -            };
  10.478 -        } else if (function instanceof AccessNode) {
  10.479 -            return new AccessNode((AccessNode)function) {
  10.480 -                @Override
  10.481 -                public boolean isFunction() {
  10.482 -                    return true;
  10.483 -                }
  10.484 -            };
  10.485 -        } else if (function instanceof IndexNode) {
  10.486 -            return new IndexNode((IndexNode)function) {
  10.487 -                @Override
  10.488 -                public boolean isFunction() {
  10.489 -                    return true;
  10.490 -                }
  10.491 -            };
  10.492 +            return ((IdentNode)function).setIsFunction();
  10.493 +        } else if (function instanceof BaseNode) {
  10.494 +            return ((BaseNode)function).setIsFunction();
  10.495          }
  10.496 -
  10.497          return function;
  10.498      }
  10.499  
  10.500 @@ -746,7 +751,7 @@
  10.501              if (args.size() >= 1 && EVAL.tag().equals(callee.getName())) {
  10.502                  final CallNode.EvalArgs evalArgs =
  10.503                      new CallNode.EvalArgs(
  10.504 -                        args.get(0).clone().accept(this), //clone as we use this for the "is eval case". original evaluated separately for "is not eval case"
  10.505 +                        args.get(0).copy().accept(this), //clone as we use this for the "is eval case". original evaluated separately for "is not eval case"
  10.506                          getCurrentFunctionNode().getThisNode(),
  10.507                          evalLocation(callee),
  10.508                          getCurrentFunctionNode().isStrictMode());
  10.509 @@ -773,13 +778,13 @@
  10.510  
  10.511          loopBody.accept(new NodeVisitor() {
  10.512              @Override
  10.513 -            public Node leave(final BreakNode node) {
  10.514 +            public Node leaveBreakNode(final BreakNode node) {
  10.515                  escapes.add(node);
  10.516                  return node;
  10.517              }
  10.518  
  10.519              @Override
  10.520 -            public Node leave(final ContinueNode node) {
  10.521 +            public Node leaveContinueNode(final ContinueNode node) {
  10.522                  // all inner loops have been popped.
  10.523                  if (nesting.contains(node.getTargetNode())) {
  10.524                      escapes.add(node);
  10.525 @@ -794,7 +799,7 @@
  10.526      private void guaranteeReturn(final FunctionNode functionNode) {
  10.527          Node resultNode;
  10.528  
  10.529 -        if (functionNode.isScript()) {
  10.530 +        if (functionNode.isProgram()) {
  10.531              resultNode = functionNode.getResultNode(); // the eval result, symbol assigned in Attr
  10.532          } else {
  10.533              if (lastStatement != null && lastStatement.isTerminal() || lastStatement instanceof ReturnNode) {
  10.534 @@ -859,18 +864,15 @@
  10.535       * @return true if try block is inside the target, false otherwise.
  10.536       */
  10.537      private boolean isNestedTry(final TryNode tryNode, final Block target) {
  10.538 -        for (Block current = getCurrentBlock(); current != target; current = current.getParent()) {
  10.539 -            if (tryNode.getBody() == current) {
  10.540 +        for(Iterator<Block> blocks = lexicalContext.getBlocks(getCurrentBlock()); blocks.hasNext();) {
  10.541 +            final Block block = blocks.next();
  10.542 +            if(block == target) {
  10.543 +                return false;
  10.544 +            }
  10.545 +            if(tryNode.isChildBlock(block)) {
  10.546                  return true;
  10.547              }
  10.548 -
  10.549 -            for (final Block catchBlock : tryNode.getCatchBlocks()) {
  10.550 -                if (catchBlock == current) {
  10.551 -                    return true;
  10.552 -                }
  10.553 -            }
  10.554          }
  10.555 -
  10.556          return false;
  10.557      }
  10.558  
  10.559 @@ -899,7 +901,7 @@
  10.560                  continue;
  10.561              }
  10.562  
  10.563 -            finallyBody = (Block)finallyBody.clone();
  10.564 +            finallyBody = (Block)finallyBody.copy();
  10.565              final boolean hasTerminalFlags = finallyBody.hasTerminalFlags();
  10.566  
  10.567              new ExecuteNode(finallyBody.getSource(), finallyBody.getToken(), finallyBody.getFinish(), finallyBody).accept(this);
  10.568 @@ -974,6 +976,3 @@
  10.569      }
  10.570  
  10.571  }
  10.572 -
  10.573 -
  10.574 -

    11.1 --- a/src/jdk/nashorn/internal/codegen/MethodEmitter.java	Tue Mar 19 11:03:24 2013 -0300
    11.2 +++ b/src/jdk/nashorn/internal/codegen/MethodEmitter.java	Sat Mar 23 00:58:39 2013 +0100
    11.3 @@ -651,11 +651,10 @@
    11.4  
    11.5      /**
    11.6       * Load the constants array
    11.7 -     * @param unitClassName name of the compile unit from which to load constants
    11.8       * @return this method emitter
    11.9       */
   11.10 -    MethodEmitter loadConstants(final String unitClassName) {
   11.11 -        getStatic(unitClassName, CONSTANTS.tag(), CONSTANTS.descriptor());
   11.12 +    MethodEmitter loadConstants() {
   11.13 +        getStatic(classEmitter.getUnitClassName(), CONSTANTS.tag(), CONSTANTS.descriptor());
   11.14          assert peekType().isArray() : peekType();
   11.15          return this;
   11.16      }

    12.1 --- a/src/jdk/nashorn/internal/codegen/Splitter.java	Tue Mar 19 11:03:24 2013 -0300
    12.2 +++ b/src/jdk/nashorn/internal/codegen/Splitter.java	Sat Mar 23 00:58:39 2013 +0100
    12.3 @@ -41,6 +41,7 @@
    12.4  import jdk.nashorn.internal.ir.FunctionNode;
    12.5  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    12.6  import jdk.nashorn.internal.ir.LabelNode;
    12.7 +import jdk.nashorn.internal.ir.LexicalContext;
    12.8  import jdk.nashorn.internal.ir.LiteralNode;
    12.9  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
   12.10  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
   12.11 @@ -49,6 +50,7 @@
   12.12  import jdk.nashorn.internal.ir.SplitNode;
   12.13  import jdk.nashorn.internal.ir.SwitchNode;
   12.14  import jdk.nashorn.internal.ir.WhileNode;
   12.15 +import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
   12.16  import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   12.17  import jdk.nashorn.internal.runtime.DebugLogger;
   12.18  import jdk.nashorn.internal.runtime.Source;
   12.19 @@ -70,6 +72,8 @@
   12.20      /** Cache for calculated block weights. */
   12.21      private final Map<Node, Long> weightCache = new HashMap<>();
   12.22  
   12.23 +    private final LexicalContext lexicalContext = new LexicalContext();
   12.24 +
   12.25      /** Weight threshold for when to start a split. */
   12.26      public static final long SPLIT_THRESHOLD = Options.getIntProperty("nashorn.compiler.splitter.threshold", 32 * 1024);
   12.27  
   12.28 @@ -112,7 +116,7 @@
   12.29              }
   12.30  
   12.31              if (weight >= SPLIT_THRESHOLD) {
   12.32 -                weight = splitBlock(functionNode);
   12.33 +                weight = splitBlock(functionNode, functionNode);
   12.34              }
   12.35  
   12.36              if (functionNode.isSplit()) {
   12.37 @@ -132,9 +136,20 @@
   12.38          }
   12.39  
   12.40          // Recursively split nested functions
   12.41 -        for (final FunctionNode function : functionNode.getFunctions()) {
   12.42 -            new Splitter(compiler, function, outermostCompileUnit).split();
   12.43 -        }
   12.44 +        functionNode.accept(new NodeOperatorVisitor() {
   12.45 +            @Override
   12.46 +            public Node enterFunctionNode(FunctionNode function) {
   12.47 +                if(function == functionNode) {
   12.48 +                    // Don't process outermost function (it was already processed) but descend into it to find nested
   12.49 +                    // functions.
   12.50 +                    return function;
   12.51 +                }
   12.52 +                // Process a nested function
   12.53 +                new Splitter(compiler, function, outermostCompileUnit).split();
   12.54 +                // Don't descend into a a nested function; Splitter.split() has taken care of nested-in-nested functions.
   12.55 +                return null;
   12.56 +            }
   12.57 +        });
   12.58  
   12.59          functionNode.setState(CompilationState.SPLIT);
   12.60      }
   12.61 @@ -155,7 +170,7 @@
   12.62       *
   12.63       * @return new weight for the resulting block.
   12.64       */
   12.65 -    private long splitBlock(final Block block) {
   12.66 +    private long splitBlock(final Block block, final FunctionNode function) {
   12.67          functionNode.setIsSplit();
   12.68  
   12.69          final List<Node> splits = new ArrayList<>();
   12.70 @@ -167,7 +182,7 @@
   12.71  
   12.72              if (statementsWeight + weight >= SPLIT_THRESHOLD || statement.isTerminal()) {
   12.73                  if (!statements.isEmpty()) {
   12.74 -                    splits.add(createBlockSplitNode(block, statements, statementsWeight));
   12.75 +                    splits.add(createBlockSplitNode(block, function, statements, statementsWeight));
   12.76                      statements = new ArrayList<>();
   12.77                      statementsWeight = 0;
   12.78                  }
   12.79 @@ -183,7 +198,7 @@
   12.80          }
   12.81  
   12.82          if (!statements.isEmpty()) {
   12.83 -            splits.add(createBlockSplitNode(block, statements, statementsWeight));
   12.84 +            splits.add(createBlockSplitNode(block, function, statements, statementsWeight));
   12.85          }
   12.86  
   12.87          block.setStatements(splits);
   12.88 @@ -199,13 +214,13 @@
   12.89       *
   12.90       * @return New split node.
   12.91       */
   12.92 -    private SplitNode createBlockSplitNode(final Block parent, final List<Node> statements, final long weight) {
   12.93 +    private SplitNode createBlockSplitNode(final Block parent, final FunctionNode function, final List<Node> statements, final long weight) {
   12.94          final Source source = parent.getSource();
   12.95          final long   token  = parent.getToken();
   12.96          final int    finish = parent.getFinish();
   12.97 -        final String name   = parent.getFunction().uniqueName(SPLIT_PREFIX.tag());
   12.98 +        final String name   = function.uniqueName(SPLIT_PREFIX.tag());
   12.99  
  12.100 -        final Block newBlock = new Block(source, token, finish, parent, functionNode);
  12.101 +        final Block newBlock = new Block(source, token, finish);
  12.102          newBlock.setFrame(new Frame(parent.getFrame()));
  12.103          newBlock.setStatements(statements);
  12.104  
  12.105 @@ -217,15 +232,17 @@
  12.106      }
  12.107  
  12.108      @Override
  12.109 -    public Node enter(final Block block) {
  12.110 +    public Node enterBlock(final Block block) {
  12.111          if (block.isCatchBlock()) {
  12.112              return null;
  12.113          }
  12.114 +        lexicalContext.push(block);
  12.115  
  12.116          final long weight = WeighNodes.weigh(block, weightCache);
  12.117  
  12.118          if (weight < SPLIT_THRESHOLD) {
  12.119              weightCache.put(block, weight);
  12.120 +            lexicalContext.pop(block);
  12.121              return null;
  12.122          }
  12.123  
  12.124 @@ -233,23 +250,24 @@
  12.125      }
  12.126  
  12.127      @Override
  12.128 -    public Node leave(final Block block) {
  12.129 +    public Node leaveBlock(final Block block) {
  12.130          assert !block.isCatchBlock();
  12.131  
  12.132          // Block was heavier than SLIT_THRESHOLD in enter, but a sub-block may have
  12.133          // been split already, so weigh again before splitting.
  12.134          long weight = WeighNodes.weigh(block, weightCache);
  12.135          if (weight >= SPLIT_THRESHOLD) {
  12.136 -            weight = splitBlock(block);
  12.137 +            weight = splitBlock(block, lexicalContext.getFunction(block));
  12.138          }
  12.139          weightCache.put(block, weight);
  12.140  
  12.141 +        lexicalContext.pop(block);
  12.142          return block;
  12.143      }
  12.144  
  12.145      @SuppressWarnings("rawtypes")
  12.146      @Override
  12.147 -    public Node leave(final LiteralNode literal) {
  12.148 +    public Node leaveLiteralNode(final LiteralNode literal) {
  12.149          long weight = WeighNodes.weigh(literal);
  12.150  
  12.151          if (weight < SPLIT_THRESHOLD) {
  12.152 @@ -294,17 +312,12 @@
  12.153      }
  12.154  
  12.155      @Override
  12.156 -    public Node enter(final FunctionNode node) {
  12.157 -        if (node.isLazy()) {
  12.158 -            return null;
  12.159 +    public Node enterFunctionNode(final FunctionNode node) {
  12.160 +        if(node == functionNode && !node.isLazy()) {
  12.161 +            lexicalContext.push(node);
  12.162 +            node.visitStatements(this);
  12.163 +            lexicalContext.pop(node);
  12.164          }
  12.165 -
  12.166 -        final List<Node> statements = node.getStatements();
  12.167 -
  12.168 -        for (final Node statement : statements) {
  12.169 -            statement.accept(this);
  12.170 -        }
  12.171 -
  12.172          return null;
  12.173      }
  12.174  
  12.175 @@ -321,38 +334,38 @@
  12.176          }
  12.177  
  12.178          @Override
  12.179 -        public Node enter(final LabelNode labelNode) {
  12.180 +        public Node enterLabelNode(final LabelNode labelNode) {
  12.181              registerJumpTarget(labelNode.getBreakNode());
  12.182              registerJumpTarget(labelNode.getContinueNode());
  12.183              return labelNode;
  12.184          }
  12.185  
  12.186          @Override
  12.187 -        public Node enter(final WhileNode whileNode) {
  12.188 +        public Node enterWhileNode(final WhileNode whileNode) {
  12.189              registerJumpTarget(whileNode);
  12.190              return whileNode;
  12.191          }
  12.192  
  12.193          @Override
  12.194 -        public Node enter(final DoWhileNode doWhileNode) {
  12.195 +        public Node enterDoWhileNode(final DoWhileNode doWhileNode) {
  12.196              registerJumpTarget(doWhileNode);
  12.197              return doWhileNode;
  12.198          }
  12.199  
  12.200          @Override
  12.201 -        public Node enter(final ForNode forNode) {
  12.202 +        public Node enterForNode(final ForNode forNode) {
  12.203              registerJumpTarget(forNode);
  12.204              return forNode;
  12.205          }
  12.206  
  12.207          @Override
  12.208 -        public Node enter(final SwitchNode switchNode) {
  12.209 +        public Node enterSwitchNode(final SwitchNode switchNode) {
  12.210              registerJumpTarget(switchNode);
  12.211              return switchNode;
  12.212          }
  12.213  
  12.214          @Override
  12.215 -        public Node enter(final ReturnNode returnNode) {
  12.216 +        public Node enterReturnNode(final ReturnNode returnNode) {
  12.217              for (final SplitNode split : splitStack) {
  12.218                  split.setHasReturn(true);
  12.219              }
  12.220 @@ -360,25 +373,25 @@
  12.221          }
  12.222  
  12.223          @Override
  12.224 -        public Node enter(final ContinueNode continueNode) {
  12.225 +        public Node enterContinueNode(final ContinueNode continueNode) {
  12.226              searchJumpTarget(continueNode.getTargetNode(), continueNode.getTargetLabel());
  12.227              return continueNode;
  12.228          }
  12.229  
  12.230          @Override
  12.231 -        public Node enter(final BreakNode breakNode) {
  12.232 +        public Node enterBreakNode(final BreakNode breakNode) {
  12.233              searchJumpTarget(breakNode.getTargetNode(), breakNode.getTargetLabel());
  12.234              return breakNode;
  12.235          }
  12.236  
  12.237          @Override
  12.238 -        public Node enter(final SplitNode splitNode) {
  12.239 +        public Node enterSplitNode(final SplitNode splitNode) {
  12.240              splitStack.addFirst(splitNode);
  12.241              return splitNode;
  12.242          }
  12.243  
  12.244          @Override
  12.245 -        public Node leave(final SplitNode splitNode) {
  12.246 +        public Node leaveSplitNode(final SplitNode splitNode) {
  12.247              assert splitNode == splitStack.peekFirst();
  12.248              splitStack.removeFirst();
  12.249              return splitNode;

    13.1 --- a/src/jdk/nashorn/internal/codegen/WeighNodes.java	Tue Mar 19 11:03:24 2013 -0300
    13.2 +++ b/src/jdk/nashorn/internal/codegen/WeighNodes.java	Sat Mar 23 00:58:39 2013 +0100
    13.3 @@ -47,7 +47,6 @@
    13.4  import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
    13.5  import jdk.nashorn.internal.ir.Node;
    13.6  import jdk.nashorn.internal.ir.PropertyNode;
    13.7 -import jdk.nashorn.internal.ir.ReferenceNode;
    13.8  import jdk.nashorn.internal.ir.ReturnNode;
    13.9  import jdk.nashorn.internal.ir.RuntimeNode;
   13.10  import jdk.nashorn.internal.ir.SplitNode;
   13.11 @@ -80,7 +79,7 @@
   13.12      private static final long LITERAL_WEIGHT   = 10;
   13.13      private static final long LOOP_WEIGHT      = 4;
   13.14      private static final long NEW_WEIGHT       = 6;
   13.15 -    private static final long REFERENCE_WEIGHT = 20;
   13.16 +    private static final long FUNC_EXPR_WEIGHT = 20;
   13.17      private static final long RETURN_WEIGHT    = 2;
   13.18      private static final long SPLIT_WEIGHT     = 40;
   13.19      private static final long SWITCH_WEIGHT    = 8;
   13.20 @@ -94,36 +93,37 @@
   13.21      /** Optional cache for weight of block nodes. */
   13.22      private final Map<Node, Long> weightCache;
   13.23  
   13.24 -    /*
   13.25 +    private final FunctionNode topFunction;
   13.26 +
   13.27 +    /**
   13.28       * Constructor
   13.29       *
   13.30       * @param weightCache cache of already calculated block weights
   13.31       */
   13.32 -    private WeighNodes(final Map<Node, Long> weightCache) {
   13.33 +    private WeighNodes(FunctionNode topFunction, final Map<Node, Long> weightCache) {
   13.34          super(null, null);
   13.35 +        this.topFunction = topFunction;
   13.36          this.weightCache = weightCache;
   13.37      }
   13.38  
   13.39      static long weigh(final Node node) {
   13.40 -        final WeighNodes weighNodes = new WeighNodes(null);
   13.41 -        node.accept(weighNodes);
   13.42 -        return weighNodes.weight;
   13.43 +        return weigh(node, null);
   13.44      }
   13.45  
   13.46      static long weigh(final Node node, final Map<Node, Long> weightCache) {
   13.47 -        final WeighNodes weighNodes = new WeighNodes(weightCache);
   13.48 +        final WeighNodes weighNodes = new WeighNodes(node instanceof FunctionNode ? (FunctionNode)node : null, weightCache);
   13.49          node.accept(weighNodes);
   13.50          return weighNodes.weight;
   13.51      }
   13.52  
   13.53      @Override
   13.54 -    public Node leave(final AccessNode accessNode) {
   13.55 +    public Node leaveAccessNode(final AccessNode accessNode) {
   13.56          weight += ACCESS_WEIGHT;
   13.57          return accessNode;
   13.58      }
   13.59  
   13.60      @Override
   13.61 -    public Node enter(final Block block) {
   13.62 +    public Node enterBlock(final Block block) {
   13.63          if (weightCache != null && weightCache.containsKey(block)) {
   13.64              weight += weightCache.get(block);
   13.65              return null;
   13.66 @@ -133,78 +133,79 @@
   13.67      }
   13.68  
   13.69      @Override
   13.70 -    public Node leave(final BreakNode breakNode) {
   13.71 +    public Node leaveBreakNode(final BreakNode breakNode) {
   13.72          weight += BREAK_WEIGHT;
   13.73          return breakNode;
   13.74      }
   13.75  
   13.76      @Override
   13.77 -    public Node leave(final CallNode callNode) {
   13.78 +    public Node leaveCallNode(final CallNode callNode) {
   13.79          weight += CALL_WEIGHT;
   13.80          return callNode;
   13.81      }
   13.82  
   13.83      @Override
   13.84 -    public Node leave(final CatchNode catchNode) {
   13.85 +    public Node leaveCatchNode(final CatchNode catchNode) {
   13.86          weight += CATCH_WEIGHT;
   13.87          return catchNode;
   13.88      }
   13.89  
   13.90      @Override
   13.91 -    public Node leave(final ContinueNode continueNode) {
   13.92 +    public Node leaveContinueNode(final ContinueNode continueNode) {
   13.93          weight += CONTINUE_WEIGHT;
   13.94          return continueNode;
   13.95      }
   13.96  
   13.97      @Override
   13.98 -    public Node leave(final DoWhileNode doWhileNode) {
   13.99 +    public Node leaveDoWhileNode(final DoWhileNode doWhileNode) {
  13.100          weight += LOOP_WEIGHT;
  13.101          return doWhileNode;
  13.102      }
  13.103  
  13.104      @Override
  13.105 -    public Node leave(final ExecuteNode executeNode) {
  13.106 +    public Node leaveExecuteNode(final ExecuteNode executeNode) {
  13.107          return executeNode;
  13.108      }
  13.109  
  13.110      @Override
  13.111 -    public Node leave(final ForNode forNode) {
  13.112 +    public Node leaveForNode(final ForNode forNode) {
  13.113          weight += LOOP_WEIGHT;
  13.114          return forNode;
  13.115      }
  13.116  
  13.117      @Override
  13.118 -    public Node enter(final FunctionNode functionNode) {
  13.119 -        final List<Node> statements = functionNode.getStatements();
  13.120 -
  13.121 -        for (final Node statement : statements) {
  13.122 -            statement.accept(this);
  13.123 +    public Node enterFunctionNode(final FunctionNode functionNode) {
  13.124 +        if(functionNode == topFunction) {
  13.125 +            // the function being weighted; descend into its statements
  13.126 +            functionNode.visitStatements(this);
  13.127 +        } else {
  13.128 +            // just a reference to inner function from outer function
  13.129 +            weight += FUNC_EXPR_WEIGHT;
  13.130          }
  13.131 -
  13.132          return null;
  13.133      }
  13.134  
  13.135      @Override
  13.136 -    public Node leave(final IdentNode identNode) {
  13.137 +    public Node leaveIdentNode(final IdentNode identNode) {
  13.138          weight += ACCESS_WEIGHT + identNode.getName().length() * 2;
  13.139          return identNode;
  13.140      }
  13.141  
  13.142      @Override
  13.143 -    public Node leave(final IfNode ifNode) {
  13.144 +    public Node leaveIfNode(final IfNode ifNode) {
  13.145          weight += IF_WEIGHT;
  13.146          return ifNode;
  13.147      }
  13.148  
  13.149      @Override
  13.150 -    public Node leave(final IndexNode indexNode) {
  13.151 +    public Node leaveIndexNode(final IndexNode indexNode) {
  13.152          weight += ACCESS_WEIGHT;
  13.153          return indexNode;
  13.154      }
  13.155  
  13.156      @SuppressWarnings("rawtypes")
  13.157      @Override
  13.158 -    public Node enter(final LiteralNode literalNode) {
  13.159 +    public Node enterLiteralNode(final LiteralNode literalNode) {
  13.160          weight += LITERAL_WEIGHT;
  13.161  
  13.162          if (literalNode instanceof ArrayLiteralNode) {
  13.163 @@ -230,67 +231,61 @@
  13.164      }
  13.165  
  13.166      @Override
  13.167 -    public Node leave(final PropertyNode propertyNode) {
  13.168 +    public Node leavePropertyNode(final PropertyNode propertyNode) {
  13.169          weight += LITERAL_WEIGHT;
  13.170          return propertyNode;
  13.171      }
  13.172  
  13.173      @Override
  13.174 -    public Node leave(final ReferenceNode referenceNode) {
  13.175 -        weight += REFERENCE_WEIGHT;
  13.176 -        return referenceNode;
  13.177 -    }
  13.178 -
  13.179 -    @Override
  13.180 -    public Node leave(final ReturnNode returnNode) {
  13.181 +    public Node leaveReturnNode(final ReturnNode returnNode) {
  13.182          weight += RETURN_WEIGHT;
  13.183          return returnNode;
  13.184      }
  13.185  
  13.186      @Override
  13.187 -    public Node leave(final RuntimeNode runtimeNode) {
  13.188 +    public Node leaveRuntimeNode(final RuntimeNode runtimeNode) {
  13.189          weight += CALL_WEIGHT;
  13.190          return runtimeNode;
  13.191      }
  13.192  
  13.193      @Override
  13.194 -    public Node enter(final SplitNode splitNode) {
  13.195 +    public Node enterSplitNode(final SplitNode splitNode) {
  13.196          weight += SPLIT_WEIGHT;
  13.197          return null;
  13.198      }
  13.199  
  13.200      @Override
  13.201 -    public Node leave(final SwitchNode switchNode) {
  13.202 +    public Node leaveSwitchNode(final SwitchNode switchNode) {
  13.203          weight += SWITCH_WEIGHT;
  13.204          return switchNode;
  13.205      }
  13.206  
  13.207      @Override
  13.208 -    public Node leave(final ThrowNode throwNode) {
  13.209 +    public Node leaveThrowNode(final ThrowNode throwNode) {
  13.210          weight += THROW_WEIGHT;
  13.211          return throwNode;
  13.212      }
  13.213  
  13.214      @Override
  13.215 -    public Node leave(final TryNode tryNode) {
  13.216 +    public Node leaveTryNode(final TryNode tryNode) {
  13.217          weight += THROW_WEIGHT;
  13.218          return tryNode;
  13.219      }
  13.220  
  13.221      @Override
  13.222 -    public Node leave(final VarNode varNode) {
  13.223 +    public Node leaveVarNode(final VarNode varNode) {
  13.224          weight += VAR_WEIGHT;
  13.225          return varNode;
  13.226      }
  13.227  
  13.228      @Override
  13.229 -    public Node leave(final WhileNode whileNode) {
  13.230 +    public Node leaveWhileNode(final WhileNode whileNode) {
  13.231          weight += LOOP_WEIGHT;
  13.232          return whileNode;
  13.233      }
  13.234  
  13.235      @Override
  13.236 -    public Node leave(final WithNode withNode) {
  13.237 +    public Node leaveWithNode(final WithNode withNode) {
  13.238          weight += WITH_WEIGHT;
  13.239          return withNode;
  13.240      }

    14.1 --- a/src/jdk/nashorn/internal/ir/AccessNode.java	Tue Mar 19 11:03:24 2013 -0300
    14.2 +++ b/src/jdk/nashorn/internal/ir/AccessNode.java	Sat Mar 23 00:58:39 2013 +0100
    14.3 @@ -36,7 +36,7 @@
    14.4   * IR representation of a property access (period operator.)
    14.5   *
    14.6   */
    14.7 -public class AccessNode extends BaseNode implements TypeOverride {
    14.8 +public class AccessNode extends BaseNode implements TypeOverride<AccessNode> {
    14.9      /** Property ident. */
   14.10      private IdentNode property;
   14.11  
   14.12 @@ -56,9 +56,7 @@
   14.13          super(source, token, finish, base);
   14.14  
   14.15          this.start    = base.getStart();
   14.16 -        this.property = property;
   14.17 -
   14.18 -        this.property.setIsPropertyName();
   14.19 +        this.property = property.setIsPropertyName();
   14.20      }
   14.21  
   14.22      /**
   14.23 @@ -106,10 +104,10 @@
   14.24       */
   14.25      @Override
   14.26      public Node accept(final NodeVisitor visitor) {
   14.27 -        if (visitor.enter(this) != null) {
   14.28 +        if (visitor.enterAccessNode(this) != null) {
   14.29              base = base.accept(visitor);
   14.30              property = (IdentNode)property.accept(visitor);
   14.31 -            return visitor.leave(this);
   14.32 +            return visitor.leaveAccessNode(this);
   14.33          }
   14.34  
   14.35          return this;
   14.36 @@ -150,13 +148,14 @@
   14.37      }
   14.38  
   14.39      @Override
   14.40 -    public void setType(final Type type) {
   14.41 +    public AccessNode setType(final Type type) {
   14.42          if (DEBUG_FIELDS && !Type.areEquivalent(getSymbol().getSymbolType(), type)) {
   14.43              ObjectClassGenerator.LOG.info(getClass().getName() + " " + this + " => " + type + " instead of " + getType());
   14.44          }
   14.45 -        property.setType(type);
   14.46 +        property = property.setType(type);
   14.47          getSymbol().setTypeOverride(type); //always a temp so this is fine.
   14.48          hasCallSiteType = true;
   14.49 +        return this;
   14.50      }
   14.51  
   14.52      @Override

    15.1 --- a/src/jdk/nashorn/internal/ir/Assignment.java	Tue Mar 19 11:03:24 2013 -0300
    15.2 +++ b/src/jdk/nashorn/internal/ir/Assignment.java	Sat Mar 23 00:58:39 2013 +0100
    15.3 @@ -46,4 +46,11 @@
    15.4       * @return get the assignment source node
    15.5       */
    15.6      public Node getAssignmentSource();
    15.7 +
    15.8 +    /**
    15.9 +     * Set assignment destination node.
   15.10 +     * @param n the assignment destination node.
   15.11 +     * @return a node equivalent to this one except for the requested change.
   15.12 +     */
   15.13 +    public Node setAssignmentDest(D n);
   15.14  }

    16.1 --- a/src/jdk/nashorn/internal/ir/BaseNode.java	Tue Mar 19 11:03:24 2013 -0300
    16.2 +++ b/src/jdk/nashorn/internal/ir/BaseNode.java	Sat Mar 23 00:58:39 2013 +0100
    16.3 @@ -38,6 +38,8 @@
    16.4      /** Base Node. */
    16.5      protected Node base;
    16.6  
    16.7 +    private boolean function;
    16.8 +
    16.9      /**
   16.10       * Constructor
   16.11       *
   16.12 @@ -96,6 +98,15 @@
   16.13  
   16.14      @Override
   16.15      public boolean isFunction() {
   16.16 -        return false;
   16.17 +        return function;
   16.18 +    }
   16.19 +
   16.20 +    /**
   16.21 +     * Mark this node as being the callee operand of a {@link CallNode}.
   16.22 +     * @return a base node identical to this one in all aspects except with its function flag set.
   16.23 +     */
   16.24 +    public BaseNode setIsFunction() {
   16.25 +        function = true;
   16.26 +        return this;
   16.27      }
   16.28  }

    17.1 --- a/src/jdk/nashorn/internal/ir/BinaryNode.java	Tue Mar 19 11:03:24 2013 -0300
    17.2 +++ b/src/jdk/nashorn/internal/ir/BinaryNode.java	Sat Mar 23 00:58:39 2013 +0100
    17.3 @@ -35,7 +35,7 @@
    17.4   */
    17.5  public class BinaryNode extends UnaryNode {
    17.6      /** Left hand side argument. */
    17.7 -    protected Node lhs;
    17.8 +    private Node lhs;
    17.9  
   17.10      /**
   17.11       * Constructor
   17.12 @@ -140,6 +140,11 @@
   17.13      }
   17.14  
   17.15      @Override
   17.16 +    public Node setAssignmentDest(Node n) {
   17.17 +        return setLHS(n);
   17.18 +    }
   17.19 +
   17.20 +    @Override
   17.21      public Node getAssignmentSource() {
   17.22          return rhs();
   17.23      }
   17.24 @@ -163,10 +168,9 @@
   17.25       */
   17.26      @Override
   17.27      public Node accept(final NodeVisitor visitor) {
   17.28 -        if (visitor.enter(this) != null) {
   17.29 -            lhs = lhs.accept(visitor);
   17.30 -            rhs = rhs.accept(visitor);
   17.31 -            return visitor.leave(this);
   17.32 +        if (visitor.enterBinaryNode(this) != null) {
   17.33 +            // TODO: good cause for a separate visitMembers: we could delegate to UnaryNode.visitMembers
   17.34 +            return visitor.leaveBinaryNode((BinaryNode)setLHS(lhs.accept(visitor)).setRHS(rhs().accept(visitor)));
   17.35          }
   17.36  
   17.37          return this;
   17.38 @@ -229,8 +233,12 @@
   17.39      /**
   17.40       * Set the left hand side expression for this node
   17.41       * @param lhs new left hand side expression
   17.42 +     * @return a node equivalent to this one except for the requested change.
   17.43       */
   17.44 -    public void setLHS(final Node lhs) {
   17.45 -        this.lhs = lhs;
   17.46 +    public BinaryNode setLHS(final Node lhs) {
   17.47 +        if(this.lhs == lhs) return this;
   17.48 +        final BinaryNode n = (BinaryNode)clone();
   17.49 +        n.lhs = lhs;
   17.50 +        return n;
   17.51      }
   17.52  }

    18.1 --- a/src/jdk/nashorn/internal/ir/Block.java	Tue Mar 19 11:03:24 2013 -0300
    18.2 +++ b/src/jdk/nashorn/internal/ir/Block.java	Sat Mar 23 00:58:39 2013 +0100
    18.3 @@ -25,14 +25,6 @@
    18.4  
    18.5  package jdk.nashorn.internal.ir;
    18.6  
    18.7 -import static jdk.nashorn.internal.ir.Symbol.IS_GLOBAL;
    18.8 -import static jdk.nashorn.internal.ir.Symbol.IS_INTERNAL;
    18.9 -import static jdk.nashorn.internal.ir.Symbol.IS_LET;
   18.10 -import static jdk.nashorn.internal.ir.Symbol.IS_PARAM;
   18.11 -import static jdk.nashorn.internal.ir.Symbol.IS_SCOPE;
   18.12 -import static jdk.nashorn.internal.ir.Symbol.IS_VAR;
   18.13 -import static jdk.nashorn.internal.ir.Symbol.KINDMASK;
   18.14 -
   18.15  import java.io.PrintWriter;
   18.16  import java.util.ArrayList;
   18.17  import java.util.Collections;
   18.18 @@ -40,9 +32,9 @@
   18.19  import java.util.HashMap;
   18.20  import java.util.Iterator;
   18.21  import java.util.List;
   18.22 +import java.util.ListIterator;
   18.23  import jdk.nashorn.internal.codegen.Frame;
   18.24  import jdk.nashorn.internal.codegen.Label;
   18.25 -import jdk.nashorn.internal.ir.annotations.Reference;
   18.26  import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   18.27  import jdk.nashorn.internal.runtime.Source;
   18.28  
   18.29 @@ -51,14 +43,6 @@
   18.30   * basis for script body.
   18.31   */
   18.32  public class Block extends Node {
   18.33 -    /** Parent context */
   18.34 -    @Reference
   18.35 -    private Block parent;
   18.36 -
   18.37 -    /** Owning function - a FunctionNode has itself as function */
   18.38 -    @Reference
   18.39 -    protected FunctionNode function;
   18.40 -
   18.41      /** List of statements */
   18.42      protected List<Node> statements;
   18.43  
   18.44 @@ -83,14 +67,10 @@
   18.45       * @param source   source code
   18.46       * @param token    token
   18.47       * @param finish   finish
   18.48 -     * @param parent   reference to parent block
   18.49 -     * @param function function node this block is in
   18.50       */
   18.51 -    public Block(final Source source, final long token, final int finish, final Block parent, final FunctionNode function) {
   18.52 +    public Block(final Source source, final long token, final int finish) {
   18.53          super(source, token, finish);
   18.54  
   18.55 -        this.parent     = parent;
   18.56 -        this.function   = function;
   18.57          this.statements = new ArrayList<>();
   18.58          this.symbols    = new HashMap<>();
   18.59          this.entryLabel = new Label("block_entry");
   18.60 @@ -106,8 +86,6 @@
   18.61      protected Block(final Block block, final CopyState cs) {
   18.62          super(block);
   18.63  
   18.64 -        this.parent     = block.parent;
   18.65 -        this.function   = block.function;
   18.66          this.statements = new ArrayList<>();
   18.67          for (final Node statement : block.getStatements()) {
   18.68              statements.add(cs.existingOrCopy(statement));
   18.69 @@ -122,55 +100,7 @@
   18.70  
   18.71      @Override
   18.72      protected Node copy(final CopyState cs) {
   18.73 -        return fixBlockChain(new Block(this, cs));
   18.74 -    }
   18.75 -
   18.76 -    /**
   18.77 -     * Whenever a clone that contains a hierarchy of blocks is created,
   18.78 -     * this function has to be called to ensure that the parents point
   18.79 -     * to the correct parent blocks or two different ASTs would not
   18.80 -     * be completely separated.
   18.81 -     *
   18.82 -     * @return the argument
   18.83 -     */
   18.84 -    static Block fixBlockChain(final Block root) {
   18.85 -        root.accept(new NodeVisitor() {
   18.86 -            private Block        parent   = root.getParent();
   18.87 -            private final FunctionNode function = root.getFunction();
   18.88 -
   18.89 -            @Override
   18.90 -            public Node enter(final Block block) {
   18.91 -                assert block.getFunction() == function;
   18.92 -                block.setParent(parent);
   18.93 -                parent = block;
   18.94 -
   18.95 -                return block;
   18.96 -            }
   18.97 -
   18.98 -            @Override
   18.99 -            public Node leave(final Block block) {
  18.100 -                parent = block.getParent();
  18.101 -
  18.102 -                return block;
  18.103 -            }
  18.104 -
  18.105 -            @Override
  18.106 -            public Node enter(final FunctionNode functionNode) {
  18.107 -                assert functionNode.getFunction() == function;
  18.108 -
  18.109 -                return enter((Block)functionNode);
  18.110 -            }
  18.111 -
  18.112 -            @Override
  18.113 -            public Node leave(final FunctionNode functionNode) {
  18.114 -                assert functionNode.getFunction() == function;
  18.115 -
  18.116 -                return leave((Block)functionNode);
  18.117 -            }
  18.118 -
  18.119 -        });
  18.120 -
  18.121 -        return root;
  18.122 +        return new Block(this, cs);
  18.123      }
  18.124  
  18.125      /**
  18.126 @@ -188,17 +118,12 @@
  18.127      }
  18.128  
  18.129      /**
  18.130 -     * Prepend a statement to the statement list
  18.131 +     * Prepend statements to the statement list
  18.132       *
  18.133 -     * @param statement Statement node to add
  18.134 +     * @param prepended statement to add
  18.135       */
  18.136 -    public void prependStatement(final Node statement) {
  18.137 -        if (statement != null) {
  18.138 -            final List<Node> newStatements = new ArrayList<>();
  18.139 -            newStatements.add(statement);
  18.140 -            newStatements.addAll(statements);
  18.141 -            setStatements(newStatements);
  18.142 -        }
  18.143 +    public void prependStatements(final List<Node> prepended) {
  18.144 +        statements.addAll(0, prepended);
  18.145      }
  18.146  
  18.147      /**
  18.148 @@ -211,39 +136,6 @@
  18.149      }
  18.150  
  18.151      /**
  18.152 -     * Add a new function to the function list.
  18.153 -     *
  18.154 -     * @param functionNode Function node to add.
  18.155 -     */
  18.156 -    public void addFunction(final FunctionNode functionNode) {
  18.157 -        assert parent != null : "Parent context missing.";
  18.158 -
  18.159 -        parent.addFunction(functionNode);
  18.160 -    }
  18.161 -
  18.162 -    /**
  18.163 -     * Add a list of functions to the function list.
  18.164 -     *
  18.165 -     * @param functionNodes Function nodes to add.
  18.166 -     */
  18.167 -    public void addFunctions(final List<FunctionNode> functionNodes) {
  18.168 -        assert parent != null : "Parent context missing.";
  18.169 -
  18.170 -        parent.addFunctions(functionNodes);
  18.171 -    }
  18.172 -
  18.173 -    /**
  18.174 -     * Set the function list to a new one
  18.175 -     *
  18.176 -     * @param functionNodes the nodes to set
  18.177 -     */
  18.178 -    public void setFunctions(final List<FunctionNode> functionNodes) {
  18.179 -        assert parent != null : "Parent context missing.";
  18.180 -
  18.181 -        parent.setFunctions(functionNodes);
  18.182 -    }
  18.183 -
  18.184 -    /**
  18.185       * Assist in IR navigation.
  18.186       *
  18.187       * @param visitor IR navigating visitor.
  18.188 @@ -257,13 +149,9 @@
  18.189          try {
  18.190              // Ignore parent to avoid recursion.
  18.191  
  18.192 -            if (visitor.enter(this) != null) {
  18.193 -                for (int i = 0, count = statements.size(); i < count; i++) {
  18.194 -                    final Node statement = statements.get(i);
  18.195 -                    statements.set(i, statement.accept(visitor));
  18.196 -                }
  18.197 -
  18.198 -                return visitor.leave(this);
  18.199 +            if (visitor.enterBlock(this) != null) {
  18.200 +                visitStatements(visitor);
  18.201 +                return visitor.leaveBlock(this);
  18.202              }
  18.203          } finally {
  18.204              visitor.setCurrentBlock(saveBlock);
  18.205 @@ -281,51 +169,13 @@
  18.206      }
  18.207  
  18.208      /**
  18.209 -     * Search for symbol.
  18.210 -     *
  18.211 -     * @param name Symbol name.
  18.212 -     *
  18.213 -     * @return Found symbol or null if not found.
  18.214 +     * Retrieves an existing symbol defined in the current block.
  18.215 +     * @param name the name of the symbol
  18.216 +     * @return an existing symbol with the specified name defined in the current block, or null if this block doesn't
  18.217 +     * define a symbol with this name.
  18.218       */
  18.219 -    public Symbol findSymbol(final String name) {
  18.220 -        // Search up block chain to locate symbol.
  18.221 -
  18.222 -        for (Block block = this; block != null; block = block.getParent()) {
  18.223 -            // Find name.
  18.224 -            final Symbol symbol = block.symbols.get(name);
  18.225 -            // If found then we are good.
  18.226 -            if (symbol != null) {
  18.227 -                return symbol;
  18.228 -            }
  18.229 -        }
  18.230 -        return null;
  18.231 -    }
  18.232 -
  18.233 -    /**
  18.234 -     * Search for symbol in current function.
  18.235 -     *
  18.236 -     * @param name Symbol name.
  18.237 -     *
  18.238 -     * @return Found symbol or null if not found.
  18.239 -     */
  18.240 -    public Symbol findLocalSymbol(final String name) {
  18.241 -        // Search up block chain to locate symbol.
  18.242 -        for (Block block = this; block != null; block = block.getParent()) {
  18.243 -            // Find name.
  18.244 -            final Symbol symbol = block.symbols.get(name);
  18.245 -            // If found then we are good.
  18.246 -            if (symbol != null) {
  18.247 -                return symbol;
  18.248 -            }
  18.249 -
  18.250 -            // If searched function then we are done.
  18.251 -            if (block == block.function) {
  18.252 -                break;
  18.253 -            }
  18.254 -        }
  18.255 -
  18.256 -        // Not found.
  18.257 -        return null;
  18.258 +    public Symbol getExistingSymbol(final String name) {
  18.259 +        return symbols.get(name);
  18.260      }
  18.261  
  18.262      /**
  18.263 @@ -338,122 +188,6 @@
  18.264          return statements.size() == 1 && statements.get(0) instanceof CatchNode;
  18.265      }
  18.266  
  18.267 -    /**
  18.268 -     * Test to see if a symbol is local to the function.
  18.269 -     *
  18.270 -     * @param symbol Symbol to test.
  18.271 -     * @return True if a local symbol.
  18.272 -     */
  18.273 -    public boolean isLocal(final Symbol symbol) {
  18.274 -        // some temp symbols have no block, so can be assumed local
  18.275 -        final Block block = symbol.getBlock();
  18.276 -        return block == null || block.getFunction() == function;
  18.277 -    }
  18.278 -
  18.279 -    /**
  18.280 -     * Declare the definition of a new symbol.
  18.281 -     *
  18.282 -     * @param name         Name of symbol.
  18.283 -     * @param symbolFlags  Symbol flags.
  18.284 -     * @param node         Defining Node.
  18.285 -     *
  18.286 -     * @return Symbol for given name or null for redefinition.
  18.287 -     */
  18.288 -    public Symbol defineSymbol(final String name, final int symbolFlags, final Node node) {
  18.289 -        int    flags  = symbolFlags;
  18.290 -        Symbol symbol = findSymbol(name); // Locate symbol.
  18.291 -
  18.292 -        if ((flags & KINDMASK) == IS_GLOBAL) {
  18.293 -            flags |= IS_SCOPE;
  18.294 -        }
  18.295 -
  18.296 -        if (symbol != null) {
  18.297 -            // Symbol was already defined. Check if it needs to be redefined.
  18.298 -            if ((flags & KINDMASK) == IS_PARAM) {
  18.299 -                if (!function.isLocal(symbol)) {
  18.300 -                    // Not defined in this function. Create a new definition.
  18.301 -                    symbol = null;
  18.302 -                } else if (symbol.isParam()) {
  18.303 -                    // Duplicate parameter. Null return will force an error.
  18.304 -                    assert false : "duplicate parameter";
  18.305 -                    return null;
  18.306 -                }
  18.307 -            } else if ((flags & KINDMASK) == IS_VAR) {
  18.308 -                if ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & Symbol.IS_LET) == Symbol.IS_LET) {
  18.309 -                    assert !((flags & IS_LET) == IS_LET && symbol.getBlock() == this) : "duplicate let variable in block";
  18.310 -                    // Always create a new definition.
  18.311 -                    symbol = null;
  18.312 -                } else {
  18.313 -                    // Not defined in this function. Create a new definition.
  18.314 -                    if (!function.isLocal(symbol) || symbol.less(IS_VAR)) {
  18.315 -                        symbol = null;
  18.316 -                    }
  18.317 -                }
  18.318 -            }
  18.319 -        }
  18.320 -
  18.321 -        if (symbol == null) {
  18.322 -            // If not found, then create a new one.
  18.323 -            Block symbolBlock;
  18.324 -
  18.325 -            // Determine where to create it.
  18.326 -            if ((flags & Symbol.KINDMASK) == IS_VAR && ((flags & IS_INTERNAL) == IS_INTERNAL || (flags & IS_LET) == IS_LET)) {
  18.327 -                symbolBlock = this;
  18.328 -            } else {
  18.329 -                symbolBlock = getFunction();
  18.330 -            }
  18.331 -
  18.332 -            // Create and add to appropriate block.
  18.333 -            symbol = new Symbol(name, flags, node, symbolBlock);
  18.334 -            symbolBlock.putSymbol(name, symbol);
  18.335 -
  18.336 -            if ((flags & Symbol.KINDMASK) != IS_GLOBAL) {
  18.337 -                symbolBlock.getFrame().addSymbol(symbol);
  18.338 -                symbol.setNeedsSlot(true);
  18.339 -            }
  18.340 -        } else if (symbol.less(flags)) {
  18.341 -            symbol.setFlags(flags);
  18.342 -        }
  18.343 -
  18.344 -        if (node != null) {
  18.345 -            node.setSymbol(symbol);
  18.346 -        }
  18.347 -
  18.348 -        return symbol;
  18.349 -    }
  18.350 -
  18.351 -    /**
  18.352 -     * Declare the use of a symbol.
  18.353 -     *
  18.354 -     * @param name Name of symbol.
  18.355 -     * @param node Using node
  18.356 -     *
  18.357 -     * @return Symbol for given name.
  18.358 -     */
  18.359 -    public Symbol useSymbol(final String name, final Node node) {
  18.360 -        Symbol symbol = findSymbol(name);
  18.361 -
  18.362 -        if (symbol == null) {
  18.363 -            // If not found, declare as a free var.
  18.364 -            symbol = defineSymbol(name, IS_GLOBAL, node);
  18.365 -        } else {
  18.366 -            node.setSymbol(symbol);
  18.367 -        }
  18.368 -
  18.369 -        return symbol;
  18.370 -    }
  18.371 -
  18.372 -    /**
  18.373 -     * Add parent name to the builder.
  18.374 -     *
  18.375 -     * @param sb String bulder.
  18.376 -     */
  18.377 -    public void addParentName(final StringBuilder sb) {
  18.378 -        if (parent != null) {
  18.379 -            parent.addParentName(sb);
  18.380 -        }
  18.381 -    }
  18.382 -
  18.383      @Override
  18.384      public void toString(final StringBuilder sb) {
  18.385          for (final Node statement : statements) {
  18.386 @@ -512,16 +246,6 @@
  18.387      }
  18.388  
  18.389      /**
  18.390 -     * Get the FunctionNode for this block, i.e. the function it
  18.391 -     * belongs to
  18.392 -     *
  18.393 -     * @return the function node
  18.394 -     */
  18.395 -    public FunctionNode getFunction() {
  18.396 -        return function;
  18.397 -    }
  18.398 -
  18.399 -    /**
  18.400       * Reset the frame for this block
  18.401       *
  18.402       * @param frame  the new frame
  18.403 @@ -531,24 +255,6 @@
  18.404      }
  18.405  
  18.406      /**
  18.407 -     * Get the parent block
  18.408 -     *
  18.409 -     * @return parent block, or null if none exists
  18.410 -     */
  18.411 -    public Block getParent() {
  18.412 -        return parent;
  18.413 -    }
  18.414 -
  18.415 -    /**
  18.416 -     * Set the parent block
  18.417 -     *
  18.418 -     * @param parent the new parent block
  18.419 -     */
  18.420 -    public void setParent(final Block parent) {
  18.421 -        this.parent = parent;
  18.422 -    }
  18.423 -
  18.424 -    /**
  18.425       * Get the list of statements in this block
  18.426       *
  18.427       * @return a list of statements
  18.428 @@ -558,6 +264,15 @@
  18.429      }
  18.430  
  18.431      /**
  18.432 +     * Applies the specified visitor to all statements in the block.
  18.433 +     * @param visitor the visitor.
  18.434 +     */
  18.435 +    public void visitStatements(NodeVisitor visitor) {
  18.436 +        for (ListIterator<Node> stmts = statements.listIterator(); stmts.hasNext();) {
  18.437 +            stmts.set(stmts.next().accept(visitor));
  18.438 +        }
  18.439 +    }
  18.440 +    /**
  18.441       * Reset the statement list for this block
  18.442       *
  18.443       * @param statements  new statement list
  18.444 @@ -592,4 +307,29 @@
  18.445          needsScope = true;
  18.446      }
  18.447  
  18.448 +    /**
  18.449 +     * Marks this block as using a specified scoped symbol. The block and its parent blocks up to but not
  18.450 +     * including the block defining the symbol will be marked as needing parent scope. The block defining the symbol
  18.451 +     * will be marked as one that needs to have its own scope.
  18.452 +     * @param symbol the symbol being used.
  18.453 +     * @param ancestors the iterator over block's containing lexical context
  18.454 +     */
  18.455 +    public void setUsesScopeSymbol(final Symbol symbol, Iterator<Block> ancestors) {
  18.456 +        if(symbol.getBlock() == this) {
  18.457 +            setNeedsScope();
  18.458 +        } else {
  18.459 +            setUsesParentScopeSymbol(symbol, ancestors);
  18.460 +        }
  18.461 +    }
  18.462 +
  18.463 +    /**
  18.464 +     * Invoked when this block uses a scope symbol defined in one of its ancestors.
  18.465 +     * @param symbol the scope symbol being used
  18.466 +     * @param ancestors iterator over ancestor blocks
  18.467 +     */
  18.468 +    void setUsesParentScopeSymbol(final Symbol symbol, Iterator<Block> ancestors) {
  18.469 +        if(ancestors.hasNext()) {
  18.470 +            ancestors.next().setUsesScopeSymbol(symbol, ancestors);
  18.471 +        }
  18.472 +    }
  18.473  }