ES6 Unscopables

src/contexts.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/v8.h"
 
 #include "src/bootstrapper.h"
 #include "src/debug.h"
 #include "src/scopeinfo.h"
+#include "src/unscopables.h"
 
 namespace v8 {
 namespace internal {
 
 Context* Context::declaration_context() {
   Context* current = this;
   while (!current->IsFunctionContext() && !current->IsNativeContext()) {
     current = current->previous();
     ASSERT(current->closure() == closure());
   }
@@ skipping 82 matching lines @@
         context->IsWithContext() ||
         (context->IsFunctionContext() && context->has_extension())) {
       Handle<JSReceiver> object(
           JSReceiver::cast(context->extension()), isolate);
       // Context extension objects needs to behave as if they have no
       // prototype.  So even if we want to follow prototype chains, we need
       // to only do a local lookup for context extension objects.
       if ((flags & FOLLOW_PROTOTYPE_CHAIN) == 0 ||
           object->IsJSContextExtensionObject()) {
         *attributes = JSReceiver::GetOwnPropertyAttributes(object, name);
+      } else if (FLAG_harmony_unscopables && context->IsWithContext()) {
+        LookupIterator it(object, name);
+        *attributes = UnscopableLookup(&it);
       } else {
         *attributes = JSReceiver::GetPropertyAttributes(object, name);
       }
+
       if (isolate->has_pending_exception()) return Handle<Object>();

[arv (Not doing code reviews), 2014/07/25 15:33:26]

Exception is handled here.

[Toon Verwaest, 2014/07/25 18:52:11]

The problem is that it was looking for pending exceptions, but it may just have
been scheduled. Anyway, after my CL that distinction is now irrelevant, and
pending is all you need to care about.

On 2014/07/25 15:33:26, arv wrote:

 
       if (*attributes != ABSENT) {
         if (FLAG_trace_contexts) {
           PrintF("=> found property in context object %p\n",
                  reinterpret_cast<void*>(*object));
         }
         return object;
       }
     }
 
@@ skipping 241 matching lines @@
 bool Context::IsBootstrappingOrGlobalObject(Isolate* isolate, Object* object) {
   // During bootstrapping we allow all objects to pass as global
   // objects. This is necessary to fix circular dependencies.
   return isolate->heap()->gc_state() != Heap::NOT_IN_GC ||
       isolate->bootstrapper()->IsActive() ||
       object->IsGlobalObject();
 }
 #endif
 
 } }  // namespace v8::internal