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"
 
@@ skipping 53 matching lines @@
 JSObject* Context::global_proxy() {
   return native_context()->global_proxy_object();
 }
 
 
 void Context::set_global_proxy(JSObject* object) {
   native_context()->set_global_proxy_object(object);
 }
 
 
+static PropertyAttributes GetWithContextAttributes(Isolate* isolate,
+                                                   Handle<String> name,
+                                                   Handle<JSReceiver> object) {
+  Handle<Symbol> unscopables_symbol(
+      isolate->native_context()->unscopables_symbol(), isolate);
+
+  while (true) {

[arv (Not doing code reviews), 2014/07/10 23:13:11]

I'll switch to use the new PrototypeIterator.

[rossberg, 2014/07/11 11:59:06]

Yes, that would be better.

[arv (Not doing code reviews), 2014/07/11 21:47:28]

Waiting for that CL to land...

+    PropertyAttributes name_attrs =
+        JSReceiver::GetOwnPropertyAttributes(object, name);
+
+    if (name_attrs != ABSENT) {
+      PropertyAttributes unscopables_attrs =
+          JSReceiver::GetOwnPropertyAttributes(object, unscopables_symbol);
+      PropertyAttributes blocked_attrs = ABSENT;
+      if (unscopables_attrs != ABSENT) {
+        Handle<Object> unscopables_object;
+        ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+            isolate, unscopables_object,
+            Object::GetProperty(object, unscopables_symbol), name_attrs);
+
+        if (unscopables_object->IsSpecObject()) {
+          blocked_attrs = JSReceiver::GetOwnPropertyAttributes(
+              Handle<JSReceiver>::cast(unscopables_object), name);
+        }
+      }
+
+      if (blocked_attrs == ABSENT) {
+        return name_attrs;
+      }
+    }
+
+    Object* prototype = object->GetPrototype();
+    if (prototype->IsNull()) {
+      return ABSENT;
+    }
+    ASSERT(prototype->IsSpecObject());
+    object = handle(JSReceiver::cast(prototype), isolate);
+  }
+
+  UNREACHABLE();
+  return ABSENT;
+}
+
+
 Handle<Object> Context::Lookup(Handle<String> name,
                                ContextLookupFlags flags,
                                int* index,
                                PropertyAttributes* attributes,
                                BindingFlags* binding_flags) {
   Isolate* isolate = GetIsolate();
   Handle<Context> context(this, isolate);
 
   bool follow_context_chain = (flags & FOLLOW_CONTEXT_CHAIN) != 0;
   *index = -1;
@@ skipping 18 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()) {
+        *attributes = GetWithContextAttributes(isolate, name, object);
       } else {
         *attributes = JSReceiver::GetPropertyAttributes(object, name);
       }
+
       if (isolate->has_pending_exception()) return Handle<Object>();
 
       if (*attributes != ABSENT) {
         if (FLAG_trace_contexts) {
           PrintF("=> found property in context object %p\n",
                  reinterpret_cast<void*>(*object));
         }
         return object;
       }
     }
@@ skipping 242 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