Only pass the outer scope info with ParseInfo

src/compiler-dispatcher/compiler-dispatcher-job.cc

 // Copyright 2016 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/compiler-dispatcher/compiler-dispatcher-job.h"
 
 #include "src/assert-scope.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/global-handles.h"
@@ skipping 65 matching lines @@
   parse_info_->set_hash_seed(isolate_->heap()->HashSeed());
   parse_info_->set_is_named_expression(shared->is_named_expression());
   parse_info_->set_calls_eval(shared->scope_info()->CallsEval());
   parse_info_->set_compiler_hints(shared->compiler_hints());
   parse_info_->set_start_position(shared->start_position());
   parse_info_->set_end_position(shared->end_position());
   parse_info_->set_unicode_cache(unicode_cache_.get());
   parse_info_->set_language_mode(shared->language_mode());
 
   parser_.reset(new Parser(parse_info_.get()));
-  parser_->DeserializeScopeChain(parse_info_.get(),
-                                 handle(function_->context(), isolate_));
+  parser_->DeserializeScopeChain(
+      parse_info_.get(),
+      function_->context()->IsNativeContext()
+          ? MaybeHandle<ScopeInfo>()
+          : MaybeHandle<ScopeInfo>(function_->context()->scope_info(),
+                                   isolate_));
 
   Handle<String> name(String::cast(shared->name()));
   parse_info_->set_function_name(
       parse_info_->ast_value_factory()->GetString(name));
   status_ = CompileJobStatus::kReadyToParse;
 }
 
 void CompilerDispatcherJob::Parse() {
   DCHECK(can_parse_on_background_thread_ ||
          ThreadId::Current().Equals(isolate_->thread_id()));
@@ skipping 41 matching lines @@
   {
     // Create a canonical handle scope before internalizing parsed values if
     // compiling bytecode. This is required for off-thread bytecode generation.
     std::unique_ptr<CanonicalHandleScope> canonical;
     if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate_));
 
     Handle<SharedFunctionInfo> shared(function_->shared(), isolate_);
     Handle<Script> script(Script::cast(shared->script()), isolate_);
 
     parse_info_->set_script(script);
-    parse_info_->set_context(handle(function_->context(), isolate_));
+    if (!function_->context()->IsNativeContext()) {
+      parse_info_->set_outer_scope_info(
+          handle(function_->context()->scope_info(), isolate_));
+    }
     parse_info_->set_shared_info(handle(function_->shared(), isolate_));
 
     // Do the parsing tasks which need to be done on the main thread. This will
     // also handle parse errors.
     parser_->Internalize(isolate_, script, parse_info_->literal() == nullptr);
     parser_->HandleSourceURLComments(isolate_, script);
 
     parse_info_->set_character_stream(nullptr);
     parse_info_->set_unicode_cache(nullptr);
     parser_.reset();
@@ skipping 92 matching lines @@
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
 
   status_ = CompileJobStatus::kInitial;
 }
 
 }  // namespace internal
 }  // namespace v8