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

src/runtime/runtime-array.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 namespace v8 {
@@ skipping 402 matching lines @@
         if (length == range) return;  // All indices accounted for already.
         break;
       }
     case SLOPPY_ARGUMENTS_ELEMENTS: {
       MaybeHandle<Object> length_obj =
           Object::GetProperty(object, isolate->factory()->length_string());
       double length_num = length_obj.ToHandleChecked()->Number();
       uint32_t length = static_cast<uint32_t>(DoubleToInt32(length_num));
       ElementsAccessor* accessor = object->GetElementsAccessor();
       for (uint32_t i = 0; i < length; i++) {
-        if (accessor->HasElement(object, object, i)) {
+        if (accessor->HasElement(object, i)) {
           indices->Add(i);
         }
       }
       break;
     }
   }
 
   PrototypeIterator iter(isolate, object);
   if (!iter.IsAtEnd()) {
     // The prototype will usually have no inherited element indices,
@@ skipping 246 matching lines @@
     }
     case FLOAT64_ELEMENTS: {
       IterateTypedArrayElements<FixedFloat64Array, double>(
       isolate, receiver, false, false, visitor);
       break;
     }
     case SLOPPY_ARGUMENTS_ELEMENTS: {
       ElementsAccessor* accessor = receiver->GetElementsAccessor();
       for (uint32_t index = 0; index < length; index++) {
         HandleScope loop_scope(isolate);
-        if (accessor->HasElement(receiver, receiver, index)) {
+        if (accessor->HasElement(receiver, index)) {
           Handle<Object> element;
           ASSIGN_RETURN_ON_EXCEPTION_VALUE(
               isolate, element, accessor->Get(receiver, receiver, index),
               false);
           visitor->visit(index, element);
         }
       }
       break;
     }
   }
@@ skipping 271 matching lines @@
     }
     // For holey elements, take samples from the buffer checking for holes
     // to generate the estimate.
     const int kNumberOfHoleCheckSamples = 97;
     int increment = (length < kNumberOfHoleCheckSamples)
                         ? 1
                         : static_cast<int>(length / kNumberOfHoleCheckSamples);
     ElementsAccessor* accessor = array->GetElementsAccessor();
     int holes = 0;
     for (int i = 0; i < length; i += increment) {
-      if (!accessor->HasElement(array, array, i, elements)) {
+      if (!accessor->HasElement(array, i, elements)) {
         ++holes;
       }
     }
     int estimate = static_cast<int>((kNumberOfHoleCheckSamples - holes) /
                                     kNumberOfHoleCheckSamples * length);
     return Smi::FromInt(estimate);
   }
 }
 
 
@@ skipping 317 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(RuntimeReference_FastOneByteArrayJoin) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 2);
   return isolate->heap()->undefined_value();
 }
 }
 }  // namespace v8::internal