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

src/objects.cc

 // Copyright 2013 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/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 92 matching lines @@
          (fun->IsHeapObject() &&
           HeapObject::cast(fun)->map()->has_instance_call_handler());
 }
 
 
 MaybeHandle<Object> Object::GetProperty(LookupIterator* it) {
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
       case LookupIterator::JSPROXY:
         return JSProxy::GetPropertyWithHandler(it->GetHolder<JSProxy>(),
                                                it->GetReceiver(), it->name());
       case LookupIterator::INTERCEPTOR: {
         MaybeHandle<Object> maybe_result = JSObject::GetPropertyWithInterceptor(
             it->GetHolder<JSObject>(), it->GetReceiver(), it->name());
         if (!maybe_result.is_null()) return maybe_result;
         if (it->isolate()->has_pending_exception()) return maybe_result;
         break;
       }
       case LookupIterator::ACCESS_CHECK:
         if (it->HasAccess(v8::ACCESS_GET)) break;
         return JSObject::GetPropertyWithFailedAccessCheck(it);
-      case LookupIterator::PROPERTY:
-        if (it->HasProperty()) {
-          switch (it->property_kind()) {
-            case LookupIterator::ACCESSOR:
-              return GetPropertyWithAccessor(it->GetReceiver(), it->name(),
-                                             it->GetHolder<JSObject>(),
-                                             it->GetAccessors());
-            case LookupIterator::DATA:
-              return it->GetDataValue();
-          }
-        }
-        break;
+      case LookupIterator::ACCESSOR:
+        return GetPropertyWithAccessor(it->GetReceiver(), it->name(),
+                                       it->GetHolder<JSObject>(),
+                                       it->GetAccessors());
+      case LookupIterator::DATA:
+        return it->GetDataValue();
     }
   }
   return it->factory()->undefined_value();
 }
 
 
 Handle<Object> JSObject::GetDataProperty(Handle<JSObject> object,
                                          Handle<Name> key) {
   LookupIterator it(object, key,
                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   return GetDataProperty(&it);
 }
 
 
 Handle<Object> JSObject::GetDataProperty(LookupIterator* it) {
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::INTERCEPTOR:
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
       case LookupIterator::ACCESS_CHECK:
         if (it->HasAccess(v8::ACCESS_GET)) continue;
       // Fall through.
       case LookupIterator::JSPROXY:
         it->NotFound();
         return it->isolate()->factory()->undefined_value();
-      case LookupIterator::PROPERTY:
-        if (!it->HasProperty()) continue;
-        switch (it->property_kind()) {
-          case LookupIterator::DATA:
-            return it->GetDataValue();
-          case LookupIterator::ACCESSOR:
-            // TODO(verwaest): For now this doesn't call into
-            // ExecutableAccessorInfo, since clients don't need it. Update once
-            // relevant.
-            it->NotFound();
-            return it->isolate()->factory()->undefined_value();
-        }
+      case LookupIterator::ACCESSOR:
+        // TODO(verwaest): For now this doesn't call into
+        // ExecutableAccessorInfo, since clients don't need it. Update once
+        // relevant.
+        it->NotFound();
+        return it->isolate()->factory()->undefined_value();
+      case LookupIterator::DATA:
+        return it->GetDataValue();
     }
   }
   return it->isolate()->factory()->undefined_value();
 }
 
 
 bool Object::ToInt32(int32_t* value) {
   if (IsSmi()) {
     *value = Smi::cast(this)->value();
     return true;
@@ skipping 387 matching lines @@
   Handle<Object> argv[] = { value };
   RETURN_ON_EXCEPTION(isolate, Execution::Call(isolate, setter, receiver,
                                                arraysize(argv), argv, true),
                       Object);
   return value;
 }
 
 
 static bool FindAllCanReadHolder(LookupIterator* it) {
   for (; it->IsFound(); it->Next()) {
-    if (it->state() == LookupIterator::PROPERTY &&
-        it->HasProperty() &&
-        it->property_kind() == LookupIterator::ACCESSOR) {
+    if (it->state() == LookupIterator::ACCESSOR) {
       Handle<Object> accessors = it->GetAccessors();
       if (accessors->IsAccessorInfo()) {
         if (AccessorInfo::cast(*accessors)->all_can_read()) return true;
       }
     }
   }
   return false;
 }
 
 
@@ skipping 18 matching lines @@
     return maybe(it->property_details().attributes());
   it->isolate()->ReportFailedAccessCheck(checked, v8::ACCESS_HAS);
   RETURN_VALUE_IF_SCHEDULED_EXCEPTION(it->isolate(),
                                       Maybe<PropertyAttributes>());
   return maybe(ABSENT);
 }
 
 
 static bool FindAllCanWriteHolder(LookupIterator* it) {
   for (; it->IsFound(); it->Next()) {
-    if (it->state() == LookupIterator::PROPERTY && it->HasProperty() &&
-        it->property_kind() == LookupIterator::ACCESSOR) {
+    if (it->state() == LookupIterator::ACCESSOR) {
       Handle<Object> accessors = it->GetAccessors();
       if (accessors->IsAccessorInfo()) {
         if (AccessorInfo::cast(*accessors)->all_can_write()) return true;
       }
     }
   }
   return false;
 }
 
 
@@ skipping 2185 matching lines @@
                                         StrictMode strict_mode,
                                         StoreFromKeyed store_mode) {
   // Make sure that the top context does not change when doing callbacks or
   // interceptor calls.
   AssertNoContextChange ncc(it->isolate());
 
   bool done = false;
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
 
       case LookupIterator::ACCESS_CHECK:
         // TODO(verwaest): Remove the distinction. This is mostly bogus since we
         // don't know whether we'll want to fetch attributes or call a setter
         // until we find the property.
         if (it->HasAccess(v8::ACCESS_SET)) break;
         return JSObject::SetPropertyWithFailedAccessCheck(it, value,
                                                           strict_mode);
 
@@ skipping 25 matching lines @@
               JSObject::GetPropertyAttributesWithInterceptor(
                   it->GetHolder<JSObject>(), it->GetReceiver(), it->name());
           if (!maybe_attributes.has_value) return MaybeHandle<Object>();
           done = maybe_attributes.value != ABSENT;
           if (done && (maybe_attributes.value & READ_ONLY) != 0) {
             return WriteToReadOnlyProperty(it, value, strict_mode);
           }
         }
         break;
 
-      case LookupIterator::PROPERTY:
-        if (!it->HasProperty()) break;
+      case LookupIterator::ACCESSOR:
         if (it->property_details().IsReadOnly()) {
           return WriteToReadOnlyProperty(it, value, strict_mode);
         }
-        switch (it->property_kind()) {
-          case LookupIterator::ACCESSOR:
-            if (it->HolderIsReceiverOrHiddenPrototype() ||
-                !it->GetAccessors()->IsDeclaredAccessorInfo()) {
-              return SetPropertyWithAccessor(it->GetReceiver(), it->name(),
-                                             value, it->GetHolder<JSObject>(),
-                                             it->GetAccessors(), strict_mode);
-            }
-            break;
-          case LookupIterator::DATA:
-            if (it->HolderIsReceiverOrHiddenPrototype()) {
-              return SetDataProperty(it, value);
-            }
+        if (it->HolderIsReceiverOrHiddenPrototype() ||
+            !it->GetAccessors()->IsDeclaredAccessorInfo()) {
+          return SetPropertyWithAccessor(it->GetReceiver(), it->name(), value,
+                                         it->GetHolder<JSObject>(),
+                                         it->GetAccessors(), strict_mode);
         }
         done = true;
         break;
+
+      case LookupIterator::DATA:
+        if (it->property_details().IsReadOnly()) {
+          return WriteToReadOnlyProperty(it, value, strict_mode);
+        }
+        if (it->HolderIsReceiverOrHiddenPrototype()) {
+          return SetDataProperty(it, value);
+        }
+        done = true;
+        break;
 
       case LookupIterator::TRANSITION:
         done = true;
         break;
     }
 
     if (done) break;
   }
 
   // If the receiver is the JSGlobalObject, the store was contextual. In case
