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 15079 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(this->NumberOfElements());
+  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