[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 277 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)
+  friend class AstNodeFactory;

[adamk, 2016/08/05 21:52:35]

I think we generally put friend declarations in the "private" section (which
keeps the "public" section more useful as API documentation).

 
   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...
@@ skipping 15 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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;
@@ skipping 36 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)
+  friend class AstNodeFactory;
 
   InitializationFlag initialization() const {
     return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
   }
 
  protected:
   VariableDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
                       Scope* scope, int pos)
       : Declaration(zone, proxy, mode, scope, pos, kVariableDeclaration) {}
 };
 
 
 class FunctionDeclaration final : public Declaration {
  public:
-  DECLARE_NODE_TYPE(FunctionDeclaration)
+  friend class AstNodeFactory;
 
   FunctionLiteral* fun() const { return fun_; }
   void set_fun(FunctionLiteral* f) { fun_ = f; }
   InitializationFlag initialization() const { return kCreatedInitialized; }
 
  protected:
   FunctionDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
                       FunctionLiteral* fun, Scope* scope, int pos)
       : Declaration(zone, proxy, mode, scope, pos, kFunctionDeclaration),
         fun_(fun) {
@@ skipping 39 matching lines @@
 
   Statement* body_;
   Label continue_target_;
   int yield_count_;
   int first_yield_id_;
 };
 
 
 class DoWhileStatement final : public IterationStatement {
  public:
-  DECLARE_NODE_TYPE(DoWhileStatement)
+  friend class AstNodeFactory;
 
   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:
   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)
+  friend class AstNodeFactory;
 
   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:
   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)
+  friend class AstNodeFactory;
 
   void Initialize(Statement* init,
                   Expression* cond,
                   Statement* next,
                   Statement* body) {
     IterationStatement::Initialize(body);
     init_ = init;
     cond_ = cond;
     next_ = next;
   }
@@ skipping 43 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)
+  friend class AstNodeFactory;
 
   void Initialize(Expression* each, Expression* subject, Statement* body) {
     ForEachStatement::Initialize(body);
     each_ = each;
     subject_ = subject;
   }
 
   Expression* enumerable() const {
     return subject();
   }
@@ skipping 41 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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 50 matching lines @@
   Variable* iterator_;
   Expression* assign_iterator_;
   Expression* next_result_;
   Expression* result_done_;
   Expression* assign_each_;
 };
 
 
 class ExpressionStatement final : public Statement {
  public:
-  DECLARE_NODE_TYPE(ExpressionStatement)
+  friend class AstNodeFactory;
 
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
   bool IsJump() const { return expression_->IsThrow(); }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   IterationStatement* target() const { return target_; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   BreakableStatement* target() const { return target_; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   Expression* expression() const { return expression_; }
 
   void set_expression(Expression* e) { expression_ = e; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   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)); }
@@ skipping 19 matching lines @@
 
   int base_id_;
   Scope* scope_;
   Expression* expression_;
   Statement* statement_;
 };
 
 
 class CaseClause final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CaseClause)
+  friend class AstNodeFactory;
 
   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_; }
 
@@ skipping 14 matching lines @@
 
   Expression* label_;
   Label body_target_;
   ZoneList<Statement*>* statements_;
   Type* compare_type_;
 };
 
 
 class SwitchStatement final : public BreakableStatement {
  public:
-  DECLARE_NODE_TYPE(SwitchStatement)
+  friend class AstNodeFactory;
 
   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; }
@@ skipping 11 matching lines @@
 };
 
 
 // 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)
+  friend class AstNodeFactory;
 
   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; }
@@ skipping 65 matching lines @@
 
   HandlerTable::CatchPrediction catch_prediction_;
 
  private:
   Block* try_block_;
 };
 
 
 class TryCatchStatement final : public TryStatement {
  public:
-  DECLARE_NODE_TYPE(TryCatchStatement)
+  friend class AstNodeFactory;
 
   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
@@ skipping 20 matching lines @@
 
  private:
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
 };
 
 
 class TryFinallyStatement final : public TryStatement {
  public:
-  DECLARE_NODE_TYPE(TryFinallyStatement)
+  friend class AstNodeFactory;
 
   Block* finally_block() const { return finally_block_; }
   void set_finally_block(Block* b) { finally_block_ = b; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   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:
   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)
+  friend class AstNodeFactory;
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   Statement* statement() const { return statement_; }
   void set_statement(Statement* statement) { statement_ = statement; }
   Scope* scope() const { return scope_; }
 
  private:
   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)
