Teach Scopes whether they will end up being lazily compiled or not

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 400 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_; }
 
   bool is_lazily_parsed() const { return is_lazily_parsed_; }
+  bool should_compile_lazily() const {
+    return is_lazily_parsed_ || should_compile_lazily_;
+  }
+
+  // Marks this scope and all inner scopes (except for inner function scopes)
+  // as lazy.

[marja, 2016/10/06 11:53:06]

Why "except for inner function scopes"?

If we compile a function lazily, don't we always compile its inner functions
lazily too?

(Also, in the comment, it's not clear what "lazy" means, I think we should be
clear with the terminology... it can mean either "lazily parsed" or "lazily
compiled" or "something that was previously lazily parsed" or "something we
happen to reparse for some other reason".)

[jochen (gone - plz use gerrit), 2016/10/06 15:05:04]

yeah, but not the other way round... if we compile it eagerly, we don't
necessarily compile inner functions lazily (but all inner scopes of the current
function)

+  void SetShouldCompileLazily(bool is_lazy);
 
  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,
                     VariableMode mode, VariableKind kind,
                     InitializationFlag initialization_flag,
                     MaybeAssignedFlag maybe_assigned_flag = kNotAssigned) {
     bool added;
     Variable* var =
         variables_.Declare(zone, scope, name, mode, kind, initialization_flag,
                            maybe_assigned_flag, &added);
     if (added) locals_.Add(var, zone);
     return var;
   }
 
   // This method should only be invoked on scopes created during parsing (i.e.,
   // not deserialized from a context). Also, since NeedsContext() is only
   // returning a valid result after variables are resolved, NeedsScopeInfo()
   // should also be invoked after resolution.
   bool NeedsScopeInfo() const {
     DCHECK(!already_resolved_);
     // A lazily parsed scope doesn't contain enough information to create a
     // ScopeInfo from it.
-    if (is_lazily_parsed_) return false;
+    if (should_compile_lazily()) return false;
     // The debugger expects all functions to have scope infos.
     // TODO(jochen|yangguo): Remove this requirement.
     if (is_function_scope()) return true;
     return NeedsContext();
   }
 
   Zone* zone_;
 
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
@@ skipping 55 matching lines @@
   // Temporary workaround that allows masking of 'this' in debug-evalute scopes.
   bool is_debug_evaluate_scope_ : 1;
 
   bool inner_scope_calls_eval_ : 1;
   bool force_context_allocation_ : 1;
 
   // True if it holds 'var' declarations.
   bool is_declaration_scope_ : 1;
 
   bool is_lazily_parsed_ : 1;
+  bool should_compile_lazily_ : 1;
 
   // Create a non-local variable with a given name.
   // These variables are looked up dynamically at runtime.
   Variable* NonLocal(const AstRawString* name, VariableMode mode);
 
   // Variable resolution.
   // Lookup a variable reference given by name recursively starting with this
   // scope, and stopping when reaching the outer_scope_end scope. If the code is
   // executed because of a call to 'eval', the context parameter should be set
   // to the calling context of 'eval'.
@@ skipping 348 matching lines @@
   void AllocateModuleVariables();
 
  private:
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_