Remove receiver as parameter to Get/Has Element in the accessors.

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 <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 713 matching lines @@
       if ((from_interceptor.value & READ_ONLY) != 0) {
         return WriteToReadOnlyElement(isolate, receiver, index, value,
                                       language_mode);
       }
       done = from_interceptor.value != ABSENT;
     }
 
     if (!done &&
         js_object->elements() != isolate->heap()->empty_fixed_array()) {
       ElementsAccessor* accessor = js_object->GetElementsAccessor();
-      PropertyAttributes attrs =
-          accessor->GetAttributes(receiver, js_object, index);
+      PropertyAttributes attrs = accessor->GetAttributes(js_object, index);
       if ((attrs & READ_ONLY) != 0) {
         return WriteToReadOnlyElement(isolate, receiver, index, value,
                                       language_mode);
       }
-      Handle<AccessorPair> accessor_pair;
-      if (accessor->GetAccessorPair(receiver, js_object, index)
-              .ToHandle(&accessor_pair)) {
-        return JSObject::SetElementWithCallback(
-            receiver, accessor_pair, index, value, js_object, language_mode);
+      Handle<AccessorPair> pair;
+      if (accessor->GetAccessorPair(js_object, index).ToHandle(&pair)) {
+        return JSObject::SetElementWithCallback(receiver, pair, index, value,
+                                                js_object, language_mode);
       } else {
         done = attrs != ABSENT;
       }
     }
   }
 
   if (!receiver->IsJSObject()) {
     return WriteToReadOnlyElement(isolate, receiver, index, value,
                                   language_mode);
   }
   Handle<JSObject> target = Handle<JSObject>::cast(receiver);
   ElementsAccessor* accessor = target->GetElementsAccessor();
-  PropertyAttributes attrs = accessor->GetAttributes(receiver, target, index);
+  PropertyAttributes attrs = accessor->GetAttributes(target, index);
   if ((attrs & READ_ONLY) != 0) {
     return WriteToReadOnlyElement(isolate, receiver, index, value,
                                   language_mode);
   }
   PropertyAttributes new_attrs = attrs != ABSENT ? attrs : NONE;
   return JSObject::SetElement(target, index, value, new_attrs, language_mode,
                               false);
 }
 
 
@@ skipping 3597 matching lines @@
     if (!result.IsEmpty()) return maybe(NONE);
   }
   RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Maybe<PropertyAttributes>());
   return maybe(ABSENT);
 }
 
 
 Maybe<PropertyAttributes> JSObject::GetElementAttributeWithoutInterceptor(
     Handle<JSObject> object, Handle<JSReceiver> receiver, uint32_t index,
     bool check_prototype) {
-  PropertyAttributes attr = object->GetElementsAccessor()->GetAttributes(
-      receiver, object, index);
+  PropertyAttributes attr =
+      object->GetElementsAccessor()->GetAttributes(object, index);
   if (attr != ABSENT) return maybe(attr);
 
   // Handle [] on String objects.
   if (object->IsStringObjectWithCharacterAt(index)) {
     return maybe(static_cast<PropertyAttributes>(READ_ONLY | DONT_DELETE));
   }
 
   if (!check_prototype) return maybe(ABSENT);
 
   PrototypeIterator iter(object->GetIsolate(), object);
@@ skipping 8131 matching lines @@
     PrototypeIterator iter(object->GetIsolate(), object);
     if (iter.IsAtEnd()) return MaybeHandle<AccessorPair>();
     DCHECK(PrototypeIterator::GetCurrent(iter)->IsJSGlobalObject());
     return GetOwnElementAccessorPair(
         Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), index);
   }
 
   // Check for lookup interceptor.
   if (object->HasIndexedInterceptor()) return MaybeHandle<AccessorPair>();
 
-  return object->GetElementsAccessor()->GetAccessorPair(object, object, index);
+  return object->GetElementsAccessor()->GetAccessorPair(object, index);
 }
 
 
 MaybeHandle<Object> JSObject::SetElementWithInterceptor(
     Handle<JSObject> object, uint32_t index, Handle<Object> value,
     PropertyAttributes attributes, LanguageMode language_mode,
     bool check_prototype, SetPropertyMode set_mode) {
   Isolate* isolate = object->GetIsolate();
 
   // Make sure that the top context does not change when doing
@@ skipping 4663 matching lines @@
                                                CompilationInfo* info) {
   Handle<DependentCode> codes = DependentCode::InsertCompilationInfo(
       handle(cell->dependent_code(), info->isolate()),
       DependentCode::kPropertyCellChangedGroup, info->object_wrapper());
   if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
   info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
       cell, info->zone());
 }
 
 } }  // namespace v8::internal