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 181 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 367 matching lines @@
   Scope* ClosureScope();
 
   // Find the first (non-arrow) function or script scope.  This is where
   // 'this' is bound, and what determines the function kind.
   Scope* ReceiverScope();
 
   Handle<ScopeInfo> GetScopeInfo(Isolate* isolate);
 
   Handle<StringSet> CollectNonLocals(Handle<StringSet> non_locals);
 
+  // Tries to resolve local variables inside max_outer_scope; collects those
+  // which cannot be resolved.
+  void CollectUnresolvableLocals(VariableProxy** still_unresolved,

[titzer, 2016/08/01 17:58:43]

Since this is a public method, is it possible to write a unit test for it?

[marja, 2016/08/02 07:42:37]

Oops, this was public by accident, making it private.

The test class can anyway be a friend of Scope, so I don't mean to reduce
testability by making it private. :)

+                                 Scope* max_outer_scope);
+
   // ---------------------------------------------------------------------------
   // 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;
   }
 
   bool IsDeclaredParameter(const AstRawString* name) {
     // If IsSimpleParameterList is false, duplicate parameters are not allowed,
     // however `arguments` may be allowed if function is not strict code. Thus,
     // the assumptions explained above do not hold.
     return params_.Contains(variables_.Lookup(name));
   }
 
   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);

[titzer, 2016/08/01 17:58:43]

Same here. Is it possible to write a unittest that cooks up a fake scope and
calls this method on it?

[marja, 2016/08/02 07:42:37]

I'll look into that after this CL to see how much code around Scope we'd need to
unit test it. verwaest@ is going to rewrite the whole scope analysis, so we need
to see what amount of unit testing is reasonable before the rewrite. I'm
optimistic that it won't require much additional machinery, but as adamk@
suggested, I won't block landing this CL on that test.

+
   // ---------------------------------------------------------------------------
   // 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 139 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);
 
   // Scope analysis.
   void PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
   bool HasTrivialContext() const;
 
@@ skipping 59 matching lines @@
 
   void SetDefaults();
 
   PendingCompilationErrorHandler pending_error_handler_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_