src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java

@@ -43,10 +43,11 @@
 import jdk.nashorn.internal.ir.BlockStatement;
 import jdk.nashorn.internal.ir.BreakNode;
 import jdk.nashorn.internal.ir.CallNode;
 import jdk.nashorn.internal.ir.CaseNode;
 import jdk.nashorn.internal.ir.CatchNode;
+import jdk.nashorn.internal.ir.DebuggerNode;
 import jdk.nashorn.internal.ir.ContinueNode;
 import jdk.nashorn.internal.ir.EmptyNode;
 import jdk.nashorn.internal.ir.Expression;
 import jdk.nashorn.internal.ir.ExpressionStatement;
 import jdk.nashorn.internal.ir.ForNode;

@@ -183,10 +184,19 @@
         addStatement(continueNode);
         return false;
     }
 
     @Override
+    public boolean enterDebuggerNode(final DebuggerNode debuggerNode) {
+        final int line = debuggerNode.getLineNumber();
+        final long token = debuggerNode.getToken();
+        final int finish = debuggerNode.getFinish();
+        addStatement(new ExpressionStatement(line, token, finish, new RuntimeNode(token, finish, RuntimeNode.Request.DEBUGGER, new ArrayList<Expression>())));
+        return false;
+    }
+
+    @Override
     public boolean enterJumpToInlinedFinally(final JumpToInlinedFinally jumpToInlinedFinally) {
         addStatement(jumpToInlinedFinally);
         return false;
     }
 

@@ -444,11 +454,11 @@
                     final int retLineNumber = returnNode.getLineNumber();
                     final long retToken = returnNode.getToken();
                     // Expression is evaluated for side effects.
                     newStatements.add(new ExpressionStatement(retLineNumber, retToken, returnNode.getFinish(), expr));
                     newStatements.add(createJumpToInlinedFinally(fn, inlinedFinallies, ensureUniqueNamesIn(finallyBlock)));
-                    return new BlockStatement(retLineNumber, new Block(retToken, finallyBlock.getFinish(), newStatements));
+                    return new BlockStatement(retLineNumber, new Block(retToken, finallyBlock.getFinish(), newStatements), true);
                 } else if (expr == null || expr instanceof PrimitiveLiteralNode<?> || (expr instanceof IdentNode && RETURN.symbolName().equals(((IdentNode)expr).getName()))) {
                     // Nonterminal finally; no return expression, or returns a primitive literal, or returns :return.
                     // Just move the return expression into the finally block.
                     return createJumpToInlinedFinally(fn, inlinedFinallies, prependFinally(finallyBlock, returnNode));
                 } else {

@@ -461,11 +471,11 @@
                     final Expression resultNode = new IdentNode(expr.getToken(), expr.getFinish(), RETURN.symbolName());
                     // ":return = <expr>;"
                     newStatements.add(new ExpressionStatement(retLineNumber, retToken, retFinish, new BinaryNode(Token.recast(returnNode.getToken(), TokenType.ASSIGN), resultNode, expr)));
                     // inline finally and end it with "return :return;"
                     newStatements.add(createJumpToInlinedFinally(fn, inlinedFinallies, prependFinally(finallyBlock, returnNode.setExpression(resultNode))));
-                    return new BlockStatement(retLineNumber, new Block(retToken, retFinish, newStatements));
+                    return new BlockStatement(retLineNumber, new Block(retToken, retFinish, newStatements), true);
                 }
             }
         });
         addStatement(inlinedFinallies.isEmpty() ? newTryNode : newTryNode.setInlinedFinallies(lc, inlinedFinallies));
         // TODO: if finallyStatement is terminal, we could just have sites of inlined finallies jump here.