Rename ASSERT* to DCHECK*.

src/lookup.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/bootstrapper.h"
 #include "src/lookup.h"
 
 namespace v8 {
@@ skipping 80 matching lines @@
   return state_;
 }
 
 
 bool LookupIterator::IsBootstrapping() const {
   return isolate_->bootstrapper()->IsActive();
 }
 
 
 bool LookupIterator::HasAccess(v8::AccessType access_type) const {
-  ASSERT_EQ(ACCESS_CHECK, state_);
-  ASSERT(is_guaranteed_to_have_holder());
+  DCHECK_EQ(ACCESS_CHECK, state_);
+  DCHECK(is_guaranteed_to_have_holder());
   return isolate_->MayNamedAccess(GetHolder<JSObject>(), name_, access_type);
 }
 
 
 bool LookupIterator::HasProperty() {
-  ASSERT_EQ(PROPERTY, state_);
-  ASSERT(is_guaranteed_to_have_holder());
+  DCHECK_EQ(PROPERTY, state_);
+  DCHECK(is_guaranteed_to_have_holder());
 
   if (property_encoding_ == DICTIONARY) {
     Handle<JSObject> holder = GetHolder<JSObject>();
     number_ = holder->property_dictionary()->FindEntry(name_);
     if (number_ == NameDictionary::kNotFound) return false;
 
     property_details_ = holder->property_dictionary()->DetailsAt(number_);
     // Holes in dictionary cells are absent values.
     if (holder->IsGlobalObject() &&
         (property_details_.IsDeleted() || FetchValue()->IsTheHole())) {
@@ skipping 19 matching lines @@
     case v8::internal::INTERCEPTOR:
       UNREACHABLE();
   }
 
   has_property_ = true;
   return true;
 }
 
 
 void LookupIterator::PrepareForDataProperty(Handle<Object> value) {
-  ASSERT(has_property_);
-  ASSERT(HolderIsReceiverOrHiddenPrototype());
+  DCHECK(has_property_);
+  DCHECK(HolderIsReceiverOrHiddenPrototype());
   if (property_encoding_ == DICTIONARY) return;
   holder_map_ =
       Map::PrepareForDataProperty(holder_map_, descriptor_number(), value);
   JSObject::MigrateToMap(GetHolder<JSObject>(), holder_map_);
   // Reload property information.
   if (holder_map_->is_dictionary_map()) {
     property_encoding_ = DICTIONARY;
   } else {
     property_encoding_ = DESCRIPTOR;
   }
   CHECK(HasProperty());
 }
 
 
 void LookupIterator::TransitionToDataProperty(
     Handle<Object> value, PropertyAttributes attributes,
     Object::StoreFromKeyed store_mode) {
-  ASSERT(!has_property_ || !HolderIsReceiverOrHiddenPrototype());
+  DCHECK(!has_property_ || !HolderIsReceiverOrHiddenPrototype());
 
   // Can only be called when the receiver is a JSObject. JSProxy has to be
   // handled via a trap. Adding properties to primitive values is not
   // observable.
   Handle<JSObject> receiver = Handle<JSObject>::cast(GetReceiver());
 
   // Properties have to be added to context extension objects through
   // SetOwnPropertyIgnoreAttributes.
-  ASSERT(!receiver->IsJSContextExtensionObject());
+  DCHECK(!receiver->IsJSContextExtensionObject());
 
   if (receiver->IsJSGlobalProxy()) {
     PrototypeIterator iter(isolate(), receiver);
     receiver =
         Handle<JSGlobalObject>::cast(PrototypeIterator::GetCurrent(iter));
   }
 
   maybe_holder_ = receiver;
   holder_map_ = Map::TransitionToDataProperty(handle(receiver->map()), name_,
                                               value, attributes, store_mode);
   JSObject::MigrateToMap(receiver, holder_map_);
 
   // Reload the information.
   state_ = NOT_FOUND;
   configuration_ = CHECK_OWN_REAL;
   state_ = LookupInHolder();
-  ASSERT(IsFound());
+  DCHECK(IsFound());
   HasProperty();
 }
 
 
 bool LookupIterator::HolderIsReceiverOrHiddenPrototype() const {
-  ASSERT(has_property_ || state_ == INTERCEPTOR || state_ == JSPROXY);
+  DCHECK(has_property_ || state_ == INTERCEPTOR || state_ == JSPROXY);
   DisallowHeapAllocation no_gc;
   Handle<Object> receiver = GetReceiver();
   if (!receiver->IsJSReceiver()) return false;
   Object* current = *receiver;
   JSReceiver* holder = *maybe_holder_.ToHandleChecked();
   // JSProxy do not occur as hidden prototypes.
   if (current->IsJSProxy()) {
     return JSReceiver::cast(current) == holder;
   }
   PrototypeIterator iter(isolate(), current,
                          PrototypeIterator::START_AT_RECEIVER);
   do {
     if (JSReceiver::cast(iter.GetCurrent()) == holder) return true;
-    ASSERT(!current->IsJSProxy());
+    DCHECK(!current->IsJSProxy());
     iter.Advance();
   } while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN));
   return false;
 }
 
 
 Handle<Object> LookupIterator::FetchValue() const {
   Object* result = NULL;
   Handle<JSObject> holder = GetHolder<JSObject>();
   switch (property_encoding_) {
@@ skipping 10 matching lines @@
         return JSObject::FastPropertyAt(
             holder, property_details_.representation(), field_index);
       }
       result = holder_map_->instance_descriptors()->GetValue(number_);
   }
   return handle(result, isolate_);
 }
 
 
 FieldIndex LookupIterator::GetFieldIndex() const {
-  ASSERT_EQ(PROPERTY, state_);
+  DCHECK_EQ(PROPERTY, state_);
   int index =
       holder_map()->instance_descriptors()->GetFieldIndex(descriptor_number());
   bool is_double = representation().IsDouble();
   return FieldIndex::ForPropertyIndex(*holder_map(), index, is_double);
 }
 
 
 Handle<PropertyCell> LookupIterator::GetPropertyCell() const {
   Handle<JSObject> holder = GetHolder<JSObject>();
   Handle<GlobalObject> global = Handle<GlobalObject>::cast(holder);
   Object* value = global->property_dictionary()->ValueAt(dictionary_entry());
   return Handle<PropertyCell>(PropertyCell::cast(value));
 }
 
 
 Handle<Object> LookupIterator::GetAccessors() const {
-  ASSERT(has_property_);
-  ASSERT_EQ(ACCESSOR, property_kind_);
+  DCHECK(has_property_);
+  DCHECK_EQ(ACCESSOR, property_kind_);
   return FetchValue();
 }
 
 
 Handle<Object> LookupIterator::GetDataValue() const {
-  ASSERT(has_property_);
-  ASSERT_EQ(DATA, property_kind_);
+  DCHECK(has_property_);
+  DCHECK_EQ(DATA, property_kind_);
   Handle<Object> value = FetchValue();
   return value;
 }
 
 
 void LookupIterator::WriteDataValue(Handle<Object> value) {
-  ASSERT(is_guaranteed_to_have_holder());
-  ASSERT(has_property_);
+  DCHECK(is_guaranteed_to_have_holder());
+  DCHECK(has_property_);
   Handle<JSObject> holder = GetHolder<JSObject>();
   if (property_encoding_ == DICTIONARY) {
     NameDictionary* property_dictionary = holder->property_dictionary();
     if (holder->IsGlobalObject()) {
       Handle<PropertyCell> cell(
           PropertyCell::cast(property_dictionary->ValueAt(dictionary_entry())));
       PropertyCell::SetValueInferType(cell, value);
     } else {
       property_dictionary->ValueAtPut(dictionary_entry(), *value);
     }
   } else if (property_details_.type() == v8::internal::FIELD) {
     holder->WriteToField(descriptor_number(), *value);
   } else {
-    ASSERT_EQ(v8::internal::CONSTANT, property_details_.type());
+    DCHECK_EQ(v8::internal::CONSTANT, property_details_.type());
   }
 }
 
 
 void LookupIterator::InternalizeName() {
   if (name_->IsUniqueName()) return;
   name_ = factory()->InternalizeString(Handle<String>::cast(name_));
 }
 } }  // namespace v8::internal