ES6 Unscopables

src/runtime.cc

 // Copyright 2012 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 <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 23 matching lines @@
 #include "src/liveedit.h"
 #include "src/misc-intrinsics.h"
 #include "src/parser.h"
 #include "src/prototype.h"
 #include "src/runtime.h"
 #include "src/runtime-profiler.h"
 #include "src/scopeinfo.h"
 #include "src/smart-pointers.h"
 #include "src/string-search.h"
 #include "src/stub-cache.h"
+#include "src/unscopables.h"
 #include "src/uri.h"
 #include "src/v8threads.h"
 #include "src/vm-state-inl.h"
 
 #ifdef V8_I18N_SUPPORT
 #include "src/i18n.h"
 #include "unicode/brkiter.h"
 #include "unicode/calendar.h"
 #include "unicode/coll.h"
 #include "unicode/curramt.h"
@@ skipping 9030 matching lines @@
   // explicitly via a with-statement.
   Object* constructor = holder->map()->constructor();
   if (constructor != context_extension_function) return holder;
   // Fall back to using the global object as the implicit receiver if
   // the property turns out to be a local variable allocated in a
   // context extension object - introduced via eval.
   return isolate->heap()->undefined_value();
 }
 
 
+static ObjectPair LoadWithContextSlot(Isolate* isolate, Handle<String> name,
+                                      Handle<JSReceiver> object,
+                                      Handle<Object> receiver_handle) {
+  UnscopableLookup lookup(isolate, name, object);
+  if (lookup.HasError()) {
+    return MakePair(isolate->heap()->exception(), NULL);
+  }
+  if (lookup.Found()) {
+    // The property might be a getter that is normally shadowed but due to the
+    // unscopables we found it further up the prototype chain. Therefore we need
+    // to ensure that we are using the right receiver and holder when we get the
+    // value.
+    Handle<Object> value;
+    LookupIterator it(object, name, lookup.GetHolder());
+    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+        isolate, value, Object::GetProperty(&it),
+        MakePair(isolate->heap()->exception(), NULL));
+    return MakePair(*value, *receiver_handle);
+  }
+  return MakePair(isolate->heap()->undefined_value(),
+                  isolate->heap()->undefined_value());
+}
+
+
 static ObjectPair LoadContextSlotHelper(Arguments args,
                                         Isolate* isolate,
                                         bool throw_error) {
   HandleScope scope(isolate);
   ASSERT_EQ(2, args.length());
 
   if (!args[0]->IsContext() || !args[1]->IsString()) {
     return MakePair(isolate->ThrowIllegalOperation(), NULL);
   }
   Handle<Context> context = args.at<Context>(0);
@@ skipping 54 matching lines @@
     Handle<JSReceiver> object = Handle<JSReceiver>::cast(holder);
     ASSERT(object->IsJSProxy() || JSReceiver::HasProperty(object, name));
     // GetProperty below can cause GC.
     Handle<Object> receiver_handle(
         object->IsGlobalObject()
             ? Object::cast(isolate->heap()->undefined_value())
             : object->IsJSProxy() ? static_cast<Object*>(*object)
                 : ComputeReceiverForNonGlobal(isolate, JSObject::cast(*object)),
         isolate);
 
+    if (FLAG_harmony_unscopables && context->IsWithContext()) {
+      return LoadWithContextSlot(isolate, name, object, receiver_handle);
+    }
+
     // No need to unhole the value here.  This is taken care of by the
     // GetProperty function.
     Handle<Object> value;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate, value,
         Object::GetProperty(object, name),
         MakePair(isolate->heap()->exception(), NULL));
     return MakePair(*value, *receiver_handle);
   }
 
@@ skipping 5778 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal