Flatten property_kind into state. Add UNKNOWN as a state for dict-mode receivers

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/deoptimizer.h"
 #include "src/lookup.h"
 #include "src/lookup-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 void LookupIterator::Next() {
+  DCHECK_NE(JSPROXY, state_);
+  DCHECK_NE(TRANSITION, state_);
   DisallowHeapAllocation no_gc;
   has_property_ = false;
 
-  JSReceiver* holder = NULL;
+  JSReceiver* holder =
+      maybe_holder_.is_null() ? NULL : *maybe_holder_.ToHandleChecked();
   Map* map = *holder_map_;
 
   // Perform lookup on current holder.
-  state_ = LookupInHolder(map);
+  state_ = LookupInHolder(map, holder);
+  if (IsFound()) return;
 
   // Continue lookup if lookup on current holder failed.
-  while (!IsFound()) {
+  do {
     JSReceiver* maybe_holder = NextHolder(map);
     if (maybe_holder == NULL) break;
     holder = maybe_holder;
     map = holder->map();
-    state_ = LookupInHolder(map);
-  }
+    state_ = LookupInHolder(map, holder);
+  } while (!IsFound());
 
-  // Either was found in the receiver, or the receiver has no prototype.
   if (holder == NULL) return;
 
   maybe_holder_ = handle(holder, isolate_);
   holder_map_ = handle(map, isolate_);
 }
 
 
 Handle<JSReceiver> LookupIterator::GetRoot() const {
   Handle<Object> receiver = GetReceiver();
   if (receiver->IsJSReceiver()) return Handle<JSReceiver>::cast(receiver);
@@ skipping 28 matching lines @@
 }
 
 
 bool LookupIterator::HasAccess(v8::AccessType access_type) const {
   DCHECK_EQ(ACCESS_CHECK, state_);
   DCHECK(is_guaranteed_to_have_holder());
   return isolate_->MayNamedAccess(GetHolder<JSObject>(), name_, access_type);
 }
 
 
-bool LookupIterator::HasProperty() {
-  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())) {
-      return false;
-    }
-  } else {
-    // Can't use descriptor_number() yet because has_property_ is still false.
-    property_details_ =
-        holder_map_->instance_descriptors()->GetDetails(number_);
-  }
-
-  LoadPropertyKind();
-
-  has_property_ = true;
-  return true;
-}
-
-
-void LookupIterator::LoadPropertyKind() {
-  switch (property_details_.type()) {
-    case v8::internal::FIELD:
-    case v8::internal::NORMAL:
-    case v8::internal::CONSTANT:
-      property_kind_ = DATA;
-      break;
-    case v8::internal::CALLBACKS:
-      property_kind_ = ACCESSOR;
-      break;
-  }
-}
-
-
 void LookupIterator::ReloadPropertyInformation() {
   state_ = BEFORE_PROPERTY;
-  state_ = LookupInHolder(*holder_map_);
-  DCHECK(IsFound());
-  HasProperty();
+  state_ = LookupInHolder(*holder_map_, *maybe_holder_.ToHandleChecked());
+  DCHECK(IsFound() || holder_map_->is_dictionary_map());
 }
 
 
 void LookupIterator::PrepareForDataProperty(Handle<Object> value) {
-  DCHECK(has_property_);
+  DCHECK(state_ == DATA || state_ == ACCESSOR);
   DCHECK(HolderIsReceiverOrHiddenPrototype());
   if (property_encoding_ == DICTIONARY) return;
   holder_map_ =
       Map::PrepareForDataProperty(holder_map_, descriptor_number(), value);
   JSObject::MigrateToMap(GetHolder<JSObject>(), holder_map_);
   ReloadPropertyInformation();
 }
 
 
 void LookupIterator::ReconfigureDataProperty(Handle<Object> value,
                                              PropertyAttributes attributes) {
-  DCHECK(has_property_);
+  DCHECK(state_ == DATA || state_ == ACCESSOR);
   DCHECK(HolderIsReceiverOrHiddenPrototype());
   Handle<JSObject> holder = GetHolder<JSObject>();
   if (property_encoding_ != DICTIONARY) {
     holder_map_ = Map::ReconfigureDataProperty(holder_map_, descriptor_number(),
                                                attributes);
     JSObject::MigrateToMap(holder, holder_map_);
   }
 
   if (holder_map_->is_dictionary_map()) {
     PropertyDetails details(attributes, NORMAL, 0);
     JSObject::SetNormalizedProperty(holder, name(), value, details);
   }
 
   ReloadPropertyInformation();
 }
 
 
 void LookupIterator::PrepareTransitionToDataProperty(
     Handle<Object> value, PropertyAttributes attributes,
     Object::StoreFromKeyed store_mode) {
   if (state_ == TRANSITION) return;
-  DCHECK(!has_property_ || property_kind_ != ACCESSOR);
-  DCHECK(!(has_property_ || state_ == JSPROXY) ||
-         !HolderIsReceiverOrHiddenPrototype());
+  DCHECK(state_ != LookupIterator::ACCESSOR ||
+         GetAccessors()->IsDeclaredAccessorInfo());
+  DCHECK(state_ == NOT_FOUND || !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 = GetStoreTarget();
 
   if (!name().is_identical_to(isolate()->factory()->hidden_string()) &&
       !receiver->map()->is_extensible()) {
     return;
   }
@@ skipping 35 matching lines @@
 
   // We have to deoptimize since accesses to data properties may have been
   // inlined without a corresponding map-check.
   if (holder_map_->IsGlobalObjectMap()) {
     Deoptimizer::DeoptimizeGlobalObject(*receiver);
   }
 
   // Install the accessor into the dictionary-mode object.
   PropertyDetails details(attributes, CALLBACKS, 0);
   Handle<AccessorPair> pair;
-  if (IsFound() && HasProperty() && property_kind() == ACCESSOR &&
-      GetAccessors()->IsAccessorPair()) {
+  if (state() == ACCESSOR && GetAccessors()->IsAccessorPair()) {
     pair = Handle<AccessorPair>::cast(GetAccessors());
     // If the component and attributes are identical, nothing has to be done.
     if (pair->get(component) == *accessor) {
       if (property_details().attributes() == attributes) return;
     } else {
       pair = AccessorPair::Copy(pair);
       pair->set(component, *accessor);
     }
   } else {
     pair = isolate()->factory()->NewAccessorPair();
@@ skipping 85 matching lines @@
 
 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 {
-  DCHECK(has_property_);
-  DCHECK_EQ(ACCESSOR, property_kind_);
+  DCHECK_EQ(ACCESSOR, state_);
   return FetchValue();
 }
 
 
 Handle<Object> LookupIterator::GetDataValue() const {
-  DCHECK(has_property_);
-  DCHECK_EQ(DATA, property_kind_);
+  DCHECK_EQ(DATA, state_);
   Handle<Object> value = FetchValue();
   return value;
 }
 
 
 void LookupIterator::WriteDataValue(Handle<Object> value) {
   DCHECK(is_guaranteed_to_have_holder());
-  DCHECK(has_property_);
+  DCHECK_EQ(DATA, state_);
   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 {
     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