Rename ASSERT* to DCHECK*.

src/types-inl.h

 // Copyright 2014 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_TYPES_INL_H_
 #define V8_TYPES_INL_H_
 
 #include "src/types.h"
 
 #include "src/factory.h"
 #include "src/handles-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // TypeImpl
 
 template<class Config>
 TypeImpl<Config>* TypeImpl<Config>::cast(typename Config::Base* object) {
   TypeImpl* t = static_cast<TypeImpl*>(object);
-  ASSERT(t->IsBitset() || t->IsClass() || t->IsConstant() || t->IsRange() ||
+  DCHECK(t->IsBitset() || t->IsClass() || t->IsConstant() || t->IsRange() ||
          t->IsUnion() || t->IsArray() || t->IsFunction() || t->IsContext());
   return t;
 }
 
 
 // Most precise _current_ type of a value (usually its class).
 template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::NowOf(
     i::Object* value, Region* region) {
   if (value->IsSmi() ||
@@ skipping 48 matching lines @@
 
 
 // static
 bool ZoneTypeConfig::is_class(Type* type) {
   return false;
 }
 
 
 // static
 int ZoneTypeConfig::as_bitset(Type* type) {
-  ASSERT(is_bitset(type));
+  DCHECK(is_bitset(type));
   return static_cast<int>(reinterpret_cast<intptr_t>(type) >> 1);
 }
 
 
 // static
 ZoneTypeConfig::Struct* ZoneTypeConfig::as_struct(Type* type) {
-  ASSERT(!is_bitset(type));
+  DCHECK(!is_bitset(type));
   return reinterpret_cast<Struct*>(type);
 }
 
 
 // static
 i::Handle<i::Map> ZoneTypeConfig::as_class(Type* type) {
   UNREACHABLE();
   return i::Handle<i::Map>();
 }
 
@@ skipping 29 matching lines @@
   Struct* structure = reinterpret_cast<Struct*>(
       zone->New(sizeof(void*) * (length + 2)));  // NOLINT
   structure[0] = reinterpret_cast<void*>(tag);
   structure[1] = reinterpret_cast<void*>(length);
   return structure;
 }
 
 
 // static
 void ZoneTypeConfig::struct_shrink(Struct* structure, int length) {
-  ASSERT(0 <= length && length <= struct_length(structure));
+  DCHECK(0 <= length && length <= struct_length(structure));
   structure[1] = reinterpret_cast<void*>(length);
 }
 
 
 // static
 int ZoneTypeConfig::struct_tag(Struct* structure) {
   return static_cast<int>(reinterpret_cast<intptr_t>(structure[0]));
 }
 
 
 // static
 int ZoneTypeConfig::struct_length(Struct* structure) {
   return static_cast<int>(reinterpret_cast<intptr_t>(structure[1]));
 }
 
 
 // static
 Type* ZoneTypeConfig::struct_get(Struct* structure, int i) {
-  ASSERT(0 <= i && i <= struct_length(structure));
+  DCHECK(0 <= i && i <= struct_length(structure));
   return static_cast<Type*>(structure[2 + i]);
 }
 
 
 // static
 void ZoneTypeConfig::struct_set(Struct* structure, int i, Type* x) {
-  ASSERT(0 <= i && i <= struct_length(structure));
+  DCHECK(0 <= i && i <= struct_length(structure));
   structure[2 + i] = x;
 }
 
 
 // static
 template<class V>
 i::Handle<V> ZoneTypeConfig::struct_get_value(Struct* structure, int i) {
-  ASSERT(0 <= i && i <= struct_length(structure));
+  DCHECK(0 <= i && i <= struct_length(structure));
   return i::Handle<V>(static_cast<V**>(structure[2 + i]));
 }
 
 
 // static
 template<class V>
 void ZoneTypeConfig::struct_set_value(
     Struct* structure, int i, i::Handle<V> x) {
-  ASSERT(0 <= i && i <= struct_length(structure));
+  DCHECK(0 <= i && i <= struct_length(structure));
   structure[2 + i] = x.location();
 }
 
 
 // -----------------------------------------------------------------------------
 // HeapTypeConfig
 
 // static
 template<class T>
 i::Handle<T> HeapTypeConfig::handle(T* type) {
@@ skipping 125 matching lines @@
 // static
 template<class V>
 void HeapTypeConfig::struct_set_value(
     i::Handle<Struct> structure, int i, i::Handle<V> x) {
   structure->set(i + 1, *x);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_INL_H_