Fix CollectNonLocals

src/ast/scopes.h

 // 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.
 
 #ifndef V8_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/base/hashmap.h"
 #include "src/globals.h"
@@ skipping 396 matching lines @@
   // the scope for which a function prologue allocates a context) or declaring
   // temporaries.
   DeclarationScope* GetClosureScope();
 
   // Find the first (non-arrow) function or script scope.  This is where
   // 'this' is bound, and what determines the function kind.
   DeclarationScope* GetReceiverScope();
 
   Handle<ScopeInfo> GetScopeInfo(Isolate* isolate);
 
-  Handle<StringSet> CollectNonLocals(Handle<StringSet> non_locals);
-
   // ---------------------------------------------------------------------------
   // Strict mode support.
   bool IsDeclared(const AstRawString* name) {
     // During formal parameter list parsing the scope only contains
     // two variables inserted at initialization: "this" and "arguments".
     // "this" is an invalid parameter name and "arguments" is invalid parameter
     // name in strict mode. Therefore looking up with the map which includes
     // "this" and "arguments" in addition to all formal parameters is safe.
     return variables_.Lookup(name) != NULL;
   }
@@ skipping 143 matching lines @@
     DYNAMIC_LOOKUP
   };
 
   // Lookup a variable reference given by name recursively starting with this
   // scope, but only until max_outer_scope (if not nullptr). If the code is
   // executed because of a call to 'eval', the context parameter should be set
   // to the calling context of 'eval'.
   Variable* LookupRecursive(VariableProxy* proxy, BindingKind* binding_kind,
                             AstNodeFactory* factory,
                             Scope* max_outer_scope = nullptr);
+  void ResolveTo(ParseInfo* info, BindingKind binding_kind,
+                 VariableProxy* proxy, Variable* var);
   void ResolveVariable(ParseInfo* info, VariableProxy* proxy,
                        AstNodeFactory* factory);
   void ResolveVariablesRecursively(ParseInfo* info, AstNodeFactory* factory);
 
-  // Tries to resolve local variables inside max_outer_scope; migrates those
-  // which cannot be resolved into migrate_to.
-  void MigrateUnresolvableLocals(DeclarationScope* migrate_to,
-                                 AstNodeFactory* ast_node_factory,
-                                 DeclarationScope* max_outer_scope);
+  // Finds free variables of this scope. This mutates the unresolved variables
+  // list along the way, so full resolution cannot be done afterwards.
+  // If a ParseInfo* is passed, non-free variables will be resolved.
+  VariableProxy* FetchFreeVariables(DeclarationScope* max_outer_scope,
+                                    ParseInfo* info = nullptr,
+                                    VariableProxy* stack = nullptr);
 
   // Scope analysis.
   void PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
   bool HasTrivialContext() const;
 
   // Predicates.
   bool MustAllocate(Variable* var);
   bool MustAllocateInContext(Variable* var);
 
   // Variable allocation.
@@ skipping 241 matching lines @@
   void AllocateVariables(ParseInfo* info, AstNodeFactory* factory);
 
   // To be called during parsing. Do just enough scope analysis that we can
   // discard the Scope for lazily compiled functions. In particular, this
   // records variables which cannot be resolved inside the Scope (we don't yet
   // know what they will resolve to since the outer Scopes are incomplete) and
   // migrates them into migrate_to.
   void AnalyzePartially(DeclarationScope* migrate_to,
                         AstNodeFactory* ast_node_factory);
 
+  Handle<StringSet> CollectNonLocals(ParseInfo* info,
+                                     Handle<StringSet> non_locals);
+
 #ifdef DEBUG
   void PrintParameters();
 #endif
 
   void AllocateLocals(AstValueFactory* ast_value_factory);
   void AllocateParameterLocals();
   void AllocateReceiver();
   // Set MODULE as VariableLocation for all variables that will live in some
   // module's export table.
   void AllocateModuleVariables();
@@ skipping 31 matching lines @@
   // Convenience variable; Subclass constructor only
   Variable* this_function_;
   // Module descriptor; module scopes only.
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_