Put Scopes into temporary Zone

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 183 matching lines @@
   // Create a new unresolved variable.
   VariableProxy* NewUnresolved(AstNodeFactory* factory,
                                const AstRawString* name,
                                Variable::Kind kind = Variable::NORMAL,
                                int start_position = kNoSourcePosition,
                                int end_position = kNoSourcePosition) {
     // Note that we must not share the unresolved variables with
     // the same name because they may be removed selectively via
     // RemoveUnresolved().
     DCHECK(!already_resolved());
+    DCHECK_EQ(factory->zone(), zone());
     VariableProxy* proxy =
         factory->NewVariableProxy(name, kind, start_position, end_position);
     proxy->set_next_unresolved(unresolved_);
     unresolved_ = proxy;
     return proxy;
   }
 
   void AddUnresolved(VariableProxy* proxy) {
     DCHECK(!already_resolved());
     DCHECK(!proxy->is_resolved());
@@ skipping 388 matching lines @@
     // the assumptions explained above do not hold.
     return params_.Contains(variables_.Lookup(name));
   }
 
   int num_var() const { return variables_.occupancy(); }
 
   SloppyBlockFunctionMap* sloppy_block_function_map() {
     return &sloppy_block_function_map_;
   }
 
+  // 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(Scope* migrate_to, AstNodeFactory* ast_node_factory);
+
   // ---------------------------------------------------------------------------
   // Debugging.
 
 #ifdef DEBUG
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 
   // Check that the scope has positions assigned.
   void CheckScopePositions();
+
+  // Check that all Scopes in the scope tree use the same Zone.
+  void CheckZones();
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  private:
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   Scope* inner_scope_;  // an inner scope of this scope
   Scope* sibling_;  // a sibling inner scope of the outer scope of this scope.
 
@@ skipping 140 matching lines @@
     // * A 'with' statement has been encountered and there is no variable
     //   binding for the name between the variable reference and the 'with'.
     //   The variable potentially references a property of the 'with' object.
     // * The code is being executed as part of a call to 'eval' and the calling
     //   context chain contains either a variable binding for the name or it
     //   contains a 'with' context.
     DYNAMIC_LOOKUP
   };
 
   // Lookup a variable reference given by name recursively starting with this
-  // scope. If the code is executed because of a call to 'eval', the context
-  // parameter should be set to the calling context of 'eval'.
+  // 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);
+                            AstNodeFactory* factory,
+                            Scope* max_outer_scope = nullptr);
   MUST_USE_RESULT
   bool ResolveVariable(ParseInfo* info, VariableProxy* proxy,
                        AstNodeFactory* factory);
   MUST_USE_RESULT
   bool ResolveVariablesRecursively(ParseInfo* info, AstNodeFactory* factory);
 
+  // Tries to resolve local variables inside max_outer_scope; collects those
+  // which cannot be resolved.
+  void CollectUnresolvableLocals(VariableProxy** still_unresolved,
+                                 Scope* max_outer_scope);
+
   // Scope analysis.
   void PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
   bool HasTrivialContext() const;
 
   // Predicates.
   bool MustAllocate(Variable* var);
   bool MustAllocateInContext(Variable* var);
 
   // Variable allocation.
   void AllocateStackSlot(Variable* var);
@@ skipping 53 matching lines @@
 
   void SetDefaults();
 
   PendingCompilationErrorHandler pending_error_handler_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_