Revert of [Compiler] Enable handles created during parsing and scope analysis to be deferred.

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"
@@ skipping 66 matching lines @@
   DCHECK(!shared_->outer_scope_info()->IsTheHole(isolate_));
   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,
-    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)
+CompilerDispatcherJob::CompilerDispatcherJob(Isolate* isolate,
+                                             CompilerDispatcherTracer* tracer,
+                                             Handle<SharedFunctionInfo> shared,
+                                             FunctionLiteral* literal,
+                                             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),
+      parse_info_(
+          new ParseInfo(Handle<Script>(Script::cast(shared->script())))),
       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_deferred_handles(parse_handles);
-  compile_info_->set_deferred_handles(compile_handles);
-
+  parse_info_->set_shared_info(shared);
+  parse_info_->set_function_literal_id(shared->function_literal_id());
+  parse_info_->set_language_mode(literal->scope()->language_mode());
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p] created for ", static_cast<void*>(this));
     shared_->ShortPrint();
     PrintF(" in Analyzed state.\n");
   }
 }
 
 CompilerDispatcherJob::~CompilerDispatcherJob() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status_ == CompileJobStatus::kInitial ||
@@ skipping 152 matching lines @@
 
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
   if (!wrapper_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(wrapper_).location());
     wrapper_ = Handle<String>::null();
   }
 
-  Handle<Script> script(Script::cast(shared_->script()), isolate_);
-  parse_info_->set_script(script);
   if (parse_info_->literal() == nullptr) {
-    parser_->ReportErrors(isolate_, script);
     status_ = CompileJobStatus::kFailed;
   } else {
     status_ = CompileJobStatus::kReadyToAnalyze;
   }
-  parser_->UpdateStatistics(isolate_, script);
 
   DeferredHandleScope scope(isolate_);
   {
-    parse_info_->ReopenHandlesInNewHandleScope();
+    Handle<Script> script(Script::cast(shared_->script()), isolate_);
+
+    parse_info_->set_script(script);
     Handle<ScopeInfo> outer_scope_info(
         handle(ScopeInfo::cast(shared_->outer_scope_info())));
     if (outer_scope_info->length() > 0) {
       parse_info_->set_outer_scope_info(outer_scope_info);
     }
     parse_info_->set_shared_info(shared_);
 
-    // Internalize ast values on the main thread.
-    parse_info_->ast_value_factory()->Internalize(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();
     unicode_cache_.reset();
     character_stream_.reset();
   }
-  parse_info_->set_deferred_handles(scope.Detach());
+  handles_from_parsing_.reset(scope.Detach());
 
   return status_ != CompileJobStatus::kFailed;
 }
 
 bool CompilerDispatcherJob::AnalyzeOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kReadyToAnalyze);
   COMPILER_DISPATCHER_TRACE_SCOPE(tracer_, kAnalyze);
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p]: Analyzing\n", static_cast<void*>(this));
@@ skipping 67 matching lines @@
 
   if (compile_job_->state() == CompilationJob::State::kFailed ||
       !Compiler::FinalizeCompilationJob(compile_job_.release())) {
     if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
     status_ = CompileJobStatus::kFailed;
     return false;
   }
 
   compile_job_.reset();
   compile_info_.reset();
-  parse_zone_.reset();
+  handles_from_parsing_.reset();
   parse_info_.reset();
 
   status_ = CompileJobStatus::kDone;
   return true;
 }
 
 void CompilerDispatcherJob::ResetOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
 
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p]: Resetting\n", static_cast<void*>(this));
   }
 
   compile_job_.reset();
   compile_info_.reset();
-  parse_zone_.reset();
   parser_.reset();
   unicode_cache_.reset();
   character_stream_.reset();
+  handles_from_parsing_.reset();
   parse_info_.reset();
 
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
   if (!wrapper_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(wrapper_).location());
     wrapper_ = Handle<String>::null();
   }
@@ skipping 35 matching lines @@
   return 0.0;
 }
 
 void CompilerDispatcherJob::ShortPrint() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   shared_->ShortPrint();
 }
 
 }  // namespace internal
 }  // namespace v8