Add a generic mechanism for expression rewriting

src/ast/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 487 matching lines @@
   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; }
 
   void MarkTail() override { block_->MarkTail(); }
 
  protected:
   DoExpression(Zone* zone, Block* block, VariableProxy* result, int pos)
       : Expression(zone, pos), block_(block), result_(result) {
     DCHECK_NOT_NULL(block_);
     DCHECK_NOT_NULL(result_);
   }
   static int parent_num_ids() { return Expression::num_ids(); }
@@ skipping 57 matching lines @@
   bool is_class_declaration_;
   int declaration_group_start_;
 };
 
 
 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 override {
     return kCreatedInitialized;
   }
   bool IsInlineable() const override;
 
  protected:
   FunctionDeclaration(Zone* zone,
                       VariableProxy* proxy,
                       VariableMode mode,
                       FunctionLiteral* fun,
@@ skipping 103 matching lines @@
 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 override { return BailoutId(local_id(0)); }
   BailoutId StackCheckId() const override { return BackEdgeId(); }
   BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
 
  protected:
   DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos), 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 override { return EntryId(); }
   BailoutId StackCheckId() const override { return BodyId(); }
   BailoutId BodyId() const { return BailoutId(local_id(0)); }
 
  protected:
   WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos), cond_(NULL) {}
   static int parent_num_ids() { return IterationStatement::num_ids(); }
@@ skipping 16 matching lines @@
     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 override { return BailoutId(local_id(0)); }
   BailoutId StackCheckId() const override { return BodyId(); }
   BailoutId BodyId() const { return BailoutId(local_id(1)); }
 
  protected:
   ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos),
         init_(NULL),
         cond_(NULL),
@@ skipping 18 matching lines @@
 
   void Initialize(Expression* each, Expression* subject, Statement* body) {
     IterationStatement::Initialize(body);
     each_ = each;
     subject_ = subject;
   }
 
   Expression* each() const { return each_; }
   Expression* subject() const { return subject_; }
 
+  void set_each(Expression* e) { each_ = e; }
+  void set_subject(Expression* e) { subject_ = e; }
+
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache) override;
   FeedbackVectorSlot EachFeedbackSlot() const { return each_slot_; }
 
  protected:
   ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : IterationStatement(zone, labels, pos), each_(NULL), subject_(NULL) {}
 
  private:
   Expression* each_;
@@ skipping 172 matching lines @@
   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:
   explicit ReturnStatement(Zone* zone, Expression* expression, int pos)
       : JumpStatement(zone, pos), 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)); }
 
   void MarkTail() override { statement_->MarkTail(); }
 
@@ skipping 24 matching lines @@
 
 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)); }
 
   void MarkTail() override {
     if (!statements_->is_empty()) statements_->last()->MarkTail();
   }
@@ skipping 21 matching lines @@
   DECLARE_NODE_TYPE(SwitchStatement)
 
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
     tag_ = tag;
     cases_ = cases;
   }
 
   Expression* tag() const { return tag_; }
   ZoneList<CaseClause*>* cases() const { return cases_; }
 
+  void set_tag(Expression* t) { tag_ = t; }
+
   void MarkTail() override {
     if (!cases_->is_empty()) cases_->last()->MarkTail();
   }
 
  protected:
   SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
         tag_(NULL),
         cases_(NULL) {}
 
@@ skipping 12 matching lines @@
  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 override {
     return HasThenStatement() && then_statement()->IsJump()
         && HasElseStatement() && else_statement()->IsJump();
   }
 
   void MarkTail() override {
     then_statement_->MarkTail();
@@ skipping 274 matching lines @@
     COMPUTED,              // Property with computed value (execution time).
     MATERIALIZED_LITERAL,  // Property value is a materialized literal.
     GETTER, SETTER,        // Property is an accessor function.
     PROTOTYPE              // Property is __proto__.
   };
 
   Expression* key() { return key_; }
   Expression* value() { return value_; }
   Kind kind() { return kind_; }
 
+  void set_key(Expression* e) { key_ = e; }
+  void set_value(Expression* e) { value_ = e; }
+
   // Type feedback information.
   bool IsMonomorphic() { return !receiver_type_.is_null(); }
   Handle<Map> GetReceiverType() { return receiver_type_; }
 
   bool IsCompileTimeValue();
 
   void set_emit_store(bool emit_store);
   bool emit_store();
 
   bool is_static() const { return is_static_; }
@@ skipping 353 matching lines @@
 
 class Property final : public Expression {
  public:
   DECLARE_NODE_TYPE(Property)
 
   bool IsValidReferenceExpression() const override { 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)); }
 
   bool IsStringAccess() const {
     return IsStringAccessField::decode(bit_field_);
   }
 
   // Type feedback information.
   bool IsMonomorphic() override { return receiver_types_.length() == 1; }
   SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
