Chain ScopeInfos together

src/ast/scopes.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 "src/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 806 matching lines @@
         if (decls_[j]->proxy()->raw_name() == name) {
           return decls_[j];
         }
       }
       DCHECK(false);
     }
   }
   return nullptr;
 }
 
+Scope* Scope::GetOuterScopeWithContext() const {
+  Scope* scope = outer_scope();
+  while (scope) {

[marja, 2016/08/29 07:53:00]

Style nit: while (scope != nullptr) seems to be the common way.

+    // If we hit a SCRIPT_SCOPE that isn't backed by a scope_info, it's the
+    // SCRIPT_SCOPE corresponding to the native context. This also means,
+    // that the variables in that scope never get resolved (they should be all
+    // dynamic lookups), and so NeedsContext() incorrectly returns true. To
+    // avoid this, we bail out here.
+    if (scope->scope_type() == SCRIPT_SCOPE && scope->scope_info_.is_null()) {

[Toon Verwaest, 2016/08/26 12:07:01]

How does this work for let variables in top-level in a top-level or eager
compile? We should also have scope info in that case right?

[jochen (gone - plz use gerrit), 2016/08/26 13:14:11]

For a top-level script, we'll invoke GetScopeInfo() on the outer most scope, so
scope_info_ will be non-NULL for any of the inner scopes that go up to this.

[marja, 2016/08/29 07:53:00]

I don't get this answer at all..

+      return nullptr;
+    }
+    if (scope->NeedsContext()) return scope;

[Toon Verwaest, 2016/08/26 12:04:37]

I guess this happens for outer function scopes from which no locals are
captured?

[jochen (gone - plz use gerrit), 2016/08/26 13:14:10]

I guess in practice, this should be always true.

+    scope = scope->outer_scope();
+  }
+  return nullptr;
+}
+
 void Scope::CollectVariables(ZoneList<Variable*>* stack_locals,
                              ZoneList<Variable*>* context_locals,
                              ZoneList<Variable*>* context_globals) {
   // TODO(verwaest): Just pass out locals_ directly and walk it?
   DCHECK_NOT_NULL(stack_locals);
   DCHECK_NOT_NULL(context_locals);
   DCHECK_NOT_NULL(context_globals);
 
   for (int i = 0; i < locals_.length(); i++) {
     Variable* var = locals_[i];
@@ skipping 813 matching lines @@
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8