[ast] Remove obsolete DECLARE_NODE_TYPE macro.

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/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
@@ skipping 113 matching lines @@
 #define DEF_FORWARD_DECLARATION(type) class type;
 AST_NODE_LIST(DEF_FORWARD_DECLARATION)
 #undef DEF_FORWARD_DECLARATION
 
 
 // Typedef only introduced to avoid unreadable code.
 typedef ZoneList<Handle<String>> ZoneStringList;
 typedef ZoneList<Handle<Object>> ZoneObjectList;
 
 
-#define DECLARE_NODE_TYPE(type)                                          \
-  friend class AstNodeFactory;
-
-
 class FeedbackVectorSlotCache {
  public:
   explicit FeedbackVectorSlotCache(Zone* zone)
       : zone_(zone),
         hash_map_(base::HashMap::PointersMatch,
                   ZoneHashMap::kDefaultHashMapCapacity,
                   ZoneAllocationPolicy(zone)) {}
 
   void Put(Variable* variable, FeedbackVectorSlot slot) {
     ZoneHashMap::Entry* entry = hash_map_.LookupOrInsert(
@@ skipping 206 matching lines @@
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId id() const { return BailoutId(local_id(0)); }
   TypeFeedbackId test_id() const { return TypeFeedbackId(local_id(1)); }
 
  protected:
   Expression(Zone* zone, int pos, NodeType type)
       : AstNode(pos, type),
         bit_field_(0),
         base_id_(BailoutId::None().ToInt()) {}
+
   static int parent_num_ids() { return 0; }
   void set_to_boolean_types(uint16_t types) {
     bit_field_ = ToBooleanTypesField::update(bit_field_, types);
   }
-
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   uint16_t bit_field_;
   int base_id_;
@@ skipping 46 matching lines @@
 
   BreakableType breakable_type_;
   int base_id_;
   Label break_target_;
   ZoneList<const AstRawString*>* labels_;
 };
 
 
 class Block final : public BreakableStatement {
  public:
-  DECLARE_NODE_TYPE(Block)
-
   ZoneList<Statement*>* statements() { return &statements_; }
   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 {
     return !statements_.is_empty() && statements_.last()->IsJump()
         && labels() == NULL;  // Good enough as an approximation...
   }
 
   Scope* scope() const { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
         bool ignore_completion_value, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos, kBlock),
         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_; }
   void set_block(Block* b) { block_ = b; }
   VariableProxy* result() { return result_; }
   void set_result(VariableProxy* v) { result_ = v; }
   FunctionLiteral* represented_function() { return represented_function_; }
   void set_represented_function(FunctionLiteral* f) {
     represented_function_ = f;
   }
   bool IsAnonymousFunctionDefinition() const;
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   DoExpression(Zone* zone, Block* block, VariableProxy* result, int pos)
       : Expression(zone, pos, kDoExpression),
         block_(block),
         result_(result),
         represented_function_(nullptr) {
     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; }
 
   Block* block_;
   VariableProxy* result_;
   FunctionLiteral* represented_function_;
 };
 
 
 class Declaration : public AstNode {
  public:
@@ skipping 13 matching lines @@
   VariableMode mode_;
   VariableProxy* proxy_;
 
   // Nested scope from which the declaration originated.
   Scope* scope_;
 };
 
 
 class VariableDeclaration final : public Declaration {
  public:
-  DECLARE_NODE_TYPE(VariableDeclaration)
-
   InitializationFlag initialization() const {
     return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
   }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   VariableDeclaration(VariableProxy* proxy, VariableMode mode, Scope* scope,
                       int pos)
       : Declaration(proxy, mode, scope, pos, kVariableDeclaration) {}
 };
 
 
 class FunctionDeclaration final : public Declaration {
  public:
-  DECLARE_NODE_TYPE(FunctionDeclaration)
-
   FunctionLiteral* fun() const { return fun_; }
   void set_fun(FunctionLiteral* f) { fun_ = f; }
   InitializationFlag initialization() const { return kCreatedInitialized; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   FunctionDeclaration(VariableProxy* proxy, VariableMode mode,
                       FunctionLiteral* fun, Scope* scope, int pos)
       : Declaration(proxy, mode, scope, pos, kFunctionDeclaration), fun_(fun) {
     DCHECK(mode == VAR || mode == LET || mode == CONST);
     DCHECK(fun != NULL);
   }
 
- private:
   FunctionLiteral* fun_;
 };
 
 
 class IterationStatement : public BreakableStatement {
  public:
   Statement* body() const { return body_; }
   void set_body(Statement* s) { body_ = s; }
 
   int yield_count() const { return yield_count_; }
@@ skipping 24 matching lines @@
 
   Statement* body_;
   Label continue_target_;
   int yield_count_;
   int first_yield_id_;
 };
 
 
 class DoWhileStatement final : public IterationStatement {
  public:
-  DECLARE_NODE_TYPE(DoWhileStatement)
-
   void Initialize(Expression* cond, Statement* body) {
     IterationStatement::Initialize(body);
     cond_ = cond;
   }
 
   Expression* cond() const { return cond_; }
   void set_cond(Expression* e) { cond_ = e; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ContinueId() const { return BailoutId(local_id(0)); }
   BailoutId StackCheckId() const { return BackEdgeId(); }
   BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos, kDoWhileStatement), cond_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* cond_;
 };
 
 
 class WhileStatement final : public IterationStatement {
  public:
-  DECLARE_NODE_TYPE(WhileStatement)
-
   void Initialize(Expression* cond, Statement* body) {
     IterationStatement::Initialize(body);
     cond_ = cond;
   }
 
   Expression* cond() const { return cond_; }
   void set_cond(Expression* e) { cond_ = e; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId ContinueId() const { return EntryId(); }
   BailoutId StackCheckId() const { return BodyId(); }
   BailoutId BodyId() const { return BailoutId(local_id(0)); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos, kWhileStatement), cond_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* cond_;
 };
 
 
 class ForStatement final : public IterationStatement {
  public:
-  DECLARE_NODE_TYPE(ForStatement)
-
   void Initialize(Statement* init,
                   Expression* cond,
                   Statement* next,
                   Statement* body) {
     IterationStatement::Initialize(body);
     init_ = init;
     cond_ = cond;
     next_ = next;
   }
 
   Statement* init() const { return init_; }
   Expression* cond() const { return cond_; }
   Statement* next() const { return next_; }
 
   void set_init(Statement* s) { init_ = s; }
   void set_cond(Expression* e) { cond_ = e; }
   void set_next(Statement* s) { next_ = s; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ContinueId() const { return BailoutId(local_id(0)); }
   BailoutId StackCheckId() const { return BodyId(); }
   BailoutId BodyId() const { return BailoutId(local_id(1)); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos, kForStatement),
         init_(NULL),
         cond_(NULL),
         next_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Statement* init_;
   Expression* cond_;
   Statement* next_;
 };
 
 
 class ForEachStatement : public IterationStatement {
  public:
@@ skipping 10 matching lines @@
 
  protected:
   ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
                    NodeType type)
       : IterationStatement(zone, labels, pos, type) {}
 };
 
 
 class ForInStatement final : public ForEachStatement {
  public:
-  DECLARE_NODE_TYPE(ForInStatement)
-
   void Initialize(Expression* each, Expression* subject, Statement* body) {
     ForEachStatement::Initialize(body);
     each_ = each;
     subject_ = subject;
   }
 
   Expression* enumerable() const {
     return subject();
   }
 
@@ skipping 19 matching lines @@
   static int num_ids() { return parent_num_ids() + 6; }
   BailoutId BodyId() const { return BailoutId(local_id(0)); }
   BailoutId EnumId() const { return BailoutId(local_id(1)); }
   BailoutId ToObjectId() const { return BailoutId(local_id(2)); }
   BailoutId PrepareId() const { return BailoutId(local_id(3)); }
   BailoutId FilterId() const { return BailoutId(local_id(4)); }
   BailoutId AssignmentId() const { return BailoutId(local_id(5)); }
   BailoutId ContinueId() const { return EntryId(); }
   BailoutId StackCheckId() const { return BodyId(); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : ForEachStatement(zone, labels, pos, kForInStatement),
         each_(nullptr),
         subject_(nullptr),
         for_in_type_(SLOW_FOR_IN) {}
   static int parent_num_ids() { return ForEachStatement::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* each_;
   Expression* subject_;
   ForInType for_in_type_;
   FeedbackVectorSlot each_slot_;
   FeedbackVectorSlot for_in_feedback_slot_;
 };
 
 
 class ForOfStatement final : public ForEachStatement {
  public:
-  DECLARE_NODE_TYPE(ForOfStatement)
-
   void Initialize(Statement* body, Variable* iterator,
                   Expression* assign_iterator, Expression* next_result,
                   Expression* result_done, Expression* assign_each) {
     ForEachStatement::Initialize(body);
     iterator_ = iterator;
     assign_iterator_ = assign_iterator;
     next_result_ = next_result;
     result_done_ = result_done;
     assign_each_ = assign_each;
   }
@@ skipping 26 matching lines @@
   void set_next_result(Expression* e) { next_result_ = e; }
   void set_result_done(Expression* e) { result_done_ = e; }
   void set_assign_each(Expression* e) { assign_each_ = e; }
 
   BailoutId ContinueId() const { return EntryId(); }
   BailoutId StackCheckId() const { return BackEdgeId(); }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : ForEachStatement(zone, labels, pos, kForOfStatement),
         iterator_(NULL),
         assign_iterator_(NULL),
         next_result_(NULL),
         result_done_(NULL),
         assign_each_(NULL) {}
   static int parent_num_ids() { return ForEachStatement::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Variable* iterator_;
   Expression* assign_iterator_;
   Expression* next_result_;
   Expression* result_done_;
   Expression* assign_each_;
 };
 
 
 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 { return expression_->IsThrow(); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ExpressionStatement(Zone* zone, Expression* expression, int pos)
       : Statement(zone, pos, kExpressionStatement), expression_(expression) {}
 
- private:
   Expression* expression_;
 };
 
 
 class JumpStatement : public Statement {
  public:
   bool IsJump() const { return true; }
 
  protected:
   JumpStatement(Zone* zone, int pos, NodeType type)
       : Statement(zone, pos, type) {}
 };
 
 
 class ContinueStatement final : public JumpStatement {
  public:
-  DECLARE_NODE_TYPE(ContinueStatement)
-
   IterationStatement* target() const { return target_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ContinueStatement(Zone* zone, IterationStatement* target, int pos)
       : JumpStatement(zone, pos, kContinueStatement), target_(target) {}
 
- private:
   IterationStatement* target_;
 };
 
 
 class BreakStatement final : public JumpStatement {
  public:
-  DECLARE_NODE_TYPE(BreakStatement)
-
   BreakableStatement* target() const { return target_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   BreakStatement(Zone* zone, BreakableStatement* target, int pos)
       : JumpStatement(zone, pos, kBreakStatement), target_(target) {}
 
- private:
   BreakableStatement* target_;
 };
 
 
 class ReturnStatement final : public JumpStatement {
  public:
-  DECLARE_NODE_TYPE(ReturnStatement)
-
   Expression* expression() const { return expression_; }
 
   void set_expression(Expression* e) { expression_ = e; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ReturnStatement(Zone* zone, Expression* expression, int pos)
       : JumpStatement(zone, pos, kReturnStatement), expression_(expression) {}
 
- private:
   Expression* expression_;
 };
 
 
 class WithStatement final : public Statement {
  public:
-  DECLARE_NODE_TYPE(WithStatement)
-
   Scope* scope() { return scope_; }
   Expression* expression() const { return expression_; }
   void set_expression(Expression* e) { expression_ = e; }
   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)); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   WithStatement(Zone* zone, Scope* scope, Expression* expression,
                 Statement* statement, int pos)
       : Statement(zone, pos, kWithStatement),
         base_id_(BailoutId::None().ToInt()),
         scope_(scope),
         expression_(expression),
         statement_(statement) {}
+
   static int parent_num_ids() { return 0; }
-
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int base_id_;
   Scope* scope_;
   Expression* expression_;
   Statement* statement_;
 };
 
 
 class CaseClause final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CaseClause)
-
   bool is_default() const { return label_ == NULL; }
   Expression* label() const {
     CHECK(!is_default());
     return label_;
   }
   void set_label(Expression* e) { label_ = e; }
   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)); }
 
   Type* compare_type() { return compare_type_; }
   void set_compare_type(Type* type) { compare_type_ = type; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   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; }
 
   Expression* label_;
   Label body_target_;
   ZoneList<Statement*>* statements_;
   Type* compare_type_;
 };
 
 
 class SwitchStatement final : public BreakableStatement {
  public:
-  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 set_tag(Expression* t) { tag_ = t; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos,
                            kSwitchStatement),
         tag_(NULL),
         cases_(NULL) {}
 
- private:
   Expression* tag_;
   ZoneList<CaseClause*>* cases_;
 };
 
 
 // If-statements always have non-null references to their then- and
 // else-parts. When parsing if-statements with no explicit else-part,
 // the parser implicitly creates an empty statement. Use the
 // HasThenStatement() and HasElseStatement() functions to check if a
 // given if-statement has a then- or an else-part containing code.
 class IfStatement final : public Statement {
  public:
-  DECLARE_NODE_TYPE(IfStatement)
-
   bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
   bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
 
   Expression* condition() const { return condition_; }
   Statement* then_statement() const { return then_statement_; }
   Statement* else_statement() const { return else_statement_; }
 
   void set_condition(Expression* e) { condition_ = e; }
   void set_then_statement(Statement* s) { then_statement_ = s; }
   void set_else_statement(Statement* s) { else_statement_ = s; }
 
   bool IsJump() const {
     return HasThenStatement() && then_statement()->IsJump()
         && HasElseStatement() && else_statement()->IsJump();
   }
 
   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:
+ private:
+  friend class AstNodeFactory;
+
   IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
               Statement* else_statement, int pos)
       : Statement(zone, pos, kIfStatement),
         base_id_(BailoutId::None().ToInt()),
         condition_(condition),
         then_statement_(then_statement),
         else_statement_(else_statement) {}
+
   static int parent_num_ids() { return 0; }
-
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int base_id_;
   Expression* condition_;
   Statement* then_statement_;
   Statement* else_statement_;
 };
 
 
 class TryStatement : public Statement {
@@ skipping 26 matching lines @@
 
   HandlerTable::CatchPrediction catch_prediction_;
 
  private:
   Block* try_block_;
 };
 
 
 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; }
 
   // The clear_pending_message flag indicates whether or not to clear the
   // isolate's pending exception message before executing the catch_block.  In
   // the normal use case, this flag is always on because the message object
   // is not needed anymore when entering the catch block and should not be kept
   // alive.
   // The use case where the flag is off is when the catch block is guaranteed to
   // rethrow the caught exception (using %ReThrow), which reuses the pending
   // message instead of generating a new one.
   // (When the catch block doesn't rethrow but is guaranteed to perform an
   // ordinary throw, not clearing the old message is safe but not very useful.)
   bool clear_pending_message() const {
     return catch_prediction_ != HandlerTable::UNCAUGHT;
   }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   TryCatchStatement(Zone* zone, Block* try_block, Scope* scope,
                     Variable* variable, Block* catch_block,
                     HandlerTable::CatchPrediction catch_prediction, int pos)
       : TryStatement(zone, try_block, pos, kTryCatchStatement),
         scope_(scope),
         variable_(variable),
         catch_block_(catch_block) {
     catch_prediction_ = catch_prediction;
   }
 
