Simplify Scope::AllowsLazyCompilationWithoutContext

src/ast/scopes.cc

 // 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.
 
 #include "src/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 862 matching lines @@
   PropagateScopeInfo(outer_scope_calls_sloppy_eval);
 
   // 2) Resolve variables.
   ResolveVariablesRecursively(info, factory);
 
   // 3) Allocate variables.
   AllocateVariablesRecursively();
 }
 
 
-bool Scope::HasTrivialContext() const {
-  // A function scope has a trivial context if it always is the global
-  // context. We iteratively scan out the context chain to see if
-  // there is anything that makes this scope non-trivial; otherwise we
-  // return true.
-  for (const Scope* scope = this; scope != NULL; scope = scope->outer_scope_) {
-    if (scope->is_eval_scope()) return false;
-    if (scope->InsideWithScope()) return false;
-    if (scope->ContextLocalCount() > 0) return false;
-    if (scope->ContextGlobalCount() > 0) return false;
-  }
-  return true;
-}
-
-
-bool Scope::HasTrivialOuterContext() const {
-  if (outer_scope_ == nullptr) return true;
-  // Note that the outer context may be trivial in general, but the current
-  // scope may be inside a 'with' statement in which case the outer context
-  // for this scope is not trivial.
-  return !is_with_scope() && outer_scope_->HasTrivialContext();
-}
-
-
 bool Scope::AllowsLazyParsing() const {
   // If we are inside a block scope, we must parse eagerly to find out how
   // to allocate variables on the block scope. At this point, declarations may
   // not have yet been parsed.
   for (const Scope* scope = this; scope != NULL; scope = scope->outer_scope_) {
     if (scope->is_block_scope()) return false;
   }
   return AllowsLazyCompilation();
 }
 
 
 bool Scope::AllowsLazyCompilation() const { return !force_eager_compilation_; }
 
 
 bool Scope::AllowsLazyCompilationWithoutContext() const {
-  return !force_eager_compilation_ && HasTrivialOuterContext();
+  if (force_eager_compilation_) return false;
+  // Disallow lazy compilation without context if any outer scope needs a
+  // context.
+  for (const Scope* scope = outer_scope_; scope != nullptr;
+       scope = scope->outer_scope_) {
+    if (scope->NeedsContext()) return false;
+  }
+  return true;
 }
 
 
 int Scope::ContextChainLength(Scope* scope) {
   int n = 0;
   for (Scope* s = this; s != scope; s = s->outer_scope_) {
     DCHECK(s != NULL);  // scope must be in the scope chain
     if (s->NeedsContext()) n++;
   }
   return n;
@@ skipping 223 matching lines @@
   PrintF(" { // (%d, %d)\n", start_position(), end_position());
 
   // Function name, if any (named function literals, only).
   if (function != nullptr) {
     Indent(n1, "// (local) function name: ");
     PrintName(function->raw_name());
     PrintF("\n");
   }
 
   // Scope info.
-  if (HasTrivialOuterContext()) {
-    Indent(n1, "// scope has trivial outer context\n");
-  }
   if (is_strict(language_mode())) {
     Indent(n1, "// strict mode scope\n");
   }
   if (IsAsmModule()) Indent(n1, "// scope is an asm module\n");
   if (IsAsmFunction()) Indent(n1, "// scope is an asm function\n");
   if (scope_calls_eval_) Indent(n1, "// scope calls 'eval'\n");
   if (scope_uses_super_property_)
     Indent(n1, "// scope uses 'super' property\n");
   if (outer_scope_calls_sloppy_eval_) {
     Indent(n1, "// outer scope calls 'eval' in sloppy context\n");
@@ skipping 607 matching lines @@
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8