diff --git a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/AssignSymbols.java b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/AssignSymbols.java index 3bb44b5aa13..7d37330dd88 100644 --- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/AssignSymbols.java +++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/AssignSymbols.java @@ -796,7 +796,7 @@ final class AssignSymbols extends SimpleNodeVisitor implements Loggable { args.add(strictFlagNode); } else { - return LiteralNode.newInstance(unaryNode, true); + throw new AssertionError("Unexpected delete with " + rhs.getClass().getName() + " expression"); } return new RuntimeNode(unaryNode, request, args); } diff --git a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java index 634b537f199..4c50be22a14 100644 --- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java +++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java @@ -228,6 +228,16 @@ final class Lower extends NodeOperatorVisitor implements Lo return super.leaveIndexNode(indexNode); } + @Override + public Node leaveDELETE(final UnaryNode delete) { + final Expression expression = delete.getExpression(); + if (expression instanceof IdentNode || expression instanceof BaseNode) { + return delete; + } + return new BinaryNode(Token.recast(delete.getToken(), TokenType.COMMARIGHT), expression, + LiteralNode.newInstance(delete.getToken(), delete.getFinish(), true)); + } + // If expression is a primitive literal that is not an array index and does return its string value. Else return null. private static String getConstantPropertyName(final Expression expression) { if (expression instanceof LiteralNode.PrimitiveLiteralNode) { diff --git a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Parser.java b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Parser.java index 56cf55a9a9e..51dcdf968be 100644 --- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Parser.java +++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Parser.java @@ -4404,15 +4404,6 @@ public class Parser extends AbstractParser implements Loggable { final long unaryToken = token; switch (type) { - case DELETE: { - next(); - final Expression expr = unaryExpression(); - if (expr instanceof BaseNode || expr instanceof IdentNode) { - return new UnaryNode(unaryToken, expr); - } - appendStatement(new ExpressionStatement(unaryLine, unaryToken, finish, expr)); - return LiteralNode.newInstance(unaryToken, finish, true); - } case ADD: case SUB: { final TokenType opType = type; @@ -4420,6 +4411,7 @@ public class Parser extends AbstractParser implements Loggable { final Expression expr = unaryExpression(); return new UnaryNode(Token.recast(unaryToken, (opType == TokenType.ADD) ? TokenType.POS : TokenType.NEG), expr); } + case DELETE: case VOID: case TYPEOF: case BIT_NOT: diff --git a/test/nashorn/src/jdk/nashorn/api/tree/test/JDK_8193296_Test.java b/test/nashorn/src/jdk/nashorn/api/tree/test/JDK_8193296_Test.java new file mode 100644 index 00000000000..e5abab87af4 --- /dev/null +++ b/test/nashorn/src/jdk/nashorn/api/tree/test/JDK_8193296_Test.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package jdk.nashorn.api.tree.test; + +import jdk.nashorn.api.tree.CompilationUnitTree; +import jdk.nashorn.api.tree.ExpressionStatementTree; +import jdk.nashorn.api.tree.FunctionCallTree; +import jdk.nashorn.api.tree.Parser; +import jdk.nashorn.api.tree.Tree; +import jdk.nashorn.api.tree.UnaryTree; +import org.testng.Assert; +import org.testng.annotations.Test; + +/** + * @test + * @bug 8184723 + * @summary Parser should not eagerly transform delete expressions + * @run testng jdk.nashorn.api.tree.test.JDK_8193296_Test + */ +public class JDK_8193296_Test { + @Test + public void test() { + Parser p = Parser.create(); + CompilationUnitTree t = p.parse("test", "function x() { }; delete x();", System.out::println); + Assert.assertEquals(t.getSourceElements().size(), 2); + Tree delt = ((ExpressionStatementTree)t.getSourceElements().get(1)).getExpression(); + Assert.assertTrue(delt instanceof UnaryTree, delt.getClass().getName()); + UnaryTree del = (UnaryTree)delt; + Assert.assertEquals(del.getKind(), Tree.Kind.DELETE); + Assert.assertTrue(del.getExpression() instanceof FunctionCallTree, del.getExpression().getClass().getName()); + } +}