Cleanup Delete backend implementation.

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 5127 matching lines @@
 
   DCHECK(result->IsBoolean());
   Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
   result_internal->VerifyApiCallResultType();
   // Rebox CustomArguments::kReturnValueOffset before returning.
   return handle(*result_internal, isolate);
 }
 
 
 void JSObject::DeleteNormalizedProperty(Handle<JSObject> object,
-                                        Handle<Name> name) {
+                                        Handle<Name> name, int entry) {
   DCHECK(!object->HasFastProperties());
   Isolate* isolate = object->GetIsolate();
 
   if (object->IsGlobalObject()) {
     // If we have a global object, invalidate the cell and swap in a new one.
     Handle<GlobalDictionary> dictionary(object->global_dictionary());
-    int entry = dictionary->FindEntry(name);
     DCHECK_NE(GlobalDictionary::kNotFound, entry);
 
     auto cell = PropertyCell::InvalidateEntry(dictionary, entry);
     cell->set_value(isolate->heap()->the_hole_value());
     // TODO(ishell): InvalidateForDelete
     cell->set_property_details(
         cell->property_details().set_cell_type(PropertyCellType::kInvalidated));
   } else {
     Handle<NameDictionary> dictionary(object->property_dictionary());
-    int entry = dictionary->FindEntry(name);
     DCHECK_NE(NameDictionary::kNotFound, entry);
 
     NameDictionary::DeleteProperty(dictionary, entry);
     Handle<NameDictionary> new_properties =
         NameDictionary::Shrink(dictionary, name);
     object->set_properties(*new_properties);
   }
 }
 
 
@@ skipping 38 matching lines @@
         return it->factory()->true_value();
       case LookupIterator::DATA:
         if (is_observed) {
           old_value = it->GetDataValue();
         }
       // Fall through.
       case LookupIterator::ACCESSOR: {
         if (!it->IsConfigurable() || receiver->map()->is_strong()) {
           // Fail if the property is not configurable, or on a strong object.
           if (is_strict(language_mode)) {
-            if (receiver->map()->is_strong()) {
-              THROW_NEW_ERROR(
-                  isolate, NewTypeError(MessageTemplate::kStrongDeleteProperty,
-                                        receiver, it->GetName()),
-                  Object);
-            }
-            THROW_NEW_ERROR(isolate,
-                            NewTypeError(MessageTemplate::kStrictDeleteProperty,
-                                         it->GetName(), receiver),
-                            Object);
+            MessageTemplate::Template templ =
+                receiver->map()->is_strong()
+                    ? MessageTemplate::kStrongDeleteProperty
+                    : MessageTemplate::kStrictDeleteProperty;
+            THROW_NEW_ERROR(
+                isolate, NewTypeError(templ, it->GetName(), receiver), Object);
           }
           return it->factory()->false_value();
         }
 
         Handle<JSObject> holder = it->GetHolder<JSObject>();
         // TODO(verwaest): Remove this temporary compatibility hack when blink
         // tests are updated.
         if (!holder.is_identical_to(receiver) &&
             !(receiver->IsJSGlobalProxy() && holder->IsJSGlobalObject())) {
           return it->factory()->true_value();
         }
 
-        if (it->IsElement()) {
-          ElementsAccessor* accessor = holder->GetElementsAccessor();
-          accessor->Delete(holder, it->index(), language_mode);
-        } else {
-          PropertyNormalizationMode mode = holder->map()->is_prototype_map()
-                                               ? KEEP_INOBJECT_PROPERTIES
-                                               : CLEAR_INOBJECT_PROPERTIES;
-
-          JSObject::NormalizeProperties(holder, mode, 0, "DeletingProperty");
-          JSObject::DeleteNormalizedProperty(holder, it->name());
-          JSObject::ReoptimizeIfPrototype(holder);
-        }
+        it->Delete();
 
         if (is_observed) {
           RETURN_ON_EXCEPTION(isolate,
                               JSObject::EnqueueChangeRecord(
                                   receiver, "delete", it->GetName(), old_value),
                               Object);
         }
 
         return it->factory()->true_value();
       }
@@ skipping 10880 matching lines @@
                                             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 internal
 }  // namespace v8