Rename ASSERT* to DCHECK*.

src/ast-value-factory.cc

 // 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 131 matching lines @@
     uint32_t index;
     return !string_->AsArrayIndex(&index);
   }
   return false;
 }
 
 
 bool AstValue::BooleanValue() const {
   switch (type_) {
     case STRING:
-      ASSERT(string_ != NULL);
+      DCHECK(string_ != NULL);
       return !string_->IsEmpty();
     case SYMBOL:
       UNREACHABLE();
       break;
     case NUMBER:
       return DoubleToBoolean(number_);
     case SMI:
       return smi_ != 0;
     case STRING_ARRAY:
       UNREACHABLE();
       break;
     case BOOLEAN:
       return bool_;
     case NULL_TYPE:
       return false;
     case THE_HOLE:
       UNREACHABLE();
       break;
     case UNDEFINED:
       return false;
   }
   UNREACHABLE();
   return false;
 }
 
 
 void AstValue::Internalize(Isolate* isolate) {
   switch (type_) {
     case STRING:
-      ASSERT(string_ != NULL);
+      DCHECK(string_ != NULL);
       // Strings are already internalized.
-      ASSERT(!string_->string().is_null());
+      DCHECK(!string_->string().is_null());
       break;
     case SYMBOL:
       value_ = Object::GetProperty(
                    isolate, handle(isolate->native_context()->builtins()),
                    symbol_name_).ToHandleChecked();
       break;
     case NUMBER:
       value_ = isolate->factory()->NewNumber(number_, TENURED);
       break;
     case SMI:
       value_ = handle(Smi::FromInt(smi_), isolate);
       break;
     case BOOLEAN:
       if (bool_) {
         value_ = isolate->factory()->true_value();
       } else {
         value_ = isolate->factory()->false_value();
       }
       break;
     case STRING_ARRAY: {
-      ASSERT(strings_ != NULL);
+      DCHECK(strings_ != NULL);
       Factory* factory = isolate->factory();
       int len = strings_->length();
       Handle<FixedArray> elements = factory->NewFixedArray(len, TENURED);
       for (int i = 0; i < len; i++) {
         const AstRawString* string = (*strings_)[i];
         Handle<Object> element = string->string();
         // Strings are already internalized.
-        ASSERT(!element.is_null());
+        DCHECK(!element.is_null());
         elements->set(i, *element);
       }
       value_ =
           factory->NewJSArrayWithElements(elements, FAST_ELEMENTS, TENURED);
       break;
     }
     case NULL_TYPE:
       value_ = isolate->factory()->null_value();
       break;
     case THE_HOLE:
@@ skipping 21 matching lines @@
   return GetString(hash, false, Vector<const byte>::cast(literal));
 }
 
 
 const AstRawString* AstValueFactory::GetString(Handle<String> literal) {
   DisallowHeapAllocation no_gc;
   String::FlatContent content = literal->GetFlatContent();
   if (content.IsAscii()) {
     return GetOneByteString(content.ToOneByteVector());
   }
-  ASSERT(content.IsTwoByte());
+  DCHECK(content.IsTwoByte());
   return GetTwoByteString(content.ToUC16Vector());
 }
 
 
 const AstConsString* AstValueFactory::NewConsString(
     const AstString* left, const AstString* right) {
   // This Vector will be valid as long as the Collector is alive (meaning that
   // the AstRawString will not be moved).
   AstConsString* new_string = new (zone_) AstConsString(left, right);
   strings_.Add(new_string);
@@ skipping 16 matching lines @@
   }
   for (int i = 0; i < values_.length(); ++i) {
     values_[i]->Internalize(isolate);
   }
   isolate_ = isolate;
 }
 
 
 const AstValue* AstValueFactory::NewString(const AstRawString* string) {
   AstValue* value = new (zone_) AstValue(string);
-  ASSERT(string != NULL);
+  DCHECK(string != NULL);
   if (isolate_) {
     value->Internalize(isolate_);
   }
   values_.Add(value);
   return value;
 }
 
 
 const AstValue* AstValueFactory::NewSymbol(const char* name) {
   AstValue* value = new (zone_) AstValue(name);
@@ skipping 97 matching lines @@
     if (isolate_) {
       new_string->Internalize(isolate_);
     }
     entry->value = reinterpret_cast<void*>(1);
   }
   return reinterpret_cast<AstRawString*>(entry->key);
 }
 
 
 } }  // namespace v8::internal