@@ skipping 71 matching lines @@
 };
 
 
 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) override;
 
   FeedbackVectorSlot CallFeedbackSlot() const { return stub_slot_; }
 
   FeedbackVectorSlot CallFeedbackICSlot() const { return ic_slot_; }
 
   SmallMapList* GetReceiverTypes() override {
     if (expression()->IsProperty()) {
@@ skipping 99 matching lines @@
 };
 
 
 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) override {
     callnew_feedback_slot_ = spec->AddGeneralSlot();
   }
 
   FeedbackVectorSlot CallNewFeedbackSlot() {
     DCHECK(!callnew_feedback_slot_.IsInvalid());
     return callnew_feedback_slot_;
   }
@@ skipping 89 matching lines @@
   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) override;
 
  protected:
@@ skipping 10 matching lines @@
   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;
   }
 
   void MarkTail() override {
     switch (op()) {
       case Token::COMMA:
       case Token::AND:
       case Token::OR:
@@ skipping 54 matching lines @@
 
   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; }
 
   bool IsMonomorphic() override { return receiver_types_.length() == 1; }
   SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
   IcCheckType GetKeyType() const override {
     return KeyTypeField::decode(bit_field_);
   }
   KeyedAccessStoreMode GetStoreMode() const override {
     return StoreModeField::decode(bit_field_);
   }
   Type* type() const { return type_; }
@@ skipping 49 matching lines @@
 
 
 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);
@@ skipping 21 matching lines @@
 
   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; }
 
   static int num_ids() { return parent_num_ids(); }
 
  protected:
   Spread(Zone* zone, Expression* expression, int pos)
       : Expression(zone, 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; }
 
   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() override {
     then_expression_->MarkTail();
     else_expression_->MarkTail();
   }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId ThenId() const { return BailoutId(local_id(0)); }
   BailoutId ElseId() const { return BailoutId(local_id(1)); }
 
  protected:
@@ skipping 19 matching lines @@
   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; }
+
   BinaryOperation* binary_operation() const { return binary_operation_; }
 
   // This check relies on the definition order of token in token.h.
   bool is_compound() const { return op() > Token::ASSIGN; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
 
   // Type feedback information.
   TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
@@ skipping 52 matching lines @@
 };
 
 
 class RewritableAssignmentExpression : public Expression {
  public:
   DECLARE_NODE_TYPE(RewritableAssignmentExpression)
 
   Expression* expression() { return expr_; }
   bool is_rewritten() const { return is_rewritten_; }
 
+  void set_expression(Expression* e) { expr_ = e; }
+
   void Rewrite(Expression* new_expression) {
     DCHECK(!is_rewritten());
     DCHECK_NOT_NULL(new_expression);
     expr_ = new_expression;
     is_rewritten_ = true;
   }
 
   static int num_ids() { return parent_num_ids(); }
 
  protected:
@@ skipping 18 matching lines @@
     kInitial,  // The initial yield that returns the unboxed generator object.
     kSuspend,  // A normal yield: { value: EXPRESSION, done: false }
     kDelegating,  // A yield*.
     kFinal        // A return: { value: EXPRESSION, done: true }
   };
 
   Expression* generator_object() const { return generator_object_; }
   Expression* expression() const { return expression_; }
   Kind yield_kind() const { return yield_kind_; }
 
+  void set_generator_object(Expression* e) { generator_object_ = e; }
+  void set_expression(Expression* e) { expression_ = e; }
+
   // Type feedback information.
   bool HasFeedbackSlots() const { return yield_kind() == kDelegating; }
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache) override {
     if (HasFeedbackSlots()) {
       yield_first_feedback_slot_ = spec->AddKeyedLoadICSlot();
       keyed_load_feedback_slot_ = spec->AddLoadICSlot();
       done_feedback_slot_ = spec->AddLoadICSlot();
     }
   }
@@ skipping 23 matching lines @@
   FeedbackVectorSlot keyed_load_feedback_slot_;
   FeedbackVectorSlot done_feedback_slot_;
 };
 
 
 class Throw final : public Expression {
  public:
   DECLARE_NODE_TYPE(Throw)
 
   Expression* exception() const { return exception_; }
+  void set_exception(Expression* e) { exception_ = e; }
 
  protected:
   Throw(Zone* zone, Expression* exception, int pos)
       : Expression(zone, pos), exception_(exception) {}
 
  private:
   Expression* exception_;
 };
 
 
@@ skipping 199 matching lines @@
   Handle<String> name() const { return raw_name_->string(); }
   const AstRawString* raw_name() const { return raw_name_; }
   void set_raw_name(const AstRawString* name) {
     DCHECK_NULL(raw_name_);
     raw_name_ = name;
   }
 
   Scope* scope() const { return scope_; }
   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 EntryId() const { return BailoutId(local_id(0)); }
   BailoutId DeclsId() const { return BailoutId(local_id(1)); }
   BailoutId ExitId() { return BailoutId(local_id(2)); }
   BailoutId CreateLiteralId() const { return BailoutId(local_id(3)); }
 
   // Return an AST id for a property that is used in simulate instructions.
