[strong] Implement per-object restrictions behaviour of delete operator

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 907 matching lines @@
 
     // Check whether the backing store should be expanded.
     uint32_t min = JSObject::NewElementsCapacity(old_capacity);
     uint32_t new_capacity = length > min ? length : min;
     FastElementsAccessorSubclass::SetFastElementsCapacityAndLength(
         array, new_capacity, length);
     JSObject::ValidateElements(array);
     return length_object;
   }
 
-  static Handle<Object> DeleteCommon(Handle<JSObject> obj, uint32_t key,
-                                     LanguageMode language_mode) {
+  static MaybeHandle<Object> DeleteCommon(Handle<JSObject> obj, uint32_t key,
+                                          LanguageMode language_mode) {
     DCHECK(obj->HasFastSmiOrObjectElements() ||
            obj->HasFastDoubleElements() ||
            obj->HasFastArgumentsElements());
     Isolate* isolate = obj->GetIsolate();
     Heap* heap = obj->GetHeap();
     Handle<FixedArrayBase> elements(obj->elements());
     if (*elements == heap->empty_fixed_array()) {
       return isolate->factory()->true_value();
     }
     Handle<BackingStore> backing_store = Handle<BackingStore>::cast(elements);
     bool is_sloppy_arguments_elements_map =
         backing_store->map() == heap->sloppy_arguments_elements_map();
     if (is_sloppy_arguments_elements_map) {
       backing_store = handle(
           BackingStore::cast(Handle<FixedArray>::cast(backing_store)->get(1)),
           isolate);
     }
     uint32_t length = static_cast<uint32_t>(
         obj->IsJSArray()
         ? Smi::cast(Handle<JSArray>::cast(obj)->length())->value()
         : backing_store->length());
     if (key < length) {
+      if (obj->map()->is_strong() && !backing_store->is_the_hole(key)) {
+        if (is_strict(language_mode)) {
+          Handle<Object> name = isolate->factory()->NewNumberFromUint(key);
+          THROW_NEW_ERROR(
+              isolate,
+              NewTypeError(MessageTemplate::kStrongDeleteProperty, obj, name),
+              Object);
+        }
+        return isolate->factory()->false_value();
+      }
       if (!is_sloppy_arguments_elements_map) {
         ElementsKind kind = KindTraits::Kind;
         if (IsFastPackedElementsKind(kind)) {
           JSObject::TransitionElementsKind(obj, GetHoleyElementsKind(kind));
         }
         if (IsFastSmiOrObjectElementsKind(KindTraits::Kind)) {
           Handle<Object> writable = JSObject::EnsureWritableFastElements(obj);
           backing_store = Handle<BackingStore>::cast(writable);
         }
       }
@@ skipping 451 matching lines @@
                                      isolate);
     bool is_arguments =
         (obj->GetElementsKind() == SLOPPY_ARGUMENTS_ELEMENTS);
     if (is_arguments) {
       backing_store = handle(FixedArray::cast(backing_store->get(1)), isolate);
     }
     Handle<SeededNumberDictionary> dictionary =
         Handle<SeededNumberDictionary>::cast(backing_store);
     int entry = dictionary->FindEntry(key);
     if (entry != SeededNumberDictionary::kNotFound) {
-      Handle<Object> result =
-          SeededNumberDictionary::DeleteProperty(dictionary, entry);
-      if (*result == *isolate->factory()->false_value()) {
+      Handle<Object> result;
+      bool strong = obj->map()->is_strong();
+      if (!strong) {
+        result = SeededNumberDictionary::DeleteProperty(dictionary, entry);
+      }
+      if (strong || *result == *isolate->factory()->false_value()) {
+        // Fail if the property is not configurable, or on a strong object.
         if (is_strict(language_mode)) {
-          // Deleting a non-configurable property in strict mode.
           Handle<Object> name = isolate->factory()->NewNumberFromUint(key);
+          if (strong) {
+            THROW_NEW_ERROR(
+                isolate,
+                NewTypeError(MessageTemplate::kStrongDeleteProperty, obj, name),
+                Object);
+          }
           THROW_NEW_ERROR(
               isolate,
               NewTypeError(MessageTemplate::kStrictDeleteProperty, name, obj),
               Object);
         }
         return isolate->factory()->false_value();
       }
       Handle<FixedArray> new_elements =
           SeededNumberDictionary::Shrink(dictionary, key);
 
@@ skipping 455 matching lines @@
       UNREACHABLE();
       break;
   }
 
   array->set_elements(*elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 } }  // namespace v8::internal