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

src/elements.cc

Index: src/elements.cc
diff --git a/src/elements.cc b/src/elements.cc
index a2068dce5df4d6a4a275436515d9857a78bfd621..b42236a65ae8cebf3b0d271a70e5a0fdd159d30e 100644
--- a/src/elements.cc
+++ b/src/elements.cc
@@ -925,8 +925,8 @@ class FastElementsAccessor
     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());
@@ -937,6 +937,16 @@ class FastElementsAccessor
       return isolate->factory()->true_value();
     }
     Handle<BackingStore> backing_store = Handle<BackingStore>::cast(elements);
+    if (obj->map()->is_strong() && !backing_store->is_the_hole(key)) {

[arv (Not doing code reviews), 2015/05/28 15:46:17]

When do we holes in the backing store of a strong object?

[conradw, 2015/05/28 16:36:44]

The elements backing store can become some flavour of holey array, so this is
needed to make sure deleting a missing property doesn't reject.

I've just realised this is in the wrong place though, if key is >length, this
trips an assert, so I've fixed that.

+      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();
+    }
     bool is_sloppy_arguments_elements_map =
         backing_store->map() == heap->sloppy_arguments_elements_map();
     if (is_sloppy_arguments_elements_map) {
@@ -1420,12 +1430,21 @@ class DictionaryElementsAccessor
         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),