nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/ExpressionStatement.java
changeset 39662 e2b36a3779b9
parent 27204 06ec78f29a56
equal deleted inserted replaced
39604:8e45018bde9d 39662:e2b36a3779b9
    25 
    25 
    26 package jdk.nashorn.internal.ir;
    26 package jdk.nashorn.internal.ir;
    27 
    27 
    28 import jdk.nashorn.internal.ir.annotations.Immutable;
    28 import jdk.nashorn.internal.ir.annotations.Immutable;
    29 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
    29 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
       
    30 import jdk.nashorn.internal.parser.TokenType;
    30 
    31 
    31 /**
    32 /**
    32  * IR representation for executing bare expressions. Basically, an expression
    33  * IR representation for executing bare expressions. Basically, an expression
    33  * node means "this code will be executed" and evaluating it results in
    34  * node means "this code will be executed" and evaluating it results in
    34  * statements being added to the IR
    35  * statements being added to the IR
    37 public final class ExpressionStatement extends Statement {
    38 public final class ExpressionStatement extends Statement {
    38     private static final long serialVersionUID = 1L;
    39     private static final long serialVersionUID = 1L;
    39 
    40 
    40     /** Expression to execute. */
    41     /** Expression to execute. */
    41     private final Expression expression;
    42     private final Expression expression;
       
    43     private final TokenType destructuringDecl;
       
    44 
       
    45     /**
       
    46      * Constructor
       
    47      *
       
    48      * @param lineNumber line number
       
    49      * @param token      token
       
    50      * @param finish     finish
       
    51      * @param expression the expression to execute
       
    52      * @param destructuringDecl does this statement represent a destructuring declaration?
       
    53      */
       
    54     public ExpressionStatement(final int lineNumber, final long token, final int finish,
       
    55             final Expression expression, final TokenType destructuringDecl) {
       
    56         super(lineNumber, token, finish);
       
    57         this.expression = expression;
       
    58         this.destructuringDecl = destructuringDecl;
       
    59     }
    42 
    60 
    43     /**
    61     /**
    44      * Constructor
    62      * Constructor
    45      *
    63      *
    46      * @param lineNumber line number
    64      * @param lineNumber line number
    47      * @param token      token
    65      * @param token      token
    48      * @param finish     finish
    66      * @param finish     finish
    49      * @param expression the expression to execute
    67      * @param expression the expression to execute
    50      */
    68      */
    51     public ExpressionStatement(final int lineNumber, final long token, final int finish, final Expression expression) {
    69     public ExpressionStatement(final int lineNumber, final long token, final int finish, final Expression expression) {
    52         super(lineNumber, token, finish);
    70         this(lineNumber, token, finish, expression, null);
    53         this.expression = expression;
       
    54     }
    71     }
    55 
    72 
    56     private ExpressionStatement(final ExpressionStatement expressionStatement, final Expression expression) {
    73     private ExpressionStatement(final ExpressionStatement expressionStatement, final Expression expression) {
    57         super(expressionStatement);
    74         super(expressionStatement);
    58         this.expression = expression;
    75         this.expression = expression;
       
    76         this.destructuringDecl = null;
    59     }
    77     }
    60 
    78 
    61     @Override
    79     @Override
    62     public Node accept(final NodeVisitor<? extends LexicalContext> visitor) {
    80     public Node accept(final NodeVisitor<? extends LexicalContext> visitor) {
    63         if (visitor.enterExpressionStatement(this)) {
    81         if (visitor.enterExpressionStatement(this)) {
    79     public Expression getExpression() {
    97     public Expression getExpression() {
    80         return expression;
    98         return expression;
    81     }
    99     }
    82 
   100 
    83     /**
   101     /**
       
   102      * Return declaration type if this expression statement is a destructuring declaration
       
   103      *
       
   104      * @return declaration type (LET, VAR, CONST) if destructuring declaration, null otherwise.
       
   105      */
       
   106     public TokenType destructuringDeclarationType() {
       
   107         return destructuringDecl;
       
   108     }
       
   109 
       
   110     /**
    84      * Reset the expression to be executed
   111      * Reset the expression to be executed
    85      * @param expression the expression
   112      * @param expression the expression
    86      * @return new or same execute node
   113      * @return new or same execute node
    87      */
   114      */
    88     public ExpressionStatement setExpression(final Expression expression) {
   115     public ExpressionStatement setExpression(final Expression expression) {