Revert of [key-accumulator] Starting to reimplement the key-accumulator

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 16 matching lines @@
 #include "src/execution.h"
 #include "src/field-index-inl.h"
 #include "src/field-index.h"
 #include "src/field-type.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/ic/ic.h"
 #include "src/identity-map.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/interpreter/source-position-table.h"
 #include "src/isolate-inl.h"
-#include "src/keys.h"
+#include "src/key-accumulator.h"
 #include "src/list.h"
 #include "src/log.h"
 #include "src/lookup.h"
 #include "src/macro-assembler.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
 #include "src/objects-body-descriptors-inl.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/property-descriptor.h"
 #include "src/prototype.h"
@@ skipping 8184 matching lines @@
       if (result->IsPrimitive()) return result;
     }
   }
   THROW_NEW_ERROR(isolate,
                   NewTypeError(MessageTemplate::kCannotConvertToPrimitive),
                   Object);
 }
 
 
 // TODO(cbruni/jkummerow): Consider moving this into elements.cc.
-bool JSObject::HasEnumerableElements() {
-  // TODO(cbruni): cleanup
-  JSObject* object = this;
+bool HasEnumerableElements(JSObject* object) {
   switch (object->GetElementsKind()) {
     case FAST_SMI_ELEMENTS:
     case FAST_ELEMENTS:
     case FAST_DOUBLE_ELEMENTS: {
       int length = object->IsJSArray()
                        ? Smi::cast(JSArray::cast(object)->length())->value()
                        : object->elements()->length();
       return length > 0;
     }
     case FAST_HOLEY_SMI_ELEMENTS:
@@ skipping 44 matching lines @@
         return true;
       }
       return object->elements()->length() > 0;
     case NO_ELEMENTS:
       return false;
   }
   UNREACHABLE();
   return true;
 }
 
+
 // Tests for the fast common case for property enumeration:
 // - This object and all prototypes has an enum cache (which means that
 //   it is no proxy, has no interceptors and needs no access checks).
 // - This object has no elements.
 // - No prototype has enumerable properties/elements.
 bool JSReceiver::IsSimpleEnum() {
   for (PrototypeIterator iter(GetIsolate(), this,
                               PrototypeIterator::START_AT_RECEIVER);
        !iter.IsAtEnd(); iter.Advance()) {
     if (!iter.GetCurrent()->IsJSObject()) return false;
     JSObject* current = iter.GetCurrent<JSObject>();
     int enum_length = current->map()->EnumLength();
     if (enum_length == kInvalidEnumCacheSentinel) return false;
     if (current->IsAccessCheckNeeded()) return false;
     DCHECK(!current->HasNamedInterceptor());
     DCHECK(!current->HasIndexedInterceptor());
-    if (current->HasEnumerableElements()) return false;
+    if (HasEnumerableElements(current)) return false;
     if (current != this && enum_length != 0) return false;
   }
   return true;
 }
 
 
 int Map::NumberOfDescribedProperties(DescriptorFlag which,
                                      PropertyFilter filter) {
   int result = 0;
   DescriptorArray* descs = instance_descriptors();
@@ skipping 43 matching lines @@
 }
 
 bool Map::OnlyHasSimpleProperties() {
   // Wrapped string elements aren't explicitly stored in the elements backing
   // store, but are loaded indirectly from the underlying string.
   return !IsStringWrapperElementsKind(elements_kind()) &&
          instance_type() > LAST_SPECIAL_RECEIVER_TYPE &&
          !has_hidden_prototype() && !is_dictionary_map();
 }
 
-// static
-Handle<FixedArray> JSObject::GetFastEnumPropertyKeys(Isolate* isolate,
-                                                     Handle<JSObject> object) {
+namespace {
+
+Handle<FixedArray> GetFastEnumPropertyKeys(Isolate* isolate,
+                                           Handle<JSObject> object) {
   Handle<Map> map(object->map());
   bool cache_enum_length = map->OnlyHasSimpleProperties();
 
   Handle<DescriptorArray> descs =
       Handle<DescriptorArray>(map->instance_descriptors(), isolate);
   int own_property_count = map->EnumLength();
   // If the enum length of the given map is set to kInvalidEnumCache, this
   // means that the map itself has never used the present enum cache. The
   // first step to using the cache is to set the enum length of the map by
   // counting the number of own descriptors that are ENUMERABLE_STRINGS.
@@ skipping 30 matching lines @@
   Handle<FixedArray> storage =
       isolate->factory()->NewFixedArray(own_property_count);
   Handle<FixedArray> indices =
       isolate->factory()->NewFixedArray(own_property_count);
 
   int size = map->NumberOfOwnDescriptors();
   int index = 0;
 
   for (int i = 0; i < size; i++) {
     PropertyDetails details = descs->GetDetails(i);
-    if (details.IsDontEnum()) continue;
     Object* key = descs->GetKey(i);
-    if (key->IsSymbol()) continue;
+    if (details.IsDontEnum() || key->IsSymbol()) continue;
     storage->set(index, key);
     if (!indices.is_null()) {
       if (details.type() != DATA) {
         indices = Handle<FixedArray>();
       } else {
         FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
         int load_by_field_index = field_index.GetLoadByFieldIndex();
         indices->set(index, Smi::FromInt(load_by_field_index));
       }
     }
     index++;
   }
   DCHECK(index == storage->length());
 
   DescriptorArray::SetEnumCache(descs, isolate, storage, indices);
   if (cache_enum_length) {
     map->SetEnumLength(own_property_count);
   }
   return storage;
 }
 
+}  // namespace
 
 Handle<FixedArray> JSObject::GetEnumPropertyKeys(Handle<JSObject> object) {
   Isolate* isolate = object->GetIsolate();
   if (object->HasFastProperties()) {
     return GetFastEnumPropertyKeys(isolate, object);
   } else if (object->IsJSGlobalObject()) {
     Handle<GlobalDictionary> dictionary(object->global_dictionary());
     int length = dictionary->NumberOfEnumElements();
     if (length == 0) {
       return Handle<FixedArray>(isolate->heap()->empty_fixed_array());
@@ skipping 2197 matching lines @@
   array = EnsureSpace(array, length + 1);
   if (mode == kReloadLengthAfterAllocation) {
     DCHECK(array->Length() <= length);
     length = array->Length();
   }
   array->Set(length, *obj);
   array->SetLength(length + 1);
   return array;
 }
 
+
 Handle<ArrayList> ArrayList::Add(Handle<ArrayList> array, Handle<Object> obj1,
                                  Handle<Object> obj2, AddMode mode) {
   int length = array->Length();
   array = EnsureSpace(array, length + 2);
   if (mode == kReloadLengthAfterAllocation) {
     length = array->Length();
   }
   array->Set(length, *obj1);
   array->Set(length + 1, *obj2);
   array->SetLength(length + 2);
@@ skipping 5741 matching lines @@
              j++ < len) {
         SwapPairs(numbers, i, p);
       }
     }
   } else {
     HeapSortPairs(this, numbers, len);
     return;
   }
 }
 
+
 void JSObject::CollectOwnPropertyNames(KeyAccumulator* keys,
                                        PropertyFilter filter) {
   if (HasFastProperties()) {
     int real_size = map()->NumberOfOwnDescriptors();
     Handle<DescriptorArray> descs(map()->instance_descriptors());
     for (int i = 0; i < real_size; i++) {
       PropertyDetails details = descs->GetDetails(i);
       if ((details.attributes() & filter) != 0) continue;
       if (filter & ONLY_ALL_CAN_READ) {
         if (details.kind() != kAccessor) continue;
@@ skipping 20 matching lines @@
         IsJSArray()
             ? static_cast<uint32_t>(
                   Smi::cast(JSArray::cast(this)->length())->value())
             : static_cast<uint32_t>(FixedArrayBase::cast(elements())->length());
     if (length == 0) return 0;
   }
   // Compute the number of enumerable elements.
   return GetOwnElementKeys(NULL, filter);
 }
 
+
 void JSObject::CollectOwnElementKeys(Handle<JSObject> object,
                                      KeyAccumulator* keys,
                                      PropertyFilter filter) {
   if (filter & SKIP_STRINGS) return;
   ElementsAccessor* accessor = object->GetElementsAccessor();
   accessor->CollectElementIndices(object, keys, kMaxUInt32, filter, 0);
 }
 
 
 int JSObject::GetOwnElementKeys(FixedArray* storage, PropertyFilter filter) {
@@ skipping 1987 matching lines @@
     if ((attr & filter) != 0) continue;
     storage->set(index++, k);
   }
   if (sort_mode == Dictionary::SORTED) {
     storage->SortPairs(storage, index);
   }
   DCHECK(storage->length() >= index);
   return index - start_index;
 }
 
+
 template <typename Derived, typename Shape, typename Key>
 void Dictionary<Derived, Shape, Key>::CollectKeysTo(
     Handle<Dictionary<Derived, Shape, Key> > dictionary, KeyAccumulator* keys,
     PropertyFilter filter) {
   int capacity = dictionary->Capacity();
   Handle<FixedArray> array =
       keys->isolate()->factory()->NewFixedArray(dictionary->NumberOfElements());
   int array_size = 0;
 
   {
@@ skipping 1266 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8