@@ skipping 909 matching lines @@
   DCHECK(!value->IsTheHole());
   LookupIterator it(object, name, LookupIterator::OWN_SKIP_INTERCEPTOR);
   bool is_observed = object->map()->is_observed() &&
                      *name != it.isolate()->heap()->hidden_string();
   for (; it.IsFound(); it.Next()) {
     switch (it.state()) {
       case LookupIterator::INTERCEPTOR:
       case LookupIterator::JSPROXY:
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
 
       case LookupIterator::ACCESS_CHECK:
         if (!it.isolate()->MayNamedAccess(object, name, v8::ACCESS_SET)) {
           return SetPropertyWithFailedAccessCheck(&it, value, SLOPPY);
         }
         break;
 
-      case LookupIterator::PROPERTY: {
-        if (!it.HasProperty()) break;
+      case LookupIterator::ACCESSOR: {
         PropertyDetails details = it.property_details();
         Handle<Object> old_value = it.isolate()->factory()->the_hole_value();
-        switch (it.property_kind()) {
-          case LookupIterator::ACCESSOR: {
-            // Ensure the context isn't changed after calling into accessors.
-            AssertNoContextChange ncc(it.isolate());
+        // Ensure the context isn't changed after calling into accessors.
+        AssertNoContextChange ncc(it.isolate());
 
-            Handle<Object> accessors = it.GetAccessors();
+        Handle<Object> accessors = it.GetAccessors();
 
-            if (is_observed && accessors->IsAccessorInfo()) {
-              ASSIGN_RETURN_ON_EXCEPTION(
-                  it.isolate(), old_value,
-                  GetPropertyWithAccessor(it.GetReceiver(), it.name(),
-                                          it.GetHolder<JSObject>(), accessors),
-                  Object);
+        if (is_observed && accessors->IsAccessorInfo()) {
+          ASSIGN_RETURN_ON_EXCEPTION(
+              it.isolate(), old_value,
+              GetPropertyWithAccessor(it.GetReceiver(), it.name(),
+                                      it.GetHolder<JSObject>(), accessors),
+              Object);
+        }
+
+        // Special handling for ExecutableAccessorInfo, which behaves like a
+        // data property.
+        if (handling == DONT_FORCE_FIELD &&
+            accessors->IsExecutableAccessorInfo()) {
+          Handle<Object> result;
+          ASSIGN_RETURN_ON_EXCEPTION(
+              it.isolate(), result,
+              JSObject::SetPropertyWithAccessor(it.GetReceiver(), it.name(),
+                                                value, it.GetHolder<JSObject>(),
+                                                accessors, STRICT),
+              Object);
+          DCHECK(result->SameValue(*value));
+
+          if (details.attributes() == attributes) {
+            // Regular property update if the attributes match.
+            if (is_observed && !old_value->SameValue(*value)) {
+              // If we are setting the prototype of a function and are
+              // observed, don't send change records because the prototype
+              // handles that itself.
+              if (!object->IsJSFunction() ||
+                  !Name::Equals(it.isolate()->factory()->prototype_string(),
+                                name) ||
+                  !Handle<JSFunction>::cast(object)->should_have_prototype()) {
+                EnqueueChangeRecord(object, "update", name, old_value);
+              }
             }
-
-            // Special handling for ExecutableAccessorInfo, which behaves like a
-            // data property.
-            if (handling == DONT_FORCE_FIELD &&
-                accessors->IsExecutableAccessorInfo()) {
-              Handle<Object> result;
-              ASSIGN_RETURN_ON_EXCEPTION(
-                  it.isolate(), result,
-                  JSObject::SetPropertyWithAccessor(
-                      it.GetReceiver(), it.name(), value,
-                      it.GetHolder<JSObject>(), accessors, STRICT),
-                  Object);
-              DCHECK(result->SameValue(*value));
-
-              if (details.attributes() == attributes) {
-                // Regular property update if the attributes match.
-                if (is_observed && !old_value->SameValue(*value)) {
-                  // If we are setting the prototype of a function and are
-                  // observed, don't send change records because the prototype
-                  // handles that itself.
-                  if (!object->IsJSFunction() ||
-                      !Name::Equals(it.isolate()->factory()->prototype_string(),
-                                    name) ||
-                      !Handle<JSFunction>::cast(object)
-                           ->should_have_prototype()) {
-                    EnqueueChangeRecord(object, "update", name, old_value);
-                  }
-                }
-                return value;
-              }
-
-              // Reconfigure the accessor if attributes mismatch.
-              Handle<ExecutableAccessorInfo> new_data =
-                  Accessors::CloneAccessor(
-                      it.isolate(),
-                      Handle<ExecutableAccessorInfo>::cast(accessors));
-              new_data->set_property_attributes(attributes);
-              // By clearing the setter we don't have to introduce a lookup to
-              // the setter, simply make it unavailable to reflect the
-              // attributes.
-              if (attributes & READ_ONLY) new_data->clear_setter();
-              SetPropertyCallback(object, name, new_data, attributes);
-              if (is_observed) {
-                if (old_value->SameValue(*value)) {
-                  old_value = it.isolate()->factory()->the_hole_value();
-                }
-                EnqueueChangeRecord(object, "reconfigure", name, old_value);
-              }
-              return value;
-            }
-
-            // Regular accessor. Reconfigure to data property.
-            break;
+            return value;
           }
 
-          case LookupIterator::DATA:
-            // Regular property update if the attributes match.
-            if (details.attributes() == attributes) {
-              return SetDataProperty(&it, value);
+          // Reconfigure the accessor if attributes mismatch.
+          Handle<ExecutableAccessorInfo> new_data = Accessors::CloneAccessor(
+              it.isolate(), Handle<ExecutableAccessorInfo>::cast(accessors));
+          new_data->set_property_attributes(attributes);
+          // By clearing the setter we don't have to introduce a lookup to
+          // the setter, simply make it unavailable to reflect the
+          // attributes.
+          if (attributes & READ_ONLY) new_data->clear_setter();
+          SetPropertyCallback(object, name, new_data, attributes);
+          if (is_observed) {
+            if (old_value->SameValue(*value)) {
+              old_value = it.isolate()->factory()->the_hole_value();
             }
-            // Reconfigure the data property if the attributes mismatch.
-            if (is_observed) old_value = it.GetDataValue();
+            EnqueueChangeRecord(object, "reconfigure", name, old_value);
+          }
+          return value;
         }
 
         it.ReconfigureDataProperty(value, attributes);
         it.PrepareForDataProperty(value);
+        it.WriteDataValue(value);
+
+        if (is_observed) {
+          if (old_value->SameValue(*value)) {
+            old_value = it.isolate()->factory()->the_hole_value();
+          }
+          EnqueueChangeRecord(object, "reconfigure", name, old_value);
+        }
+
+        return value;
+      }
+
+      case LookupIterator::DATA: {
+        PropertyDetails details = it.property_details();
+        Handle<Object> old_value = it.isolate()->factory()->the_hole_value();
+        // Regular property update if the attributes match.
+        if (details.attributes() == attributes) {
+          return SetDataProperty(&it, value);
+        }
+        // Reconfigure the data property if the attributes mismatch.
+        if (is_observed) old_value = it.GetDataValue();
+
+        it.ReconfigureDataProperty(value, attributes);
+        it.PrepareForDataProperty(value);
         it.WriteDataValue(value);
 
         if (is_observed) {
           if (old_value->SameValue(*value)) {
             old_value = it.isolate()->factory()->the_hole_value();
           }
           EnqueueChangeRecord(object, "reconfigure", name, old_value);
         }
 
         return value;
@@ skipping 59 matching lines @@
   LookupIterator it(object, name, LookupIterator::HIDDEN);
   return GetPropertyAttributes(&it);
 }
 
 
 Maybe<PropertyAttributes> JSReceiver::GetPropertyAttributes(
     LookupIterator* it) {
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
+      case LookupIterator::UNKNOWN:
       case LookupIterator::TRANSITION:
         UNREACHABLE();
       case LookupIterator::JSPROXY:
         return JSProxy::GetPropertyAttributesWithHandler(
             it->GetHolder<JSProxy>(), it->GetReceiver(), it->name());
       case LookupIterator::INTERCEPTOR: {
         Maybe<PropertyAttributes> result =
             JSObject::GetPropertyAttributesWithInterceptor(
                 it->GetHolder<JSObject>(), it->GetReceiver(), it->name());
         if (!result.has_value) return result;
         if (result.value != ABSENT) return result;
         break;
       }
       case LookupIterator::ACCESS_CHECK:
         if (it->HasAccess(v8::ACCESS_HAS)) break;
         return JSObject::GetPropertyAttributesWithFailedAccessCheck(it);
-      case LookupIterator::PROPERTY:
-        if (it->HasProperty()) {
-          return maybe(it->property_details().attributes());
-        }
-        break;
+      case LookupIterator::ACCESSOR:
+      case LookupIterator::DATA:
+        return maybe(it->property_details().attributes());
     }
   }
   return maybe(ABSENT);
 }
 
 
 Maybe<PropertyAttributes> JSObject::GetElementAttributeWithReceiver(
     Handle<JSObject> object, Handle<JSReceiver> receiver, uint32_t index,
     bool check_prototype) {
   Isolate* isolate = object->GetIsolate();
@@ skipping 656 matching lines @@
   Handle<ObjectHashTable> hashtable(ObjectHashTable::cast(inline_value));
   bool was_present = false;
   ObjectHashTable::Remove(hashtable, key, &was_present);
 }
 
 
 bool JSObject::HasHiddenProperties(Handle<JSObject> object) {
   Handle<Name> hidden = object->GetIsolate()->factory()->hidden_string();
   LookupIterator it(object, hidden, LookupIterator::OWN_SKIP_INTERCEPTOR);
   CHECK_NE(LookupIterator::ACCESS_CHECK, it.state());
-  return it.IsFound() && it.HasProperty();
+  return it.IsFound();
 }
 
 
 Object* JSObject::GetHiddenPropertiesHashTable() {
   DCHECK(!IsJSGlobalProxy());
   if (HasFastProperties()) {
     // If the object has fast properties, check whether the first slot
     // in the descriptor array matches the hidden string. Since the
     // hidden strings hash code is zero (and no other name has hash
     // code zero) it will always occupy the first entry if present.
@@ skipping 12 matching lines @@
         return GetHeap()->undefined_value();
       }
     } else {
       return GetHeap()->undefined_value();
     }
   } else {
     Isolate* isolate = GetIsolate();
     LookupIterator it(handle(this), isolate->factory()->hidden_string(),
                       LookupIterator::OWN_SKIP_INTERCEPTOR);
     CHECK_NE(LookupIterator::ACCESS_CHECK, it.state());
-    if (it.IsFound() && it.HasProperty()) {
-      DCHECK_EQ(LookupIterator::DATA, it.property_kind());
+    if (it.state() == LookupIterator::DATA) {
       return *it.GetDataValue();
     }
+    DCHECK(!it.IsFound());
     return GetHeap()->undefined_value();
   }
 }
 
 Handle<ObjectHashTable> JSObject::GetOrCreateHiddenPropertiesHashtable(
     Handle<JSObject> object) {
   Isolate* isolate = object->GetIsolate();
 
   static const int kInitialCapacity = 4;
   Handle<Object> inline_value(object->GetHiddenPropertiesHashTable(), isolate);
@@ skipping 176 matching lines @@
 
   // Skip interceptors on FORCE_DELETION.
   LookupIterator::Configuration config =
       delete_mode == FORCE_DELETION ? LookupIterator::HIDDEN_SKIP_INTERCEPTOR
                                     : LookupIterator::HIDDEN;
 
   LookupIterator it(object, name, config);
 
   bool is_observed = object->map()->is_observed() &&
                      *name != it.isolate()->heap()->hidden_string();
+  Handle<Object> old_value = it.isolate()->factory()->the_hole_value();
 
   for (; it.IsFound(); it.Next()) {
     switch (it.state()) {
       case LookupIterator::JSPROXY:
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
       case LookupIterator::ACCESS_CHECK:
         if (it.HasAccess(v8::ACCESS_DELETE)) break;
         it.isolate()->ReportFailedAccessCheck(it.GetHolder<JSObject>(),
                                               v8::ACCESS_DELETE);
         RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(it.isolate(), Object);
         return it.isolate()->factory()->false_value();
       case LookupIterator::INTERCEPTOR: {
         MaybeHandle<Object> maybe_result =
             JSObject::DeletePropertyWithInterceptor(it.GetHolder<JSObject>(),
                                                     object, it.name());
         // Delete with interceptor succeeded. Return result.
         if (!maybe_result.is_null()) return maybe_result;
         // An exception was thrown in the interceptor. Propagate.
         if (it.isolate()->has_pending_exception()) return maybe_result;
         break;
       }
-      case LookupIterator::PROPERTY: {
-        if (!it.HasProperty()) continue;
+      case LookupIterator::DATA:
+        if (is_observed) {
+          old_value = it.GetDataValue();
+        }
+      // Fall through.
+      case LookupIterator::ACCESSOR: {
         if (delete_mode != FORCE_DELETION && !it.IsConfigurable()) {
           // Fail if the property is not configurable.
           if (delete_mode == STRICT_DELETION) {
             Handle<Object> args[2] = {name, object};
             THROW_NEW_ERROR(it.isolate(),
                             NewTypeError("strict_delete_property",
                                          HandleVector(args, arraysize(args))),
                             Object);
           }
           return it.isolate()->factory()->false_value();
         }
 
-        Handle<Object> old_value;
-        if (is_observed) {
-          switch (it.property_kind()) {
-            case LookupIterator::ACCESSOR:
-              old_value = it.isolate()->factory()->the_hole_value();
-              break;
-            case LookupIterator::DATA:
-              old_value = it.GetDataValue();
-          }
-        }
-
         PropertyNormalizationMode mode = object->map()->is_prototype_map()
                                              ? KEEP_INOBJECT_PROPERTIES
                                              : CLEAR_INOBJECT_PROPERTIES;
         Handle<JSObject> holder = it.GetHolder<JSObject>();
         // TODO(verwaest): Remove this temporary compatibility hack when blink
         // tests are updated.
         if (!holder.is_identical_to(object) &&
             !(object->IsJSGlobalProxy() && holder->IsJSGlobalObject())) {
           return it.isolate()->factory()->true_value();
         }
@@ skipping 1156 matching lines @@
       }
       preexists = maybe.value;
       if (preexists && GetOwnElementAccessorPair(object, index).is_null()) {
         old_value =
             Object::GetElement(isolate, object, index).ToHandleChecked();
       }
     } else {
       LookupIterator it(object, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
       CHECK(GetPropertyAttributes(&it).has_value);
       preexists = it.IsFound();
-      if (preexists && (it.property_kind() == LookupIterator::DATA ||
+      if (preexists && (it.state() == LookupIterator::DATA ||
                         it.GetAccessors()->IsAccessorInfo())) {
         old_value = GetProperty(&it).ToHandleChecked();
       }
     }
   }
 
   if (is_element) {
     DefineElementAccessor(object, index, getter, setter, attributes);
   } else {
     DCHECK(getter->IsSpecFunction() || getter->IsUndefined() ||
@@ skipping 143 matching lines @@
       }
     }
   } else {
     LookupIterator it(object, name,
                       LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
     for (; it.IsFound(); it.Next()) {
       switch (it.state()) {
         case LookupIterator::INTERCEPTOR:
         case LookupIterator::NOT_FOUND:
         case LookupIterator::TRANSITION:
+        case LookupIterator::UNKNOWN:
           UNREACHABLE();
 
         case LookupIterator::ACCESS_CHECK:
           if (it.HasAccess(v8::ACCESS_HAS)) continue;
           isolate->ReportFailedAccessCheck(it.GetHolder<JSObject>(),
                                            v8::ACCESS_HAS);
           RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
           return isolate->factory()->undefined_value();
 
         case LookupIterator::JSPROXY:
           return isolate->factory()->undefined_value();
 
-        case LookupIterator::PROPERTY:
-          if (!it.HasProperty()) continue;
-          switch (it.property_kind()) {
-            case LookupIterator::DATA:
-              continue;
-            case LookupIterator::ACCESSOR: {
-              Handle<Object> maybe_pair = it.GetAccessors();
-              if (maybe_pair->IsAccessorPair()) {
-                return handle(
-                    AccessorPair::cast(*maybe_pair)->GetComponent(component),
-                    isolate);
-              }
-            }
+        case LookupIterator::DATA:
+          continue;
+        case LookupIterator::ACCESSOR: {
+          Handle<Object> maybe_pair = it.GetAccessors();
+          if (maybe_pair->IsAccessorPair()) {
+            return handle(
+                AccessorPair::cast(*maybe_pair)->GetComponent(component),
+                isolate);
           }
+        }
       }
     }
   }
   return isolate->factory()->undefined_value();
 }
 
 
 Object* JSObject::SlowReverseLookup(Object* value) {
   if (HasFastProperties()) {
     int number_of_own_descriptors = map()->NumberOfOwnDescriptors();
@@ skipping 6489 matching lines @@
 
 bool JSArray::WouldChangeReadOnlyLength(Handle<JSArray> array,
                                         uint32_t index) {
   uint32_t length = 0;
   CHECK(array->length()->ToArrayIndex(&length));
   if (length <= index) {
     LookupIterator it(array, array->GetIsolate()->factory()->length_string(),
                       LookupIterator::OWN_SKIP_INTERCEPTOR);
     CHECK_NE(LookupIterator::ACCESS_CHECK, it.state());
     CHECK(it.IsFound());
-    CHECK(it.HasProperty());
+    CHECK_EQ(LookupIterator::ACCESSOR, it.state());
     return it.IsReadOnly();
   }
   return false;
 }
 
 
 MaybeHandle<Object> JSArray::ReadOnlyLengthError(Handle<JSArray> array) {
   Isolate* isolate = array->GetIsolate();
   Handle<Name> length = isolate->factory()->length_string();
   Handle<Object> args[2] = { length, array };
@@ skipping 405 matching lines @@
   if (!result.has_value) return Maybe<bool>();
   return maybe(result.value != ABSENT);
 }
 
 
 Maybe<bool> JSObject::HasRealNamedCallbackProperty(Handle<JSObject> object,
                                                    Handle<Name> key) {
   LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
   Maybe<PropertyAttributes> maybe_result = GetPropertyAttributes(&it);
   if (!maybe_result.has_value) return Maybe<bool>();
-  return maybe(it.IsFound() && it.property_kind() == LookupIterator::ACCESSOR);
+  return maybe(it.state() == LookupIterator::ACCESSOR);
 }
 
 
 int JSObject::NumberOfOwnProperties(PropertyAttributes filter) {
   if (HasFastProperties()) {
     Map* map = this->map();
     if (filter == NONE) return map->NumberOfOwnDescriptors();
     if (filter & DONT_ENUM) {
       int result = map->EnumLength();
       if (result != kInvalidEnumCacheSentinel) return result;
@@ skipping 3133 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal