Sort names in JSObject::CollectOwnPropertyNames.

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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 15078 matching lines @@
   } else if (IsJSGlobalObject()) {
     return global_dictionary()->CopyKeysTo(storage, index, filter,
                                            GlobalDictionary::UNSORTED);
   } else {
     return property_dictionary()->CopyKeysTo(storage, index, filter,
                                              NameDictionary::UNSORTED);
   }
 }
 
 
-int JSObject::CollectOwnPropertyNames(KeyAccumulator* keys,
-                                      PropertyAttributes filter) {
+void JSObject::CollectOwnPropertyNames(KeyAccumulator* keys,
+                                       PropertyAttributes filter) {
   if (HasFastProperties()) {
-    int nof_keys = keys->length();
     int real_size = map()->NumberOfOwnDescriptors();
     Handle<DescriptorArray> descs(map()->instance_descriptors());
     for (int i = 0; i < real_size; i++) {
       if ((descs->GetDetails(i).attributes() & filter) != 0) continue;
       Name* key = descs->GetKey(i);
       if (key->FilterKey(filter)) continue;
       keys->AddKey(key);
     }
-    return nof_keys - keys->length();
   } else if (IsJSGlobalObject()) {
-    return global_dictionary()->CollectKeysTo(keys, filter);
+    global_dictionary()->CollectKeysTo(keys, filter);
   } else {
-    return property_dictionary()->CollectKeysTo(keys, filter);
+    property_dictionary()->CollectKeysTo(keys, filter);
   }
 }
 
 
 int JSObject::NumberOfOwnElements(PropertyAttributes filter) {
   // Fast case for objects with no elements.
   if (!IsJSValue() && HasFastElements()) {
     uint32_t length =
         IsJSArray()
             ? static_cast<uint32_t>(
@@ skipping 1770 matching lines @@
   }
   if (sort_mode == Dictionary::SORTED) {
     storage->SortPairs(storage, index);
   }
   DCHECK(storage->length() >= index);
   return index - start_index;
 }
 
 
 template <typename Derived, typename Shape, typename Key>
-int Dictionary<Derived, Shape, Key>::CollectKeysTo(KeyAccumulator* keys,
-                                                   PropertyAttributes filter) {
+void Dictionary<Derived, Shape, Key>::CollectKeysTo(KeyAccumulator* keys,
+                                                    PropertyAttributes filter) {
   int capacity = this->Capacity();
-  int keyLength = keys->length();
+  Handle<FixedArray> array =
+      keys->isolate()->factory()->NewFixedArray(capacity);

[Camillo Bruni, 2015/11/17 10:02:52]

I think NumberOfElements() would be better here no? Capacity should be quite an
overestimate for Dictionaries. (I think it was me who even added that piece of
code in the first place :)

+  int array_size = 0;
+
   for (int i = 0; i < capacity; i++) {
     Object* k = this->KeyAt(i);
     if (!this->IsKey(k) || k->FilterKey(filter)) continue;
     if (this->IsDeleted(i)) continue;
     PropertyDetails details = this->DetailsAt(i);
     PropertyAttributes attr = details.attributes();
     if ((attr & filter) != 0) continue;
-    keys->AddKey(k);
+    array->set(array_size++, Smi::FromInt(i));
   }
-  return keyLength - keys->length();
+
+  EnumIndexComparator<Derived> cmp(static_cast<Derived*>(this));
+  Smi** start = reinterpret_cast<Smi**>(array->GetFirstElementAddress());
+  std::sort(start, start + array_size, cmp);
+  for (int i = 0; i < array_size; i++) {
+    int index = Smi::cast(array->get(i))->value();
+    keys->AddKey(this->KeyAt(index));
+  }
 }
 
 
 // Backwards lookup (slow).
 template<typename Derived, typename Shape, typename Key>
 Object* Dictionary<Derived, Shape, Key>::SlowReverseLookup(Object* value) {
   int capacity = this->Capacity();
   for (int i = 0; i < capacity; i++) {
     Object* k = this->KeyAt(i);
     if (this->IsKey(k)) {
@@ skipping 1192 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