- 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; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   TryFinallyStatement(Zone* zone, Block* try_block, Block* finally_block,
                       int pos)
       : TryStatement(zone, try_block, pos, kTryFinallyStatement),
         finally_block_(finally_block) {}
 
- private:
   Block* finally_block_;
 };
 
 
 class DebuggerStatement final : public Statement {
  public:
-  DECLARE_NODE_TYPE(DebuggerStatement)
-
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DebugBreakId() const { return BailoutId(local_id(0)); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   DebuggerStatement(Zone* zone, int pos)
       : Statement(zone, pos, kDebuggerStatement),
         base_id_(BailoutId::None().ToInt()) {}
+
   static int parent_num_ids() { return 0; }
-
   int base_id() const {
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int base_id_;
 };
 
 
 class EmptyStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(EmptyStatement)
-
- protected:
+ private:
+  friend class AstNodeFactory;
   EmptyStatement(Zone* zone, int pos) : Statement(zone, pos, kEmptyStatement) {}
 };
 
 
 // Delegates to another statement, which may be overwritten.
 // This was introduced to implement ES2015 Annex B3.3 for conditionally making
 // sloppy-mode block-scoped functions have a var binding, which is changed
 // from one statement to another during parsing.
 class SloppyBlockFunctionStatement final : public Statement {
  public:
-  DECLARE_NODE_TYPE(SloppyBlockFunctionStatement)
-
   Statement* statement() const { return statement_; }
   void set_statement(Statement* statement) { statement_ = statement; }
   Scope* scope() const { return scope_; }
 
  private:
+  friend class AstNodeFactory;
+
   SloppyBlockFunctionStatement(Zone* zone, Statement* statement, Scope* scope)
       : Statement(zone, kNoSourcePosition, kSloppyBlockFunctionStatement),
         statement_(statement),
         scope_(scope) {}
 
   Statement* statement_;
   Scope* const scope_;
 };
 
 
 class Literal final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Literal)
-
   bool IsPropertyName() const { return value_->IsPropertyName(); }
 
   Handle<String> AsPropertyName() {
     DCHECK(IsPropertyName());
     return Handle<String>::cast(value());
   }
 
   const AstRawString* AsRawPropertyName() {
     DCHECK(IsPropertyName());
     return value_->AsString();
   }
 
   bool ToBooleanIsTrue() const { return value()->BooleanValue(); }
   bool ToBooleanIsFalse() const { return !value()->BooleanValue(); }
 
   Handle<Object> value() const { return value_->value(); }
   const AstValue* raw_value() const { return value_; }
 
   // Support for using Literal as a HashMap key. NOTE: Currently, this works
   // only for string and number literals!
   uint32_t Hash();
   static bool Match(void* literal1, void* literal2);
 
   static int num_ids() { return parent_num_ids() + 1; }
   TypeFeedbackId LiteralFeedbackId() const {
     return TypeFeedbackId(local_id(0));
   }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Literal(Zone* zone, const AstValue* value, int position)
       : Expression(zone, position, kLiteral), value_(value) {}
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   const AstValue* value_;
 };
 
 
 class AstLiteralReindexer;
 
 // Base class for literals that needs space in the corresponding JSFunction.
 class MaterializedLiteral : public Expression {
@@ skipping 84 matching lines @@
   }
   void SetSlot(FeedbackVectorSlot slot, int offset = 0) {
     DCHECK_LT(offset, static_cast<int>(arraysize(slots_)));
     slots_[offset] = slot;
   }
 
   void set_receiver_type(Handle<Map> map) { receiver_type_ = map; }
 
   bool NeedsSetFunctionName() const;
 
- protected:
+ private:
   friend class AstNodeFactory;
 
   ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
                         bool is_static, bool is_computed_name);
   ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
                         Expression* value, bool is_static,
                         bool is_computed_name);
 
- private:
   Expression* key_;
   Expression* value_;
   FeedbackVectorSlot slots_[2];
   Kind kind_;
   bool emit_store_;
   bool is_static_;
   bool is_computed_name_;
   Handle<Map> receiver_type_;
 };
 
 
 // An object literal has a boilerplate object that is used
 // for minimizing the work when constructing it at runtime.
 class ObjectLiteral final : public MaterializedLiteral {
  public:
   typedef ObjectLiteralProperty Property;
 
-  DECLARE_NODE_TYPE(ObjectLiteral)
-
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
   int properties_count() const { return constant_properties_->length() / 2; }
   ZoneList<Property*>* properties() const { return properties_; }
   bool fast_elements() const { return fast_elements_; }
   bool may_store_doubles() const { return may_store_doubles_; }
   bool has_elements() const { return has_elements_; }
   bool has_shallow_properties() const {
     return depth() == 1 && !has_elements() && !may_store_doubles();
@@ skipping 50 matching lines @@
   // ObjectLiteral can vary, so num_ids() is not a static method.
   int num_ids() const {
     return parent_num_ids() + 1 + 2 * properties()->length();
   }
 
   // Object literals need one feedback slot for each non-trivial value, as well
   // as some slots for home objects.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ObjectLiteral(Zone* zone, ZoneList<Property*>* properties, int literal_index,
                 uint32_t boilerplate_properties, int pos)
       : MaterializedLiteral(zone, literal_index, pos, kObjectLiteral),
         boilerplate_properties_(boilerplate_properties),
         fast_elements_(false),
         has_elements_(false),
         may_store_doubles_(false),
         properties_(properties) {}
+
   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
+  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
   uint32_t boilerplate_properties_ : 29;
   bool fast_elements_ : 1;
   bool has_elements_ : 1;
   bool may_store_doubles_ : 1;
   FeedbackVectorSlot slot_;
   Handle<FixedArray> constant_properties_;
   ZoneList<Property*>* properties_;
 };
 
 
