Rename ASSERT* to DCHECK*.

src/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_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 410 matching lines @@
 
  protected:
   BreakableStatement(
       Zone* zone, ZoneList<const AstRawString*>* labels,
       BreakableType breakable_type, int position)
       : Statement(zone, position),
         labels_(labels),
         breakable_type_(breakable_type),
         entry_id_(GetNextId(zone)),
         exit_id_(GetNextId(zone)) {
-    ASSERT(labels == NULL || labels->length() > 0);
+    DCHECK(labels == NULL || labels->length() > 0);
   }
 
 
  private:
   ZoneList<const AstRawString*>* labels_;
   BreakableType breakable_type_;
   Label break_target_;
   const BailoutId entry_id_;
   const BailoutId exit_id_;
 };
@@ skipping 52 matching lines @@
  protected:
   Declaration(Zone* zone,
               VariableProxy* proxy,
               VariableMode mode,
               Scope* scope,
               int pos)
       : AstNode(pos),
         proxy_(proxy),
         mode_(mode),
         scope_(scope) {
-    ASSERT(IsDeclaredVariableMode(mode));
+    DCHECK(IsDeclaredVariableMode(mode));
   }
 
  private:
   VariableProxy* proxy_;
   VariableMode mode_;
 
   // Nested scope from which the declaration originated.
   Scope* scope_;
 };
 
@@ skipping 30 matching lines @@
  protected:
   FunctionDeclaration(Zone* zone,
                       VariableProxy* proxy,
                       VariableMode mode,
                       FunctionLiteral* fun,
                       Scope* scope,
                       int pos)
       : Declaration(zone, proxy, mode, scope, pos),
         fun_(fun) {
     // At the moment there are no "const functions" in JavaScript...
-    ASSERT(mode == VAR || mode == LET);
-    ASSERT(fun != NULL);
+    DCHECK(mode == VAR || mode == LET);
+    DCHECK(fun != NULL);
   }
 
  private:
   FunctionLiteral* fun_;
 };
 
 
 class ModuleDeclaration V8_FINAL : public Declaration {
  public:
   DECLARE_NODE_TYPE(ModuleDeclaration)
@@ skipping 351 matching lines @@
 
   Expression* enumerable() const {
     return subject();
   }
 
   // Type feedback information.
   virtual int ComputeFeedbackSlotCount() { return 1; }
   virtual void SetFirstFeedbackSlot(int slot) { for_in_feedback_slot_ = slot; }
 
   int ForInFeedbackSlot() {
-    ASSERT(for_in_feedback_slot_ != kInvalidFeedbackSlot);
+    DCHECK(for_in_feedback_slot_ != kInvalidFeedbackSlot);
     return for_in_feedback_slot_;
   }
 
   enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
   ForInType for_in_type() const { return for_in_type_; }
   void set_for_in_type(ForInType type) { for_in_type_ = type; }
 
   BailoutId BodyId() const { return body_id_; }
   BailoutId PrepareId() const { return prepare_id_; }
   virtual BailoutId ContinueId() const V8_OVERRIDE { return EntryId(); }
@@ skipping 400 matching lines @@
 
 class Literal V8_FINAL : public Expression {
  public:
   DECLARE_NODE_TYPE(Literal)
 
   virtual bool IsPropertyName() const V8_OVERRIDE {
     return value_->IsPropertyName();
   }
 
   Handle<String> AsPropertyName() {
-    ASSERT(IsPropertyName());
+    DCHECK(IsPropertyName());
     return Handle<String>::cast(value());
   }
 
   const AstRawString* AsRawPropertyName() {
-    ASSERT(IsPropertyName());
+    DCHECK(IsPropertyName());
     return value_->AsString();
   }
 
   virtual bool ToBooleanIsTrue() const V8_OVERRIDE {
     return value()->BooleanValue();
   }
   virtual bool ToBooleanIsFalse() const V8_OVERRIDE {
     return !value()->BooleanValue();
   }
 
@@ skipping 29 matching lines @@
 
 // Base class for literals that needs space in the corresponding JSFunction.
 class MaterializedLiteral : public Expression {
  public:
   virtual MaterializedLiteral* AsMaterializedLiteral() { return this; }
 
   int literal_index() { return literal_index_; }
 
   int depth() const {
     // only callable after initialization.
-    ASSERT(depth_ >= 1);
+    DCHECK(depth_ >= 1);
     return depth_;
   }
 
  protected:
   MaterializedLiteral(Zone* zone,
                       int literal_index,
                       int pos)
       : Expression(zone, pos),
         literal_index_(literal_index),
         is_simple_(false),
         depth_(0) {}
 
   // A materialized literal is simple if the values consist of only
   // constants and simple object and array literals.
   bool is_simple() const { return is_simple_; }
   void set_is_simple(bool is_simple) { is_simple_ = is_simple; }
   friend class CompileTimeValue;
 
   void set_depth(int depth) {
-    ASSERT(depth >= 1);
+    DCHECK(depth >= 1);
     depth_ = depth;
   }
 
   // Populate the constant properties/elements fixed array.
   void BuildConstants(Isolate* isolate);
   friend class ArrayLiteral;
   friend class ObjectLiteral;
 
   // If the expression is a literal, return the literal value;
   // if the expression is a materialized literal and is simple return a
@@ skipping 417 matching lines @@
 
   // Type feedback information.
   virtual int ComputeFeedbackSlotCount() {
     return FLAG_pretenuring_call_new ? 2 : 1;
   }
   virtual void SetFirstFeedbackSlot(int slot) {
     callnew_feedback_slot_ = slot;
   }
 
   int CallNewFeedbackSlot() {
-    ASSERT(callnew_feedback_slot_ != kInvalidFeedbackSlot);
+    DCHECK(callnew_feedback_slot_ != kInvalidFeedbackSlot);
     return callnew_feedback_slot_;
   }
   int AllocationSiteFeedbackSlot() {
-    ASSERT(callnew_feedback_slot_ != kInvalidFeedbackSlot);
-    ASSERT(FLAG_pretenuring_call_new);
+    DCHECK(callnew_feedback_slot_ != kInvalidFeedbackSlot);
+    DCHECK(FLAG_pretenuring_call_new);
     return callnew_feedback_slot_ + 1;
   }
 
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() V8_OVERRIDE { return is_monomorphic_; }
   Handle<JSFunction> target() const { return target_; }
   ElementsKind elements_kind() const { return elements_kind_; }
   Handle<AllocationSite> allocation_site() const {
     return allocation_site_;
   }
@@ skipping 45 matching lines @@
 
   // Type feedback information.
   virtual int ComputeFeedbackSlotCount() {
     return (FLAG_vector_ics && is_jsruntime()) ? 1 : 0;
   }
   virtual void SetFirstFeedbackSlot(int slot) {
     callruntime_feedback_slot_ = slot;
   }
 
   int CallRuntimeFeedbackSlot() {
-    ASSERT(!is_jsruntime() ||
+    DCHECK(!is_jsruntime() ||
            callruntime_feedback_slot_ != kInvalidFeedbackSlot);
     return callruntime_feedback_slot_;
   }
 
   TypeFeedbackId CallRuntimeFeedbackId() const { return reuse(id()); }
 
  protected:
   CallRuntime(Zone* zone,
               const AstRawString* name,
               const Runtime::Function* function,
@@ skipping 28 matching lines @@
  protected:
   UnaryOperation(Zone* zone,
                  Token::Value op,
                  Expression* expression,
                  int pos)
       : Expression(zone, pos),
         op_(op),
         expression_(expression),
         materialize_true_id_(GetNextId(zone)),
         materialize_false_id_(GetNextId(zone)) {
-    ASSERT(Token::IsUnaryOp(op));
+    DCHECK(Token::IsUnaryOp(op));
   }
 
  private:
   Token::Value op_;
   Expression* expression_;
 
   // For unary not (Token::NOT), the AST ids where true and false will
   // actually be materialized, respectively.
   const BailoutId materialize_true_id_;
   const BailoutId materialize_false_id_;
@@ skipping 27 matching lines @@
   BinaryOperation(Zone* zone,
                   Token::Value op,
                   Expression* left,
                   Expression* right,
                   int pos)
       : Expression(zone, pos),
         op_(op),
         left_(left),
         right_(right),
         right_id_(GetNextId(zone)) {
-    ASSERT(Token::IsBinaryOp(op));
+    DCHECK(Token::IsBinaryOp(op));
   }
 
  private:
   Token::Value op_;
   Expression* left_;
   Expression* right_;
   Handle<AllocationSite> allocation_site_;
 
   // TODO(rossberg): the fixed arg should probably be represented as a Constant
   // type for the RHS.
@@ skipping 87 matching lines @@
   CompareOperation(Zone* zone,
                    Token::Value op,
                    Expression* left,
                    Expression* right,
                    int pos)
       : Expression(zone, pos),
         op_(op),
         left_(left),
         right_(right),
         combined_type_(Type::None(zone)) {
-    ASSERT(Token::IsCompareOp(op));
+    DCHECK(Token::IsCompareOp(op));
   }
 
  private:
   Token::Value op_;
   Expression* left_;
   Expression* right_;
 
   Type* combined_type_;
 };
 
@@ skipping 69 matching lines @@
 
  protected:
   Assignment(Zone* zone,
              Token::Value op,
              Expression* target,
              Expression* value,
              int pos);
 
   template<class Visitor>
   void Init(Zone* zone, AstNodeFactory<Visitor>* factory) {
-    ASSERT(Token::IsAssignmentOp(op_));
+    DCHECK(Token::IsAssignmentOp(op_));
     if (is_compound()) {
       binary_operation_ = factory->NewBinaryOperation(
           binary_op(), target_, value_, position() + 1);
     }
   }
 
  private:
   Token::Value op_;
   Expression* target_;
   Expression* value_;
@@ skipping 19 matching lines @@
   };
 
   Expression* generator_object() const { return generator_object_; }
   Expression* expression() const { return expression_; }
   Kind yield_kind() const { return yield_kind_; }
 
   // Delegating yield surrounds the "yield" in a "try/catch".  This index
   // locates the catch handler in the handler table, and is equivalent to
   // TryCatchStatement::index().
   int index() const {
-    ASSERT(yield_kind() == DELEGATING);
+    DCHECK(yield_kind() == DELEGATING);
     return index_;
   }
   void set_index(int index) {
-    ASSERT(yield_kind() == DELEGATING);
+    DCHECK(yield_kind() == DELEGATING);
     index_ = index;
   }
 
   // Type feedback information.
   virtual int ComputeFeedbackSlotCount() {
     return (FLAG_vector_ics && yield_kind() == DELEGATING) ? 3 : 0;
   }
   virtual void SetFirstFeedbackSlot(int slot) {
     yield_first_feedback_slot_ = slot;
   }
 
   int KeyedLoadFeedbackSlot() {
-    ASSERT(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
+    DCHECK(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
     return yield_first_feedback_slot_;
   }
 
   int DoneFeedbackSlot() {
-    ASSERT(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
+    DCHECK(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
     return yield_first_feedback_slot_ + 1;
   }
 
   int ValueFeedbackSlot() {
-    ASSERT(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
+    DCHECK(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
     return yield_first_feedback_slot_ + 2;
   }
 
  protected:
   Yield(Zone* zone,
         Expression* generator_object,
         Expression* expression,
         Kind yield_kind,
         int pos)
       : Expression(zone, pos),
@@ skipping 89 matching lines @@
 
   Handle<String> debug_name() const {
     if (raw_name_ != NULL && !raw_name_->IsEmpty()) {
       return raw_name_->string();
     }
     return inferred_name();
   }
 
   Handle<String> inferred_name() const {
     if (!inferred_name_.is_null()) {
-      ASSERT(raw_inferred_name_ == NULL);
+      DCHECK(raw_inferred_name_ == NULL);
       return inferred_name_;
     }
     if (raw_inferred_name_ != NULL) {
       return raw_inferred_name_->string();
     }
     UNREACHABLE();
     return Handle<String>();
   }
 
   // Only one of {set_inferred_name, set_raw_inferred_name} should be called.
   void set_inferred_name(Handle<String> inferred_name) {
-    ASSERT(!inferred_name.is_null());
+    DCHECK(!inferred_name.is_null());
     inferred_name_ = inferred_name;
-    ASSERT(raw_inferred_name_== NULL || raw_inferred_name_->IsEmpty());
+    DCHECK(raw_inferred_name_== NULL || raw_inferred_name_->IsEmpty());
     raw_inferred_name_ = NULL;
   }
 
   void set_raw_inferred_name(const AstString* raw_inferred_name) {
-    ASSERT(raw_inferred_name != NULL);
+    DCHECK(raw_inferred_name != NULL);
     raw_inferred_name_ = raw_inferred_name;
-    ASSERT(inferred_name_.is_null());
+    DCHECK(inferred_name_.is_null());
     inferred_name_ = Handle<String>();
   }
 
   // shared_info may be null if it's not cached in full code.
   Handle<SharedFunctionInfo> shared_info() { return shared_info_; }
 
   bool pretenure() { return Pretenure::decode(bitfield_); }
   void set_pretenure() { bitfield_ |= Pretenure::encode(true); }
 
   bool has_duplicate_parameters() {
@@ skipping 1040 matching lines @@
  private:
   Zone* zone_;
   Visitor visitor_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_