Keyed stores to super with numeric keys.

src/elements.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 "src/v8.h"
 
 #include "src/arguments.h"
 #include "src/conversions.h"
 #include "src/elements.h"
 #include "src/objects.h"
@@ skipping 641 matching lines @@
         uint32_t key,
         Handle<FixedArrayBase> backing_store) {
     if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) {
       return ABSENT;
     }
     return
         Handle<BackingStore>::cast(backing_store)->is_the_hole(key)
           ? ABSENT : NONE;
   }
 
-  MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair(
-      Handle<Object> receiver,
-      Handle<JSObject> holder,
-      uint32_t key,
+  MUST_USE_RESULT virtual MaybeHandle<Object> GetStructure(
+      Handle<Object> receiver, Handle<JSObject> holder, uint32_t key,
       Handle<FixedArrayBase> backing_store) FINAL OVERRIDE {
-    return ElementsAccessorSubclass::GetAccessorPairImpl(
-        receiver, holder, key, backing_store);
+    return ElementsAccessorSubclass::GetStructureImpl(receiver, holder, key,
+                                                      backing_store);
   }
 
-  MUST_USE_RESULT static MaybeHandle<AccessorPair> GetAccessorPairImpl(
-      Handle<Object> receiver,
-      Handle<JSObject> obj,
-      uint32_t key,
+  MUST_USE_RESULT static MaybeHandle<Object> GetStructureImpl(
+      Handle<Object> receiver, Handle<JSObject> obj, uint32_t key,
       Handle<FixedArrayBase> backing_store) {
-    return MaybeHandle<AccessorPair>();
+    return MaybeHandle<Object>();
   }
 
   MUST_USE_RESULT virtual MaybeHandle<Object> SetLength(
       Handle<JSArray> array,
       Handle<Object> length) FINAL OVERRIDE {
     return ElementsAccessorSubclass::SetLengthImpl(
         array, length, handle(array->elements()));
   }
 
   MUST_USE_RESULT static MaybeHandle<Object> SetLengthImpl(
@@ skipping 820 matching lines @@
       Handle<FixedArrayBase> backing_store) {
     Handle<SeededNumberDictionary> dictionary =
         Handle<SeededNumberDictionary>::cast(backing_store);
     int entry = dictionary->FindEntry(key);
     if (entry != SeededNumberDictionary::kNotFound) {
       return dictionary->DetailsAt(entry).attributes();
     }
     return ABSENT;
   }
 
-  MUST_USE_RESULT static MaybeHandle<AccessorPair> GetAccessorPairImpl(
-      Handle<Object> receiver,
-      Handle<JSObject> obj,
-      uint32_t key,
+  MUST_USE_RESULT static MaybeHandle<Object> GetStructureImpl(
+      Handle<Object> receiver, Handle<JSObject> obj, uint32_t key,
       Handle<FixedArrayBase> store) {
     Handle<SeededNumberDictionary> backing_store =
         Handle<SeededNumberDictionary>::cast(store);
     int entry = backing_store->FindEntry(key);
     if (entry != SeededNumberDictionary::kNotFound &&
-        backing_store->DetailsAt(entry).type() == CALLBACKS &&
-        backing_store->ValueAt(entry)->IsAccessorPair()) {
-      return handle(AccessorPair::cast(backing_store->ValueAt(entry)));
+        backing_store->DetailsAt(entry).type() == CALLBACKS) {
+      return handle(backing_store->ValueAt(entry), obj->GetIsolate());
     }
-    return MaybeHandle<AccessorPair>();
+    return MaybeHandle<Object>();
   }
 
   static bool HasElementImpl(Handle<Object> receiver,
                              Handle<JSObject> holder,
                              uint32_t key,
                              Handle<FixedArrayBase> store) {
     Handle<SeededNumberDictionary> backing_store =
         Handle<SeededNumberDictionary>::cast(store);
     return backing_store->FindEntry(key) != SeededNumberDictionary::kNotFound;
   }
@@ skipping 70 matching lines @@
     if (!probe->IsTheHole()) {
       return NONE;
     } else {
       // If not aliased, check the arguments.
       Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
       return ElementsAccessor::ForArray(arguments)->GetAttributes(
           receiver, obj, key, arguments);
     }
   }
 
-  MUST_USE_RESULT static MaybeHandle<AccessorPair> GetAccessorPairImpl(
-      Handle<Object> receiver,
-      Handle<JSObject> obj,
-      uint32_t key,
+  MUST_USE_RESULT static MaybeHandle<Object> GetStructureImpl(
+      Handle<Object> receiver, Handle<JSObject> obj, uint32_t key,
       Handle<FixedArrayBase> parameters) {
     Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(parameters);
     Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key);
     if (!probe->IsTheHole()) {
-      return MaybeHandle<AccessorPair>();
+      return MaybeHandle<Object>();
     } else {
       // If not aliased, check the arguments.
       Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
-      return ElementsAccessor::ForArray(arguments)->GetAccessorPair(
-          receiver, obj, key, arguments);
+      return ElementsAccessor::ForArray(arguments)
+          ->GetStructure(receiver, obj, key, arguments);
     }
   }
 
   MUST_USE_RESULT static MaybeHandle<Object> SetLengthImpl(
       Handle<JSObject> obj,
       Handle<Object> length,
       Handle<FixedArrayBase> parameter_map) {
     // TODO(mstarzinger): This was never implemented but will be used once we
     // correctly implement [[DefineOwnProperty]] on arrays.
     UNIMPLEMENTED();
@@ skipping 266 matching lines @@
       UNREACHABLE();
       break;
   }
 
   array->set_elements(*elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 } }  // namespace v8::internal