Find the last outer eval scope to check in fullcodegen rather than scope analysis

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 196 matching lines @@
 
   set_language_mode(SLOPPY);
 
   scope_calls_eval_ = false;
   scope_uses_super_property_ = false;
   has_arguments_parameter_ = false;
   scope_nonlinear_ = false;
   is_hidden_ = false;
   is_debug_evaluate_scope_ = false;
 
-  outer_scope_calls_sloppy_eval_ = false;
   inner_scope_calls_eval_ = false;
   force_eager_compilation_ = false;
   force_context_allocation_ = false;
 
   is_declaration_scope_ = false;
 }
 
 bool Scope::HasSimpleParameters() {
   DeclarationScope* scope = GetClosureScope();
   return !scope->is_function_scope() || scope->has_simple_parameters();
@@ skipping 62 matching lines @@
                            ast_value_factory->GetString(handle(name, isolate)));
     }
     if (deserialization_mode == DeserializationMode::kDeserializeOffHeap) {
       current_scope->DeserializeScopeInfo(isolate, ast_value_factory);
     }
     if (innermost_scope == nullptr) innermost_scope = current_scope;
     context = context->previous();
   }
 
   script_scope->AddInnerScope(current_scope);
-  script_scope->PropagateScopeInfo(false);
+  script_scope->PropagateScopeInfo();
   return (innermost_scope == NULL) ? script_scope : innermost_scope;
 }
 
 void Scope::DeserializeScopeInfo(Isolate* isolate,
                                  AstValueFactory* ast_value_factory) {
   if (scope_info_.is_null()) return;
 
   DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
 
   std::set<const AstRawString*> names_seen;
@@ skipping 546 matching lines @@
       context_locals->Add(var, zone());
     } else if (var->IsGlobalSlot()) {
       context_globals->Add(var, zone());
     }
   }
 }
 
 void DeclarationScope::AllocateVariables(ParseInfo* info,
                                          AstNodeFactory* factory) {
   // 1) Propagate scope information.
-  bool outer_scope_calls_sloppy_eval = false;
-  if (outer_scope_ != NULL) {
-    outer_scope_calls_sloppy_eval =
-        outer_scope_->outer_scope_calls_sloppy_eval() |
-        outer_scope_->calls_sloppy_eval();
-  }
-  PropagateScopeInfo(outer_scope_calls_sloppy_eval);
+  PropagateScopeInfo();
 
   // 2) Resolve variables.
   ResolveVariablesRecursively(info, factory);
 
   // 3) Allocate variables.
   AllocateVariablesRecursively();
 }
 
 
 bool Scope::AllowsLazyParsing() const {
@@ skipping 14 matching lines @@
   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 Scope::ContextChainLength(Scope* scope) const {
   int n = 0;
-  for (Scope* s = this; s != scope; s = s->outer_scope_) {
+  for (const 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;
 }
 
+int Scope::ContextChainLengthUntilOutermostSloppyEval() const {
+  int result = 0;
+  int length = 0;
+
+  for (const Scope* s = this; s != nullptr; s = s->outer_scope()) {
+    if (!s->NeedsContext()) continue;
+    length++;
+    if (s->calls_sloppy_eval()) result = length;
+  }
+
+  return result;
+}
 
 int Scope::MaxNestedContextChainLength() {
   int max_context_chain_length = 0;
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     max_context_chain_length = std::max(scope->MaxNestedContextChainLength(),
                                         max_context_chain_length);
   }
   if (NeedsContext()) {
     max_context_chain_length += 1;
   }
@@ skipping 41 matching lines @@
   for (VariableProxy* proxy = free_variables; proxy != nullptr;
        proxy = proxy->next_unresolved()) {
     non_locals = StringSet::Add(non_locals, proxy->name());
   }
   return non_locals;
 }
 
 void DeclarationScope::AnalyzePartially(DeclarationScope* migrate_to,
                                         AstNodeFactory* ast_node_factory) {
   // Gather info from inner scopes.
-  PropagateScopeInfo(false);
+  PropagateScopeInfo();
 
   // Try to resolve unresolved variables for this Scope and migrate those which
   // cannot be resolved inside. It doesn't make sense to try to resolve them in
   // the outer Scopes here, because they are incomplete.
   for (VariableProxy* proxy = FetchFreeVariables(this); proxy != nullptr;
        proxy = proxy->next_unresolved()) {
     DCHECK(!proxy->is_resolved());
     VariableProxy* copy = ast_node_factory->CopyVariableProxy(proxy);
     migrate_to->AddUnresolved(copy);
   }
@@ skipping 157 matching lines @@
 
   // Scope info.
   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");
-  }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
   if (num_stack_slots_ > 0) {
     Indent(n1, "// ");
     PrintF("%d stack slots\n", num_stack_slots_);
   }
   if (num_heap_slots_ > 0) {
     Indent(n1, "// ");
     PrintF("%d heap slots (including %d global slots)\n", num_heap_slots_,
            num_global_slots_);
   }
@@ skipping 287 matching lines @@
   // Clear unresolved_ as it's in an inconsistent state.
   unresolved_ = nullptr;
 
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     stack = scope->FetchFreeVariables(max_outer_scope, info, stack);
   }
 
   return stack;
 }
 
-void Scope::PropagateScopeInfo(bool outer_scope_calls_sloppy_eval) {
-  if (outer_scope_calls_sloppy_eval) {
-    outer_scope_calls_sloppy_eval_ = true;
-  }
-
-  bool calls_sloppy_eval =
-      this->calls_sloppy_eval() || outer_scope_calls_sloppy_eval_;
+void Scope::PropagateScopeInfo() {
   for (Scope* inner = inner_scope_; inner != nullptr; inner = inner->sibling_) {
-    inner->PropagateScopeInfo(calls_sloppy_eval);
+    inner->PropagateScopeInfo();
     if (inner->scope_calls_eval_ || inner->inner_scope_calls_eval_) {
       inner_scope_calls_eval_ = true;
     }
     if (inner->force_eager_compilation_) {
       force_eager_compilation_ = true;
     }
     if (IsAsmModule() && inner->is_function_scope()) {
       inner->AsDeclarationScope()->set_asm_function();
     }
   }
@@ skipping 280 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