harmony-scoping: Correct dynamic lookups on a top level.

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 104 matching lines @@
   *index = -1;
   *attributes = ABSENT;
   *binding_flags = MISSING_BINDING;
 
   if (FLAG_trace_contexts) {
     PrintF("Context::Lookup(");
     name->ShortPrint();
     PrintF(")\n");
   }
 
+  bool visited_global_context = false;
+
   do {
     if (FLAG_trace_contexts) {
       PrintF(" - looking in context %p", reinterpret_cast<void*>(*context));
+      if (context->IsGlobalContext()) PrintF(" (global context)");
       if (context->IsNativeContext()) PrintF(" (native context)");
       PrintF("\n");
     }
 
+    if (follow_context_chain && FLAG_harmony_scoping &&
+        !visited_global_context &&
+        (context->IsGlobalContext() || context->IsNativeContext())) {
+      // For lexical scoping, on a top level, we might resolve to the
+      // lexical bindings introduced by later scrips. Therefore we need to
+      // switch to the the last added global context during lookup here.
+      context = Handle<Context>(context->global_object()->global_context());
+      visited_global_context = true;
+      if (FLAG_trace_contexts) {
+        PrintF("   - switching to current global context %p\n",
+               reinterpret_cast<void*>(*context));
+      }
+    }
+
     // 1. Check global objects, subjects of with, and extension objects.
     if (context->IsNativeContext() ||
         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.
       Maybe<PropertyAttributes> maybe;
@@ skipping 14 matching lines @@
       if (maybe.value != ABSENT) {
         if (FLAG_trace_contexts) {
           PrintF("=> found property in context object %p\n",
                  reinterpret_cast<void*>(*object));
         }
         return object;
       }
     }
 
     // 2. Check the context proper if it has slots.
-    if (context->IsFunctionContext() || context->IsBlockContext()) {
+    if (context->IsFunctionContext() || context->IsBlockContext() ||
+        (FLAG_harmony_scoping && context->IsGlobalContext())) {
       // Use serialized scope information of functions and blocks to search
       // for the context index.
       Handle<ScopeInfo> scope_info;
       if (context->IsFunctionContext()) {
         scope_info = Handle<ScopeInfo>(
             context->closure()->shared()->scope_info(), isolate);
       } else {
         scope_info = Handle<ScopeInfo>(
             ScopeInfo::cast(context->extension()), isolate);
       }
@@ skipping 232 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