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

src/runtime.cc

 // Copyright 2012 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 <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 1972 matching lines @@
     }
   } else {
     // Get attributes.
     LookupIterator it(obj, name, LookupIterator::HIDDEN);
     Maybe<PropertyAttributes> maybe = JSObject::GetPropertyAttributes(&it);
     if (!maybe.has_value) return MaybeHandle<Object>();
     attrs = maybe.value;
     if (attrs == ABSENT) return factory->undefined_value();
 
     // Get AccessorPair if present.
-    if (it.state() == LookupIterator::PROPERTY &&
-        it.property_kind() == LookupIterator::ACCESSOR &&
+    if (it.state() == LookupIterator::ACCESSOR &&
         it.GetAccessors()->IsAccessorPair()) {
       maybe_accessors = Handle<AccessorPair>::cast(it.GetAccessors());
     }
 
     // Get value if not an AccessorPair.
     if (maybe_accessors.is_null()) {
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, value, Object::GetProperty(&it), Object);
     }
   }
@@ skipping 311 matching lines @@
   PropertyAttributes old_attributes = maybe.value;
 
   PropertyAttributes attr =
       static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
   // Set the value if the property is either missing, or the property attributes
   // allow setting the value without invoking an accessor.
   if (it.IsFound()) {
     // Ignore if we can't reconfigure the value.
     if ((old_attributes & DONT_DELETE) != 0) {
       if ((old_attributes & READ_ONLY) != 0 ||
-          it.property_kind() == LookupIterator::ACCESSOR) {
+          it.state() == LookupIterator::ACCESSOR) {
         return *value;
       }
       attr = static_cast<PropertyAttributes>(old_attributes | READ_ONLY);
     }
   }
 
   RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
                                            global, name, value, attr));
 
   return *value;
@@ skipping 124 matching lines @@
     DCHECK(holder->IsJSGlobalObject() || holder->IsJSContextExtensionObject());
 
     LookupIterator it(holder, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
     Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
     if (!maybe.has_value) return isolate->heap()->exception();
     PropertyAttributes old_attributes = maybe.value;
 
     // Ignore if we can't reconfigure the value.
     if ((old_attributes & DONT_DELETE) != 0) {
       if ((old_attributes & READ_ONLY) != 0 ||
-          it.property_kind() == LookupIterator::ACCESSOR) {
+          it.state() == LookupIterator::ACCESSOR) {
         return *value;
       }
       attr = static_cast<PropertyAttributes>(old_attributes | READ_ONLY);
     }
   }
 
   RETURN_FAILURE_ON_EXCEPTION(
       isolate, JSObject::SetOwnPropertyIgnoreAttributes(
                    Handle<JSObject>::cast(holder), name, value, attr));
 
@@ skipping 2402 matching lines @@
         KeyedLookupCache* keyed_lookup_cache = isolate->keyed_lookup_cache();
         int index = keyed_lookup_cache->Lookup(receiver_map, key);
         if (index != -1) {
           // Doubles are not cached, so raw read the value.
           return receiver->RawFastPropertyAt(
               FieldIndex::ForKeyedLookupCacheIndex(*receiver_map, index));
         }
         // Lookup cache miss.  Perform lookup and update the cache if
         // appropriate.
         LookupIterator it(receiver, key, LookupIterator::OWN);
