Rename ASSERT* to DCHECK*.

src/ast-value-factory.h

 // Copyright 2014 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 34 matching lines @@
   virtual ~AstString() {}
 
   virtual int length() const = 0;
   bool IsEmpty() const { return length() == 0; }
 
   // Puts the string into the V8 heap.
   virtual void Internalize(Isolate* isolate) = 0;
 
   // This function can be called after internalizing.
   V8_INLINE Handle<String> string() const {
-    ASSERT(!string_.is_null());
+    DCHECK(!string_.is_null());
     return string_;
   }
 
  protected:
   // This is null until the string is internalized.
   Handle<String> string_;
 };
 
 
 class AstRawString : public AstString {
@@ skipping 104 matching lines @@
 
   bool BooleanValue() const;
 
   void Internalize(Isolate* isolate);
 
   // Can be called after Internalize has been called.
   V8_INLINE Handle<Object> value() const {
     if (type_ == STRING) {
       return string_->string();
     }
-    ASSERT(!value_.is_null());
+    DCHECK(!value_.is_null());
     return value_;
   }
 
  private:
   friend class AstValueFactory;
 
   enum Type {
     STRING,
     SYMBOL,
     NUMBER,
     SMI,
     BOOLEAN,
     STRING_ARRAY,
     NULL_TYPE,
     UNDEFINED,
     THE_HOLE
   };
 
   explicit AstValue(const AstRawString* s) : type_(STRING) { string_ = s; }
 
   explicit AstValue(const char* name) : type_(SYMBOL) { symbol_name_ = name; }
 
   explicit AstValue(double n) : type_(NUMBER) { number_ = n; }
 
   AstValue(Type t, int i) : type_(t) {
-    ASSERT(type_ == SMI);
+    DCHECK(type_ == SMI);
     smi_ = i;
   }
 
   explicit AstValue(bool b) : type_(BOOLEAN) { bool_ = b; }
 
   explicit AstValue(ZoneList<const AstRawString*>* s) : type_(STRING_ARRAY) {
     strings_ = s;
   }
 
   explicit AstValue(Type t) : type_(t) {
-    ASSERT(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
+    DCHECK(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
   }
 
   Type type_;
 
   // Uninternalized value.
   union {
     const AstRawString* string_;
     double number_;
     int smi_;
     bool bool_;
@@ skipping 107 matching lines @@
   const AstRawString* name##_string_;
   STRING_CONSTANTS(F)
 #undef F
 };
 
 } }  // namespace v8::internal
 
 #undef STRING_CONSTANTS
 
 #endif  // V8_AST_VALUE_FACTORY_H_