Cleanup scope resolution

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 1252 matching lines @@
     var = map->Declare(zone(), NULL, name, mode, Variable::NORMAL, init_flag);
     // Allocate it by giving it a dynamic lookup.
     var->AllocateTo(VariableLocation::LOOKUP, -1);
   }
   return var;
 }
 
 Variable* Scope::LookupRecursive(VariableProxy* proxy,
                                  BindingKind* binding_kind,
                                  AstNodeFactory* factory,
-                                 Scope* max_outer_scope) {
-  DCHECK(binding_kind != NULL);
+                                 Scope* outer_scope_end) {
+  DCHECK_NE(outer_scope_end, this);
+  DCHECK_NOT_NULL(binding_kind);
+  DCHECK_EQ(UNBOUND, *binding_kind);
   if (already_resolved() && is_with_scope()) {
     // Short-cut: if the scope is deserialized from a scope info, variable
     // allocation is already fixed.  We can simply return with dynamic lookup.
     *binding_kind = DYNAMIC_LOOKUP;
-    return NULL;
+    return nullptr;
   }
 
   // Try to find the variable in this scope.
   Variable* var = LookupLocal(proxy->raw_name());
 
   // We found a variable and we are done. (Even if there is an 'eval' in
   // this scope which introduces the same variable again, the resulting
   // variable remains the same.)
-  if (var != NULL) {
+  if (var != nullptr) {
     *binding_kind = BOUND;
     return var;
   }
 
   // We did not find a variable locally. Check against the function variable, if
   // any.
-  *binding_kind = UNBOUND;
-  var =
-      is_function_scope()
-          ? AsDeclarationScope()->LookupFunctionVar(proxy->raw_name(), factory)
-          : nullptr;
-  if (var != NULL) {
-    *binding_kind = BOUND;
-  } else if (outer_scope_ != nullptr && this != max_outer_scope) {
+  if (is_function_scope()) {
+    var = AsDeclarationScope()->LookupFunctionVar(proxy->raw_name(), factory);
+    if (var != nullptr) {
+      *binding_kind = BOUND;
+      return var;

[marja, 2016/08/11 09:37:35]

As discussed offline, this changes the behavior wrt shadowing the function var.

+    }
+  }
+
+  if (outer_scope_ != outer_scope_end) {
     var = outer_scope_->LookupRecursive(proxy, binding_kind, factory,
-                                        max_outer_scope);
+                                        outer_scope_end);
     if (*binding_kind == BOUND && is_function_scope()) {
       var->ForceContextAllocation();
     }
+    // "this" can't be shadowed by "eval"-introduced bindings or by "with"
+    // scopes.
+    // TODO(wingo): There are other variables in this category; add them.
+    if (var != nullptr && var->is_this()) return var;
+
+    if (is_with_scope()) {
+      DCHECK(!already_resolved());
+      // The current scope is a with scope, so the variable binding can not be
+      // statically resolved. However, note that it was necessary to do a lookup
+      // in the outer scope anyway, because if a binding exists in an outer
+      // scope,

[marja, 2016/08/11 09:37:35]

pls re-wrap this

+      // the associated variable has to be marked as potentially being accessed
+      // from inside of an inner with scope (the property may not be in the
+      // 'with'
+      // object).
+      if (var != nullptr) {
+        var->set_is_used();
+        var->ForceContextAllocation();
+        if (proxy->is_assigned()) var->set_maybe_assigned();
+      }
+      *binding_kind = DYNAMIC_LOOKUP;
+      return nullptr;
+    }
   } else {
-    DCHECK(is_script_scope() || this == max_outer_scope);
+    DCHECK(is_function_scope() || is_script_scope() || is_eval_scope());
+    DCHECK(!is_with_scope());
   }
 
-  // "this" can't be shadowed by "eval"-introduced bindings or by "with" scopes.
-  // TODO(wingo): There are other variables in this category; add them.
-  bool name_can_be_shadowed = var == nullptr || !var->is_this();
-
-  if (is_with_scope() && name_can_be_shadowed) {
-    DCHECK(!already_resolved());
-    // The current scope is a with scope, so the variable binding can not be
-    // statically resolved. However, note that it was necessary to do a lookup
-    // in the outer scope anyway, because if a binding exists in an outer scope,
-    // the associated variable has to be marked as potentially being accessed
-    // from inside of an inner with scope (the property may not be in the 'with'
-    // object).
-    if (var != NULL) {
-      var->set_is_used();
-      var->ForceContextAllocation();
-      if (proxy->is_assigned()) var->set_maybe_assigned();
-    }
-    *binding_kind = DYNAMIC_LOOKUP;
-    return NULL;
-  } else if (calls_sloppy_eval() && is_declaration_scope() &&
-             !is_script_scope() && name_can_be_shadowed) {
+  if (calls_sloppy_eval() && is_declaration_scope() && !is_script_scope()) {
     // A variable binding may have been found in an outer scope, but the current
-    // scope makes a sloppy 'eval' call, so the found variable may not be
-    // the correct one (the 'eval' may introduce a binding with the same name).
-    // In that case, change the lookup result to reflect this situation.
-    // Only scopes that can host var bindings (declaration scopes) need be
-    // considered here (this excludes block and catch scopes), and variable
-    // lookups at script scope are always dynamic.
+    // scope makes a sloppy 'eval' call, so the found variable may not be the
+    // correct one (the 'eval' may introduce a binding with the same name).  In
+    // that case, change the lookup result to reflect this situation.  Only
+    // scopes that can host var bindings (declaration scopes) need be considered
+    // here (this excludes block and catch scopes), and variable lookups at
+    // script scope are always dynamic.
     if (*binding_kind == BOUND) {
       *binding_kind = BOUND_EVAL_SHADOWED;
     } else if (*binding_kind == UNBOUND) {
       *binding_kind = UNBOUND_EVAL_SHADOWED;
     }
   }
+
   return var;
 }
 
 void Scope::ResolveVariable(ParseInfo* info, VariableProxy* proxy,
                             AstNodeFactory* factory) {
   DCHECK(info->script_scope()->is_script_scope());
 
   // If the proxy is already resolved there's nothing to do
   // (functions and consts may be resolved by the parser).
   if (proxy->is_resolved()) return;
 
   // Otherwise, try to resolve the variable.
-  BindingKind binding_kind;
+  BindingKind binding_kind = UNBOUND;
   Variable* var = LookupRecursive(proxy, &binding_kind, factory);
 
   ResolveTo(info, binding_kind, proxy, var);
 }
 
 void Scope::ResolveTo(ParseInfo* info, BindingKind binding_kind,
                       VariableProxy* proxy, Variable* var) {
 #ifdef DEBUG
   if (info->script_is_native()) {
     // To avoid polluting the global object in native scripts
@@ skipping 69 matching lines @@
 
   // Resolve unresolved variables for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     scope->ResolveVariablesRecursively(info, factory);
   }
 }
 
 VariableProxy* Scope::FetchFreeVariables(DeclarationScope* max_outer_scope,
                                          ParseInfo* info,
                                          VariableProxy* stack) {
-  BindingKind binding_kind = BOUND;
   for (VariableProxy *proxy = unresolved_, *next = nullptr; proxy != nullptr;
        proxy = next) {
     next = proxy->next_unresolved();
     if (proxy->is_resolved()) continue;
     // Note that we pass nullptr as AstNodeFactory: this phase should not create
     // any new AstNodes, since none of the Scopes involved are backed up by
     // ScopeInfo.
-    Variable* var =
-        LookupRecursive(proxy, &binding_kind, nullptr, max_outer_scope);
+    BindingKind binding_kind = UNBOUND;
+    Variable* var = LookupRecursive(proxy, &binding_kind, nullptr,
+                                    max_outer_scope->outer_scope());
     // Anything that was bound

[marja, 2016/08/11 09:37:35]

What is this comment? (Not introduced by this CL but since you're touching this,
can you either remove the comment or modify it so that it makes sense.)

     if (var == nullptr) {
       proxy->set_next_unresolved(stack);
       stack = proxy;
     } else if (info != nullptr) {
       DCHECK_NE(UNBOUND, binding_kind);
       DCHECK_NE(UNBOUND_EVAL_SHADOWED, binding_kind);
       ResolveTo(info, binding_kind, proxy, var);
     }
   }
 
@@ skipping 322 matching lines @@
       function != NULL && function->proxy()->var()->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