1 /*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.nashorn.internal.codegen;
27
28 import static jdk.nashorn.internal.codegen.CompilerConstants.EVAL;
29 import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;
30 import static jdk.nashorn.internal.ir.Expression.isAlwaysTrue;
31
32 import java.util.ArrayList;
33 import java.util.Arrays;
34 import java.util.Collections;
35 import java.util.List;
36 import java.util.ListIterator;
37 import jdk.nashorn.internal.ir.BaseNode;
38 import jdk.nashorn.internal.ir.BinaryNode;
39 import jdk.nashorn.internal.ir.Block;
40 import jdk.nashorn.internal.ir.BlockLexicalContext;
41 import jdk.nashorn.internal.ir.BlockStatement;
42 import jdk.nashorn.internal.ir.BreakNode;
43 import jdk.nashorn.internal.ir.CallNode;
44 import jdk.nashorn.internal.ir.CaseNode;
45 import jdk.nashorn.internal.ir.CatchNode;
46 import jdk.nashorn.internal.ir.ContinueNode;
47 import jdk.nashorn.internal.ir.EmptyNode;
48 import jdk.nashorn.internal.ir.Expression;
49 import jdk.nashorn.internal.ir.ExpressionStatement;
50 import jdk.nashorn.internal.ir.ForNode;
51 import jdk.nashorn.internal.ir.FunctionNode;
52 import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
53 import jdk.nashorn.internal.ir.IdentNode;
54 import jdk.nashorn.internal.ir.IfNode;
55 import jdk.nashorn.internal.ir.JumpStatement;
56 import jdk.nashorn.internal.ir.LabelNode;
57 import jdk.nashorn.internal.ir.LexicalContext;
58 import jdk.nashorn.internal.ir.LiteralNode;
59 import jdk.nashorn.internal.ir.LoopNode;
60 import jdk.nashorn.internal.ir.Node;
61 import jdk.nashorn.internal.ir.ReturnNode;
62 import jdk.nashorn.internal.ir.RuntimeNode;
63 import jdk.nashorn.internal.ir.Statement;
64 import jdk.nashorn.internal.ir.SwitchNode;
65 import jdk.nashorn.internal.ir.Symbol;
66 import jdk.nashorn.internal.ir.ThrowNode;
67 import jdk.nashorn.internal.ir.TryNode;
68 import jdk.nashorn.internal.ir.VarNode;
69 import jdk.nashorn.internal.ir.WhileNode;
70 import jdk.nashorn.internal.ir.WithNode;
71 import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;
72 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
73 import jdk.nashorn.internal.parser.Token;
74 import jdk.nashorn.internal.parser.TokenType;
75 import jdk.nashorn.internal.runtime.Context;
76 import jdk.nashorn.internal.runtime.JSType;
77 import jdk.nashorn.internal.runtime.Source;
78 import jdk.nashorn.internal.runtime.logging.DebugLogger;
79 import jdk.nashorn.internal.runtime.logging.Loggable;
80 import jdk.nashorn.internal.runtime.logging.Logger;
81
82 /**
83 * Lower to more primitive operations. After lowering, an AST still has no symbols
84 * and types, but several nodes have been turned into more low level constructs
85 * and control flow termination criteria have been computed.
86 *
87 * We do things like code copying/inlining of finallies here, as it is much
88 * harder and context dependent to do any code copying after symbols have been
89 * finalized.
90 */
91 @Logger(name="lower")
92 final class Lower extends NodeOperatorVisitor<BlockLexicalContext> implements Loggable {
93
94 private final DebugLogger log;
95
96 /**
97 * Constructor.
98 */
99 Lower(final Compiler compiler) {
100 super(new BlockLexicalContext() {
101
102 @Override
103 public List<Statement> popStatements() {
104 final List<Statement> newStatements = new ArrayList<>();
105 boolean terminated = false;
106
107 final List<Statement> statements = super.popStatements();
108 for (final Statement statement : statements) {
109 if (!terminated) {
110 newStatements.add(statement);
111 if (statement.isTerminal() || statement instanceof BreakNode || statement instanceof ContinueNode) { //TODO hasGoto? But some Loops are hasGoto too - why?
112 terminated = true;
113 }
114 } else {
115 statement.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
116 @Override
117 public boolean enterVarNode(final VarNode varNode) {
118 newStatements.add(varNode.setInit(null));
119 return false;
120 }
121 });
122 }
123 }
124 return newStatements;
125 }
126
127 @Override
128 protected Block afterSetStatements(final Block block) {
129 final List<Statement> stmts = block.getStatements();
130 for(final ListIterator<Statement> li = stmts.listIterator(stmts.size()); li.hasPrevious();) {
131 final Statement stmt = li.previous();
132 // popStatements() guarantees that the only thing after a terminal statement are uninitialized
133 // VarNodes. We skip past those, and set the terminal state of the block to the value of the
134 // terminal state of the first statement that is not an uninitialized VarNode.
135 if(!(stmt instanceof VarNode && ((VarNode)stmt).getInit() == null)) {
136 return block.setIsTerminal(this, stmt.isTerminal());
137 }
138 }
139 return block.setIsTerminal(this, false);
140 }
141 });
142
143 this.log = initLogger(compiler.getContext());
144 }
145
146 @Override
147 public DebugLogger getLogger() {
148 return log;
149 }
150
151 @Override
152 public DebugLogger initLogger(final Context context) {
153 return context.getLogger(this.getClass());
154 }
155
156 @Override
157 public boolean enterBreakNode(final BreakNode breakNode) {
158 addStatement(breakNode);
159 return false;
160 }
161
162 @Override
163 public Node leaveCallNode(final CallNode callNode) {
164 return checkEval(callNode.setFunction(markerFunction(callNode.getFunction())));
165 }
166
167 @Override
168 public Node leaveCatchNode(final CatchNode catchNode) {
169 return addStatement(catchNode);
170 }
171
172 @Override
173 public boolean enterContinueNode(final ContinueNode continueNode) {
174 addStatement(continueNode);
175 return false;
176 }
177
178 @Override
179 public boolean enterEmptyNode(final EmptyNode emptyNode) {
180 return false;
181 }
182
183 @Override
184 public Node leaveExpressionStatement(final ExpressionStatement expressionStatement) {
185 final Expression expr = expressionStatement.getExpression();
186 ExpressionStatement node = expressionStatement;
187
188 final FunctionNode currentFunction = lc.getCurrentFunction();
189
190 if (currentFunction.isProgram()) {
191 if (!isInternalExpression(expr) && !isEvalResultAssignment(expr)) {
192 node = expressionStatement.setExpression(
193 new BinaryNode(
194 Token.recast(
195 expressionStatement.getToken(),
196 TokenType.ASSIGN),
197 compilerConstant(RETURN),
198 expr));
199 }
200 }
201
202 return addStatement(node);
203 }
204
205 @Override
206 public Node leaveBlockStatement(final BlockStatement blockStatement) {
207 return addStatement(blockStatement);
208 }
209
210 @Override
211 public Node leaveForNode(final ForNode forNode) {
212 ForNode newForNode = forNode;
213
214 final Expression test = forNode.getTest();
215 if (!forNode.isForIn() && isAlwaysTrue(test)) {
216 newForNode = forNode.setTest(lc, null);
217 }
218
219 newForNode = checkEscape(newForNode);
220 if(newForNode.isForIn()) {
221 // Wrap it in a block so its internally created iterator is restricted in scope
222 addStatementEnclosedInBlock(newForNode);
223 } else {
224 addStatement(newForNode);
225 }
226 return newForNode;
227 }
228
229 @Override
230 public Node leaveFunctionNode(final FunctionNode functionNode) {
231 log.info("END FunctionNode: ", functionNode.getName());
232 return functionNode.setState(lc, CompilationState.LOWERED);
233 }
234
235 @Override
236 public Node leaveIfNode(final IfNode ifNode) {
237 return addStatement(ifNode);
238 }
239
240 @Override
241 public Node leaveIN(final BinaryNode binaryNode) {
242 return new RuntimeNode(binaryNode);
243 }
244
245 @Override
246 public Node leaveINSTANCEOF(final BinaryNode binaryNode) {
247 return new RuntimeNode(binaryNode);
248 }
249
250 @Override
251 public Node leaveLabelNode(final LabelNode labelNode) {
252 return addStatement(labelNode);
253 }
254
255 @Override
256 public Node leaveReturnNode(final ReturnNode returnNode) {
257 addStatement(returnNode); //ReturnNodes are always terminal, marked as such in constructor
258 return returnNode;
259 }
260
261 @Override
262 public Node leaveCaseNode(final CaseNode caseNode) {
263 // Try to represent the case test as an integer
264 final Node test = caseNode.getTest();
265 if (test instanceof LiteralNode) {
266 final LiteralNode<?> lit = (LiteralNode<?>)test;
267 if (lit.isNumeric() && !(lit.getValue() instanceof Integer)) {
268 if (JSType.isRepresentableAsInt(lit.getNumber())) {
269 return caseNode.setTest((Expression)LiteralNode.newInstance(lit, lit.getInt32()).accept(this));
270 }
271 }
272 }
273 return caseNode;
274 }
275
276 @Override
277 public Node leaveSwitchNode(final SwitchNode switchNode) {
278 if(!switchNode.isInteger()) {
279 // Wrap it in a block so its internally created tag is restricted in scope
280 addStatementEnclosedInBlock(switchNode);
281 } else {
282 addStatement(switchNode);
283 }
284 return switchNode;
285 }
286
287 @Override
288 public Node leaveThrowNode(final ThrowNode throwNode) {
289 return addStatement(throwNode); //ThrowNodes are always terminal, marked as such in constructor
290 }
291
292 private static Node ensureUniqueNamesIn(final Node node) {
293 return node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
294 @Override
295 public Node leaveFunctionNode(final FunctionNode functionNode) {
296 final String name = functionNode.getName();
297 return functionNode.setName(lc, lc.getCurrentFunction().uniqueName(name));
298 }
299
300 @Override
301 public Node leaveDefault(final Node labelledNode) {
302 return labelledNode.ensureUniqueLabels(lc);
303 }
304 });
305 }
306
307 private static List<Statement> copyFinally(final Block finallyBody) {
308 final List<Statement> newStatements = new ArrayList<>();
309 for (final Statement statement : finallyBody.getStatements()) {
310 newStatements.add((Statement)ensureUniqueNamesIn(statement));
311 if (statement.hasTerminalFlags()) {
312 return newStatements;
313 }
314 }
315 return newStatements;
316 }
317
318 private Block catchAllBlock(final TryNode tryNode) {
319 final int lineNumber = tryNode.getLineNumber();
320 final long token = tryNode.getToken();
321 final int finish = tryNode.getFinish();
322
323 final IdentNode exception = new IdentNode(token, finish, lc.getCurrentFunction().uniqueName(CompilerConstants.EXCEPTION_PREFIX.symbolName()));
324
325 final Block catchBody = new Block(token, finish, new ThrowNode(lineNumber, token, finish, new IdentNode(exception), true));
326 assert catchBody.isTerminal(); //ends with throw, so terminal
327
328 final CatchNode catchAllNode = new CatchNode(lineNumber, token, finish, new IdentNode(exception), null, catchBody, true);
329 final Block catchAllBlock = new Block(token, finish, catchAllNode);
330
331 //catchallblock -> catchallnode (catchnode) -> exception -> throw
332
333 return (Block)catchAllBlock.accept(this); //not accepted. has to be accepted by lower
334 }
335
336 private IdentNode compilerConstant(final CompilerConstants cc) {
337 final FunctionNode functionNode = lc.getCurrentFunction();
338 return new IdentNode(functionNode.getToken(), functionNode.getFinish(), cc.symbolName());
339 }
340
341 private static boolean isTerminal(final List<Statement> statements) {
342 return !statements.isEmpty() && statements.get(statements.size() - 1).hasTerminalFlags();
343 }
344
345 /**
346 * Splice finally code into all endpoints of a trynode
347 * @param tryNode the try node
348 * @param rethrows list of rethrowing throw nodes from synthetic catch blocks
349 * @param finallyBody the code in the original finally block
350 * @return new try node after splicing finally code (same if nop)
351 */
352 private Node spliceFinally(final TryNode tryNode, final List<ThrowNode> rethrows, final Block finallyBody) {
353 assert tryNode.getFinallyBody() == null;
354
355 final TryNode newTryNode = (TryNode)tryNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
356 final List<Node> insideTry = new ArrayList<>();
357
358 @Override
359 public boolean enterDefault(final Node node) {
360 insideTry.add(node);
361 return true;
362 }
363
364 @Override
365 public boolean enterFunctionNode(final FunctionNode functionNode) {
366 // do not enter function nodes - finally code should not be inlined into them
367 return false;
368 }
369
370 @Override
371 public Node leaveThrowNode(final ThrowNode throwNode) {
372 if (rethrows.contains(throwNode)) {
373 final List<Statement> newStatements = copyFinally(finallyBody);
374 if (!isTerminal(newStatements)) {
375 newStatements.add(throwNode);
376 }
377 return BlockStatement.createReplacement(throwNode, newStatements);
378 }
379 return throwNode;
380 }
381
382 @Override
383 public Node leaveBreakNode(final BreakNode breakNode) {
384 return leaveJumpStatement(breakNode);
385 }
386
387 @Override
388 public Node leaveContinueNode(final ContinueNode continueNode) {
389 return leaveJumpStatement(continueNode);
390 }
391
392 private Node leaveJumpStatement(final JumpStatement jump) {
393 return copy(jump, (Node)jump.getTarget(Lower.this.lc));
394 }
395
396 @Override
397 public Node leaveReturnNode(final ReturnNode returnNode) {
398 final Expression expr = returnNode.getExpression();
399 final List<Statement> newStatements = new ArrayList<>();
400
401 final Expression resultNode;
402 if (expr != null) {
403 //we need to evaluate the result of the return in case it is complex while
404 //still in the try block, store it in a result value and return it afterwards
405 resultNode = new IdentNode(Lower.this.compilerConstant(RETURN));
406 newStatements.add(new ExpressionStatement(returnNode.getLineNumber(), returnNode.getToken(), returnNode.getFinish(), new BinaryNode(Token.recast(returnNode.getToken(), TokenType.ASSIGN), resultNode, expr)));
407 } else {
408 resultNode = null;
409 }
410
411 newStatements.addAll(copyFinally(finallyBody));
412 if (!isTerminal(newStatements)) {
413 newStatements.add(expr == null ? returnNode : returnNode.setExpression(resultNode));
414 }
415
416 return BlockStatement.createReplacement(returnNode, lc.getCurrentBlock().getFinish(), newStatements);
417 }
418
419 private Node copy(final Statement endpoint, final Node targetNode) {
420 if (!insideTry.contains(targetNode)) {
421 final List<Statement> newStatements = copyFinally(finallyBody);
422 if (!isTerminal(newStatements)) {
423 newStatements.add(endpoint);
424 }
425 return BlockStatement.createReplacement(endpoint, tryNode.getFinish(), newStatements);
426 }
427 return endpoint;
428 }
429 });
430
431 addStatement(newTryNode);
432 for (final Node statement : finallyBody.getStatements()) {
433 addStatement((Statement)statement);
434 }
435
436 return newTryNode;
437 }
438
439 @Override
440 public Node leaveTryNode(final TryNode tryNode) {
441 final Block finallyBody = tryNode.getFinallyBody();
442
443 if (finallyBody == null) {
444 return addStatement(ensureUnconditionalCatch(tryNode));
445 }
446
447 /*
448 * create a new trynode
449 * if we have catches:
450 *
451 * try try
452 * x try
453 * catch x
454 * y catch
455 * finally z y
456 * catchall
457 * rethrow
458 *
459 * otheriwse
460 *
461 * try try
462 * x x
463 * finally catchall
464 * y rethrow
465 *
466 *
467 * now splice in finally code wherever needed
468 *
469 */
470 TryNode newTryNode;
471
472 final Block catchAll = catchAllBlock(tryNode);
473
474 final List<ThrowNode> rethrows = new ArrayList<>();
475 catchAll.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
476 @Override
477 public boolean enterThrowNode(final ThrowNode throwNode) {
478 rethrows.add(throwNode);
479 return true;
480 }
481 });
482 assert rethrows.size() == 1;
483
484 if (tryNode.getCatchBlocks().isEmpty()) {
485 newTryNode = tryNode.setFinallyBody(null);
486 } else {
487 final Block outerBody = new Block(tryNode.getToken(), tryNode.getFinish(), ensureUnconditionalCatch(tryNode.setFinallyBody(null)));
488 newTryNode = tryNode.setBody(outerBody).setCatchBlocks(null);
489 }
490
491 newTryNode = newTryNode.setCatchBlocks(Arrays.asList(catchAll)).setFinallyBody(null);
492
493 /*
494 * Now that the transform is done, we have to go into the try and splice
495 * the finally block in front of any statement that is outside the try
496 */
497 return spliceFinally(newTryNode, rethrows, finallyBody);
498 }
499
500 private TryNode ensureUnconditionalCatch(final TryNode tryNode) {
501 final List<CatchNode> catches = tryNode.getCatches();
502 if(catches == null || catches.isEmpty() || catches.get(catches.size() - 1).getExceptionCondition() == null) {
503 return tryNode;
504 }
505 // If the last catch block is conditional, add an unconditional rethrow block
506 final List<Block> newCatchBlocks = new ArrayList<>(tryNode.getCatchBlocks());
507
508 newCatchBlocks.add(catchAllBlock(tryNode));
509 return tryNode.setCatchBlocks(newCatchBlocks);
510 }
511
512 @Override
513 public Node leaveVarNode(final VarNode varNode) {
514 addStatement(varNode);
515 if (varNode.getFlag(VarNode.IS_LAST_FUNCTION_DECLARATION) && lc.getCurrentFunction().isProgram()) {
516 new ExpressionStatement(varNode.getLineNumber(), varNode.getToken(), varNode.getFinish(), new IdentNode(varNode.getName())).accept(this);
517 }
518 return varNode;
519 }
520
521 @Override
522 public Node leaveWhileNode(final WhileNode whileNode) {
523 final Expression test = whileNode.getTest();
524 final Block body = whileNode.getBody();
525
526 if (isAlwaysTrue(test)) {
527 //turn it into a for node without a test.
528 final ForNode forNode = (ForNode)new ForNode(whileNode.getLineNumber(), whileNode.getToken(), whileNode.getFinish(), body, 0).accept(this);
529 lc.replace(whileNode, forNode);
530 return forNode;
531 }
532
533 return addStatement(checkEscape(whileNode));
534 }
535
536 @Override
537 public Node leaveWithNode(final WithNode withNode) {
538 return addStatement(withNode);
539 }
540
541 /**
542 * Given a function node that is a callee in a CallNode, replace it with
543 * the appropriate marker function. This is used by {@link CodeGenerator}
544 * for fast scope calls
545 *
546 * @param function function called by a CallNode
547 * @return transformed node to marker function or identity if not ident/access/indexnode
548 */
549 private static Expression markerFunction(final Expression function) {
550 if (function instanceof IdentNode) {
551 return ((IdentNode)function).setIsFunction();
552 } else if (function instanceof BaseNode) {
553 return ((BaseNode)function).setIsFunction();
554 }
555 return function;
556 }
557
558 /**
559 * Calculate a synthetic eval location for a node for the stacktrace, for example src#17<eval>
560 * @param node a node
561 * @return eval location
562 */
563 private String evalLocation(final IdentNode node) {
564 final Source source = lc.getCurrentFunction().getSource();
565 final int pos = node.position();
566 return new StringBuilder().
567 append(source.getName()).
568 append('#').
569 append(source.getLine(pos)).
570 append(':').
571 append(source.getColumn(pos)).
572 append("<eval>").
573 toString();
574 }
575
576 /**
577 * Check whether a call node may be a call to eval. In that case we
578 * clone the args in order to create the following construct in
579 * {@link CodeGenerator}
580 *
581 * <pre>
582 * if (calledFuntion == buildInEval) {
583 * eval(cloned arg);
584 * } else {
585 * cloned arg;
586 * }
587 * </pre>
588 *
589 * @param callNode call node to check if it's an eval
590 */
591 private CallNode checkEval(final CallNode callNode) {
592 if (callNode.getFunction() instanceof IdentNode) {
593
594 final List<Expression> args = callNode.getArgs();
595 final IdentNode callee = (IdentNode)callNode.getFunction();
596
597 // 'eval' call with at least one argument
598 if (args.size() >= 1 && EVAL.symbolName().equals(callee.getName())) {
599 final List<Expression> evalArgs = new ArrayList<>(args.size());
600 for(final Expression arg: args) {
601 evalArgs.add((Expression)ensureUniqueNamesIn(arg).accept(this));
602 }
603 return callNode.setEvalArgs(new CallNode.EvalArgs(evalArgs, evalLocation(callee)));
604 }
605 }
606
607 return callNode;
608 }
609
610 /**
611 * Helper that given a loop body makes sure that it is not terminal if it
612 * has a continue that leads to the loop header or to outer loops' loop
613 * headers. This means that, even if the body ends with a terminal
614 * statement, we cannot tag it as terminal
615 *
616 * @param loopBody the loop body to check
617 * @return true if control flow may escape the loop
618 */
619 private static boolean controlFlowEscapes(final LexicalContext lex, final Block loopBody) {
620 final List<Node> escapes = new ArrayList<>();
621
622 loopBody.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
623 @Override
624 public Node leaveBreakNode(final BreakNode node) {
625 escapes.add(node);
626 return node;
627 }
628
629 @Override
630 public Node leaveContinueNode(final ContinueNode node) {
631 // all inner loops have been popped.
632 if (lex.contains(node.getTarget(lex))) {
633 escapes.add(node);
634 }
635 return node;
636 }
637 });
638
639 return !escapes.isEmpty();
640 }
641
642 @SuppressWarnings("unchecked")
643 private <T extends LoopNode> T checkEscape(final T loopNode) {
644 final boolean escapes = controlFlowEscapes(lc, loopNode.getBody());
645 if (escapes) {
646 return (T)loopNode.
647 setBody(lc, loopNode.getBody().setIsTerminal(lc, false)).
648 setControlFlowEscapes(lc, escapes);
649 }
650 return loopNode;
651 }
652
653
654 private Node addStatement(final Statement statement) {
655 lc.appendStatement(statement);
656 return statement;
657 }
658
659 private void addStatementEnclosedInBlock(final Statement stmt) {
660 BlockStatement b = BlockStatement.createReplacement(stmt, Collections.<Statement>singletonList(stmt));
661 if(stmt.isTerminal()) {
662 b = b.setBlock(b.getBlock().setIsTerminal(null, true));
663 }
664 addStatement(b);
665 }
666
667 /**
668 * An internal expression has a symbol that is tagged internal. Check if
669 * this is such a node
670 *
671 * @param expression expression to check for internal symbol
672 * @return true if internal, false otherwise
673 */
674 private static boolean isInternalExpression(final Expression expression) {
675 if (!(expression instanceof IdentNode)) {
676 return false;
677 }
678 final Symbol symbol = ((IdentNode)expression).getSymbol();
679 return symbol != null && symbol.isInternal();
680 }
681
682 /**
683 * Is this an assignment to the special variable that hosts scripting eval
684 * results, i.e. __return__?
685 *
686 * @param expression expression to check whether it is $evalresult = X
687 * @return true if an assignment to eval result, false otherwise
688 */
689 private static boolean isEvalResultAssignment(final Node expression) {
690 final Node e = expression;
691 if (e instanceof BinaryNode) {
692 final Node lhs = ((BinaryNode)e).lhs();
693 if (lhs instanceof IdentNode) {
694 return ((IdentNode)lhs).getName().equals(RETURN.symbolName());
695 }
696 }
697 return false;
698 }
699 }