Introduce NonJSProxyHolder returning Handle<JSObject> and return Handle<JSReceiver> for GetHolder

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"
 
 namespace v8 {
@@ skipping 82 matching lines @@
 
 
 bool LookupIterator::IsBootstrapping() const {
   return isolate_->bootstrapper()->IsActive();
 }
 
 
 bool LookupIterator::HasAccess(v8::AccessType access_type) const {
   ASSERT_EQ(ACCESS_CHECK, state_);
   ASSERT(is_guaranteed_to_have_holder());
-  return isolate_->MayNamedAccess(GetHolder(), name_, access_type);
+  return isolate_->MayNamedAccess(GetNonJSProxyHolder(), name_, access_type);
 }
 
 
 bool LookupIterator::HasProperty() {
   ASSERT_EQ(PROPERTY, state_);
   ASSERT(is_guaranteed_to_have_holder());
 
   if (property_encoding_ == DICTIONARY) {
-    Handle<JSObject> holder = GetHolder();
+    Handle<JSObject> holder = GetNonJSProxyHolder();
     number_ = holder->property_dictionary()->FindEntry(name_);
     if (number_ == NameDictionary::kNotFound) return false;
 
-    property_details_ = GetHolder()->property_dictionary()->DetailsAt(number_);
+    property_details_ = holder->property_dictionary()->DetailsAt(number_);
     // Holes in dictionary cells are absent values.
     if (holder->IsGlobalObject() &&
         (property_details_.IsDeleted() || FetchValue()->IsTheHole())) {
       return false;
     }
   } else {
     property_details_ = holder_map_->instance_descriptors()->GetDetails(
         number_);
   }
 
@@ skipping 15 matching lines @@
   has_property_ = true;
   return true;
 }
 
 
 void LookupIterator::PrepareForDataProperty(Handle<Object> value) {
   ASSERT(has_property_);
   ASSERT(HolderIsReceiver());
   if (property_encoding_ == DICTIONARY) return;
   holder_map_ = Map::PrepareForDataProperty(holder_map_, number_, value);
-  JSObject::MigrateToMap(GetHolder(), holder_map_);
+  JSObject::MigrateToMap(GetNonJSProxyHolder(), holder_map_);
   // Reload property information.
   if (holder_map_->is_dictionary_map()) {
     property_encoding_ = DICTIONARY;
   } else {
     property_encoding_ = DESCRIPTOR;
   }
   CHECK(HasProperty());
 }
 
 
@@ skipping 48 matching lines @@
     if (JSReceiver::cast(iter.GetCurrent()) == holder) return true;
     ASSERT(!current->IsJSProxy());
     iter.Advance();
   } while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN));
   return false;
 }
 
 
 Handle<Object> LookupIterator::FetchValue() const {
   Object* result = NULL;
+  Handle<JSObject> holder = GetNonJSProxyHolder();
   switch (property_encoding_) {
     case DICTIONARY:
-      result = GetHolder()->property_dictionary()->ValueAt(number_);
-      if (GetHolder()->IsGlobalObject()) {
+      result = holder->property_dictionary()->ValueAt(number_);
+      if (holder->IsGlobalObject()) {
         result = PropertyCell::cast(result)->value();
       }
       break;
     case DESCRIPTOR:
       if (property_details_.type() == v8::internal::FIELD) {
         FieldIndex field_index = FieldIndex::ForDescriptor(
             *holder_map_, number_);
         return JSObject::FastPropertyAt(
-            GetHolder(), property_details_.representation(), field_index);
+            holder, property_details_.representation(), field_index);
       }
       result = holder_map_->instance_descriptors()->GetValue(number_);
   }
   return handle(result, isolate_);
 }
 
 
 Handle<Object> LookupIterator::GetAccessors() const {
   ASSERT(has_property_);
   ASSERT_EQ(ACCESSOR, property_kind_);
   return FetchValue();
 }
 
 
 Handle<Object> LookupIterator::GetDataValue() const {
   ASSERT(has_property_);
   ASSERT_EQ(DATA, property_kind_);
   Handle<Object> value = FetchValue();
   return value;
 }
 
 
 void LookupIterator::WriteDataValue(Handle<Object> value) {
   ASSERT(is_guaranteed_to_have_holder());
   ASSERT(has_property_);
+  Handle<JSObject> holder = GetNonJSProxyHolder();
   if (property_encoding_ == DICTIONARY) {
-    Handle<JSObject> holder = GetHolder();
     NameDictionary* property_dictionary = holder->property_dictionary();
     if (holder->IsGlobalObject()) {
       Handle<PropertyCell> cell(
           PropertyCell::cast(property_dictionary->ValueAt(number_)));
       PropertyCell::SetValueInferType(cell, value);
     } else {
       property_dictionary->ValueAtPut(number_, *value);
     }
   } else if (property_details_.type() == v8::internal::FIELD) {
-    GetHolder()->WriteToField(number_, *value);
+    holder->WriteToField(number_, *value);
   } else {
     ASSERT_EQ(v8::internal::CONSTANT, property_details_.type());
   }
 }
 
 
 void LookupIterator::InternalizeName() {
   if (name_->IsUniqueName()) return;
   name_ = factory()->InternalizeString(Handle<String>::cast(name_));
 }
 } }  // namespace v8::internal