Version 3.0.2.

src/ast.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 417 matching lines @@
   FunctionLiteral* fun_;
 };
 
 
 class IterationStatement: public BreakableStatement {
  public:
   // Type testing & conversion.
   virtual IterationStatement* AsIterationStatement() { return this; }
 
   Statement* body() const { return body_; }
+  void set_body(Statement* stmt) { body_ = stmt; }
 
   // Bailout support.
   int OsrEntryId() const { return osr_entry_id_; }
   virtual int ContinueId() const = 0;
 
   // Code generation
   BreakTarget* continue_target()  { return &continue_target_; }
 
  protected:
   explicit inline IterationStatement(ZoneStringList* labels);
@@ skipping 76 matching lines @@
                   Expression* cond,
                   Statement* next,
                   Statement* body) {
     IterationStatement::Initialize(body);
     init_ = init;
     cond_ = cond;
     next_ = next;
   }
 
   Statement* init() const { return init_; }
+  void set_init(Statement* stmt) { init_ = stmt; }
   Expression* cond() const { return cond_; }
+  void set_cond(Expression* expr) { cond_ = expr; }
   Statement* next() const { return next_; }
+  void set_next(Statement* stmt) { next_ = stmt; }
 
   bool may_have_function_literal() const {
     return may_have_function_literal_;
   }
   void set_may_have_function_literal(bool value) {
     may_have_function_literal_ = value;
   }
 
   // Bailout support.
   virtual int ContinueId() const { return next_id_; }
@@ skipping 22 matching lines @@
   void Initialize(Expression* each, Expression* enumerable, Statement* body) {
     IterationStatement::Initialize(body);
     each_ = each;
     enumerable_ = enumerable;
   }
 
   Expression* each() const { return each_; }
   Expression* enumerable() const { return enumerable_; }
 
   // Bailout support.
-  int AssignmentId() const { return assignment_id_; }
   virtual int ContinueId() const { return EntryId(); }
 
  private:
   Expression* each_;
   Expression* enumerable_;
-  int assignment_id_;
 };
 
 
 class ExpressionStatement: public Statement {
  public:
   explicit ExpressionStatement(Expression* expression)
       : expression_(expression) { }
 
   DECLARE_NODE_TYPE(ExpressionStatement)
 
@@ skipping 144 matching lines @@
 
   DECLARE_NODE_TYPE(IfStatement)
 
   virtual bool IsInlineable() const;
 
   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_; }
+  void set_then_statement(Statement* stmt) { then_statement_ = stmt; }
   Statement* else_statement() const { return else_statement_; }
+  void set_else_statement(Statement* stmt) { else_statement_ = stmt; }
 
  private:
   Expression* condition_;
   Statement* then_statement_;
   Statement* else_statement_;
 };
 
 
 // NOTE: TargetCollectors are represented as nodes to fit in the target
 // stack in the compiler; this should probably be reworked.
@@ skipping 661 matching lines @@
  private:
   Token::Value op_;
   Expression* expression_;
   int pos_;
 };
 
 
 class CountOperation: public Expression {
  public:
   CountOperation(bool is_prefix, IncrementOperation* increment, int pos)
-      : is_prefix_(is_prefix), increment_(increment), pos_(pos),
-        assignment_id_(GetNextId()) {
-  }
+      : is_prefix_(is_prefix), increment_(increment), pos_(pos) { }
 
   DECLARE_NODE_TYPE(CountOperation)
 
   bool is_prefix() const { return is_prefix_; }
   bool is_postfix() const { return !is_prefix_; }
 
   Token::Value op() const { return increment_->op(); }
   Token::Value binary_op() {
     return (op() == Token::INC) ? Token::ADD : Token::SUB;
   }
 
   Expression* expression() const { return increment_->expression(); }
   IncrementOperation* increment() const { return increment_; }
   int position() const { return pos_; }
 
   virtual void MarkAsStatement() { is_prefix_ = true; }
 
   virtual bool IsInlineable() const;
 
-  // Bailout support.
-  int AssignmentId() const { return assignment_id_; }
-
  private:
   bool is_prefix_;
   IncrementOperation* increment_;
   int pos_;
-  int assignment_id_;
 };
 
 
 class CompareOperation: public Expression {
  public:
   CompareOperation(Token::Value op,
                    Expression* left,
                    Expression* right,
                    int pos)
       : op_(op), left_(left), right_(right), pos_(pos), compare_type_(NONE) {
@@ skipping 109 matching lines @@
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   virtual ZoneMapList* GetReceiverTypes() { return receiver_types_; }
   virtual Handle<Map> GetMonomorphicReceiverType() {
     return monomorphic_receiver_type_;
   }
 
   // Bailout support.
-  int CompoundLoadId() const { return compound_load_id_; }
-  int AssignmentId() const { return assignment_id_; }
+  int compound_bailout_id() const { return compound_bailout_id_; }
 
  private:
   Token::Value op_;
   Expression* target_;
   Expression* value_;
   int pos_;
   BinaryOperation* binary_operation_;
-  int compound_load_id_;
-  int assignment_id_;
+  int compound_bailout_id_;
 
   bool block_start_;
   bool block_end_;
 
   bool is_monomorphic_;
   ZoneMapList* receiver_types_;
   Handle<Map> monomorphic_receiver_type_;
 };
 
 
@@ skipping 518 matching lines @@
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_