Revert of Reland: [Parse] ParseInfo owns the parsing Zone.

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 77 matching lines @@
                                              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(Handle<Script>(Script::cast(shared->script())))),
+      zone_(new Zone(isolate->allocator(), ZONE_NAME)),
+      parse_info_(new ParseInfo(
+          zone_.get(), Handle<Script>(Script::cast(shared->script())))),
       compile_info_(
           new CompilationInfo(parse_info_.get(), Handle<JSFunction>::null())),
       trace_compiler_dispatcher_jobs_(FLAG_trace_compiler_dispatcher_jobs) {
   parse_info_->set_literal(literal);
   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();
@@ skipping 16 matching lines @@
 void CompilerDispatcherJob::PrepareToParseOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kInitial);
   COMPILER_DISPATCHER_TRACE_SCOPE(tracer_, kPrepareToParse);
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p]: Preparing to parse\n",
            static_cast<void*>(this));
   }
   HandleScope scope(isolate_);
   unicode_cache_.reset(new UnicodeCache());
+  zone_.reset(new Zone(isolate_->allocator(), ZONE_NAME));
   Handle<Script> script(Script::cast(shared_->script()), isolate_);
   DCHECK(script->type() != Script::TYPE_NATIVE);
 
   Handle<String> source(String::cast(script->source()), isolate_);
-  parse_info_.reset(new ParseInfo(isolate_->allocator()));
   if (source->IsExternalTwoByteString() || source->IsExternalOneByteString()) {
     character_stream_.reset(ScannerStream::For(
         source, shared_->start_position(), shared_->end_position()));
   } else {
     source = String::Flatten(source);
     const void* data;
     int offset = 0;
     int length = source->length();
 
     // Objects in lo_space don't move, so we can just read the contents from
@@ skipping 10 matching lines @@
           content.IsOneByte()
               ? reinterpret_cast<const void*>(content.ToOneByteVector().start())
               : reinterpret_cast<const void*>(content.ToUC16Vector().start());
     } else {
       // Otherwise, create a copy of the part of the string we'll parse in the
       // zone.
       length = (shared_->end_position() - shared_->start_position());
       offset = shared_->start_position();
 
       int byte_len = length * (source->IsOneByteRepresentation() ? 1 : 2);
-      data = parse_info_->zone()->New(byte_len);
+      data = zone_->New(byte_len);
 
       DisallowHeapAllocation no_allocation;
       String::FlatContent content = source->GetFlatContent();
       DCHECK(content.IsFlat());
       if (content.IsOneByte()) {
         MemCopy(const_cast<void*>(data),
                 &content.ToOneByteVector().at(shared_->start_position()),
                 byte_len);
       } else {
         MemCopy(const_cast<void*>(data),
@@ skipping 17 matching lines @@
                     ->NewExternalStringFromTwoByte(resource)
                     .ToHandleChecked();
     }
     wrapper_ =
         Handle<String>::cast(isolate_->global_handles()->Create(*wrapper));
 
     character_stream_.reset(
         ScannerStream::For(wrapper_, shared_->start_position() - offset,
                            shared_->end_position() - offset));
   }
+  parse_info_.reset(new ParseInfo(zone_.get()));
   parse_info_->set_isolate(isolate_);
   parse_info_->set_character_stream(character_stream_.get());
   parse_info_->set_hash_seed(isolate_->heap()->HashSeed());
   parse_info_->set_is_named_expression(shared_->is_named_expression());
   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());
   parse_info_->set_function_literal_id(shared_->function_literal_id());
@@ skipping 165 matching lines @@
            static_cast<void*>(this));
   }
 
   if (compile_job_->state() == CompilationJob::State::kFailed ||
       !Compiler::FinalizeCompilationJob(compile_job_.release())) {
     if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
     status_ = CompileJobStatus::kFailed;
     return false;
   }
 
+  zone_.reset();
   compile_job_.reset();
   compile_info_.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();
   parser_.reset();
   unicode_cache_.reset();
   character_stream_.reset();
   handles_from_parsing_.reset();
   parse_info_.reset();
+  zone_.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 34 matching lines @@
   return 0.0;
 }
 
 void CompilerDispatcherJob::ShortPrint() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   shared_->ShortPrint();
 }
 
 }  // namespace internal
 }  // namespace v8