@@ skipping 15 matching lines @@
   }
 
  private:
   Zone* zone_;
 };
 
 
 // Node for capturing a regexp literal.
 class RegExpLiteral final : public MaterializedLiteral {
  public:
-  DECLARE_NODE_TYPE(RegExpLiteral)
-
   Handle<String> pattern() const { return pattern_->string(); }
   int flags() const { return flags_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   RegExpLiteral(Zone* zone, const AstRawString* pattern, int flags,
                 int literal_index, int pos)
       : MaterializedLiteral(zone, literal_index, pos, kRegExpLiteral),
         flags_(flags),
         pattern_(pattern) {
     set_depth(1);
   }
 
- private:
   int const flags_;
   const AstRawString* const pattern_;
 };
 
 
 // An array literal has a literals object that is used
 // for minimizing the work when constructing it at runtime.
 class ArrayLiteral final : public MaterializedLiteral {
  public:
-  DECLARE_NODE_TYPE(ArrayLiteral)
-
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
   ElementsKind constant_elements_kind() const {
     DCHECK_EQ(2, constant_elements_->length());
     return static_cast<ElementsKind>(
         Smi::cast(constant_elements_->get(0))->value());
   }
 
   ZoneList<Expression*>* values() const { return values_; }
 
   BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
@@ skipping 33 matching lines @@
   enum Flags {
     kNoFlags = 0,
     kShallowElements = 1,
     kDisableMementos = 1 << 1
   };
 
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot LiteralFeedbackSlot() const { return literal_slot_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   ArrayLiteral(Zone* zone, ZoneList<Expression*>* values,
                int first_spread_index, int literal_index, int pos)
       : MaterializedLiteral(zone, literal_index, pos, kArrayLiteral),
         first_spread_index_(first_spread_index),
         values_(values) {}
+
   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int first_spread_index_;
   FeedbackVectorSlot literal_slot_;
   Handle<FixedArray> constant_elements_;
   ZoneList<Expression*>* values_;
 };
 
 
 class VariableProxy final : public Expression {
  public:
-  DECLARE_NODE_TYPE(VariableProxy)
-
   bool IsValidReferenceExpression() const {
     return !is_this() && !is_new_target();
   }
 
   bool IsArguments() const { return is_resolved() && var()->is_arguments(); }
 
   Handle<String> name() const { return raw_name()->string(); }
   const AstRawString* raw_name() const {
     return is_resolved() ? var_->raw_name() : raw_name_;
   }
@@ skipping 37 matching lines @@
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot VariableFeedbackSlot() { return variable_feedback_slot_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BeforeId() const { return BailoutId(local_id(0)); }
   void set_next_unresolved(VariableProxy* next) { next_unresolved_ = next; }
   VariableProxy* next_unresolved() { return next_unresolved_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   VariableProxy(Zone* zone, Variable* var, int start_position,
                 int end_position);
-
   VariableProxy(Zone* zone, const AstRawString* name,
                 Variable::Kind variable_kind, int start_position,
                 int end_position);
   VariableProxy(Zone* zone, const VariableProxy* copy_from);
+
   static int parent_num_ids() { return Expression::num_ids(); }
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsThisField : public BitField8<bool, 0, 1> {};
   class IsAssignedField : public BitField8<bool, 1, 1> {};
   class IsResolvedField : public BitField8<bool, 2, 1> {};
   class IsNewTargetField : public BitField8<bool, 3, 1> {};
 
   // Start with 16-bit (or smaller) field, which should get packed together
   // with Expression's trailing 16-bit field.
@@ skipping 17 matching lines @@
   VARIABLE,
   NAMED_PROPERTY,
   KEYED_PROPERTY,
   NAMED_SUPER_PROPERTY,
   KEYED_SUPER_PROPERTY
 };
 
 
 class Property final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Property)
-
   bool IsValidReferenceExpression() const { return true; }
 
   Expression* obj() const { return obj_; }
   Expression* key() const { return key_; }
 
   void set_obj(Expression* e) { obj_ = e; }
   void set_key(Expression* e) { key_ = e; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId LoadId() const { return BailoutId(local_id(0)); }
@@ skipping 45 matching lines @@
   }
 
   static LhsKind GetAssignType(Property* property) {
     if (property == NULL) return VARIABLE;
     bool super_access = property->IsSuperAccess();
     return (property->key()->IsPropertyName())
                ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
                : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
   }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Property(Zone* zone, Expression* obj, Expression* key, int pos)
       : Expression(zone, pos, kProperty),
         bit_field_(IsForCallField::encode(false) |
                    IsStringAccessField::encode(false) |
                    InlineCacheStateField::encode(UNINITIALIZED)),
         obj_(obj),
         key_(key) {}
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsForCallField : public BitField8<bool, 0, 1> {};
   class IsStringAccessField : public BitField8<bool, 1, 1> {};
   class KeyTypeField : public BitField8<IcCheckType, 2, 1> {};
   class InlineCacheStateField : public BitField8<InlineCacheState, 3, 4> {};
+
   uint8_t bit_field_;
   FeedbackVectorSlot property_feedback_slot_;
   Expression* obj_;
   Expression* key_;
   SmallMapList receiver_types_;
 };
 
 
 class Call final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Call)
-
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   void set_expression(Expression* e) { expression_ = e; }
 
   // Type feedback information.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot CallFeedbackSlot() const { return stub_slot_; }
@@ skipping 70 matching lines @@
   // Helpers to determine how to handle the call.
   CallType GetCallType(Isolate* isolate) const;
   bool IsUsingCallFeedbackSlot(Isolate* isolate) const;
   bool IsUsingCallFeedbackICSlot(Isolate* isolate) const;
 
 #ifdef DEBUG
   // Used to assert that the FullCodeGenerator records the return site.
   bool return_is_recorded_;
 #endif
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
        int pos)
       : Expression(zone, pos, kCall),
         bit_field_(IsUninitializedField::encode(false)),
         expression_(expression),
         arguments_(arguments) {
     if (expression->IsProperty()) {
       expression->AsProperty()->mark_for_call();
     }
   }
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsUninitializedField : public BitField8<bool, 0, 1> {};
   class IsTailField : public BitField8<bool, 1, 1> {};
+
   uint8_t bit_field_;
   FeedbackVectorSlot ic_slot_;
   FeedbackVectorSlot stub_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
 };
 
 
 class CallNew final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CallNew)
-
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
 
   void set_expression(Expression* e) { expression_ = e; }
 
   // Type feedback information.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache) {
     callnew_feedback_slot_ = spec->AddGeneralSlot();
     // Construct calls have two slots, one right after the other.
@@ skipping 19 matching lines @@
   void set_allocation_site(Handle<AllocationSite> site) {
     allocation_site_ = site;
   }
   void set_is_monomorphic(bool monomorphic) { is_monomorphic_ = monomorphic; }
   void set_target(Handle<JSFunction> target) { target_ = target; }
   void SetKnownGlobalTarget(Handle<JSFunction> target) {
     target_ = target;
     is_monomorphic_ = true;
   }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   CallNew(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
           int pos)
       : Expression(zone, pos, kCallNew),
         is_monomorphic_(false),
         expression_(expression),
         arguments_(arguments) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   bool is_monomorphic_;
   FeedbackVectorSlot callnew_feedback_slot_;
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   Handle<JSFunction> target_;
   Handle<AllocationSite> allocation_site_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
 // with a set of arguments. This is used from the builtins that are
 // implemented in JavaScript (see "v8natives.js").
 class CallRuntime final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CallRuntime)
-
   ZoneList<Expression*>* arguments() const { return arguments_; }
   bool is_jsruntime() const { return function_ == NULL; }
 
   int context_index() const {
     DCHECK(is_jsruntime());
     return context_index_;
   }
   const Runtime::Function* function() const {
     DCHECK(!is_jsruntime());
     return function_;
   }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId CallId() { return BailoutId(local_id(0)); }
 
   const char* debug_name() {
     return is_jsruntime() ? "(context function)" : function_->name;
   }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   CallRuntime(Zone* zone, const Runtime::Function* function,
               ZoneList<Expression*>* arguments, int pos)
       : Expression(zone, pos, kCallRuntime),
         function_(function),
         arguments_(arguments) {}
