jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/ir/Node.java

-:755404d7d189
+:59970b70ebb5
 */
 package jdk.nashorn.internal.ir;
 import java.util.IdentityHashMap;
-import java.util.List;
 import jdk.nashorn.internal.codegen.types.Type;
 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
 import jdk.nashorn.internal.parser.Token;
 import jdk.nashorn.internal.runtime.Source;
 * Nodes are used to compose Abstract Syntax Trees.
 *
 */
 public abstract class Node extends Location {
 /** Node symbol. */
-private Symbol nodeSymbol;
+private Symbol symbol;
 /** Start of source range. */
 protected int start;
 /** End of source range. */
 * @param finish finish
 */
 public Node(final Source source, final long token, final int finish) {
 super(source, token);
-start  = Token.descPosition(token);
+this.start  = Token.descPosition(token);
 this.finish = finish;
 }
 /**
 * Copy constructor
 * @param node source node
 */
 protected Node(final Node node) {
 super(node);
-this.nodeSymbol    = node.nodeSymbol;
+this.symbol        = node.symbol;
 this.isResolved    = node.isResolved;
 this.isTerminal    = node.isTerminal;
 this.hasGoto       = node.hasGoto;
 this.shouldDiscard = node.shouldDiscard;
 this.start         = node.start;
 * are stored in the node itself, unless it implements TypeOverride
 *
 * @return the type of the node.
 */
 public Type getType() {
-assert hasType();
+assert hasType() : this + " has no type";
-return nodeSymbol.getSymbolType();
+return symbol.getSymbolType();
 }
 /**
 * Is this an atom node - for example a literal or an identity
 *
 * is the place where it's expression value is stored after evaluation
 *
 * @return the symbol
 */
 public Symbol getSymbol() {
-return nodeSymbol;
+return symbol;
 }
 /**
 * Assign a symbol to this node. See {@link Node#getSymbol()} for explanation
 * of what a symbol is
 *
 * @param symbol the symbol
 */
 public void setSymbol(final Symbol symbol) {
-nodeSymbol = symbol;
+this.symbol = symbol;
 }
 /**
 * Is this a terminal Node, i.e. does it end control flow like a throw or return
 * expression does?
 */
 public void setIsTerminal(final boolean isTerminal) {
 this.isTerminal = isTerminal;
 }
-/**
-* Return last node in a statement list.
-*
-* @param statements Statement list.
-*
-* @return Last (non-debug) statement or null if empty block.
-*/
-public static Node lastStatement(final List<Node> statements) {
-for (int lastIndex = statements.size() - 1; lastIndex >= 0; lastIndex--) {
-final Node node = statements.get(lastIndex);
-if (!node.isDebug()) {
-return node;
-}
-}
-return null;
-}
 }

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

comparison: src/jdk/nashorn/internal/ir/Node.java

src/jdk/nashorn/internal/ir/Node.java