ES6 Unscopables

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 "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 111 matching lines @@
     } else {
       result->isolate()->PushStackTraceAndDie(
           0xDEAD0000, this, JSReceiver::cast(this)->map(), 0xDEAD0001);
     }
   }
   ASSERT(holder != NULL);  // Cannot handle null or undefined.
   JSReceiver::cast(holder)->Lookup(name, result);
 }
 
 
-MaybeHandle<Object> Object::GetProperty(LookupIterator* it) {
+MaybeHandle<Object> Object::GetPropertyHelper(
+    LookupIterator* it, bool force_holder_as_receiver_for_accessor_callback) {
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
         UNREACHABLE();
       case LookupIterator::JSPROXY:
         return JSProxy::GetPropertyWithHandler(
             it->GetJSProxy(), it->GetReceiver(), it->name());
       case LookupIterator::INTERCEPTOR: {
         MaybeHandle<Object> maybe_result = JSObject::GetPropertyWithInterceptor(
             it->GetHolder(), it->GetReceiver(), it->name());
         if (!maybe_result.is_null()) return maybe_result;
         if (it->isolate()->has_pending_exception()) return maybe_result;
         break;
       }
       case LookupIterator::ACCESS_CHECK:
         if (it->HasAccess(v8::ACCESS_GET)) break;
         return JSObject::GetPropertyWithFailedAccessCheck(it);
       case LookupIterator::PROPERTY:
         if (it->HasProperty()) {
           switch (it->property_kind()) {
-            case LookupIterator::ACCESSOR:
-              return GetPropertyWithAccessor(
-                  it->GetReceiver(), it->name(),
-                  it->GetHolder(), it->GetAccessors());
+            case LookupIterator::ACCESSOR: {
+              Handle<Object> accessors = it->GetAccessors();
+              Handle<Object> receiver;
+              if (force_holder_as_receiver_for_accessor_callback &&
+                  !accessors->IsAccessorPair()) {
+                receiver = it->GetHolder();
+              } else {
+                receiver = it->GetReceiver();
+              }
+              return GetPropertyWithAccessor(receiver, it->name(),
+                                             it->GetHolder(), accessors);
+            }

[Toon Verwaest, 2014/07/23 12:08:38]

Euh, no.

What you want to do is fix a bug in Array.length; but what you do instead is
modify get-property to change the semantics of all API accessors...

The right fix is to change ArrayLengthGetter to not use This() (via
GetThisFrom), but rather read the value from the Holder(). That also removes the
need for FindInstanceOf.

             case LookupIterator::DATA:
               return it->GetDataValue();
           }
         }
         break;
     }
   }
   return it->factory()->undefined_value();
 }
 
 
+MaybeHandle<Object> Object::GetProperty(LookupIterator* it) {
+  return GetPropertyHelper(it, false);
+}
+
+
+MaybeHandle<Object> Object::GetPropertyForUnscopables(LookupIterator* it) {
+  // TODO(arv): For unscopables we need to make sure that we use the holder as
+  // the receiver for data properties that are implemented as callbacks
+  // (ACCESSER && !IsAccessorPair).
+  return GetPropertyHelper(it, true);
+}
+
+
 bool Object::ToInt32(int32_t* value) {
   if (IsSmi()) {
     *value = Smi::cast(this)->value();
     return true;
   }
   if (IsHeapNumber()) {
     double num = HeapNumber::cast(this)->value();
     if (FastI2D(FastD2I(num)) == num) {
       *value = FastD2I(num);
       return true;
@@ skipping 16760 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal