Cleanup typed array setters, the property is guaranteed to be there.

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/messages.h"
@@ skipping 595 matching lines @@
 
   static Handle<Object> GetImpl(Handle<JSObject> obj, uint32_t key,
                                 Handle<FixedArrayBase> backing_store) {
     if (key < ElementsAccessorSubclass::GetCapacityImpl(*obj, *backing_store)) {
       return BackingStore::get(Handle<BackingStore>::cast(backing_store), key);
     } else {
       return backing_store->GetIsolate()->factory()->the_hole_value();
     }
   }
 
-  virtual void Set(Handle<JSObject> holder, uint32_t key,
-                   Handle<FixedArrayBase> backing_store,
+  virtual void Set(Handle<FixedArrayBase> backing_store, uint32_t key,
                    Handle<Object> value) final {
-    ElementsAccessorSubclass::SetImpl(holder, key, backing_store, value);
+    ElementsAccessorSubclass::SetImpl(backing_store, key, value);
   }
 
-  static void SetImpl(Handle<JSObject> obj, uint32_t key,
-                      Handle<FixedArrayBase> backing_store,
+  static void SetImpl(Handle<FixedArrayBase> backing_store, uint32_t key,
                       Handle<Object> value) {
-    CHECK(key <
-          ElementsAccessorSubclass::GetCapacityImpl(*obj, *backing_store));
-    BackingStore::SetValue(obj, Handle<BackingStore>::cast(backing_store), key,
+    BackingStore::SetValue(Handle<BackingStore>::cast(backing_store), key,
                            value);
   }
 
   virtual MaybeHandle<AccessorPair> GetAccessorPair(
       Handle<JSObject> holder, uint32_t key,
       Handle<FixedArrayBase> backing_store) final {
     return ElementsAccessorSubclass::GetAccessorPairImpl(holder, key,
                                                          backing_store);
   }
 
@@ skipping 802 matching lines @@
     Handle<SeededNumberDictionary> backing_store =
         Handle<SeededNumberDictionary>::cast(store);
     Isolate* isolate = backing_store->GetIsolate();
     int entry = backing_store->FindEntry(key);
     if (entry != SeededNumberDictionary::kNotFound) {
       return handle(backing_store->ValueAt(entry), isolate);
     }
     return isolate->factory()->the_hole_value();
   }
 
-  static void SetImpl(Handle<JSObject> obj, uint32_t key,
-                      Handle<FixedArrayBase> store, Handle<Object> value) {
+  static void SetImpl(Handle<FixedArrayBase> store, uint32_t key,
+                      Handle<Object> value) {
     Handle<SeededNumberDictionary> backing_store =
         Handle<SeededNumberDictionary>::cast(store);
     int entry = backing_store->FindEntry(key);
     DCHECK_NE(SeededNumberDictionary::kNotFound, entry);
     backing_store->ValueAtPut(entry, *value);
   }
 
   static MaybeHandle<AccessorPair> GetAccessorPairImpl(
       Handle<JSObject> obj, uint32_t key, Handle<FixedArrayBase> store) {
     Handle<SeededNumberDictionary> backing_store =
@@ skipping 75 matching lines @@
         Context* context = Context::cast(parameter_map->get(0));
         int context_index = entry->aliased_context_slot();
         DCHECK(!context->get(context_index)->IsTheHole());
         return handle(context->get(context_index), isolate);
       } else {
         return result;
       }
     }
   }
 
-  static void SetImpl(Handle<JSObject> obj, uint32_t key,
-                      Handle<FixedArrayBase> store, Handle<Object> value) {
+  static void SetImpl(Handle<FixedArrayBase> store, uint32_t key,
+                      Handle<Object> value) {
     Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(store);
     Object* probe = GetParameterMapArg(*parameter_map, key);
     if (!probe->IsTheHole()) {
       Context* context = Context::cast(parameter_map->get(0));
       int context_index = Smi::cast(probe)->value();
       DCHECK(!context->get(context_index)->IsTheHole());
       context->set(context_index, *value);
     } else {
       Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
-      ElementsAccessor::ForArray(arguments)->Set(obj, key, arguments, value);
+      ElementsAccessor::ForArray(arguments)->Set(arguments, key, value);
     }
   }
 
   static MaybeHandle<AccessorPair> GetAccessorPairImpl(
       Handle<JSObject> obj, uint32_t key, Handle<FixedArrayBase> parameters) {
     Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(parameters);
     Handle<Object> probe(GetParameterMapArg(*parameter_map, key),
                          obj->GetIsolate());
     if (!probe->IsTheHole()) {
       return MaybeHandle<AccessorPair>();
@@ skipping 298 matching lines @@
       break;
   }
 
   array->set_elements(*elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 }  // namespace internal
 }  // namespace v8