Replace Set*Callback with TransitionToAccessorPair

src/lookup.cc

 // Copyright 2014 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/bootstrapper.h"
 #include "src/deoptimizer.h"
 #include "src/lookup.h"
 #include "src/lookup-inl.h"
@@ skipping 259 matching lines @@
 
 
 void LookupIterator::TransitionToAccessorProperty(
     AccessorComponent component, Handle<Object> accessor,
     PropertyAttributes attributes) {
   DCHECK(!accessor->IsNull());
   // Can only be called when the receiver is a JSObject. JSProxy has to be
   // handled via a trap. Adding properties to primitive values is not
   // observable.
   Handle<JSObject> receiver = GetStoreTarget();
-  holder_ = receiver;
 
   if (!IsElement() && !receiver->map()->is_dictionary_map()) {
+    holder_ = receiver;
     holder_map_ = Map::TransitionToAccessorProperty(
         handle(receiver->map(), isolate_), name_, component, accessor,
         attributes);
     JSObject::MigrateToMap(receiver, holder_map_);
 
     ReloadPropertyInformation();
 
     if (!holder_map_->is_dictionary_map()) return;
   }
 
-  PropertyDetails details(attributes, ACCESSOR_CONSTANT, 0,
-                          PropertyCellType::kMutable);
   Handle<AccessorPair> pair;
   if (state() == ACCESSOR && GetAccessors()->IsAccessorPair()) {
     pair = Handle<AccessorPair>::cast(GetAccessors());
     // If the component and attributes are identical, nothing has to be done.
     if (pair->get(component) == *accessor) {
       if (property_details().attributes() == attributes) return;
     } else {
       pair = AccessorPair::Copy(pair);
       pair->set(component, *accessor);
     }
   } else {
     pair = factory()->NewAccessorPair();
     pair->set(component, *accessor);
   }
 
+  TransitionToAccessorPair(pair, attributes);
+}
+
+
+void LookupIterator::TransitionToAccessorPair(Handle<Object> pair,
+                                              PropertyAttributes attributes) {
+  Handle<JSObject> receiver = GetStoreTarget();
+  holder_ = receiver;
+
+  PropertyDetails details(attributes, ACCESSOR_CONSTANT, 0,
+                          PropertyCellType::kMutable);
+
   if (IsElement()) {
     // TODO(verwaest): Remove this hack once we have a quick way to check the
     // prototype chain in element setters.
     // TODO(verwaest): Move code into the element accessor.
     bool was_dictionary = receiver->HasDictionaryElements();
     Handle<SeededNumberDictionary> dictionary =
         JSObject::NormalizeElements(receiver);
     was_dictionary = was_dictionary && dictionary->requires_slow_elements();
 
     dictionary = SeededNumberDictionary::Set(dictionary, index_, pair, details);
     dictionary->set_requires_slow_elements();
 
     if (receiver->HasSlowArgumentsElements()) {
       FixedArray* parameter_map = FixedArray::cast(receiver->elements());
       uint32_t length = parameter_map->length() - 2;
       if (number_ < length) {
         parameter_map->set(number_ + 2, heap()->the_hole_value());
       }
       FixedArray::cast(receiver->elements())->set(1, *dictionary);
     } else {
       receiver->set_elements(*dictionary);
       if (!was_dictionary) heap()->ClearAllICsByKind(Code::KEYED_STORE_IC);
     }
   } else {
+    PropertyNormalizationMode mode = receiver->map()->is_prototype_map()
+                                         ? KEEP_INOBJECT_PROPERTIES
+                                         : CLEAR_INOBJECT_PROPERTIES;
+    // Normalize object to make this operation simple.
+    JSObject::NormalizeProperties(receiver, mode, 0,
+                                  "TransitionToAccessorPair");
+
     JSObject::SetNormalizedProperty(receiver, name_, pair, details);
     JSObject::ReoptimizeIfPrototype(receiver);
   }
 
   holder_map_ = handle(receiver->map(), isolate_);
   ReloadPropertyInformation();
 }
 
 
 bool LookupIterator::HolderIsReceiverOrHiddenPrototype() const {
@@ skipping 199 matching lines @@
       case InterceptorState::kSkipNonMasking:
         return true;
       case InterceptorState::kProcessNonMasking:
         return false;
     }
   }
   return interceptor_state_ == InterceptorState::kProcessNonMasking;
 }
 }  // namespace internal
 }  // namespace v8