-        if (it.IsFound() && it.state() == LookupIterator::PROPERTY &&
-            it.HasProperty() && it.property_details().type() == FIELD) {
+        if (it.state() == LookupIterator::DATA &&
+            it.property_details().type() == FIELD) {
           FieldIndex field_index = it.GetFieldIndex();
           // Do not track double fields in the keyed lookup cache. Reading
           // double values requires boxing.
           if (!it.representation().IsDouble()) {
             keyed_lookup_cache->Update(receiver_map, key,
                 field_index.GetKeyedLookupCacheIndex());
           }
           AllowHeapAllocation allow_allocation;
           return *JSObject::FastPropertyAt(receiver, it.representation(),
                                            field_index);
@@ skipping 137 matching lines @@
   LookupIterator it(js_object, name, LookupIterator::OWN_SKIP_INTERCEPTOR);
   if (it.IsFound() && it.state() == LookupIterator::ACCESS_CHECK) {
     if (!isolate->MayNamedAccess(js_object, name, v8::ACCESS_SET)) {
       return isolate->heap()->undefined_value();
     }
     it.Next();
   }
 
   // Take special care when attributes are different and there is already
   // a property.
-  if (it.IsFound() && it.HasProperty() &&
-      it.property_kind() == LookupIterator::ACCESSOR) {
+  if (it.state() == LookupIterator::ACCESSOR) {
     // Use IgnoreAttributes version since a readonly property may be
     // overridden and SetProperty does not allow this.
     Handle<Object> result;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, result,
         JSObject::SetOwnPropertyIgnoreAttributes(
             js_object, name, obj_value, attr,
             JSObject::DONT_FORCE_FIELD));
     return *result;
   }
@@ skipping 5826 matching lines @@
   return isolate->heap()->undefined_value();
 }
 
 
 static Handle<Object> DebugGetProperty(LookupIterator* it,
                                        bool* has_caught = NULL) {
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
       case LookupIterator::ACCESS_CHECK:
         // Ignore access checks.
         break;
       case LookupIterator::INTERCEPTOR:
       case LookupIterator::JSPROXY:
         return it->isolate()->factory()->undefined_value();
-      case LookupIterator::PROPERTY:
-        if (!it->HasProperty()) continue;
-        switch (it->property_kind()) {
-          case LookupIterator::ACCESSOR: {
-            Handle<Object> accessors = it->GetAccessors();
-            if (!accessors->IsAccessorInfo()) {
-              return it->isolate()->factory()->undefined_value();
-            }
-            MaybeHandle<Object> maybe_result =
-                JSObject::GetPropertyWithAccessor(it->GetReceiver(), it->name(),
-                                                  it->GetHolder<JSObject>(),
-                                                  accessors);
-            Handle<Object> result;
-            if (!maybe_result.ToHandle(&result)) {
-              result =
-                  handle(it->isolate()->pending_exception(), it->isolate());
-              it->isolate()->clear_pending_exception();
-              if (has_caught != NULL) *has_caught = true;
-            }
-            return result;
-          }
-          case LookupIterator::DATA:
-            return it->GetDataValue();
+      case LookupIterator::ACCESSOR: {
+        Handle<Object> accessors = it->GetAccessors();
+        if (!accessors->IsAccessorInfo()) {
+          return it->isolate()->factory()->undefined_value();
         }
+        MaybeHandle<Object> maybe_result = JSObject::GetPropertyWithAccessor(
+            it->GetReceiver(), it->name(), it->GetHolder<JSObject>(),
+            accessors);
+        Handle<Object> result;
+        if (!maybe_result.ToHandle(&result)) {
+          result = handle(it->isolate()->pending_exception(), it->isolate());
+          it->isolate()->clear_pending_exception();
+          if (has_caught != NULL) *has_caught = true;
+        }
+        return result;
+      }
+
+      case LookupIterator::DATA:
+        return it->GetDataValue();
     }
   }
 
   return it->isolate()->factory()->undefined_value();
 }
 
 
 // Get debugger related details for an object property, in the following format:
 // 0: Property value
 // 1: Property details
@@ skipping 34 matching lines @@
         1, PropertyDetails(NONE, NORMAL, Representation::None()).AsSmi());
     return *isolate->factory()->NewJSArrayWithElements(details);
   }
 
   LookupIterator it(obj, name, LookupIterator::HIDDEN);
   bool has_caught = false;
   Handle<Object> value = DebugGetProperty(&it, &has_caught);
   if (!it.IsFound()) return isolate->heap()->undefined_value();
 
   Handle<Object> maybe_pair;
-  if (it.state() == LookupIterator::PROPERTY &&
-      it.property_kind() == LookupIterator::ACCESSOR) {
+  if (it.state() == LookupIterator::ACCESSOR) {
     maybe_pair = it.GetAccessors();
   }
 
   // If the callback object is a fixed array then it contains JavaScript
   // getter and/or setter.
   bool has_js_accessors = !maybe_pair.is_null() && maybe_pair->IsAccessorPair();
   Handle<FixedArray> details =
       isolate->factory()->NewFixedArray(has_js_accessors ? 6 : 3);
   details->set(0, *value);
   // TODO(verwaest): Get rid of this random way of handling interceptors.
@@ skipping 4649 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal