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

src/objects.cc

 // Copyright 2013 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 <iomanip>
 #include <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 5451 matching lines @@
         break;
       }
       case LookupIterator::INTEGER_INDEXED_EXOTIC:
         return it.isolate()->factory()->true_value();
       case LookupIterator::DATA:
         if (is_observed) {
           old_value = it.GetDataValue();
         }
       // Fall through.
       case LookupIterator::ACCESSOR: {
-        if (!it.IsConfigurable()) {
-          // Fail if the property is not configurable.
+        if (!it.IsConfigurable() || object->map()->is_strong()) {
+          // Fail if the property is not configurable, or on a strong object.
           if (is_strict(language_mode)) {
+            if (object->map()->is_strong()) {
+              THROW_NEW_ERROR(
+                  it.isolate(),
+                  NewTypeError(MessageTemplate::kStrongDeleteProperty, object,
+                               name),
+                  Object);
+            }
             THROW_NEW_ERROR(it.isolate(),
                             NewTypeError(MessageTemplate::kStrictDeleteProperty,
                                          name, object),
                             Object);
           }
           return it.isolate()->factory()->false_value();
         }
 
         PropertyNormalizationMode mode = object->map()->is_prototype_map()
                                              ? KEEP_INOBJECT_PROPERTIES
@@ skipping 9506 matching lines @@
 template Object*
 Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape, uint32_t>::
     SlowReverseLookup(Object* value);
 
 template Object*
 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
     SlowReverseLookup(Object* value);
 
 template Handle<Object>
 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::DeleteProperty(
-    Handle<NameDictionary>, int);
+    Handle<NameDictionary>, int, bool);
 
 template Handle<Object>
 Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape,
-           uint32_t>::DeleteProperty(Handle<SeededNumberDictionary>, int);
+           uint32_t>::DeleteProperty(Handle<SeededNumberDictionary>, int, bool);
 
 template Handle<NameDictionary>
 HashTable<NameDictionary, NameDictionaryShape, Handle<Name> >::
     New(Isolate*, int, MinimumCapacity, PretenureFlag);
 
 template Handle<NameDictionary>
 HashTable<NameDictionary, NameDictionaryShape, Handle<Name> >::
     Shrink(Handle<NameDictionary>, Handle<Name>);
 
 template Handle<SeededNumberDictionary>
@@ skipping 948 matching lines @@
       !PropertyDetails::IsValidIndex(dictionary->NextEnumerationIndex() + n)) {
     // If not, we generate new indices for the properties.
     GenerateNewEnumerationIndices(dictionary);
   }
   return DerivedHashTable::EnsureCapacity(dictionary, n, key);
 }
 
 
 template <typename Derived, typename Shape, typename Key>
 Handle<Object> Dictionary<Derived, Shape, Key>::DeleteProperty(
-    Handle<Derived> dictionary, int entry) {
+    Handle<Derived> dictionary, int entry, bool strong_obj) {
   Factory* factory = dictionary->GetIsolate()->factory();
   PropertyDetails details = dictionary->DetailsAt(entry);
-  if (!details.IsConfigurable()) return factory->false_value();
+  if (!details.IsConfigurable() || strong_obj) return factory->false_value();
 
   dictionary->SetEntry(
       entry, factory->the_hole_value(), factory->the_hole_value());
   dictionary->ElementRemoved();
   return factory->true_value();
 }
 
 
 template<typename Derived, typename Shape, typename Key>
 Handle<Derived> Dictionary<Derived, Shape, Key>::AtPut(
@@ skipping 1265 matching lines @@
 void PropertyCell::SetValueWithInvalidation(Handle<PropertyCell> cell,
                                             Handle<Object> new_value) {
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 } }  // namespace v8::internal