jdk-sandbox: comparison nashorn/src/jdk/nashorn/internal/codegen/Lower.java

equal deleted inserted replaced

-:cb4a7c901e0d
+:703643aeb0d6
 import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import jdk.nashorn.internal.ir.BaseNode;
 import jdk.nashorn.internal.ir.BinaryNode;
 import jdk.nashorn.internal.ir.Block;
 import jdk.nashorn.internal.ir.BlockLexicalContext;
 import jdk.nashorn.internal.ir.BreakNode;
 import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
 import jdk.nashorn.internal.ir.IdentNode;
 import jdk.nashorn.internal.ir.IfNode;
 import jdk.nashorn.internal.ir.LabelNode;
 import jdk.nashorn.internal.ir.LexicalContext;
-import jdk.nashorn.internal.ir.LineNumberNode;
 import jdk.nashorn.internal.ir.LiteralNode;
 import jdk.nashorn.internal.ir.LoopNode;
 import jdk.nashorn.internal.ir.Node;
 import jdk.nashorn.internal.ir.ReturnNode;
+import jdk.nashorn.internal.ir.Statement;
 import jdk.nashorn.internal.ir.SwitchNode;
 import jdk.nashorn.internal.ir.Symbol;
 import jdk.nashorn.internal.ir.ThrowNode;
 import jdk.nashorn.internal.ir.TryNode;
-import jdk.nashorn.internal.ir.UnaryNode;
 import jdk.nashorn.internal.ir.VarNode;
 import jdk.nashorn.internal.ir.WhileNode;
 import jdk.nashorn.internal.ir.WithNode;
 import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
 */
 Lower() {
 super(new BlockLexicalContext() {
 @Override
-public List<Node> popStatements() {
+public List<Statement> popStatements() {
-List<Node> newStatements = new ArrayList<>();
+final List<Statement> newStatements = new ArrayList<>();
 boolean terminated = false;
-final List<Node> statements = super.popStatements();
+final List<Statement> statements = super.popStatements();
-for (final Node statement : statements) {
+for (final Statement statement : statements) {
 if (!terminated) {
 newStatements.add(statement);
-if (statement.isTerminal()) {
+if (statement.isTerminal() || statement instanceof BreakNode || statement instanceof ContinueNode) { //TODO hasGoto? But some Loops are hasGoto too - why?
 terminated = true;
 }
 } else {
-if (statement instanceof VarNode) {
+statement.accept(new NodeVisitor() {
-newStatements.add(((VarNode)statement).setInit(null));
+@Override
-}
+public boolean enterVarNode(final VarNode varNode) {
+newStatements.add(varNode.setInit(null));
+return false;
+}
+});
 }
 }
 return newStatements;
 }
 });
 @Override
 public boolean enterBlock(final Block block) {
 final LexicalContext lc = getLexicalContext();
 final FunctionNode   function = lc.getCurrentFunction();
 if (lc.isFunctionBody() && function.isProgram() && !function.hasDeclaredFunctions()) {
-new ExecuteNode(block.getToken(), block.getFinish(), LiteralNode.newInstance(block, ScriptRuntime.UNDEFINED)).accept(this);
+new ExecuteNode(block.getLineNumber(), block.getToken(), block.getFinish(), LiteralNode.newInstance(block, ScriptRuntime.UNDEFINED)).accept(this);
 }
 return true;
 }
 @Override
 //now we have committed the entire statement list to the block, but we need to truncate
 //whatever is after the last terminal. block append won't append past it
 final BlockLexicalContext lc = (BlockLexicalContext)getLexicalContext();
-Node last = lc.getLastStatement();
+Statement last = lc.getLastStatement();
 if (lc.isFunctionBody()) {
 final FunctionNode currentFunction = getLexicalContext().getCurrentFunction();
 final boolean isProgram = currentFunction.isProgram();
 final ReturnNode returnNode = new ReturnNode(
+last == null ? block.getLineNumber() : last.getLineNumber(), //TODO?
 currentFunction.getToken(),
 currentFunction.getFinish(),
 isProgram ?
 compilerConstant(RETURN) :
 LiteralNode.newInstance(block, ScriptRuntime.UNDEFINED));
-last = returnNode.accept(this);
+last = (Statement)returnNode.accept(this);
 }
 if (last != null && last.isTerminal()) {
 return block.setIsTerminal(lc, true);
 }
 public Node leaveLabelNode(final LabelNode labelNode) {
 return addStatement(labelNode);
 }
 @Override
-public boolean enterLineNumberNode(final LineNumberNode lineNumberNode) {
-addStatement(lineNumberNode); // don't put it in lastStatement cache
-return false;
-}
-@Override
 public Node leaveReturnNode(final ReturnNode returnNode) {
 addStatement(returnNode); //ReturnNodes are always terminal, marked as such in constructor
 return returnNode;
 }
 return labelledNode.ensureUniqueLabels(getLexicalContext());
 }
 });
 }
-private static List<Node> copyFinally(final Block finallyBody) {
+private static List<Statement> copyFinally(final Block finallyBody) {
-final List<Node> newStatements = new ArrayList<>();
+final List<Statement> newStatements = new ArrayList<>();
-for (final Node statement : finallyBody.getStatements()) {
+for (final Statement statement : finallyBody.getStatements()) {
-newStatements.add(ensureUniqueLabelsIn(statement));
+newStatements.add((Statement)ensureUniqueLabelsIn(statement));
 if (statement.hasTerminalFlags()) {
 return newStatements;
 }
 }
 return newStatements;
 }
 private Block catchAllBlock(final TryNode tryNode) {
-final long   token  = tryNode.getToken();
+final int  lineNumber = tryNode.getLineNumber();
-final int    finish = tryNode.getFinish();
+final long token      = tryNode.getToken();
+final int  finish     = tryNode.getFinish();
 final IdentNode exception = new IdentNode(token, finish, getLexicalContext().getCurrentFunction().uniqueName("catch_all"));
-final Block catchBody = new Block(token, finish, new ThrowNode(token, finish, new IdentNode(exception))).
+final Block catchBody = new Block(lineNumber, token, finish, new ThrowNode(lineNumber, token, finish, new IdentNode(exception))).
 setIsTerminal(getLexicalContext(), true); //ends with throw, so terminal
-final CatchNode catchAllNode  = new CatchNode(token, finish, new IdentNode(exception), null, catchBody);
+final CatchNode catchAllNode  = new CatchNode(lineNumber, token, finish, new IdentNode(exception), null, catchBody);
-final Block     catchAllBlock = new Block(token, finish, catchAllNode);
+final Block     catchAllBlock = new Block(lineNumber, token, finish, catchAllNode);
 //catchallblock -> catchallnode (catchnode) -> exception -> throw
 return (Block)catchAllBlock.accept(this); //not accepted. has to be accepted by lower
 }
 private IdentNode compilerConstant(final CompilerConstants cc) {
 final FunctionNode functionNode = getLexicalContext().getCurrentFunction();
 return new IdentNode(functionNode.getToken(), functionNode.getFinish(), cc.symbolName());
 }
-private static boolean isTerminal(final List<Node> statements) {
+private static boolean isTerminal(final List<Statement> statements) {
 return !statements.isEmpty() && statements.get(statements.size() - 1).hasTerminalFlags();
 }
 /**
 * Splice finally code into all endpoints of a trynode
 * @param list of rethrowing throw nodes from synthetic catch blocks
 * @param finallyBody the code in the original finally block
 * @return new try node after splicing finally code (same if nop)
 */
 private Node spliceFinally(final TryNode tryNode, final List<ThrowNode> rethrows, final Block finallyBody) {
-final int    finish = tryNode.getFinish();
+final int finish = tryNode.getFinish();
 assert tryNode.getFinallyBody() == null;
 final TryNode newTryNode = (TryNode)tryNode.accept(new NodeVisitor() {
 final List<Node> insideTry = new ArrayList<>();
 }
 @Override
 public Node leaveThrowNode(final ThrowNode throwNode) {
 if (rethrows.contains(throwNode)) {
-final List<Node> newStatements = copyFinally(finallyBody);
+final List<Statement> newStatements = copyFinally(finallyBody);
 if (!isTerminal(newStatements)) {
 newStatements.add(throwNode);
 }
-return new Block(throwNode.getToken(), throwNode.getFinish(), newStatements);
+return new Block(throwNode.getLineNumber(), throwNode.getToken(), throwNode.getFinish(), newStatements);
 }
 return throwNode;
 }
 @Override
 }
 @Override
 public Node leaveReturnNode(final ReturnNode returnNode) {
 final Node  expr  = returnNode.getExpression();
-final List<Node> newStatements = new ArrayList<>();
+final List<Statement> newStatements = new ArrayList<>();
 final Node resultNode;
 if (expr != null) {
 //we need to evaluate the result of the return in case it is complex while
 //still in the try block, store it in a result value and return it afterwards
 resultNode = new IdentNode(Lower.this.compilerConstant(RETURN));
-newStatements.add(new ExecuteNode(new BinaryNode(Token.recast(returnNode.getToken(), TokenType.ASSIGN), resultNode, expr)));
+newStatements.add(new ExecuteNode(returnNode.getLineNumber(), returnNode.getToken(), returnNode.getFinish(), new BinaryNode(Token.recast(returnNode.getToken(), TokenType.ASSIGN), resultNode, expr)));
 } else {
 resultNode = null;
 }
 newStatements.addAll(copyFinally(finallyBody));
 if (!isTerminal(newStatements)) {
 newStatements.add(expr == null ? returnNode : returnNode.setExpression(resultNode));
 }
-return new ExecuteNode(new Block(returnNode.getToken(), getLexicalContext().getCurrentBlock().getFinish(), newStatements));
+return new ExecuteNode(returnNode.getLineNumber(), returnNode.getToken(), returnNode.getFinish(), new Block(returnNode.getLineNumber(), returnNode.getToken(), getLexicalContext().getCurrentBlock().getFinish(), newStatements));
 }
-private Node copy(final Node endpoint, final Node targetNode) {
+private Node copy(final Statement endpoint, final Node targetNode) {
 if (!insideTry.contains(targetNode)) {
-final List<Node> newStatements = copyFinally(finallyBody);
+final List<Statement> newStatements = copyFinally(finallyBody);
 if (!isTerminal(newStatements)) {
 newStatements.add(endpoint);
 }
-return new ExecuteNode(new Block(endpoint.getToken(), finish, newStatements));
+return new ExecuteNode(endpoint.getLineNumber(), endpoint.getToken(), endpoint.getFinish(), new Block(endpoint.getLineNumber(), endpoint.getToken(), finish, newStatements));
 }
 return endpoint;
 }
 });
 addStatement(newTryNode);
 for (final Node statement : finallyBody.getStatements()) {
-addStatement(statement);
+addStatement((Statement)statement);
 }
 return newTryNode;
 }
 assert rethrows.size() == 1;
 if (tryNode.getCatchBlocks().isEmpty()) {
 newTryNode = tryNode.setFinallyBody(null);
 } else {
-Block outerBody = new Block(tryNode.getToken(), tryNode.getFinish(), new ArrayList<Node>(Arrays.asList(tryNode.setFinallyBody(null))));
+Block outerBody = new Block(tryNode.getLineNumber(), tryNode.getToken(), tryNode.getFinish(), new ArrayList<Statement>(Arrays.asList(tryNode.setFinallyBody(null))));
 newTryNode = tryNode.setBody(outerBody).setCatchBlocks(null);
 }
 newTryNode = newTryNode.setCatchBlocks(Arrays.asList(catchAll)).setFinallyBody(null);
 @Override
 public Node leaveVarNode(final VarNode varNode) {
 addStatement(varNode);
 if (varNode.getFlag(VarNode.IS_LAST_FUNCTION_DECLARATION) && getLexicalContext().getCurrentFunction().isProgram()) {
-new ExecuteNode(varNode.getToken(), varNode.getFinish(), new IdentNode(varNode.getName())).accept(this);
+new ExecuteNode(varNode.getLineNumber(), varNode.getToken(), varNode.getFinish(), new IdentNode(varNode.getName())).accept(this);
 }
 return varNode;
 }
 @Override
 final Node test  = whileNode.getTest();
 final Block body = whileNode.getBody();
 if (conservativeAlwaysTrue(test)) {
 //turn it into a for node without a test.
-final ForNode forNode = (ForNode)new ForNode(whileNode.getToken(), whileNode.getFinish(), null, null, body, null, ForNode.IS_FOR).accept(this);
+final ForNode forNode = (ForNode)new ForNode(whileNode.getLineNumber(), whileNode.getToken(), whileNode.getFinish(), null, null, body, null, ForNode.IS_FOR).accept(this);
 getLexicalContext().replace(whileNode, forNode);
 return forNode;
 }
 return addStatement(checkEscape(whileNode));
 }
 @Override
 public Node leaveWithNode(final WithNode withNode) {
 return addStatement(withNode);
-}
-@Override
-public Node leaveDELETE(final UnaryNode unaryNode) {
-final Node rhs = unaryNode.rhs();
-if (rhs instanceof IdentNode || rhs instanceof BaseNode) {
-return unaryNode;
-}
-addStatement(new ExecuteNode(rhs));
-return LiteralNode.newInstance(unaryNode, true);
 }
 /**
 * Given a function node that is a callee in a CallNode, replace it with
 * the appropriate marker function. This is used by {@link CodeGenerator}
 }
 return loopNode;
 }
-private Node addStatement(final Node statement) {
+private Node addStatement(final Statement statement) {
 ((BlockLexicalContext)getLexicalContext()).appendStatement(statement);
 return statement;
 }
 /**

changeset 17524	703643aeb0d6
parent 17523	cb4a7c901e0d
child 17745	86e5a15b3b20