+  friend class AstNodeFactory;
 
   bool IsPropertyName() const { return value_->IsPropertyName(); }
 
   Handle<String> AsPropertyName() {
     DCHECK(IsPropertyName());
     return Handle<String>::cast(value());
   }
 
   const AstRawString* AsRawPropertyName() {
     DCHECK(IsPropertyName());
@@ skipping 146 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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 {
@@ skipping 99 matching lines @@
   }
 
  private:
   Zone* zone_;
 };
 
 
 // Node for capturing a regexp literal.
 class RegExpLiteral final : public MaterializedLiteral {
  public:
-  DECLARE_NODE_TYPE(RegExpLiteral)
+  friend class AstNodeFactory;
 
   Handle<String> pattern() const { return pattern_->string(); }
   int flags() const { return flags_; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   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_; }
 
@@ skipping 54 matching lines @@
 
   int first_spread_index_;
   FeedbackVectorSlot literal_slot_;
   Handle<FixedArray> constant_elements_;
   ZoneList<Expression*>* values_;
 };
 
 
 class VariableProxy final : public Expression {
  public:
-  DECLARE_NODE_TYPE(VariableProxy)
+  friend class AstNodeFactory;
 
   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 83 matching lines @@
   VARIABLE,
   NAMED_PROPERTY,
   KEYED_PROPERTY,
   NAMED_SUPER_PROPERTY,
   KEYED_SUPER_PROPERTY
 };
 
 
 class Property final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Property)
+  friend class AstNodeFactory;
 
   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; }
@@ skipping 73 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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);
 
@@ skipping 101 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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();
@@ skipping 48 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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());
@@ skipping 27 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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)); }
@@ skipping 12 matching lines @@
  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)
+  friend class AstNodeFactory;
 
   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 49 matching lines @@
   bool has_fixed_right_arg_;
   int fixed_right_arg_value_;
   Expression* left_;
   Expression* right_;
   Handle<AllocationSite> allocation_site_;
 };
 
 
 class CountOperation final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CountOperation)
+  friend class AstNodeFactory;
 
   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_; }
@@ skipping 52 matching lines @@
   uint16_t bit_field_;
   FeedbackVectorSlot slot_;
   Type* type_;
   Expression* expression_;
   SmallMapList receiver_types_;
 };
 
 
 class CompareOperation final : public Expression {
  public:
-  DECLARE_NODE_TYPE(CompareOperation)
+  friend class AstNodeFactory;
 
   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; }
@@ skipping 26 matching lines @@
   Token::Value op_;
   Expression* left_;
   Expression* right_;
 
   Type* combined_type_;
 };
 
 
 class Spread final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Spread)
+  friend class AstNodeFactory;
 
   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:
   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)
+  friend class AstNodeFactory;
 
   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() {
@@ skipping 18 matching lines @@
   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)
+  friend class AstNodeFactory;
 
   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; }
@@ skipping 72 matching lines @@
 //
 // 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 {
  public:
-  DECLARE_NODE_TYPE(RewritableExpression)
+  friend class AstNodeFactory;
 
   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;
@@ skipping 14 matching lines @@
 
   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)
+  friend class AstNodeFactory;
 
   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_; }
 
@@ skipping 13 matching lines @@
  private:
   OnException on_exception_;
   int yield_id_;
   Expression* generator_object_;
   Expression* expression_;
 };
 
 
 class Throw final : public Expression {
  public:
-  DECLARE_NODE_TYPE(Throw)
+  friend class AstNodeFactory;
 
   Expression* exception() const { return exception_; }
   void set_exception(Expression* e) { exception_ = e; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
   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; }
   Scope* 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;
@@ skipping 164 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)
+  friend class AstNodeFactory;
 
   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_; }
 
@@ skipping 43 matching lines @@
   FeedbackVectorSlot proxy_slot_;
   VariableProxy* class_variable_proxy_;
   Expression* extends_;
   FunctionLiteral* constructor_;
   ZoneList<Property*>* properties_;
 };
 
 
 class NativeFunctionLiteral final : public Expression {
  public:
-  DECLARE_NODE_TYPE(NativeFunctionLiteral)
+  friend class AstNodeFactory;
 
   Handle<String> name() const { return name_->string(); }
   v8::Extension* extension() const { return extension_; }
 
  protected:
   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)
+  friend class AstNodeFactory;
 
  protected:
   ThisFunction(Zone* zone, int pos) : Expression(zone, pos, kThisFunction) {}
 };
 
 
 class SuperPropertyReference final : public Expression {
  public:
-  DECLARE_NODE_TYPE(SuperPropertyReference)
+  friend class AstNodeFactory;
 
   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:
   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)
+  friend class AstNodeFactory;
 
   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:
   SuperCallReference(Zone* zone, VariableProxy* this_var,
@@ skipping 12 matching lines @@
   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)
+  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 632 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_