@@ skipping 70 matching lines @@
  protected:
   ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
 };
 
 
 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:
   SuperPropertyReference(Zone* zone, VariableProxy* this_var,
                          Expression* home_object, int pos)
       : Expression(zone, pos), 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:
   SuperCallReference(Zone* zone, VariableProxy* this_var,
                      VariableProxy* new_target_var,
                      VariableProxy* this_function_var, int pos)
       : Expression(zone, pos),
         this_var_(this_var),
         new_target_var_(new_target_var),
         this_function_var_(this_function_var) {
     DCHECK(this_var->is_this());
@@ skipping 423 matching lines @@
   }                                                         \
                                                             \
   void InitializeAstVisitor(uintptr_t stack_limit) {        \
     stack_limit_ = stack_limit;                             \
     stack_overflow_ = false;                                \
   }                                                         \
                                                             \
   uintptr_t stack_limit_;                                   \
   bool stack_overflow_
 
+#define DEFINE_AST_REWRITER_SUBCLASS_MEMBERS()        \
+ public:                                              \
+  AstNode* Rewrite(AstNode* node) {                   \
+    DCHECK_NULL(replacement_);                        \
+    Visit(node);                                      \
+    if (HasStackOverflow()) return nullptr;           \
+    if (replacement_ == nullptr) return node;         \
+    AstNode* result = replacement_;                   \
+    replacement_ = nullptr;                           \
+    return result;                                    \
+  }                                                   \
+                                                      \
+ private:                                             \
+  void InitializeAstRewriter(Isolate* isolate) {      \
+    InitializeAstVisitor(isolate);                    \
+    replacement_ = nullptr;                           \
+  }                                                   \
+                                                      \
+  void InitializeAstRewriter(uintptr_t stack_limit) { \
+    InitializeAstVisitor(stack_limit);                \
+    replacement_ = nullptr;                           \
+  }                                                   \
+                                                      \
+  DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();              \
+                                                      \
+ protected:                                           \
+  AstNode* replacement_
+
+// Macro for rewriting things; `GET` is the expression to be rewritten;
+// `SET` is a command that should do the rewriting, i.e. something
+// sensible with the variable called `replacement`.
+#define AST_REWRITE(Type, GET, SET)                            \

[rossberg, 2016/01/08 10:36:57]

Can this macro be simplified to just AST_REWRITE(Type, name),

[rossberg, 2016/01/08 10:36:57]

Is there a strong reason to put this here instead of ast-rewriter.cc?

Also, do you think it's worth adding a second wrapper macro around this one,
like AST_REWRITE_PROPERTY(Type, name)? Almost all invocations are of that form.

[nickie, 2016/01/08 13:22:09]

Most of its uses are of the form:

    AST_REWRITE(Statement, node->body(), node->set_body(replacement));

In these cases, we could assume that there are getter/setter methods called
"##name()" and "set_# ##name(Type)", but still the "node" object would either
have to be hardwired, or made into a third parameter.

However, there are some uses of the form:

    AST_REWRITE(Statement, statements->at(i), statements->Set(i, replacement));

and these are the main reason why I did not try to make something fancier here. 
It's not clear what these will become.  Unless you want to have two macros --- a
simpler and a more generic.

[nickie, 2016/01/08 13:22:09]

I think that the macro will be useful in classes derived from
AstExpressionRewriter, to define specific rewriting behaviour.  That's why I put
it here.  So far, it's only used from ast-expression-rewriter.cc.
Yes, this was addressed in the comment above.  I think it would need a third
parameter (the object whose property we're replacing).

+  do {                                                         \
+    DCHECK(!HasStackOverflow());                               \
+    DCHECK_NULL(replacement_);                                 \
+    Visit(GET);                                                \
+    if (HasStackOverflow()) return;                            \
+    if (replacement_ == nullptr) break;                        \
+    Type* replacement = reinterpret_cast<Type*>(replacement_); \
+    do {                                                       \
+      SET;                                                     \
+    } while (false);                                           \
+    replacement_ = nullptr;                                    \
+  } while (false)
+
 
 // ----------------------------------------------------------------------------
 // AstNode factory
 
 class AstNodeFactory final BASE_EMBEDDED {
  public:
   explicit AstNodeFactory(AstValueFactory* ast_value_factory)
       : local_zone_(ast_value_factory->zone()),
         parser_zone_(ast_value_factory->zone()),
         ast_value_factory_(ast_value_factory) {}
@@ skipping 432 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_