jdk8-mips64-public/nashorn: comparison src/jdk/nashorn/internal/codegen/FinalizeTypes.java

-:8af550dee961
+:6fc7b51e83d6
 import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import jdk.nashorn.internal.codegen.types.Type;
 import jdk.nashorn.internal.ir.AccessNode;
 import jdk.nashorn.internal.ir.Assignment;
 import jdk.nashorn.internal.ir.BinaryNode;
 import jdk.nashorn.internal.ir.Block;
 * For any op that we process in FinalizeTypes it is an absolute guarantee
 * that scope and slot information is correct. This enables e.g. AccessSpecialization
 * and frame optimizations
 */
-final class FinalizeTypes extends NodeOperatorVisitor {
+final class FinalizeTypes extends NodeOperatorVisitor<LexicalContext> {
 private static final DebugLogger LOG = new DebugLogger("finalize");
 private final TemporarySymbols temporarySymbols;
 FinalizeTypes(final TemporarySymbols temporarySymbols) {
+super(new LexicalContext());
 this.temporarySymbols = temporarySymbols;
 }
 @Override
 public Node leaveCallNode(final CallNode callNode) {
 return leaveASSIGN(binaryNode);
 }
 private boolean symbolIsInteger(Node node) {
 final Symbol symbol = node.getSymbol();
-assert symbol != null && symbol.getSymbolType().isInteger() : "int coercion expected: " + Debug.id(symbol) + " " + symbol + " " + getLexicalContext().getCurrentFunction().getSource();
+assert symbol != null && symbol.getSymbolType().isInteger() : "int coercion expected: " + Debug.id(symbol) + " " + symbol + " " + lc.getCurrentFunction().getSource();
 return true;
 }
 @Override
 public Node leaveBIT_AND(final BinaryNode binaryNode) {
 public Node leaveForNode(final ForNode forNode) {
 final Node init   = forNode.getInit();
 final Node test   = forNode.getTest();
 final Node modify = forNode.getModify();
-final LexicalContext lc = getLexicalContext();
 if (forNode.isForIn()) {
 return forNode.setModify(lc, convert(forNode.getModify(), Type.OBJECT)); // NASHORN-400
 }
-assert test != null || forNode.hasGoto() : "forNode " + forNode + " needs goto and is missing it in " + getLexicalContext().getCurrentFunction();
+assert test != null || forNode.hasGoto() : "forNode " + forNode + " needs goto and is missing it in " + lc.getCurrentFunction();
 return forNode.
 setInit(lc, init == null ? null : discard(init)).
 setTest(lc, test == null ? null : convert(test, Type.BOOLEAN)).
 setModify(lc, modify == null ? null : discard(modify));
 return true;
 }
 @Override
 public Node leaveFunctionNode(final FunctionNode functionNode) {
-return functionNode.setState(getLexicalContext(), CompilationState.FINALIZED);
+return functionNode.setState(lc, CompilationState.FINALIZED);
 }
 @Override
 public Node leaveIfNode(final IfNode ifNode) {
 return ifNode.setTest(convert(ifNode.getTest(), Type.BOOLEAN));
 @Override
 public Node leaveReturnNode(final ReturnNode returnNode) {
 final Node expr = returnNode.getExpression();
 if (expr != null) {
-return returnNode.setExpression(convert(expr, getLexicalContext().getCurrentFunction().getReturnType()));
+return returnNode.setExpression(convert(expr, lc.getCurrentFunction().getReturnType()));
 }
 return returnNode;
 }
 @Override
 final Node test = caseNode.getTest();
 newCases.add(test != null ? caseNode.setTest(convert(test, Type.OBJECT)) : caseNode);
 }
 return switchNode.
-setExpression(getLexicalContext(), convert(expression, Type.OBJECT)).
+setExpression(lc, convert(expression, Type.OBJECT)).
-setCases(getLexicalContext(), newCases);
+setCases(lc, newCases);
 }
 @Override
 public Node leaveTernaryNode(final TernaryNode ternaryNode) {
 return ternaryNode.setLHS(convert(ternaryNode.lhs(), Type.BOOLEAN));
 @Override
 public Node leaveWhileNode(final WhileNode whileNode) {
 final Node test = whileNode.getTest();
 if (test != null) {
-return whileNode.setTest(getLexicalContext(), convert(test, Type.BOOLEAN));
+return whileNode.setTest(lc, convert(test, Type.BOOLEAN));
 }
 return whileNode;
 }
 @Override
 public Node leaveWithNode(final WithNode withNode) {
-return withNode.setExpression(getLexicalContext(), convert(withNode.getExpression(), Type.OBJECT));
+return withNode.setExpression(lc, convert(withNode.getExpression(), Type.OBJECT));
 }
 private static void updateSymbolsLog(final FunctionNode functionNode, final Symbol symbol, final boolean loseSlot) {
 if (LOG.isEnabled()) {
 if (!symbol.isScope()) {
 private void updateSymbols(final Block block) {
 if (!block.needsScope()) {
 return; // nothing to do
 }
-final LexicalContext lc             = getLexicalContext();
 final FunctionNode   functionNode   = lc.getFunction(block);
 final boolean        allVarsInScope = functionNode.allVarsInScope();
 final boolean        isVarArg       = functionNode.isVarArg();
 for (final Symbol symbol : block.getSymbols()) {
 * @param to   which primitive type to use for tagging
 */
 private static void setCanBePrimitive(final Node node, final Type to) {
 final HashSet<Node> exclude = new HashSet<>();
-node.accept(new NodeVisitor() {
+node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
 private void setCanBePrimitive(final Symbol symbol) {
 LOG.info("*** can be primitive symbol ", symbol, " ", Debug.id(symbol));
 symbol.setCanBePrimitive(to);
 }
 if (!to.isObject() && from.isObject()) {
 setCanBePrimitive(node, to);
 }
 }
 LOG.info("Type override for lhs in '", node, "' => ", to);
-return ((TypeOverride<T>)node).setType(temporarySymbols, getLexicalContext(), to);
+return ((TypeOverride<T>)node).setType(temporarySymbols, lc, to);
 }
 /**
 * Add an explicit conversion. This is needed when attribution has created types
 * that do not mesh into an op type, e.g. a = b, where b is object and a is double
 * @return     conversion node
 */
 private Node convert(final Node node, final Type to) {
 assert !to.isUnknown() : "unknown type for " + node + " class=" + node.getClass();
 assert node != null : "node is null";
-assert node.getSymbol() != null : "node " + node + " " + node.getClass() + " has no symbol! " + getLexicalContext().getCurrentFunction();
+assert node.getSymbol() != null : "node " + node + " " + node.getClass() + " has no symbol! " + lc.getCurrentFunction();
-assert node.tokenType() != TokenType.CONVERT : "assert convert in convert " + node + " in " + getLexicalContext().getCurrentFunction();
+assert node.tokenType() != TokenType.CONVERT : "assert convert in convert " + node + " in " + lc.getCurrentFunction();
 final Type from = node.getType();
 if (Type.areEquivalent(from, to)) {
 return node;
 LOG.info("CONVERT('", node, "', ", to, ") => '", resultNode, "'");
 assert !node.isTerminal();
-final LexicalContext lc = getLexicalContext();
 //This is the only place in this file that can create new temporaries
 //FinalizeTypes may not introduce ANY node that is not a conversion.
 return temporarySymbols.ensureSymbol(lc, to, resultNode);
 }
 Symbol symbol = node.getSymbol();
 if (symbol.isTemp() && symbol.getSymbolType() != to) {
 symbol = symbol.setTypeOverrideShared(to, temporarySymbols);
 LOG.info("Type override for temporary in '", node, "' => ", to);
 }
-return node.setSymbol(getLexicalContext(), symbol);
+return node.setSymbol(lc, symbol);
 }
 /**
 * Determine if the outcome of + operator is a string.
 *
 literalNode = LiteralNode.newInstance(token, finish, JSType.toNumber(value));
 }
 if (literalNode != null) {
 //inherit literal symbol for attr.
-literalNode = (LiteralNode<?>)literalNode.setSymbol(getLexicalContext(), parent.getSymbol());
+literalNode = (LiteralNode<?>)literalNode.setSymbol(lc, parent.getSymbol());
 }
 return literalNode;
 }
 }

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

comparison: src/jdk/nashorn/internal/codegen/FinalizeTypes.java

src/jdk/nashorn/internal/codegen/FinalizeTypes.java