-
   CallRuntime(Zone* zone, int context_index, ZoneList<Expression*>* arguments,
               int pos)
       : Expression(zone, pos, kCallRuntime),
         context_index_(context_index),
         function_(NULL),
         arguments_(arguments) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int context_index_;
   const Runtime::Function* function_;
   ZoneList<Expression*>* arguments_;
 };
 
 
 class UnaryOperation final : public Expression {
  public:
-  DECLARE_NODE_TYPE(UnaryOperation)
-
   Token::Value op() const { return op_; }
   Expression* expression() const { return expression_; }
   void set_expression(Expression* e) { expression_ = e; }
 
   // For unary not (Token::NOT), the AST ids where true and false will
   // actually be materialized, respectively.
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
   BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
 
   void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos)
       : Expression(zone, pos, kUnaryOperation),
         op_(op),
         expression_(expression) {
     DCHECK(Token::IsUnaryOp(op));
   }
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Token::Value op_;
   Expression* expression_;
 };
 
 
 class BinaryOperation final : public Expression {
  public:
-  DECLARE_NODE_TYPE(BinaryOperation)
-
   Token::Value op() const { return static_cast<Token::Value>(op_); }
   Expression* left() const { return left_; }
   void set_left(Expression* e) { left_ = e; }
   Expression* right() const { return right_; }
   void set_right(Expression* e) { right_ = e; }
   Handle<AllocationSite> allocation_site() const { return allocation_site_; }
   void set_allocation_site(Handle<AllocationSite> allocation_site) {
     allocation_site_ = allocation_site;
   }
 
@@ skipping 29 matching lines @@
   Maybe<int> fixed_right_arg() const {
     return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
   }
   void set_fixed_right_arg(Maybe<int> arg) {
     has_fixed_right_arg_ = arg.IsJust();
     if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
   }
 
   void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   BinaryOperation(Zone* zone, Token::Value op, Expression* left,
                   Expression* right, int pos)
       : Expression(zone, pos, kBinaryOperation),
         op_(static_cast<byte>(op)),
         has_fixed_right_arg_(false),
         fixed_right_arg_value_(0),
         left_(left),
         right_(right) {
     DCHECK(Token::IsBinaryOp(op));
   }
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   const byte op_;  // actually Token::Value
   // TODO(rossberg): the fixed arg should probably be represented as a Constant
   // type for the RHS. Currenty it's actually a Maybe<int>
   bool has_fixed_right_arg_;
   int fixed_right_arg_value_;
   Expression* left_;
   Expression* right_;
   Handle<AllocationSite> allocation_site_;
   FeedbackVectorSlot type_feedback_slot_;
 };
 
 
 class CountOperation final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CountOperation)
-
   bool is_prefix() const { return IsPrefixField::decode(bit_field_); }
   bool is_postfix() const { return !is_prefix(); }
 
   Token::Value op() const { return TokenField::decode(bit_field_); }
   Token::Value binary_op() {
     return (op() == Token::INC) ? Token::ADD : Token::SUB;
   }
 
   Expression* expression() const { return expression_; }
   void set_expression(Expression* e) { expression_ = e; }
@@ skipping 25 matching lines @@
 
   // Feedback slot for binary operation is only used by ignition.
   FeedbackVectorSlot CountBinaryOpFeedbackSlot() const {
     return binary_operation_slot_;
   }
 
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot CountSlot() const { return slot_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   CountOperation(Zone* zone, Token::Value op, bool is_prefix, Expression* expr,
                  int pos)
       : Expression(zone, pos, kCountOperation),
         bit_field_(
             IsPrefixField::encode(is_prefix) | KeyTypeField::encode(ELEMENT) |
             StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op)),
         type_(NULL),
         expression_(expr) {}
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsPrefixField : public BitField16<bool, 0, 1> {};
   class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
   class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
   class TokenField : public BitField16<Token::Value, 5, 8> {};
 
   // Starts with 16-bit field, which should get packed together with
   // Expression's trailing 16-bit field.
   uint16_t bit_field_;
   FeedbackVectorSlot slot_;
   FeedbackVectorSlot binary_operation_slot_;
   Type* type_;
   Expression* expression_;
   SmallMapList receiver_types_;
 };
 
 
 class CompareOperation final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CompareOperation)
-
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
 
   void set_left(Expression* e) { left_ = e; }
   void set_right(Expression* e) { right_ = e; }
 
   // Type feedback information.
   static int num_ids() { return parent_num_ids() + 1; }
   TypeFeedbackId CompareOperationFeedbackId() const {
     return TypeFeedbackId(local_id(0));
   }
   Type* combined_type() const { return combined_type_; }
   void set_combined_type(Type* type) { combined_type_ = type; }
 
   // Match special cases.
   bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
   bool IsLiteralCompareUndefined(Expression** expr);
   bool IsLiteralCompareNull(Expression** expr);
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   CompareOperation(Zone* zone, Token::Value op, Expression* left,
                    Expression* right, int pos)
       : Expression(zone, pos, kCompareOperation),
         op_(op),
         left_(left),
         right_(right),
         combined_type_(Type::None()) {
     DCHECK(Token::IsCompareOp(op));
   }
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Token::Value op_;
   Expression* left_;
   Expression* right_;
 
   Type* combined_type_;
 };
 
 
 class Spread final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Spread)
-
   Expression* expression() const { return expression_; }
   void set_expression(Expression* e) { expression_ = e; }
 
   int expression_position() const { return expr_pos_; }
 
   static int num_ids() { return parent_num_ids(); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Spread(Zone* zone, Expression* expression, int pos, int expr_pos)
       : Expression(zone, pos, kSpread),
         expr_pos_(expr_pos),
         expression_(expression) {}
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int expr_pos_;
   Expression* expression_;
 };
 
 
 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 set_condition(Expression* e) { condition_ = e; }
   void set_then_expression(Expression* e) { then_expression_ = e; }
   void set_else_expression(Expression* e) { else_expression_ = e; }
 
   void MarkTail() {
     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:
+ private:
+  friend class AstNodeFactory;
+
   Conditional(Zone* zone, Expression* condition, Expression* then_expression,
               Expression* else_expression, int position)
       : Expression(zone, position, kConditional),
         condition_(condition),
         then_expression_(then_expression),
         else_expression_(else_expression) {}
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* condition_;
   Expression* then_expression_;
   Expression* else_expression_;
 };
 
 
 class Assignment final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Assignment)
-
   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
 
   Token::Value binary_op() const;
 
   Token::Value op() const { return TokenField::decode(bit_field_); }
   Expression* target() const { return target_; }
   Expression* value() const { return value_; }
 
   void set_target(Expression* e) { target_ = e; }
   void set_value(Expression* e) { value_ = e; }
