If we are trimming the whole array, just return the empty fixed array.

src/objects.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 12456 matching lines @@
        if ((attr & filter) == 0) storage->set(index++, k);
      }
   }
   if (sort_mode == Dictionary<Shape, Key>::SORTED) {
     storage->SortPairs(storage, index);
   }
   ASSERT(storage->length() >= index);
 }
 
 
-void StringDictionary::CopyEnumKeysTo(FixedArray* storage) {
+FixedArray* StringDictionary::CopyEnumKeysTo(FixedArray* storage) {
   int length = storage->length();
   ASSERT(length >= NumberOfEnumElements());
   Heap* heap = GetHeap();
   Object* undefined_value = heap->undefined_value();
   int capacity = Capacity();
   int properties = 0;
 
   // Fill in the enumeration array by assigning enumerable keys at their
   // enumeration index. This will leave holes in the array if there are keys
   // that are deleted or not enumerable.
   for (int i = 0; i < capacity; i++) {
      Object* k = KeyAt(i);
      if (IsKey(k)) {
        PropertyDetails details = DetailsAt(i);
        if (details.IsDeleted() || details.IsDontEnum()) continue;
        properties++;
        storage->set(details.dictionary_index() - 1, k);
        if (properties == length) break;
      }
   }
 
   // There are holes in the enumeration array if less properties were assigned
   // than the length of the array. If so, crunch all the existing properties
   // together by shifting them to the left (maintaining the enumeration order),
   // and trimming of the right side of the array.
   if (properties < length) {
+    if (properties == 0) return heap->empty_fixed_array();
     properties = 0;
     for (int i = 0; i < length; ++i) {
       Object* value = storage->get(i);
       if (value != undefined_value) {
         storage->set(properties, value);
         ++properties;
       }
     }
     RightTrimFixedArray<FROM_MUTATOR>(heap, storage, length - properties);
   }
+  return storage;
 }
 
 
 template<typename Shape, typename Key>
 void Dictionary<Shape, Key>::CopyKeysTo(
     FixedArray* storage,
     int index,
     typename Dictionary<Shape, Key>::SortMode sort_mode) {
   ASSERT(storage->length() >= NumberOfElementsFilterAttributes(
       static_cast<PropertyAttributes>(NONE)));
@@ skipping 673 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal