Rename ASSERT* to DCHECK*.

src/types.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_H_
 #define V8_TYPES_H_
 
 #include "src/factory.h"
 #include "src/handles.h"
 
@@ skipping 435 matching lines @@
   TypeImpl* unhandle() { return this; }
 
   // Internal inspection.
 
   bool IsNone() { return this == None(); }
   bool IsAny() { return this == Any(); }
   bool IsBitset() { return Config::is_bitset(this); }
   bool IsUnion() { return Config::is_struct(this, StructuralType::kUnionTag); }
 
   int AsBitset() {
-    ASSERT(this->IsBitset());
+    DCHECK(this->IsBitset());
     return static_cast<BitsetType*>(this)->Bitset();
   }
   UnionType* AsUnion() { return UnionType::cast(this); }
 
   // Auxiliary functions.
 
   int BitsetGlb() { return BitsetType::Glb(this); }
   int BitsetLub() { return BitsetType::Lub(this); }
   int InherentBitsetLub() { return BitsetType::InherentLub(this); }
 
@@ skipping 72 matching lines @@
     kContextTag,
     kArrayTag,
     kFunctionTag,
     kUnionTag
   };
 
   int Length() {
     return Config::struct_length(Config::as_struct(this));
   }
   TypeHandle Get(int i) {
-    ASSERT(0 <= i && i < this->Length());
+    DCHECK(0 <= i && i < this->Length());
     return Config::struct_get(Config::as_struct(this), i);
   }
   void Set(int i, TypeHandle type) {
-    ASSERT(0 <= i && i < this->Length());
+    DCHECK(0 <= i && i < this->Length());
     Config::struct_set(Config::as_struct(this), i, type);
   }
   void Shrink(int length) {
-    ASSERT(2 <= length && length <= this->Length());
+    DCHECK(2 <= length && length <= this->Length());
     Config::struct_shrink(Config::as_struct(this), length);
   }
   template<class V> i::Handle<V> GetValue(int i) {
-    ASSERT(0 <= i && i < this->Length());
+    DCHECK(0 <= i && i < this->Length());
     return Config::template struct_get_value<V>(Config::as_struct(this), i);
   }
   template<class V> void SetValue(int i, i::Handle<V> x) {
-    ASSERT(0 <= i && i < this->Length());
+    DCHECK(0 <= i && i < this->Length());
     Config::struct_set_value(Config::as_struct(this), i, x);
   }
 
   static TypeHandle New(Tag tag, int length, Region* region) {
-    ASSERT(1 <= length);
+    DCHECK(1 <= length);
     return Config::from_struct(Config::struct_create(tag, length, region));
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Union types (internal).
 // A union is a structured type with the following invariants:
 // - its length is at least 2
 // - at most one field is a bitset, and it must go into index 0
 // - no field is a union
 // - no field is a subtype of any other field
 template<class Config>
 class TypeImpl<Config>::UnionType : public StructuralType {
  public:
   static UnionHandle New(int length, Region* region) {
     return Config::template cast<UnionType>(
         StructuralType::New(StructuralType::kUnionTag, length, region));
   }
 
   static UnionType* cast(TypeImpl* type) {
-    ASSERT(type->IsUnion());
+    DCHECK(type->IsUnion());
     return static_cast<UnionType*>(type);
   }
 
   bool Wellformed();
 };
 
 
 // -----------------------------------------------------------------------------
 // Class types.
 
 template<class Config>
 class TypeImpl<Config>::ClassType : public StructuralType {
  public:
   TypeHandle Bound(Region* region) {
     return Config::is_class(this)
         ? BitsetType::New(BitsetType::Lub(*Config::as_class(this)), region)
         : this->Get(0);
   }
   i::Handle<i::Map> Map() {
     return Config::is_class(this)
         ? Config::as_class(this)
         : this->template GetValue<i::Map>(1);
   }
 
   static ClassHandle New(
       i::Handle<i::Map> map, TypeHandle bound, Region* region) {
-    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*map)));
+    DCHECK(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*map)));
     ClassHandle type = Config::template cast<ClassType>(
         StructuralType::New(StructuralType::kClassTag, 2, region));
     type->Set(0, bound);
     type->SetValue(1, map);
     return type;
   }
 
   static ClassHandle New(i::Handle<i::Map> map, Region* region) {
     ClassHandle type =
         Config::template cast<ClassType>(Config::from_class(map, region));
     if (type->IsClass()) {
       return type;
     } else {
       TypeHandle bound = BitsetType::New(BitsetType::Lub(*map), region);
       return New(map, bound, region);
     }
   }
 
   static ClassType* cast(TypeImpl* type) {
-    ASSERT(type->IsClass());
+    DCHECK(type->IsClass());
     return static_cast<ClassType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Constant types.
 
 template<class Config>
 class TypeImpl<Config>::ConstantType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   i::Handle<i::Object> Value() { return this->template GetValue<i::Object>(1); }
 
   static ConstantHandle New(
       i::Handle<i::Object> value, TypeHandle bound, Region* region) {
-    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*value)));
+    DCHECK(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*value)));
     ConstantHandle type = Config::template cast<ConstantType>(
         StructuralType::New(StructuralType::kConstantTag, 2, region));
     type->Set(0, bound);
     type->SetValue(1, value);
     return type;
   }
 
   static ConstantHandle New(i::Handle<i::Object> value, Region* region) {
     TypeHandle bound = BitsetType::New(BitsetType::Lub(*value), region);
     return New(value, bound, region);
   }
 
   static ConstantType* cast(TypeImpl* type) {
-    ASSERT(type->IsConstant());
+    DCHECK(type->IsConstant());
     return static_cast<ConstantType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Range types.
 
 template<class Config>
 class TypeImpl<Config>::RangeType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   double Min() { return this->template GetValue<i::HeapNumber>(1)->value(); }
   double Max() { return this->template GetValue<i::HeapNumber>(2)->value(); }
 
   static RangeHandle New(
       double min, double max, TypeHandle bound, Region* region) {
-    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kNumber));
-    ASSERT(!std::isnan(min) && !std::isnan(max) && min <= max);
+    DCHECK(BitsetType::Is(bound->AsBitset(), BitsetType::kNumber));
+    DCHECK(!std::isnan(min) && !std::isnan(max) && min <= max);
     RangeHandle type = Config::template cast<RangeType>(
         StructuralType::New(StructuralType::kRangeTag, 3, region));
     type->Set(0, bound);
     Factory* factory = Config::isolate(region)->factory();
     Handle<HeapNumber> minV = factory->NewHeapNumber(min);
     Handle<HeapNumber> maxV = factory->NewHeapNumber(max);
     type->SetValue(1, minV);
     type->SetValue(2, maxV);
     return type;
   }
 
   static RangeHandle New(double min, double max, Region* region) {
     TypeHandle bound = BitsetType::New(BitsetType::kNumber, region);
     return New(min, max, bound, region);
   }
 
   static RangeType* cast(TypeImpl* type) {
-    ASSERT(type->IsRange());
+    DCHECK(type->IsRange());
     return static_cast<RangeType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Context types.
 
 template<class Config>
 class TypeImpl<Config>::ContextType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   TypeHandle Outer() { return this->Get(1); }
 
   static ContextHandle New(TypeHandle outer, TypeHandle bound, Region* region) {
-    ASSERT(BitsetType::Is(
+    DCHECK(BitsetType::Is(
         bound->AsBitset(), BitsetType::kInternal & BitsetType::kTaggedPtr));
     ContextHandle type = Config::template cast<ContextType>(
         StructuralType::New(StructuralType::kContextTag, 2, region));
     type->Set(0, bound);
     type->Set(1, outer);
     return type;
   }
 
   static ContextHandle New(TypeHandle outer, Region* region) {
     TypeHandle bound = BitsetType::New(
         BitsetType::kInternal & BitsetType::kTaggedPtr, region);
     return New(outer, bound, region);
   }
 
   static ContextType* cast(TypeImpl* type) {
-    ASSERT(type->IsContext());
+    DCHECK(type->IsContext());
     return static_cast<ContextType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Array types.
 
 template<class Config>
 class TypeImpl<Config>::ArrayType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   TypeHandle Element() { return this->Get(1); }
 
   static ArrayHandle New(TypeHandle element, TypeHandle bound, Region* region) {
-    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kArray));
+    DCHECK(BitsetType::Is(bound->AsBitset(), BitsetType::kArray));
     ArrayHandle type = Config::template cast<ArrayType>(
         StructuralType::New(StructuralType::kArrayTag, 2, region));
     type->Set(0, bound);
     type->Set(1, element);
     return type;
   }
 
   static ArrayHandle New(TypeHandle element, Region* region) {
     TypeHandle bound = BitsetType::New(BitsetType::kArray, region);
     return New(element, bound, region);
   }
 
   static ArrayType* cast(TypeImpl* type) {
-    ASSERT(type->IsArray());
+    DCHECK(type->IsArray());
     return static_cast<ArrayType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Function types.
 
 template<class Config>
 class TypeImpl<Config>::FunctionType : public StructuralType {
  public:
   int Arity() { return this->Length() - 3; }
   TypeHandle Bound() { return this->Get(0); }
   TypeHandle Result() { return this->Get(1); }
   TypeHandle Receiver() { return this->Get(2); }
   TypeHandle Parameter(int i) { return this->Get(3 + i); }
 
   void InitParameter(int i, TypeHandle type) { this->Set(3 + i, type); }
 
   static FunctionHandle New(
       TypeHandle result, TypeHandle receiver, TypeHandle bound,
       int arity, Region* region) {
-    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kFunction));
+    DCHECK(BitsetType::Is(bound->AsBitset(), BitsetType::kFunction));
     FunctionHandle type = Config::template cast<FunctionType>(
         StructuralType::New(StructuralType::kFunctionTag, 3 + arity, region));
     type->Set(0, bound);
     type->Set(1, result);
     type->Set(2, receiver);
     return type;
   }
 
   static FunctionHandle New(
       TypeHandle result, TypeHandle receiver, int arity, Region* region) {
     TypeHandle bound = BitsetType::New(BitsetType::kFunction, region);
     return New(result, receiver, bound, arity, region);
   }
 
   static FunctionType* cast(TypeImpl* type) {
-    ASSERT(type->IsFunction());
+    DCHECK(type->IsFunction());
     return static_cast<FunctionType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
 // Type iterators.
 
 template<class Config> template<class T>
 class TypeImpl<Config>::Iterator {
@@ skipping 125 matching lines @@
   typedef TypeImpl<Config> Type;
   typedef typename Type::TypeHandle TypeHandle;
   typedef typename Type::Region Region;
 
   TypeHandle lower;
   TypeHandle upper;
 
   BoundsImpl() {}
   explicit BoundsImpl(TypeHandle t) : lower(t), upper(t) {}
   BoundsImpl(TypeHandle l, TypeHandle u) : lower(l), upper(u) {
-    ASSERT(lower->Is(upper));
+    DCHECK(lower->Is(upper));
   }
 
   // Unrestricted bounds.
   static BoundsImpl Unbounded(Region* region) {
     return BoundsImpl(Type::None(region), Type::Any(region));
   }
 
   // Meet: both b1 and b2 are known to hold.
   static BoundsImpl Both(BoundsImpl b1, BoundsImpl b2, Region* region) {
     TypeHandle lower = Type::Union(b1.lower, b2.lower, region);
@@ skipping 25 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_