[Compiler] Avoid blocking on inner function parallel compilation.

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-dispatcher/compiler-dispatcher-tracer.h"
 #include "src/compiler.h"
 #include "src/flags.h"
 #include "src/global-handles.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 #include "src/parsing/parse-info.h"
 #include "src/parsing/parser.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/unicode-cache.h"
 #include "src/utils.h"
-#include "src/zone/zone.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 class OneByteWrapper : public v8::String::ExternalOneByteStringResource {
  public:
   OneByteWrapper(const void* data, int length) : data_(data), length_(length) {}
   ~OneByteWrapper() override = default;
@@ skipping 47 matching lines @@
   Handle<Script> script(Script::cast(shared_->script()), isolate_);
   Handle<String> source(String::cast(script->source()), isolate_);
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p] created for ", static_cast<void*>(this));
     shared_->ShortPrint();
     PrintF(" in initial state.\n");
   }
 }
 
 CompilerDispatcherJob::CompilerDispatcherJob(
-    Isolate* isolate, CompilerDispatcherTracer* tracer,
+    Isolate* isolate, CompilerDispatcherTracer* tracer, Handle<Script> script,
     Handle<SharedFunctionInfo> shared, FunctionLiteral* literal,
     std::shared_ptr<Zone> parse_zone,
     std::shared_ptr<DeferredHandles> parse_handles,
     std::shared_ptr<DeferredHandles> compile_handles, size_t max_stack_size)
     : status_(CompileJobStatus::kAnalyzed),
       isolate_(isolate),
       tracer_(tracer),
       shared_(Handle<SharedFunctionInfo>::cast(
           isolate_->global_handles()->Create(*shared))),
       max_stack_size_(max_stack_size),
       parse_info_(new ParseInfo(shared_)),
       parse_zone_(parse_zone),
       compile_info_(new CompilationInfo(parse_info_->zone(), parse_info_.get(),
                                         Handle<JSFunction>::null())),
       trace_compiler_dispatcher_jobs_(FLAG_trace_compiler_dispatcher_jobs) {
   parse_info_->set_literal(literal);
+  parse_info_->set_script(script);
   parse_info_->set_deferred_handles(parse_handles);
   compile_info_->set_deferred_handles(compile_handles);
 
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p] created for ", static_cast<void*>(this));
     shared_->ShortPrint();
     PrintF(" in Analyzed state.\n");
   }
 }
 
@@ skipping 348 matching lines @@
   return 0.0;
 }
 
 void CompilerDispatcherJob::ShortPrint() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   shared_->ShortPrint();
 }
 
 }  // namespace internal
 }  // namespace v8