Preparse inner functions: fix maybe_assigned

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/ast/ast.h"
@@ skipping 1595 matching lines @@
 
   return var;
 }
 
 void Scope::ResolveVariable(ParseInfo* info, VariableProxy* proxy) {
   DCHECK(info->script_scope()->is_script_scope());
   DCHECK(!proxy->is_resolved());
   Variable* var = LookupRecursive(proxy, nullptr);
   ResolveTo(info, proxy, var);
 
-  if (FLAG_lazy_inner_functions) {
-    if (info != nullptr && info->is_native()) return;
-    // Pessimistically force context allocation for all variables to which inner
-    // scope variables could potentially resolve to.
-    Scope* scope = GetClosureScope()->outer_scope_;
-    while (scope != nullptr && scope->scope_info_.is_null()) {
-      var = scope->LookupLocal(proxy->raw_name());
-      if (var != nullptr) {
-        // Since we don't lazy parse inner arrow functions, inner functions
-        // cannot refer to the outer "this".
-        if (!var->is_dynamic() && !var->is_this() &&
-            !var->has_forced_context_allocation()) {
-          var->ForceContextAllocation();
-          var->set_is_used();
-          // We don't know what the (potentially lazy parsed) inner function
-          // does with the variable; pessimistically assume that it's assigned.
-          var->set_maybe_assigned();
-        }
-      }
-      scope = scope->outer_scope_;
+  // Pessimistically set is_used and maybe_assigned for variables which lazy
+  // parsed inner functions refer to.
+  if (FLAG_lazy_inner_functions && is_declaration_scope() &&
+      AsDeclarationScope()->is_lazily_parsed()) {
+    // Since we don't lazy parse inner arrow functions, inner functions
+    // cannot refer to the outer "this".
+    if (!var->is_dynamic() && !var->is_this()) {
+      var->set_is_used();
+      var->set_maybe_assigned();

[Toon Verwaest, 2016/11/22 13:11:42]

I don't think we need to set is_used here, since ResolveTo will already set it.

What about making proxy->is_assigned() be true if it comes from the preparser
(through AnalyzePartially + FLAG_lazy_inner_functions I presume).

     }
   }
 }
 
 namespace {
 
 bool AccessNeedsHoleCheck(Variable* var, VariableProxy* proxy, Scope* scope) {
   if (!var->binding_needs_init()) {
     return false;
   }
@@ skipping 381 matching lines @@
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   bool is_function_var_in_context =
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
          (is_function_var_in_context ? 1 : 0);
 }
 
 }  // namespace internal
 }  // namespace v8