[es6] Mark tail Call nodes

src/ast/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 233 matching lines @@
   int position_;
 };
 
 
 class Statement : public AstNode {
  public:
   explicit Statement(Zone* zone, int position) : AstNode(position) {}
 
   bool IsEmpty() { return AsEmptyStatement() != NULL; }
   virtual bool IsJump() const { return false; }
+  virtual void MarkTail() {}
 };
 
 
 class SmallMapList final {
  public:
   SmallMapList() {}
   SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
 
   void Reserve(int capacity, Zone* zone) { list_.Reserve(capacity, zone); }
   void Clear() { list_.Clear(); }
@@ skipping 44 matching lines @@
     // code generation.
     kUninitialized,
     // Evaluated for its side effects.
     kEffect,
     // Evaluated for its value (and side effects).
     kValue,
     // Evaluated for control flow (and side effects).
     kTest
   };
 
+  // Mark this expression as being in tail position.
+  virtual void MarkTail() {}
+
   // True iff the expression is a valid reference expression.
   virtual bool IsValidReferenceExpression() const { return false; }
 
   // Helpers for ToBoolean conversion.
   virtual bool ToBooleanIsTrue() const { return false; }
   virtual bool ToBooleanIsFalse() const { return false; }
 
   // Symbols that cannot be parsed as array indices are considered property
   // names.  We do not treat symbols that can be array indexes as property
   // names because [] for string objects is handled only by keyed ICs.
@@ skipping 136 matching lines @@
   bool ignore_completion_value() const { return ignore_completion_value_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DeclsId() const { return BailoutId(local_id(0)); }
 
   bool IsJump() const override {
     return !statements_.is_empty() && statements_.last()->IsJump()
         && labels() == NULL;  // Good enough as an approximation...
   }
 
+  void MarkTail() override {
+    if (!statements_.is_empty()) statements_.last()->MarkTail();
+  }
+
   Scope* scope() const { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
  protected:
   Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
         bool ignore_completion_value, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos),
         statements_(capacity, zone),
         ignore_completion_value_(ignore_completion_value),
         scope_(NULL) {}
   static int parent_num_ids() { return BreakableStatement::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   ZoneList<Statement*> statements_;
   bool ignore_completion_value_;
   Scope* scope_;
 };
 
 
 class DoExpression final : public Expression {
  public:
   DECLARE_NODE_TYPE(DoExpression)
 
   Block* block() { return block_; }
   VariableProxy* result() { return result_; }
 
+  void MarkTail() override { block_->MarkTail(); }
+
  protected:
   DoExpression(Zone* zone, Block* block, VariableProxy* result, int pos)
       : Expression(zone, pos), block_(block), result_(result) {
     DCHECK_NOT_NULL(block_);
     DCHECK_NOT_NULL(result_);
   }
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
@@ skipping 415 matching lines @@
 };
 
 
 class ExpressionStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(ExpressionStatement)
 
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
   bool IsJump() const override { return expression_->IsThrow(); }
+  void MarkTail() override { expression_->MarkTail(); }
 
  protected:
   ExpressionStatement(Zone* zone, Expression* expression, int pos)
       : Statement(zone, pos), expression_(expression) { }
 
  private:
   Expression* expression_;
 };
 
 
@@ skipping 58 matching lines @@
   Scope* scope() { return scope_; }
   Expression* expression() const { return expression_; }
   Statement* statement() const { return statement_; }
   void set_statement(Statement* s) { statement_ = s; }
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ToObjectId() const { return BailoutId(local_id(0)); }
   BailoutId EntryId() const { return BailoutId(local_id(1)); }
 
+  void MarkTail() override { statement_->MarkTail(); }
+
  protected:
   WithStatement(Zone* zone, Scope* scope, Expression* expression,
                 Statement* statement, int pos)
       : Statement(zone, pos),
         scope_(scope),
         expression_(expression),
         statement_(statement),
         base_id_(BailoutId::None().ToInt()) {}
   static int parent_num_ids() { return 0; }
 
@@ skipping 21 matching lines @@
     CHECK(!is_default());
     return label_;
   }
   Label* body_target() { return &body_target_; }
   ZoneList<Statement*>* statements() const { return statements_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId EntryId() const { return BailoutId(local_id(0)); }
   TypeFeedbackId CompareId() { return TypeFeedbackId(local_id(1)); }
 
+  void MarkTail() override {
+    if (!statements_->is_empty()) statements_->last()->MarkTail();
+  }
+
   Type* compare_type() { return compare_type_; }
   void set_compare_type(Type* type) { compare_type_ = type; }
 
  protected:
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   CaseClause(Zone* zone, Expression* label, ZoneList<Statement*>* statements,
              int pos);
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
@@ skipping 10 matching lines @@
   DECLARE_NODE_TYPE(SwitchStatement)
 
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
     tag_ = tag;
     cases_ = cases;
   }
 
   Expression* tag() const { return tag_; }
   ZoneList<CaseClause*>* cases() const { return cases_; }
 
+  void MarkTail() override {
+    if (!cases_->is_empty()) cases_->last()->MarkTail();
+  }
+
  protected:
   SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
         tag_(NULL),
         cases_(NULL) {}
 
  private:
   Expression* tag_;
   ZoneList<CaseClause*>* cases_;
 };
@@ skipping 16 matching lines @@
   Statement* else_statement() const { return else_statement_; }
 
   void set_then_statement(Statement* s) { then_statement_ = s; }
   void set_else_statement(Statement* s) { else_statement_ = s; }
 
   bool IsJump() const override {
     return HasThenStatement() && then_statement()->IsJump()
         && HasElseStatement() && else_statement()->IsJump();
   }
 
+  void MarkTail() override {
+    then_statement_->MarkTail();
+    else_statement_->MarkTail();
+  }
+
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 3; }
   BailoutId IfId() const { return BailoutId(local_id(0)); }
   BailoutId ThenId() const { return BailoutId(local_id(1)); }
   BailoutId ElseId() const { return BailoutId(local_id(2)); }
 
  protected:
   IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
               Statement* else_statement, int pos)
       : Statement(zone, pos),
@@ skipping 49 matching lines @@
 
 class TryCatchStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryCatchStatement)
 
   Scope* scope() { return scope_; }
   Variable* variable() { return variable_; }
   Block* catch_block() const { return catch_block_; }
   void set_catch_block(Block* b) { catch_block_ = b; }
 
+  void MarkTail() override { catch_block_->MarkTail(); }
+
  protected:
   TryCatchStatement(Zone* zone, Block* try_block, Scope* scope,
                     Variable* variable, Block* catch_block, int pos)
       : TryStatement(zone, try_block, pos),
         scope_(scope),
         variable_(variable),
         catch_block_(catch_block) {}
 
  private:
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
 };
 
 
 class TryFinallyStatement final : public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryFinallyStatement)
 
   Block* finally_block() const { return finally_block_; }
   void set_finally_block(Block* b) { finally_block_ = b; }
 
+  void MarkTail() override { finally_block_->MarkTail(); }
+
  protected:
   TryFinallyStatement(Zone* zone, Block* try_block, Block* finally_block,
                       int pos)
       : TryStatement(zone, try_block, pos), finally_block_(finally_block) {}
 
  private:
   Block* finally_block_;
 };
 
 
@@ skipping 680 matching lines @@
   BailoutId LookupId() const { return BailoutId(local_id(2)); }
   BailoutId CallId() const { return BailoutId(local_id(3)); }
 
   bool is_uninitialized() const {
     return IsUninitializedField::decode(bit_field_);
   }
   void set_is_uninitialized(bool b) {
     bit_field_ = IsUninitializedField::update(bit_field_, b);
   }
 
+  bool is_tail() const { return IsTailField::decode(bit_field_); }
+  void MarkTail() override {
+    bit_field_ = IsTailField::update(bit_field_, true);
+  }
+
   enum CallType {
     POSSIBLY_EVAL_CALL,
     GLOBAL_CALL,
     LOOKUP_SLOT_CALL,
     NAMED_PROPERTY_CALL,
     KEYED_PROPERTY_CALL,
     NAMED_SUPER_PROPERTY_CALL,
     KEYED_SUPER_PROPERTY_CALL,
     SUPER_CALL,
     OTHER_CALL
@@ skipping 25 matching lines @@
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   FeedbackVectorSlot ic_slot_;
   FeedbackVectorSlot stub_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
   class IsUninitializedField : public BitField8<bool, 0, 1> {};
+  class IsTailField : public BitField8<bool, 1, 1> {};
   uint8_t bit_field_;
 };
 
 
 class CallNew final : public Expression {
  public:
   DECLARE_NODE_TYPE(CallNew)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
@@ skipping 136 matching lines @@
   DECLARE_NODE_TYPE(BinaryOperation)
 
   Token::Value op() const { return static_cast<Token::Value>(op_); }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
   Handle<AllocationSite> allocation_site() const { return allocation_site_; }
   void set_allocation_site(Handle<AllocationSite> allocation_site) {
     allocation_site_ = allocation_site;
   }
 
+  void MarkTail() override {
+    switch (op()) {
+      case Token::COMMA:
+      case Token::AND:
+      case Token::OR:
+        right_->MarkTail();
+      default:
+        break;
+    }
+  }
+
   // The short-circuit logical operations need an AST ID for their
   // right-hand subexpression.
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId RightId() const { return BailoutId(local_id(0)); }
 
   TypeFeedbackId BinaryOperationFeedbackId() const {
     return TypeFeedbackId(local_id(1));
   }
   Maybe<int> fixed_right_arg() const {
     return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
@@ skipping 171 matching lines @@
 
 
 class Conditional final : public Expression {
  public:
   DECLARE_NODE_TYPE(Conditional)
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
 
+  void MarkTail() override {
+    then_expression_->MarkTail();
+    else_expression_->MarkTail();
+  }
+
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ThenId() const { return BailoutId(local_id(0)); }
   BailoutId ElseId() const { return BailoutId(local_id(1)); }
 
  protected:
   Conditional(Zone* zone, Expression* condition, Expression* then_expression,
               Expression* else_expression, int position)
       : Expression(zone, position),
         condition_(condition),
         then_expression_(then_expression),
@@ skipping 1395 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_