Add support for calculating a scopes maximum nested context chain.

src/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_SCOPES_H_
 #define V8_SCOPES_H_
 
 #include "src/ast.h"
 #include "src/pending-compilation-error-handler.h"
 #include "src/zone.h"
@@ skipping 323 matching lines @@
   // Does this scope access "arguments".
   bool uses_arguments() const { return scope_uses_arguments_; }
   // Does any inner scope access "arguments".
   bool inner_uses_arguments() const { return inner_scope_uses_arguments_; }
   // Does this scope access "super" property (super.foo).
   bool uses_super_property() const { return scope_uses_super_property_; }
   // Does this scope have the potential to execute declarations non-linearly?
   bool is_nonlinear() const { return scope_nonlinear_; }
 
   // Whether this needs to be represented by a runtime context.
-  bool NeedsContext() const { return num_heap_slots() > 0; }
+  bool NeedsContext() const {
+    // Catch and module scopes always have heap slots.
+    DCHECK(!is_catch_scope() || num_heap_slots() > 0);
+    DCHECK(!is_module_scope() || num_heap_slots() > 0);
+    return is_with_scope() || num_heap_slots() > 0;

[adamk, 2015/10/15 07:38:45]

The other callers of NeedsContext() only call it on a block scope, so this is
sort of weird. Maybe change them to do the num_heap_slots() check directly, and
make this method private on Scope?

[rmcilroy, 2015/10/15 09:23:07]

I could do this, however personally I think it is a bit weird that NeedsContext
is only valid for block scopes - is there any particular reason for this that
I'm missing? As for making this private - it is called by Fullcodegen,
Crankshaft and TF, so I would need to change a bunch of other places if I made
this private.

[adamk, 2015/10/15 09:34:32]

What I'm saying is that testing "is_with_scope()" for cases where the code knows
it has a block scope (or in the case of your other caller, a function scope)
seems a bit odd. But I guess it doesn't cause any problems, so I'll take your
perspective as someone new to this code as advise here, and since this
additional check won't cause any problems, it's fine.

[rmcilroy, 2015/10/15 14:06:16]

Acknowledged.

+  }
 
   bool NeedsHomeObject() const {
     return scope_uses_super_property_ ||
            (scope_calls_eval_ && (IsConciseMethod(function_kind()) ||
                                   IsAccessorFunction(function_kind()) ||
                                   IsClassConstructor(function_kind())));
   }
 
   const Scope* NearestOuterEvalScope() const {
     if (is_eval_scope()) return this;
@@ skipping 157 matching lines @@
 
   // Determine if we can use lazy compilation for this scope without a context.
   bool AllowsLazyCompilationWithoutContext() const;
 
   // True if the outer context of this scope is always the native context.
   bool HasTrivialOuterContext() const;
 
   // The number of contexts between this and scope; zero if this == scope.
   int ContextChainLength(Scope* scope);
 
+  // The maximum number of nested contexts required for this scope and any inner
+  // scopes.
+  int MaxNestedContextChainLength();
+
   // Find the first function, script, eval or (declaration) block scope. This is
   // the scope where var declarations will be hoisted to in the implementation.
   Scope* DeclarationScope();
 
   // Find the first non-block declaration scope. This should be either a script,
   // function, or eval scope. Same as DeclarationScope(), but skips
   // declaration "block" scopes. Used for differentiating associated
   // function objects (i.e., the scope for which a function prologue allocates
   // a context) or declaring temporaries.
   Scope* ClosureScope();
@@ skipping 283 matching lines @@
 
   // For tracking which classes are declared consecutively. Needed for strong
   // mode.
   int class_declaration_group_start_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SCOPES_H_