Use the LookupIterator for SetElement and friends

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 600 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 Handle<Object> Set(Handle<JSObject> holder, uint32_t key,
+                             Handle<FixedArrayBase> backing_store,
+                             Handle<Object> value) final {
+    return ElementsAccessorSubclass::SetImpl(holder, key, backing_store, value);
+  }
+
+  static Handle<Object> SetImpl(Handle<JSObject> obj, uint32_t key,
+                                Handle<FixedArrayBase> backing_store,
+                                Handle<Object> value) {
+    CHECK(key <
+          ElementsAccessorSubclass::GetCapacityImpl(*obj, *backing_store));
+    return BackingStore::SetValue(
+        obj, Handle<BackingStore>::cast(backing_store), key, value);
+  }
+
   virtual PropertyAttributes GetAttributes(
       JSObject* holder, uint32_t key, FixedArrayBase* backing_store) final {
     return ElementsAccessorSubclass::GetAttributesImpl(holder, key,
                                                        backing_store);
   }
 
   static PropertyAttributes GetAttributesImpl(JSObject* obj, uint32_t key,
                                               FixedArrayBase* backing_store) {
     if (key >= ElementsAccessorSubclass::GetCapacityImpl(obj, backing_store)) {
       return ABSENT;
@@ skipping 642 matching lines @@
                                 Handle<FixedArrayBase> backing_store) {
     if (key < AccessorClass::GetCapacityImpl(*obj, *backing_store)) {
       return BackingStore::get(Handle<BackingStore>::cast(backing_store), key);
     } else {
       return backing_store->GetIsolate()->factory()->undefined_value();
     }
   }
 
   static PropertyAttributes GetAttributesImpl(JSObject* obj, uint32_t key,
                                               FixedArrayBase* backing_store) {
-    return key < AccessorClass::GetCapacityImpl(obj, backing_store) ? NONE
-                                                                    : ABSENT;
+    return key < AccessorClass::GetCapacityImpl(obj, backing_store)
+               ? DONT_DELETE
+               : ABSENT;
+  }
+
+  static PropertyDetails GetDetailsImpl(FixedArrayBase* backing_store,
+                                        uint32_t index) {
+    return PropertyDetails(DONT_DELETE, DATA, 0, PropertyCellType::kNoCell);
   }
 
   MUST_USE_RESULT static MaybeHandle<Object> SetLengthImpl(
       Handle<JSObject> obj,
       Handle<Object> length,
       Handle<FixedArrayBase> backing_store) {
     // External arrays do not support changing their length.
     UNREACHABLE();
     return obj;
   }
@@ skipping 151 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 Handle<Object> SetImpl(Handle<JSObject> obj, uint32_t key,
+                                Handle<FixedArrayBase> store,
+                                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);
+    return value;
+  }
+
   static PropertyAttributes GetAttributesImpl(JSObject* obj, uint32_t key,
                                               FixedArrayBase* backing_store) {
     SeededNumberDictionary* dictionary =
         SeededNumberDictionary::cast(backing_store);
     int entry = dictionary->FindEntry(key);
     if (entry != SeededNumberDictionary::kNotFound) {
       return dictionary->DetailsAt(entry).attributes();
     }
     return ABSENT;
   }
@@ skipping 86 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 Handle<Object> SetImpl(Handle<JSObject> obj, uint32_t key,
+                                Handle<FixedArrayBase> store,
+                                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);
+      return value;
+    }
+    Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
+    return ElementsAccessor::ForArray(arguments)
+        ->Set(obj, key, arguments, value);
+  }
+
   static PropertyAttributes GetAttributesImpl(JSObject* obj, uint32_t key,
                                               FixedArrayBase* backing_store) {
     FixedArray* parameter_map = FixedArray::cast(backing_store);
     Object* probe = GetParameterMapArg(parameter_map, key);
     if (!probe->IsTheHole()) {
       return NONE;
     } else {
       // If not aliased, check the arguments.
       FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
       return ElementsAccessor::ForArray(arguments)
@@ skipping 308 matching lines @@
       break;
   }
 
   array->set_elements(*elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 }  // namespace internal
 }  // namespace v8