Rewriting SetOwnPropertyIgnoreAttributes using the LookupIterator

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/lookup.h"
 #include "src/lookup-inl.h"
 
@@ skipping 108 matching lines @@
   // Reload property information.
   if (holder_map_->is_dictionary_map()) {
     property_encoding_ = DICTIONARY;
   } else {
     property_encoding_ = DESCRIPTOR;
   }
   CHECK(HasProperty());
 }
 
 
+void LookupIterator::ReconfigureDataProperty(Handle<Object> value,
+                                             PropertyAttributes attributes) {
+  DCHECK(has_property_);
+  DCHECK(HolderIsReceiverOrHiddenPrototype());
+  Handle<JSObject> holder = GetHolder<JSObject>();
+  if (property_encoding_ != DICTIONARY) {
+    holder_map_ = Map::ReconfigureDataProperty(holder_map_, descriptor_number(),
+                                               attributes);
+    JSObject::MigrateToMap(holder, holder_map_);
+  }
+
+  // Reload property information and update the descriptor if in dictionary
+  // mode.
+  if (holder_map_->is_dictionary_map()) {
+    property_encoding_ = DICTIONARY;
+    PropertyDetails details(attributes, NORMAL, 0);
+    JSObject::SetNormalizedProperty(holder, name(), value, details);
+  } else {
+    property_encoding_ = DESCRIPTOR;
+  }
+
+  CHECK(HasProperty());
+}
+
+
 void LookupIterator::TransitionToDataProperty(
     Handle<Object> value, PropertyAttributes attributes,
     Object::StoreFromKeyed store_mode) {
   DCHECK(!has_property_ || !HolderIsReceiverOrHiddenPrototype());
 
   // 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 = Handle<JSObject>::cast(GetReceiver());
 
-  // Properties have to be added to context extension objects through
-  // SetOwnPropertyIgnoreAttributes.
-  DCHECK(!receiver->IsJSContextExtensionObject());
-
   if (receiver->IsJSGlobalProxy()) {
     PrototypeIterator iter(isolate(), receiver);
     receiver =
         Handle<JSGlobalObject>::cast(PrototypeIterator::GetCurrent(iter));
   }
 
   maybe_holder_ = receiver;
   holder_map_ = Map::TransitionToDataProperty(handle(receiver->map()), name_,
                                               value, attributes, store_mode);
   JSObject::MigrateToMap(receiver, holder_map_);
 
   // Reload the information.
   state_ = NOT_FOUND;
   configuration_ = CHECK_OWN_REAL;
   state_ = LookupInHolder(*holder_map_);
   DCHECK(IsFound());
   HasProperty();
 }
 
 
 bool LookupIterator::HolderIsReceiverOrHiddenPrototype() const {
   DCHECK(has_property_ || state_ == INTERCEPTOR || state_ == JSPROXY);
+  // Optimization that only works if configuration_ is not mutable.
+  if (!check_derived()) return true;
   DisallowHeapAllocation no_gc;
   Handle<Object> receiver = GetReceiver();
   if (!receiver->IsJSReceiver()) return false;
   Object* current = *receiver;
   JSReceiver* holder = *maybe_holder_.ToHandleChecked();
   // JSProxy do not occur as hidden prototypes.
   if (current->IsJSProxy()) {
     return JSReceiver::cast(current) == holder;
   }
   PrototypeIterator iter(isolate(), current,
                          PrototypeIterator::START_AT_RECEIVER);
   do {
     if (JSReceiver::cast(iter.GetCurrent()) == holder) return true;
     DCHECK(!current->IsJSProxy());
     iter.Advance();
   } while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN));
   return false;
 }
 
 
+bool LookupIterator::HolderIsNonGlobalHiddenPrototype() const {
+  if (!HolderIsReceiverOrHiddenPrototype()) return false;
+  Handle<Object> receiver = GetReceiver();
+  Handle<JSReceiver> holder = GetHolder<JSReceiver>();
+  if (receiver.is_identical_to(holder)) return false;
+  if (receiver->IsJSGlobalProxy()) return !holder->IsJSGlobalObject();
+  return true;
+}
+
+
 Handle<Object> LookupIterator::FetchValue() const {
   Object* result = NULL;
   Handle<JSObject> holder = GetHolder<JSObject>();
   switch (property_encoding_) {
     case DICTIONARY:
       result = holder->property_dictionary()->ValueAt(number_);
       if (holder->IsGlobalObject()) {
         result = PropertyCell::cast(result)->value();
       }
       break;
@@ skipping 71 matching lines @@
     DCHECK_EQ(v8::internal::CONSTANT, property_details_.type());
   }
 }
 
 
 void LookupIterator::InternalizeName() {
   if (name_->IsUniqueName()) return;
   name_ = factory()->InternalizeString(Handle<String>::cast(name_));
 }
 } }  // namespace v8::internal