Don't use different function scopes when parsing with temp zones

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/base/hashmap.h"
 #include "src/globals.h"
 #include "src/objects.h"
@@ skipping 56 matching lines @@
   // ---------------------------------------------------------------------------
   // Construction
 
   Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type);
 
 #ifdef DEBUG
   // The scope name is only used for printing/debugging.
   void SetScopeName(const AstRawString* scope_name) {
     scope_name_ = scope_name;
   }
+  void set_needs_migration() { needs_migration_ = true; }
 #endif
 
   // TODO(verwaest): Is this needed on Scope?
   int num_parameters() const;
 
   DeclarationScope* AsDeclarationScope();
   const DeclarationScope* AsDeclarationScope() const;
   ModuleScope* AsModuleScope();
   const ModuleScope* AsModuleScope() const;
 
@@ skipping 321 matching lines @@
 
   // Check that all Scopes in the scope tree use the same Zone.
   void CheckZones();
 #endif
 
   // Retrieve `IsSimpleParameterList` of current or outer function.
   bool HasSimpleParameters();
   void set_is_debug_evaluate_scope() { is_debug_evaluate_scope_ = true; }
   bool is_debug_evaluate_scope() const { return is_debug_evaluate_scope_; }
 
-  void set_is_lazily_parsed(bool is_lazily_parsed) {
-    is_lazily_parsed_ = is_lazily_parsed;
-  }
+  bool is_lazily_parsed() const { return is_lazily_parsed_; }
 
  protected:
   explicit Scope(Zone* zone);
 
   void set_language_mode(LanguageMode language_mode) {
     is_strict_ = is_strict(language_mode);
   }
 
  private:
   Variable* Declare(Zone* zone, Scope* scope, const AstRawString* name,
@@ skipping 48 matching lines @@
 
   // Serialized scope info support.
   Handle<ScopeInfo> scope_info_;
 // Debugging support.
 #ifdef DEBUG
   const AstRawString* scope_name_;
 
   // True if it doesn't need scope resolution (e.g., if the scope was
   // constructed based on a serialized scope info or a catch context).
   bool already_resolved_ : 1;
+  // True if this scope may contain objects from a temp zone that needs to be
+  // fixed up.
+  bool needs_migration_ : 1;

[adamk, 2016/09/27 20:33:17]

Can we remove these ": 1"s from these debug-only fields? They just look like
noise to me (I doubt we care about the size of a debug version of Scope...)

 #endif
 
   // Source positions.
   int start_position_;
   int end_position_;
 
   // Computed via AllocateVariables.
   int num_stack_slots_;
   int num_heap_slots_;
 
@@ skipping 60 matching lines @@
                                      MaybeHandle<ScopeInfo> outer_scope);
 
   // Construct a scope based on the scope info.
   Scope(Zone* zone, ScopeType type, Handle<ScopeInfo> scope_info);
 
   // Construct a catch scope with a binding for the name.
   Scope(Zone* zone, const AstRawString* catch_variable_name,
         Handle<ScopeInfo> scope_info);
 
   void AddInnerScope(Scope* inner_scope) {
+    DCHECK(!needs_migration_ || inner_scope->zone() != zone());

[marja, 2016/09/27 18:54:41]

Hmm? Why not DCHECK(needs_migration_ || inner_scope->zone() == zone()); ?

Let's see.. your DCHECK says:
either needs_migration_ is false or zones differ (or both)
so it's disallowing zones to be same if needs_migration_

I guess that makes sense too (that asserts that the Scope which needs migration
really is on the Zone boundary) but I think the more interesting check is that
Zones match unless needs_migration_.

So why not have both:
DCHECK(needs_migration_ == (inner_scope->zone() != zone()); ?

     inner_scope->sibling_ = inner_scope_;
     inner_scope_ = inner_scope;
     inner_scope->outer_scope_ = this;
   }
 
   void RemoveInnerScope(Scope* inner_scope) {
     DCHECK_NOT_NULL(inner_scope);
     if (inner_scope == inner_scope_) {
       inner_scope_ = inner_scope_->sibling_;
       return;
@@ skipping 193 matching lines @@
   // Compute top scope and allocate variables. For lazy compilation the top
   // scope only contains the single lazily compiled function, so this
   // doesn't re-allocate variables repeatedly.
   static void Analyze(ParseInfo* info, AnalyzeMode mode);
 
   // 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);
+  void AnalyzePartially(AstNodeFactory* ast_node_factory);
 
   Handle<StringSet> CollectNonLocals(ParseInfo* info,
                                      Handle<StringSet> non_locals);
 
   // Determine if we can use lazy compilation for this scope.
   bool AllowsLazyCompilation() const;
 
   // Determine if we can use lazy compilation for this scope without a context.
   bool AllowsLazyCompilationWithoutContext() const;
 
@@ skipping 87 matching lines @@
   void AllocateModuleVariables();
 
  private:
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_