@@ skipping 27 matching lines @@
     bit_field_ = KeyTypeField::update(bit_field_, key_type);
   }
   void set_store_mode(KeyedAccessStoreMode mode) {
     bit_field_ = StoreModeField::update(bit_field_, mode);
   }
 
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
   FeedbackVectorSlot AssignmentSlot() const { return slot_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
              int pos);
+
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   class IsUninitializedField : public BitField16<bool, 0, 1> {};
   class KeyTypeField
       : public BitField16<IcCheckType, IsUninitializedField::kNext, 1> {};
   class StoreModeField
       : public BitField16<KeyedAccessStoreMode, KeyTypeField::kNext, 3> {};
   class TokenField : public BitField16<Token::Value, StoreModeField::kNext, 8> {
   };
 
@@ skipping 16 matching lines @@
 // phases, RewritableExpressions are considered as exceptions of AST nodes
 // in the following sense:
 //
 // 1. IsRewritableExpression and AsRewritableExpression behave as usual.
 // 2. All other Is* and As* methods are practically delegated to the
 //    wrapped node, i.e. IsArrayLiteral() will return true iff the
 //    wrapped node is an array literal.
 //
 // Furthermore, an invariant that should be respected is that the wrapped
 // node is not a RewritableExpression.
-class RewritableExpression : public Expression {
+class RewritableExpression final : public Expression {
  public:
-  DECLARE_NODE_TYPE(RewritableExpression)
-
   Expression* expression() const { return expr_; }
   bool is_rewritten() const { return is_rewritten_; }
 
   void Rewrite(Expression* new_expression) {
     DCHECK(!is_rewritten());
     DCHECK_NOT_NULL(new_expression);
     DCHECK(!new_expression->IsRewritableExpression());
     expr_ = new_expression;
     is_rewritten_ = true;
   }
 
   static int num_ids() { return parent_num_ids(); }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   RewritableExpression(Zone* zone, Expression* expression)
       : Expression(zone, expression->position(), kRewritableExpression),
         is_rewritten_(false),
         expr_(expression) {
     DCHECK(!expression->IsRewritableExpression());
   }
 
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   bool is_rewritten_;
   Expression* expr_;
 };
 
 // Our Yield is different from the JS yield in that it "returns" its argument as
 // is, without wrapping it in an iterator result object.  Such wrapping, if
 // desired, must be done beforehand (see the parser).
 class Yield final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Yield)
-
   enum OnException { kOnExceptionThrow, kOnExceptionRethrow };
 
   Expression* generator_object() const { return generator_object_; }
   Expression* expression() const { return expression_; }
   bool rethrow_on_exception() const {
     return on_exception_ == kOnExceptionRethrow;
   }
   int yield_id() const { return yield_id_; }
 
   void set_generator_object(Expression* e) { generator_object_ = e; }
   void set_expression(Expression* e) { expression_ = e; }
   void set_yield_id(int yield_id) { yield_id_ = yield_id; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Yield(Zone* zone, Expression* generator_object, Expression* expression,
         int pos, OnException on_exception)
       : Expression(zone, pos, kYield),
         on_exception_(on_exception),
         yield_id_(-1),
         generator_object_(generator_object),
         expression_(expression) {}
 
- private:
   OnException on_exception_;
   int yield_id_;
   Expression* generator_object_;
   Expression* expression_;
 };
 
 
 class Throw final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Throw)
-
   Expression* exception() const { return exception_; }
   void set_exception(Expression* e) { exception_ = e; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   Throw(Zone* zone, Expression* exception, int pos)
       : Expression(zone, pos, kThrow), exception_(exception) {}
 
- private:
   Expression* exception_;
 };
 
 
 class FunctionLiteral final : public Expression {
  public:
   enum FunctionType {
     kAnonymousExpression,
     kNamedExpression,
     kDeclaration,
     kAccessorOrMethod
   };
 
   enum ParameterFlag { kNoDuplicateParameters, kHasDuplicateParameters };
 
   enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
 
-  DECLARE_NODE_TYPE(FunctionLiteral)
-
   Handle<String> name() const { return raw_name_->string(); }
   const AstString* raw_name() const { return raw_name_; }
   void set_raw_name(const AstString* name) { raw_name_ = name; }
   DeclarationScope* scope() const { return scope_; }
   ZoneList<Statement*>* body() const { return body_; }
   void set_function_token_position(int pos) { function_token_position_ = pos; }
   int function_token_position() const { return function_token_position_; }
   int start_position() const;
   int end_position() const;
   int SourceSize() const { return end_position() - start_position(); }
@@ skipping 98 matching lines @@
     dont_optimize_reason_ = reason;
   }
 
   bool IsAnonymousFunctionDefinition() const {
     return is_anonymous_expression();
   }
 
   int yield_count() { return yield_count_; }
   void set_yield_count(int yield_count) { yield_count_ = yield_count; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   FunctionLiteral(Zone* zone, const AstString* name,
                   AstValueFactory* ast_value_factory, DeclarationScope* scope,
                   ZoneList<Statement*>* body, int materialized_literal_count,
                   int expected_property_count, int parameter_count,
                   FunctionType function_type,
                   ParameterFlag has_duplicate_parameters,
                   EagerCompileHint eager_compile_hint, FunctionKind kind,
                   int position, bool is_function)
       : Expression(zone, position, kFunctionLiteral),
         dont_optimize_reason_(kNoReason),
@@ skipping 10 matching lines @@
     bitfield_ =
         FunctionTypeBits::encode(function_type) | Pretenure::encode(false) |
         HasDuplicateParameters::encode(has_duplicate_parameters ==
                                        kHasDuplicateParameters) |
         IsFunction::encode(is_function) |
         ShouldEagerCompile::encode(eager_compile_hint == kShouldEagerCompile) |
         FunctionKindBits::encode(kind) | ShouldBeUsedOnceHint::encode(false);
     DCHECK(IsValidFunctionKind(kind));
   }
 
- private:
   class FunctionTypeBits : public BitField16<FunctionType, 0, 2> {};
   class Pretenure : public BitField16<bool, 2, 1> {};
   class HasDuplicateParameters : public BitField16<bool, 3, 1> {};
   class IsFunction : public BitField16<bool, 4, 1> {};
   class ShouldEagerCompile : public BitField16<bool, 5, 1> {};
   class ShouldBeUsedOnceHint : public BitField16<bool, 6, 1> {};
   class FunctionKindBits : public BitField16<FunctionKind, 7, 9> {};
 
   // Start with 16-bit field, which should get packed together
   // with Expression's trailing 16-bit field.
