Add GetProperty/GetElement to JSReceiver and use it where possible

src/property-descriptor.cc

 // Copyright 2011 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/property-descriptor.h"
 
 #include "src/bootstrapper.h"
 #include "src/factory.h"
 #include "src/isolate-inl.h"
 #include "src/lookup.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 // Helper function for ToPropertyDescriptor. Comments describe steps for
 // "enumerable", other properties are handled the same way.
 // Returns false if an exception was thrown.
-bool GetPropertyIfPresent(Handle<Object> obj, Handle<String> name,
+bool GetPropertyIfPresent(Handle<JSReceiver> receiver, Handle<String> name,
                           Handle<Object>* value) {
-  LookupIterator it(obj, name);
+  LookupIterator it(receiver, name, receiver);
   // 4. Let hasEnumerable be HasProperty(Obj, "enumerable").
   Maybe<bool> has_property = JSReceiver::HasProperty(&it);
   // 5. ReturnIfAbrupt(hasEnumerable).
   if (has_property.IsNothing()) return false;
   // 6. If hasEnumerable is true, then
   if (has_property.FromJust() == true) {
     // 6a. Let enum be ToBoolean(Get(Obj, "enumerable")).
     // 6b. ReturnIfAbrupt(enum).
-    if (!JSObject::GetProperty(&it).ToHandle(value)) return false;
+    if (!Object::GetProperty(&it).ToHandle(value)) return false;
   }
   return true;
 }
 
 
 // Helper function for ToPropertyDescriptor. Handles the case of "simple"
 // objects: nothing on the prototype chain, just own fast data properties.
 // Must not have observable side effects, because the slow path will restart
 // the entire conversion!
-bool ToPropertyDescriptorFastPath(Isolate* isolate, Handle<Object> obj,
+bool ToPropertyDescriptorFastPath(Isolate* isolate, Handle<JSReceiver> obj,
                                   PropertyDescriptor* desc) {
   if (!obj->IsJSObject()) return false;
   Map* map = Handle<JSObject>::cast(obj)->map();
   if (map->instance_type() != JS_OBJECT_TYPE) return false;
   if (map->is_access_check_needed()) return false;
   if (map->prototype() != *isolate->initial_object_prototype()) return false;
   // During bootstrapping, the object_function_prototype_map hasn't been
   // set up yet.
   if (isolate->bootstrapper()->IsActive()) return false;
   if (JSObject::cast(map->prototype())->map() !=
@@ skipping 130 matching lines @@
   // 1. ReturnIfAbrupt(Obj).
   // 2. If Type(Obj) is not Object, throw a TypeError exception.
   if (!obj->IsJSReceiver()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
         MessageTemplate::kPropertyDescObject, obj));
     return false;
   }
   // 3. Let desc be a new Property Descriptor that initially has no fields.
   DCHECK(desc->is_empty());
 
-  if (ToPropertyDescriptorFastPath(isolate, obj, desc)) {
+  Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(obj);
+  if (ToPropertyDescriptorFastPath(isolate, receiver, desc)) {
     return true;
   }
 
   // enumerable?
   Handle<Object> enumerable;
   // 4 through 6b.
-  if (!GetPropertyIfPresent(obj, isolate->factory()->enumerable_string(),
+  if (!GetPropertyIfPresent(receiver, isolate->factory()->enumerable_string(),
                             &enumerable)) {
     return false;
   }
   // 6c. Set the [[Enumerable]] field of desc to enum.
   if (!enumerable.is_null()) {
     desc->set_enumerable(enumerable->BooleanValue());
   }
 
   // configurable?
   Handle<Object> configurable;
   // 7 through 9b.
-  if (!GetPropertyIfPresent(obj, isolate->factory()->configurable_string(),
+  if (!GetPropertyIfPresent(receiver, isolate->factory()->configurable_string(),
                             &configurable)) {
     return false;
   }
   // 9c. Set the [[Configurable]] field of desc to conf.
   if (!configurable.is_null()) {
     desc->set_configurable(configurable->BooleanValue());
   }
 
   // value?
   Handle<Object> value;
   // 10 through 12b.
-  if (!GetPropertyIfPresent(obj, isolate->factory()->value_string(), &value)) {
+  if (!GetPropertyIfPresent(receiver, isolate->factory()->value_string(),
+                            &value)) {
     return false;
   }
   // 12c. Set the [[Value]] field of desc to value.
   if (!value.is_null()) desc->set_value(value);
 
   // writable?
   Handle<Object> writable;
   // 13 through 15b.
-  if (!GetPropertyIfPresent(obj, isolate->factory()->writable_string(),
+  if (!GetPropertyIfPresent(receiver, isolate->factory()->writable_string(),
                             &writable)) {
     return false;
   }
   // 15c. Set the [[Writable]] field of desc to writable.
   if (!writable.is_null()) desc->set_writable(writable->BooleanValue());
 
   // getter?
   Handle<Object> getter;
   // 16 through 18b.
-  if (!GetPropertyIfPresent(obj, isolate->factory()->get_string(), &getter)) {
+  if (!GetPropertyIfPresent(receiver, isolate->factory()->get_string(),
+                            &getter)) {
     return false;
   }
   if (!getter.is_null()) {
     // 18c. If IsCallable(getter) is false and getter is not undefined,
     // throw a TypeError exception.
     if (!getter->IsCallable() && !getter->IsUndefined()) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kObjectGetterCallable, getter));
       return false;
     }
     // 18d. Set the [[Get]] field of desc to getter.
     desc->set_get(getter);
   }
   // setter?
   Handle<Object> setter;
   // 19 through 21b.
-  if (!GetPropertyIfPresent(obj, isolate->factory()->set_string(), &setter)) {
+  if (!GetPropertyIfPresent(receiver, isolate->factory()->set_string(),
+                            &setter)) {
     return false;
   }
   if (!setter.is_null()) {
     // 21c. If IsCallable(setter) is false and setter is not undefined,
     // throw a TypeError exception.
     if (!setter->IsCallable() && !setter->IsUndefined()) {
       isolate->Throw(*isolate->factory()->NewTypeError(
           MessageTemplate::kObjectSetterCallable, setter));
       return false;
     }
@@ skipping 54 matching lines @@
   //    Desc.[[Enumerable]] to like.[[Enumerable]].
   if (!desc->has_enumerable()) desc->set_enumerable(false);
   // 7. If Desc does not have a [[Configurable]] field, set
   //    Desc.[[Configurable]] to like.[[Configurable]].
   if (!desc->has_configurable()) desc->set_configurable(false);
   // 8. Return Desc.
 }
 
 }  // namespace internal
 }  // namespace v8