@@ skipping 13 matching lines @@
   const AstString* raw_inferred_name_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
 };
 
 
 class ClassLiteral final : public Expression {
  public:
   typedef ObjectLiteralProperty Property;
 
-  DECLARE_NODE_TYPE(ClassLiteral)
-
   VariableProxy* class_variable_proxy() const { return class_variable_proxy_; }
   Expression* extends() const { return extends_; }
   void set_extends(Expression* e) { extends_ = e; }
   FunctionLiteral* constructor() const { return constructor_; }
   void set_constructor(FunctionLiteral* f) { constructor_ = f; }
   ZoneList<Property*>* properties() const { return properties_; }
   int start_position() const { return position(); }
   int end_position() const { return end_position_; }
 
   BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
@@ skipping 12 matching lines @@
                                  FeedbackVectorSlotCache* cache);
 
   bool NeedsProxySlot() const {
     return class_variable_proxy() != nullptr &&
            class_variable_proxy()->var()->IsUnallocated();
   }
 
   FeedbackVectorSlot PrototypeSlot() const { return prototype_slot_; }
   FeedbackVectorSlot ProxySlot() const { return proxy_slot_; }
 
+ private:
+  friend class AstNodeFactory;
 
- protected:
   ClassLiteral(Zone* zone, VariableProxy* class_variable_proxy,
                Expression* extends, FunctionLiteral* constructor,
                ZoneList<Property*>* properties, int start_position,
                int end_position)
       : Expression(zone, start_position, kClassLiteral),
         end_position_(end_position),
         class_variable_proxy_(class_variable_proxy),
         extends_(extends),
         constructor_(constructor),
         properties_(properties) {}
 
   static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   int end_position_;
   FeedbackVectorSlot prototype_slot_;
   FeedbackVectorSlot proxy_slot_;
   VariableProxy* class_variable_proxy_;
   Expression* extends_;
   FunctionLiteral* constructor_;
   ZoneList<Property*>* properties_;
 };
 
 
 class NativeFunctionLiteral final : public Expression {
  public:
-  DECLARE_NODE_TYPE(NativeFunctionLiteral)
-
   Handle<String> name() const { return name_->string(); }
   v8::Extension* extension() const { return extension_; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   NativeFunctionLiteral(Zone* zone, const AstRawString* name,
                         v8::Extension* extension, int pos)
       : Expression(zone, pos, kNativeFunctionLiteral),
         name_(name),
         extension_(extension) {}
 
- private:
   const AstRawString* name_;
   v8::Extension* extension_;
 };
 
 
 class ThisFunction final : public Expression {
- public:
-  DECLARE_NODE_TYPE(ThisFunction)
-
- protected:
+ private:
+  friend class AstNodeFactory;
   ThisFunction(Zone* zone, int pos) : Expression(zone, pos, kThisFunction) {}
 };
 
 
 class SuperPropertyReference final : public Expression {
  public:
-  DECLARE_NODE_TYPE(SuperPropertyReference)
-
   VariableProxy* this_var() const { return this_var_; }
   void set_this_var(VariableProxy* v) { this_var_ = v; }
   Expression* home_object() const { return home_object_; }
   void set_home_object(Expression* e) { home_object_ = e; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   SuperPropertyReference(Zone* zone, VariableProxy* this_var,
                          Expression* home_object, int pos)
       : Expression(zone, pos, kSuperPropertyReference),
         this_var_(this_var),
         home_object_(home_object) {
     DCHECK(this_var->is_this());
     DCHECK(home_object->IsProperty());
   }
 
- private:
   VariableProxy* this_var_;
   Expression* home_object_;
 };
 
 
 class SuperCallReference final : public Expression {
  public:
-  DECLARE_NODE_TYPE(SuperCallReference)
-
   VariableProxy* this_var() const { return this_var_; }
   void set_this_var(VariableProxy* v) { this_var_ = v; }
   VariableProxy* new_target_var() const { return new_target_var_; }
   void set_new_target_var(VariableProxy* v) { new_target_var_ = v; }
   VariableProxy* this_function_var() const { return this_function_var_; }
   void set_this_function_var(VariableProxy* v) { this_function_var_ = v; }
 
- protected:
+ private:
+  friend class AstNodeFactory;
+
   SuperCallReference(Zone* zone, VariableProxy* this_var,
                      VariableProxy* new_target_var,
                      VariableProxy* this_function_var, int pos)
       : Expression(zone, pos, kSuperCallReference),
         this_var_(this_var),
         new_target_var_(new_target_var),
         this_function_var_(this_function_var) {
     DCHECK(this_var->is_this());
     DCHECK(new_target_var->raw_name()->IsOneByteEqualTo(".new.target"));
     DCHECK(this_function_var->raw_name()->IsOneByteEqualTo(".this_function"));
   }
 
- private:
   VariableProxy* this_var_;
   VariableProxy* new_target_var_;
   VariableProxy* this_function_var_;
 };
 
 
 // This class is produced when parsing the () in arrow functions without any
 // arguments and is not actually a valid expression.
 class EmptyParentheses final : public Expression {
- public:
-  DECLARE_NODE_TYPE(EmptyParentheses)
+ private:
+  friend class AstNodeFactory;
 
- private:
   EmptyParentheses(Zone* zone, int pos)
       : Expression(zone, pos, kEmptyParentheses) {}
 };
 
 
-#undef DECLARE_NODE_TYPE
-
 
 // ----------------------------------------------------------------------------
 // Basic visitor
 // Sub-class should parametrize AstVisitor with itself, e.g.:
 //   class SpecificVisitor : public AstVisitor<SpecificVisitor> { ... }
 
 template <class Subclass>
 class AstVisitor BASE_EMBEDDED {
  public:
   void Visit(AstNode* node) { impl()->Visit(node); }
@@ skipping 630 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_