Revert "[Parse] ParseInfo owns the parsing Zone."

Speculative reason for issue 684481.

BUG=chromium:684481
TBR=marja@chromium.org,mstarzinger@chromium.org,ahaas@chromium.org,verwaest@chromium.org,

Original issue's description:
> [Parse] ParseInfo owns the parsing Zone.
>
> Moves ownership of the parsing Zone to ParseInfo with a shared_ptr. This is
> in preperation for enabling background compilation jobs for inner functions
> share the AST in the outer-function's parse zone memory (read-only), with the
> and zone being released when all compilation jobs have completed.
>
> BUG=v8:5203, v8:5215
> Review-Url: https://codereview.chromium.org/2632123006
> Cr-Commit-Position: refs/heads/master@{#42562}
> Committed: https://chromium.googlesource.com/v8/v8/+/4b0101d369af121a6daf5e5c731cb939c026d526

Review-Url: https://codereview.chromium.org/2648383005
Cr-Commit-Position: refs/heads/master@{#42633}

src/asmjs/asm-wasm-builder.cc

@@ -142,27 +142,27 @@ class AsmWasmBuilderImpl final : public AstVisitor<AsmWasmBuilderImpl> {
     DCHECK_EQ(kModuleScope, scope_);
     DCHECK_NULL(current_function_builder_);
     FunctionLiteral* old_func = decl->fun();
+    Zone zone(isolate_->allocator(), ZONE_NAME);
     DeclarationScope* new_func_scope = nullptr;
-    std::unique_ptr<ParseInfo> info;
     if (decl->fun()->body() == nullptr) {
       // TODO(titzer/bradnelson): Reuse SharedFunctionInfos used here when
       // compiling the wasm module.
       Handle<SharedFunctionInfo> shared =
           Compiler::GetSharedFunctionInfo(decl->fun(), script_, info_);
       shared->set_is_toplevel(false);
-      info.reset(new ParseInfo(script_));
-      info->set_shared_info(shared);
-      info->set_toplevel(false);
-      info->set_language_mode(decl->fun()->scope()->language_mode());
-      info->set_allow_lazy_parsing(false);
-      info->set_function_literal_id(shared->function_literal_id());
-      info->set_ast_value_factory(ast_value_factory_);
-      info->set_ast_value_factory_owned(false);
+      ParseInfo info(&zone, script_);
+      info.set_shared_info(shared);
+      info.set_toplevel(false);
+      info.set_language_mode(decl->fun()->scope()->language_mode());
+      info.set_allow_lazy_parsing(false);
+      info.set_function_literal_id(shared->function_literal_id());
+      info.set_ast_value_factory(ast_value_factory_);
+      info.set_ast_value_factory_owned(false);
       // Create fresh function scope to use to parse the function in.
-      new_func_scope = new (info->zone()) DeclarationScope(
-          info->zone(), decl->fun()->scope()->outer_scope(), FUNCTION_SCOPE);
-      info->set_asm_function_scope(new_func_scope);
-      if (!Compiler::ParseAndAnalyze(info.get())) {
+      new_func_scope = new (info.zone()) DeclarationScope(
+          info.zone(), decl->fun()->scope()->outer_scope(), FUNCTION_SCOPE);
+      info.set_asm_function_scope(new_func_scope);
+      if (!Compiler::ParseAndAnalyze(&info)) {
         decl->fun()->scope()->outer_scope()->RemoveInnerScope(new_func_scope);
         if (isolate_->has_pending_exception()) {
           isolate_->clear_pending_exception();
@@ -171,7 +171,7 @@ class AsmWasmBuilderImpl final : public AstVisitor<AsmWasmBuilderImpl> {
         typer_failed_ = true;
         return;
       }
-      FunctionLiteral* func = info->literal();
+      FunctionLiteral* func = info.literal();
       DCHECK_NOT_NULL(func);
       decl->set_fun(func);
     }

src/background-parsing-task.cc

@@ -13,6 +13,7 @@ namespace internal {
 void StreamedSource::Release() {
   parser.reset();
   info.reset();
+  zone.reset();
 }
 
 BackgroundParsingTask::BackgroundParsingTask(
@@ -28,8 +29,10 @@ BackgroundParsingTask::BackgroundParsingTask(
 
   // Prepare the data for the internalization phase and compilation phase, which
   // will happen in the main thread after parsing.
-  ParseInfo* info = new ParseInfo(isolate->allocator());
+  Zone* zone = new Zone(isolate->allocator(), ZONE_NAME);
+  ParseInfo* info = new ParseInfo(zone);
   info->set_toplevel();
+  source->zone.reset(zone);
   source->info.reset(info);
   info->set_isolate(isolate);
   info->set_source_stream(source->source_stream.get());

src/background-parsing-task.h

@@ -38,6 +38,7 @@ struct StreamedSource {
   // between parsing and compilation. These need to be initialized before the
   // compilation starts.
   UnicodeCache unicode_cache;
+  std::unique_ptr<Zone> zone;
   std::unique_ptr<ParseInfo> info;
   std::unique_ptr<Parser> parser;
 

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

@@ -105,11 +105,11 @@ void CompilerDispatcherJob::PrepareToParseOnMainThread() {
   }
   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()));
@@ -140,7 +140,7 @@ void CompilerDispatcherJob::PrepareToParseOnMainThread() {
       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();
@@ -178,6 +178,7 @@ void CompilerDispatcherJob::PrepareToParseOnMainThread() {
         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());
@@ -350,6 +351,7 @@ bool CompilerDispatcherJob::FinalizeCompilingOnMainThread() {
     return false;
   }
 
+  zone_.reset();
   compile_job_.reset();
   compile_info_.reset();
   handles_from_parsing_.reset();
@@ -373,6 +375,7 @@ void CompilerDispatcherJob::ResetOnMainThread() {
   character_stream_.reset();
   handles_from_parsing_.reset();
   parse_info_.reset();
+  zone_.reset();
 
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());

src/compiler-dispatcher/compiler-dispatcher-job.h

@@ -97,6 +97,7 @@ class V8_EXPORT_PRIVATE CompilerDispatcherJob {
 
   // Members required for parsing.
   std::unique_ptr<UnicodeCache> unicode_cache_;
+  std::unique_ptr<Zone> zone_;
   std::unique_ptr<Utf16CharacterStream> character_stream_;
   std::unique_ptr<ParseInfo> parse_info_;
   std::unique_ptr<Parser> parser_;

src/compiler.cc

@@ -503,7 +503,8 @@ bool CompileUnoptimizedInnerFunctions(
     // eagerly compiled function literals.
     SetSharedFunctionFlagsFromLiteral(literal, shared);
 
-    ParseInfo parse_info(script);
+    Zone zone(isolate->allocator(), ZONE_NAME);
+    ParseInfo parse_info(&zone, script);
     parse_info.set_literal(literal);
     parse_info.set_shared_info(shared);
     parse_info.set_function_literal_id(shared->function_literal_id());
@@ -887,7 +888,8 @@ MaybeHandle<Code> GetBaselineCode(Handle<JSFunction> function) {
   Isolate* isolate = function->GetIsolate();
   VMState<COMPILER> state(isolate);
   PostponeInterruptsScope postpone(isolate);
-  ParseInfo parse_info(handle(function->shared()));
+  Zone zone(isolate->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, handle(function->shared()));
   CompilationInfo info(&parse_info, function);
 
   DCHECK(function->shared()->is_compiled());
@@ -1020,7 +1022,8 @@ MaybeHandle<Code> GetLazyCode(Handle<JSFunction> function) {
     return entry;
   }
 
-  ParseInfo parse_info(handle(function->shared()));
+  Zone zone(isolate->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, handle(function->shared()));
   CompilationInfo info(&parse_info, function);
   Handle<Code> result;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, result, GetUnoptimizedCode(&info), Code);
@@ -1199,7 +1202,8 @@ bool Compiler::CompileOptimized(Handle<JSFunction> function,
       code = isolate->builtins()->InterpreterEntryTrampoline();
       function->shared()->ReplaceCode(*code);
     } else {
-      ParseInfo parse_info(handle(function->shared()));
+      Zone zone(isolate->allocator(), ZONE_NAME);
+      ParseInfo parse_info(&zone, handle(function->shared()));
       CompilationInfo info(&parse_info, function);
       if (!GetUnoptimizedCode(&info).ToHandle(&code)) {
         return false;
@@ -1223,7 +1227,8 @@ bool Compiler::CompileDebugCode(Handle<SharedFunctionInfo> shared) {
   DCHECK(AllowCompilation::IsAllowed(isolate));
 
   // Start a compilation.
-  ParseInfo parse_info(shared);
+  Zone zone(isolate->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, shared);
   CompilationInfo info(&parse_info, Handle<JSFunction>::null());
   info.MarkAsDebug();
   if (GetUnoptimizedCode(&info).is_null()) {
@@ -1250,7 +1255,8 @@ MaybeHandle<JSArray> Compiler::CompileForLiveEdit(Handle<Script> script) {
   script->set_shared_function_infos(isolate->heap()->empty_fixed_array());
 
   // Start a compilation.
-  ParseInfo parse_info(script);
+  Zone zone(isolate->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, script);
   CompilationInfo info(&parse_info, Handle<JSFunction>::null());
   info.MarkAsDebug();
 
@@ -1261,7 +1267,7 @@ MaybeHandle<JSArray> Compiler::CompileForLiveEdit(Handle<Script> script) {
     // Check postconditions on success.
     DCHECK(!isolate->has_pending_exception());
     infos = LiveEditFunctionTracker::Collect(parse_info.literal(), script,
-                                             parse_info.zone(), isolate);
+                                             &zone, isolate);
   }
 
   // Restore the original function info list in order to remain side-effect
@@ -1385,7 +1391,8 @@ MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
     script->set_compilation_type(Script::COMPILATION_TYPE_EVAL);
     Script::SetEvalOrigin(script, outer_info, eval_position);
 
-    ParseInfo parse_info(script);
+    Zone zone(isolate->allocator(), ZONE_NAME);
+    ParseInfo parse_info(&zone, script);
     CompilationInfo info(&parse_info, Handle<JSFunction>::null());
     parse_info.set_eval();
     parse_info.set_language_mode(language_mode);
@@ -1563,7 +1570,8 @@ Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
     }
 
     // Compile the function and add it to the cache.
-    ParseInfo parse_info(script);
+    Zone zone(isolate->allocator(), ZONE_NAME);
+    ParseInfo parse_info(&zone, script);
     CompilationInfo info(&parse_info, Handle<JSFunction>::null());
     if (resource_options.IsModule()) parse_info.set_module();
     if (compile_options != ScriptCompiler::kNoCompileOptions) {

src/compiler/js-inlining.cc

@@ -474,7 +474,8 @@ Reduction JSInliner::ReduceJSCall(Node* node, Handle<JSFunction> function) {
     }
   }
 
-  ParseInfo parse_info(shared_info);
+  Zone zone(info_->isolate()->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, shared_info);
   CompilationInfo info(&parse_info, Handle<JSFunction>::null());
   if (info_->is_deoptimization_enabled()) info.MarkAsDeoptimizationEnabled();
   info.MarkAsOptimizeFromBytecode();
@@ -513,7 +514,7 @@ Reduction JSInliner::ReduceJSCall(Node* node, Handle<JSFunction> function) {
     // Run the BytecodeGraphBuilder to create the subgraph.
     Graph::SubgraphScope scope(graph());
     BytecodeGraphBuilder graph_builder(
-        parse_info.zone(), shared_info, handle(function->feedback_vector()),
+        &zone, shared_info, handle(function->feedback_vector()),
         BailoutId::None(), jsgraph(), call.frequency(), source_positions_,
         inlining_id);
     graph_builder.CreateGraph(false);

src/compiler/pipeline.cc

@@ -550,8 +550,9 @@ class PipelineCompilationJob final : public CompilationJob {
       // Note that the CompilationInfo is not initialized at the time we pass it
       // to the CompilationJob constructor, but it is not dereferenced there.
       : CompilationJob(isolate, &info_, "TurboFan"),
-        parse_info_(handle(function->shared())),
+        zone_(isolate->allocator(), ZONE_NAME),
         zone_stats_(isolate->allocator()),
+        parse_info_(&zone_, handle(function->shared())),
         info_(&parse_info_, function),
         pipeline_statistics_(CreatePipelineStatistics(info(), &zone_stats_)),
         data_(&zone_stats_, info(), pipeline_statistics_.get()),
@@ -564,8 +565,9 @@ class PipelineCompilationJob final : public CompilationJob {
   Status FinalizeJobImpl() final;
 
  private:
-  ParseInfo parse_info_;
+  Zone zone_;
   ZoneStats zone_stats_;
+  ParseInfo parse_info_;
   CompilationInfo info_;
   std::unique_ptr<PipelineStatistics> pipeline_statistics_;
   PipelineData data_;
@@ -602,8 +604,7 @@ PipelineCompilationJob::Status PipelineCompilationJob::PrepareJobImpl() {
     info()->MarkAsInliningEnabled();
   }
 
-  linkage_ = new (info()->zone())
-      Linkage(Linkage::ComputeIncoming(info()->zone(), info()));
+  linkage_ = new (&zone_) Linkage(Linkage::ComputeIncoming(&zone_, info()));
 
   if (!pipeline_.CreateGraph()) {
     if (isolate()->has_pending_exception()) return FAILED;  // Stack overflowed.

src/crankshaft/hydrogen.cc

@@ -8035,7 +8035,7 @@ bool HOptimizedGraphBuilder::TryInline(Handle<JSFunction> target,
   // Use the same AstValueFactory for creating strings in the sub-compilation
   // step, but don't transfer ownership to target_info.
   Handle<SharedFunctionInfo> target_shared(target->shared());
-  ParseInfo parse_info(target_shared, top_info()->parse_info()->zone_shared());
+  ParseInfo parse_info(zone(), target_shared);
   parse_info.set_ast_value_factory(
       top_info()->parse_info()->ast_value_factory());
   parse_info.set_ast_value_factory_owned(false);

src/crankshaft/hydrogen.h

@@ -37,7 +37,8 @@ class HCompilationJob final : public CompilationJob {
  public:
   explicit HCompilationJob(Handle<JSFunction> function)
       : CompilationJob(function->GetIsolate(), &info_, "Crankshaft"),
-        parse_info_(handle(function->shared())),
+        zone_(function->GetIsolate()->allocator(), ZONE_NAME),
+        parse_info_(&zone_, handle(function->shared())),
         info_(&parse_info_, function),
         graph_(nullptr),
         chunk_(nullptr) {}
@@ -48,6 +49,7 @@ class HCompilationJob final : public CompilationJob {
   virtual Status FinalizeJobImpl();
 
  private:
+  Zone zone_;
   ParseInfo parse_info_;
   CompilationInfo info_;
   HGraph* graph_;

src/debug/debug-scopes.cc

@@ -87,11 +87,12 @@ ScopeIterator::ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
 
   // Reparse the code and analyze the scopes.
   // Check whether we are in global, eval or function code.
+  Zone zone(isolate->allocator(), ZONE_NAME);
   std::unique_ptr<ParseInfo> info;
   if (scope_info->scope_type() != FUNCTION_SCOPE) {
     // Global or eval code.
     Handle<Script> script(Script::cast(shared_info->script()));
-    info.reset(new ParseInfo(script));
+    info.reset(new ParseInfo(&zone, script));
     if (scope_info->scope_type() == EVAL_SCOPE) {
       info->set_eval();
       if (!function->context()->IsNativeContext()) {
@@ -107,7 +108,7 @@ ScopeIterator::ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
     }
   } else {
     // Inner function.
-    info.reset(new ParseInfo(shared_info));
+    info.reset(new ParseInfo(&zone, shared_info));
   }
   if (parsing::ParseAny(info.get()) && Rewriter::Rewrite(info.get())) {
     DeclarationScope* scope = info->literal()->scope();

src/parsing/parse-info.cc

@@ -9,13 +9,12 @@
 #include "src/heap/heap-inl.h"
 #include "src/objects-inl.h"
 #include "src/objects/scope-info.h"
-#include "src/zone/zone.h"
 
 namespace v8 {
 namespace internal {
 
-ParseInfo::ParseInfo(AccountingAllocator* zone_allocator)
-    : zone_(std::make_shared<Zone>(zone_allocator, ZONE_NAME)),
+ParseInfo::ParseInfo(Zone* zone)
+    : zone_(zone),
       flags_(0),
       source_stream_(nullptr),
       source_stream_encoding_(ScriptCompiler::StreamedSource::ONE_BYTE),
@@ -38,8 +37,8 @@ ParseInfo::ParseInfo(AccountingAllocator* zone_allocator)
       function_name_(nullptr),
       literal_(nullptr) {}
 
-ParseInfo::ParseInfo(Handle<SharedFunctionInfo> shared)
-    : ParseInfo(shared->GetIsolate()->allocator()) {
+ParseInfo::ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared)
+    : ParseInfo(zone) {
   isolate_ = shared->GetIsolate();
 
   set_toplevel(shared->is_toplevel());
@@ -69,14 +68,7 @@ ParseInfo::ParseInfo(Handle<SharedFunctionInfo> shared)
   }
 }
 
-ParseInfo::ParseInfo(Handle<SharedFunctionInfo> shared,
-                     std::shared_ptr<Zone> zone)
-    : ParseInfo(shared) {
-  zone_.swap(zone);
-}
-
-ParseInfo::ParseInfo(Handle<Script> script)
-    : ParseInfo(script->GetIsolate()->allocator()) {
+ParseInfo::ParseInfo(Zone* zone, Handle<Script> script) : ParseInfo(zone) {
   isolate_ = script->GetIsolate();
 
   set_allow_lazy_parsing();

src/parsing/parse-info.h

@@ -5,8 +5,6 @@
 #ifndef V8_PARSING_PARSE_INFO_H_
 #define V8_PARSING_PARSE_INFO_H_
 
-#include <memory>
-
 #include "include/v8.h"
 #include "src/globals.h"
 #include "src/handles.h"
@@ -17,7 +15,6 @@ class Extension;
 
 namespace internal {
 
-class AccountingAllocator;
 class AstRawString;
 class AstValueFactory;
 class DeclarationScope;
@@ -31,18 +28,13 @@ class Zone;
 // A container for the inputs, configuration options, and outputs of parsing.
 class V8_EXPORT_PRIVATE ParseInfo {
  public:
-  explicit ParseInfo(AccountingAllocator* zone_allocator);
-  ParseInfo(Handle<Script> script);
-  ParseInfo(Handle<SharedFunctionInfo> shared);
-
-  // TODO(rmcilroy): Remove once Hydrogen no longer needs this.
-  ParseInfo(Handle<SharedFunctionInfo> shared, std::shared_ptr<Zone> zone);
+  explicit ParseInfo(Zone* zone);
+  ParseInfo(Zone* zone, Handle<Script> script);
+  ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared);
 
   ~ParseInfo();
 
-  Zone* zone() const { return zone_.get(); }
-
-  std::shared_ptr<Zone> zone_shared() const { return zone_; }
+  Zone* zone() const { return zone_; }
 
 // Convenience accessor methods for flags.
 #define FLAG_ACCESSOR(flag, getter, setter)     \
@@ -231,7 +223,7 @@ class V8_EXPORT_PRIVATE ParseInfo {
   };
 
   //------------- Inputs to parsing and scope analysis -----------------------
-  std::shared_ptr<Zone> zone_;
+  Zone* zone_;
   unsigned flags_;
   ScriptCompiler::ExternalSourceStream* source_stream_;
   ScriptCompiler::StreamedSource::Encoding source_stream_encoding_;

src/runtime/runtime-internal.cc

@@ -352,7 +352,8 @@ bool ComputeLocation(Isolate* isolate, MessageLocation* target) {
 Handle<String> RenderCallSite(Isolate* isolate, Handle<Object> object) {
   MessageLocation location;
   if (ComputeLocation(isolate, &location)) {
-    std::unique_ptr<ParseInfo> info(new ParseInfo(location.shared()));
+    Zone zone(isolate->allocator(), ZONE_NAME);
+    std::unique_ptr<ParseInfo> info(new ParseInfo(&zone, location.shared()));
     if (parsing::ParseAny(info.get())) {
       CallPrinter printer(isolate, location.shared()->IsUserJavaScript());
       Handle<String> str = printer.Print(info->literal(), location.start_pos());

test/cctest/asmjs/test-asm-typer.cc

@@ -45,32 +45,33 @@ class AsmTyperHarnessBuilder {
       : source_(source),
         validation_type_(type),
         handles_(),
+        zone_(handles_.main_zone()),
         isolate_(CcTest::i_isolate()),
+        ast_value_factory_(zone_, isolate_->ast_string_constants(),
+                           isolate_->heap()->HashSeed()),
         factory_(isolate_->factory()),
         source_code_(
             factory_->NewStringFromUtf8(CStrVector(source)).ToHandleChecked()),
-        script_(factory_->NewScript(source_code_)),
-        info_(script_),
-        ast_value_factory_(info_.zone(), isolate_->ast_string_constants(),
-                           isolate_->heap()->HashSeed()) {
-    info_.set_allow_lazy_parsing(false);
-    info_.set_toplevel(true);
-    info_.set_ast_value_factory(&ast_value_factory_);
-    info_.set_ast_value_factory_owned(false);
-    Parser parser(&info_);
-
-    if (!Compiler::ParseAndAnalyze(&info_)) {
+        script_(factory_->NewScript(source_code_)) {
+    ParseInfo info(zone_, script_);
+    info.set_allow_lazy_parsing(false);
+    info.set_toplevel(true);
+    info.set_ast_value_factory(&ast_value_factory_);
+    info.set_ast_value_factory_owned(false);
+    Parser parser(&info);
+
+    if (!Compiler::ParseAndAnalyze(&info)) {
       std::cerr << "Failed to parse:\n" << source_ << "\n";
       CHECK(false);
     }
 
-    outer_scope_ = info_.script_scope();
-    module_ = info_.scope()
+    outer_scope_ = info.script_scope();
+    module_ = info.scope()
                   ->declarations()
                   ->AtForTest(0)
                   ->AsFunctionDeclaration()
                   ->fun();
-    typer_.reset(new AsmTyper(isolate_, zone(), script_, module_));
+    typer_.reset(new AsmTyper(isolate_, zone_, script_, module_));
 
     if (validation_type_ == ValidateStatement ||
         validation_type_ == ValidateExpression) {
@@ -103,7 +104,7 @@ class AsmTyperHarnessBuilder {
     if (var->IsUnallocated()) {
       var->AllocateTo(VariableLocation::LOCAL, -1);
     }
-    auto* var_info = new (zone()) AsmTyper::VariableInfo(type);
+    auto* var_info = new (zone_) AsmTyper::VariableInfo(type);
     var_info->set_mutability(AsmTyper::VariableInfo::kLocal);
     CHECK(typer_->AddLocal(var, var_info));
     return this;
@@ -115,7 +116,7 @@ class AsmTyperHarnessBuilder {
       var->AllocateTo(VariableLocation::MODULE, -1);
     }
     if (type != nullptr) {
-      auto* var_info = new (zone()) AsmTyper::VariableInfo(type);
+      auto* var_info = new (zone_) AsmTyper::VariableInfo(type);
       var_info->set_mutability(AsmTyper::VariableInfo::kMutableGlobal);
       CHECK(typer_->AddGlobal(var, var_info));
     }
@@ -124,12 +125,12 @@ class AsmTyperHarnessBuilder {
 
   AsmTyperHarnessBuilder* WithGlobal(
       VariableName var_name, std::function<AsmType*(Zone*)> type_creator) {
-    return WithGlobal(var_name, type_creator(zone()));
+    return WithGlobal(var_name, type_creator(zone_));
   }
 
   AsmTyperHarnessBuilder* WithUndefinedGlobal(
       VariableName var_name, std::function<AsmType*(Zone*)> type_creator) {
-    auto* type = type_creator(zone());
+    auto* type = type_creator(zone_);
     CHECK(type->AsFunctionType() != nullptr ||
           type->AsFunctionTableType() != nullptr);
     WithGlobal(var_name, type);
@@ -156,8 +157,7 @@ class AsmTyperHarnessBuilder {
         CHECK(false);
       case AsmTyper::kFFI:
         stdlib_map = nullptr;
-        var_info =
-            new (zone()) AsmTyper::VariableInfo(AsmType::FFIType(zone()));
+        var_info = new (zone_) AsmTyper::VariableInfo(AsmType::FFIType(zone_));
         var_info->set_mutability(AsmTyper::VariableInfo::kImmutableGlobal);
         break;
       case AsmTyper::kInfinity:
@@ -176,7 +176,7 @@ class AsmTyperHarnessBuilder {
       }
 
       CHECK(var_info != nullptr);
-      var_info = var_info->Clone(zone());
+      var_info = var_info->Clone(zone_);
     }
 
     CHECK(typer_->AddGlobal(var, var_info));
@@ -193,7 +193,7 @@ class AsmTyperHarnessBuilder {
   AsmTyperHarnessBuilder* WithStdlib(VariableName var_name) {
     auto* var = DeclareVariable(var_name);
     auto* var_info =
-        AsmTyper::VariableInfo::ForSpecialSymbol(zone(), AsmTyper::kStdlib);
+        AsmTyper::VariableInfo::ForSpecialSymbol(zone_, AsmTyper::kStdlib);
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
@@ -201,7 +201,7 @@ class AsmTyperHarnessBuilder {
   AsmTyperHarnessBuilder* WithHeap(VariableName var_name) {
     auto* var = DeclareVariable(var_name);
     auto* var_info =
-        AsmTyper::VariableInfo::ForSpecialSymbol(zone(), AsmTyper::kHeap);
+        AsmTyper::VariableInfo::ForSpecialSymbol(zone_, AsmTyper::kHeap);
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
@@ -209,7 +209,7 @@ class AsmTyperHarnessBuilder {
   AsmTyperHarnessBuilder* WithFFI(VariableName var_name) {
     auto* var = DeclareVariable(var_name);
     auto* var_info =
-        AsmTyper::VariableInfo::ForSpecialSymbol(zone(), AsmTyper::kFFI);
+        AsmTyper::VariableInfo::ForSpecialSymbol(zone_, AsmTyper::kFFI);
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
@@ -305,7 +305,7 @@ class AsmTyperHarnessBuilder {
   }
 
   bool ValidateAllStatements(FunctionDeclaration* fun_decl) {
-    AsmTyper::FlattenedStatements iter(zone(), fun_decl->fun()->body());
+    AsmTyper::FlattenedStatements iter(zone_, fun_decl->fun()->body());
     while (auto* curr = iter.Next()) {
       if (typer_->ValidateStatement(curr) == AsmType::None()) {
         return false;
@@ -315,7 +315,7 @@ class AsmTyperHarnessBuilder {
   }
 
   AsmType* ValidateExpressionStatment(FunctionDeclaration* fun_decl) {
-    AsmTyper::FlattenedStatements iter(zone(), fun_decl->fun()->body());
+    AsmTyper::FlattenedStatements iter(zone_, fun_decl->fun()->body());
     AsmType* ret = AsmType::None();
     bool last_was_expression_statement = false;
     while (auto* curr = iter.Next()) {
@@ -337,17 +337,15 @@ class AsmTyperHarnessBuilder {
     return ret;
   }
 
-  Zone* zone() { return info_.zone(); }
-
   std::string source_;
   ValidationType validation_type_;
   HandleAndZoneScope handles_;
+  Zone* zone_;
   Isolate* isolate_;
+  AstValueFactory ast_value_factory_;
   Factory* factory_;
   Handle<String> source_code_;
   Handle<Script> script_;
-  ParseInfo info_;
-  AstValueFactory ast_value_factory_;
 
   DeclarationScope* outer_scope_;
   FunctionLiteral* module_;

test/cctest/compiler/function-tester.cc

@@ -155,7 +155,8 @@ Handle<JSFunction> FunctionTester::ForMachineGraph(Graph* graph,
 }
 
 Handle<JSFunction> FunctionTester::Compile(Handle<JSFunction> function) {
-  ParseInfo parse_info(handle(function->shared()));
+  Zone zone(function->GetIsolate()->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, handle(function->shared()));
   CompilationInfo info(&parse_info, function);
 
   info.SetOptimizing();
@@ -184,7 +185,8 @@ Handle<JSFunction> FunctionTester::Compile(Handle<JSFunction> function) {
 // Compile the given machine graph instead of the source of the function
 // and replace the JSFunction's code with the result.
 Handle<JSFunction> FunctionTester::CompileGraph(Graph* graph) {
-  ParseInfo parse_info(handle(function->shared()));
+  Zone zone(function->GetIsolate()->allocator(), ZONE_NAME);
+  ParseInfo parse_info(&zone, handle(function->shared()));
   CompilationInfo info(&parse_info, function);
 
   CHECK(parsing::ParseFunction(info.parse_info()));

test/cctest/compiler/test-linkage.cc

@@ -43,7 +43,7 @@ static Handle<JSFunction> Compile(const char* source) {
 TEST(TestLinkageCreate) {
   HandleAndZoneScope handles;
   Handle<JSFunction> function = Compile("a + b");
-  ParseInfo parse_info(handle(function->shared()));
+  ParseInfo parse_info(handles.main_zone(), handle(function->shared()));
   CompilationInfo info(&parse_info, function);
   CallDescriptor* descriptor = Linkage::ComputeIncoming(info.zone(), &info);
   CHECK(descriptor);
@@ -59,7 +59,7 @@ TEST(TestLinkageJSFunctionIncoming) {
     Handle<JSFunction> function =
         Handle<JSFunction>::cast(v8::Utils::OpenHandle(
             *v8::Local<v8::Function>::Cast(CompileRun(sources[i]))));
-    ParseInfo parse_info(handle(function->shared()));
+    ParseInfo parse_info(handles.main_zone(), handle(function->shared()));
     CompilationInfo info(&parse_info, function);
     CallDescriptor* descriptor = Linkage::ComputeIncoming(info.zone(), &info);
     CHECK(descriptor);
@@ -75,7 +75,7 @@ TEST(TestLinkageJSFunctionIncoming) {
 TEST(TestLinkageJSCall) {
   HandleAndZoneScope handles;
   Handle<JSFunction> function = Compile("a + c");
-  ParseInfo parse_info(handle(function->shared()));
+  ParseInfo parse_info(handles.main_zone(), handle(function->shared()));
   CompilationInfo info(&parse_info, function);
 
   for (int i = 0; i < 32; i++) {

test/cctest/compiler/test-loop-assignment-analysis.cc

@@ -33,7 +33,7 @@ struct TestHelper : public HandleAndZoneScope {
 
   void CheckLoopAssignedCount(int expected, const char* var_name) {
     // TODO(titzer): don't scope analyze every single time.
-    ParseInfo parse_info(handle(function->shared()));
+    ParseInfo parse_info(main_zone(), handle(function->shared()));
     CompilationInfo info(&parse_info, function);
 
     CHECK(parsing::ParseFunction(&parse_info));

test/cctest/test-parsing.cc

@@ -825,7 +825,8 @@ TEST(ScopeUsesArgumentsSuperThis) {
           factory->NewStringFromUtf8(i::CStrVector(program.start()))
               .ToHandleChecked();
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::ParseInfo info(script);
+      i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+      i::ParseInfo info(&zone, script);
       // The information we're checking is only produced when eager parsing.
       info.set_allow_lazy_parsing(false);
       CHECK(i::parsing::ParseProgram(&info));
@@ -881,7 +882,7 @@ static void CheckParsesToNumber(const char* source, bool with_dot) {
 
   i::Handle<i::Script> script = factory->NewScript(source_code);
 
-  i::ParseInfo info(script);
+  i::ParseInfo info(handles.main_zone(), script);
   i::Parser parser(&info);
   info.set_allow_lazy_parsing(false);
   info.set_toplevel(true);
@@ -1179,7 +1180,8 @@ TEST(ScopePositions) {
         i::CStrVector(program.start())).ToHandleChecked();
     CHECK_EQ(source->length(), kProgramSize);
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::ParseInfo info(script);
+    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+    i::ParseInfo info(&zone, script);
     info.set_language_mode(source_data[i].language_mode);
     i::parsing::ParseProgram(&info);
     CHECK_NOT_NULL(info.literal());
@@ -1225,7 +1227,8 @@ TEST(DiscardFunctionBody) {
     i::Handle<i::String> source_code =
         factory->NewStringFromUtf8(i::CStrVector(source)).ToHandleChecked();
     i::Handle<i::Script> script = factory->NewScript(source_code);
-    i::ParseInfo info(script);
+    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+    i::ParseInfo info(&zone, script);
     i::parsing::ParseProgram(&info);
     function = info.literal();
     CHECK_NOT_NULL(function);
@@ -1351,7 +1354,8 @@ void TestParserSyncWithFlags(i::Handle<i::String> source,
   i::FunctionLiteral* function;
   {
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::ParseInfo info(script);
+    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+    i::ParseInfo info(&zone, script);
     info.set_allow_lazy_parsing(flags.Contains(kAllowLazy));
     SetGlobalFlags(flags);
     if (is_module) info.set_module();
@@ -2482,7 +2486,8 @@ TEST(DontRegressPreParserDataSizes) {
     i::Handle<i::String> source =
         factory->NewStringFromUtf8(i::CStrVector(program)).ToHandleChecked();
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::ParseInfo info(script);
+    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+    i::ParseInfo info(&zone, script);
     i::ScriptData* sd = NULL;
     info.set_cached_data(&sd);
     info.set_compile_options(v8::ScriptCompiler::kProduceParserCache);
@@ -3369,6 +3374,7 @@ TEST(InnerAssignment) {
         i::SNPrintF(program, "%s%s%s%s%s", prefix, outer, midfix, inner,
                     suffix);
 
+        i::Zone zone(isolate->allocator(), ZONE_NAME);
         std::unique_ptr<i::ParseInfo> info;
         if (lazy) {
           printf("%s\n", program.start());
@@ -3376,7 +3382,7 @@ TEST(InnerAssignment) {
           i::Handle<i::Object> o = v8::Utils::OpenHandle(*v);
           i::Handle<i::JSFunction> f = i::Handle<i::JSFunction>::cast(o);
           i::Handle<i::SharedFunctionInfo> shared = i::handle(f->shared());
-          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(shared));
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, shared));
           CHECK(i::parsing::ParseFunction(info.get()));
         } else {
           i::Handle<i::String> source =
@@ -3384,7 +3390,7 @@ TEST(InnerAssignment) {
           source->PrintOn(stdout);
           printf("\n");
           i::Handle<i::Script> script = factory->NewScript(source);
-          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(script));
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, script));
           info->set_allow_lazy_parsing(false);
           CHECK(i::parsing::ParseProgram(info.get()));
         }
@@ -3483,13 +3489,14 @@ TEST(MaybeAssignedParameters) {
       i::ScopedVector<char> program(Utf8LengthHelper(source) +
                                     Utf8LengthHelper(suffix) + 1);
       i::SNPrintF(program, "%s%s", source, suffix);
+      i::Zone zone(isolate->allocator(), ZONE_NAME);
       std::unique_ptr<i::ParseInfo> info;
       printf("%s\n", program.start());
       v8::Local<v8::Value> v = CompileRun(program.start());
       i::Handle<i::Object> o = v8::Utils::OpenHandle(*v);
       i::Handle<i::JSFunction> f = i::Handle<i::JSFunction>::cast(o);
       i::Handle<i::SharedFunctionInfo> shared = i::handle(f->shared());
-      info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(shared));
+      info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, shared));
       info->set_allow_lazy_parsing(allow_lazy);
       CHECK(i::parsing::ParseFunction(info.get()));
       CHECK(i::Compiler::Analyze(info.get()));
@@ -3534,6 +3541,7 @@ TEST(MaybeAssignedTopLevel) {
       i::ScopedVector<char> program(Utf8LengthHelper(prefix) +
                                     Utf8LengthHelper(source) + 1);
       i::SNPrintF(program, "%s%s", prefix, source);
+      i::Zone zone(isolate->allocator(), ZONE_NAME);
 
       i::Handle<i::String> string =
           factory->InternalizeUtf8String(program.start());
@@ -3544,7 +3552,7 @@ TEST(MaybeAssignedTopLevel) {
       for (unsigned allow_lazy = 0; allow_lazy < 2; ++allow_lazy) {
         for (unsigned module = 0; module < 2; ++module) {
           std::unique_ptr<i::ParseInfo> info;
-          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(script));
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, script));
           info->set_module(module);
           info->set_allow_lazy_parsing(allow_lazy);
 
@@ -5863,7 +5871,8 @@ TEST(BasicImportExportParsing) {
     // Show that parsing as a module works
     {
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::ParseInfo info(script);
+      i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+      i::ParseInfo info(&zone, script);
       info.set_module();
       if (!i::parsing::ParseProgram(&info)) {
         i::Handle<i::JSObject> exception_handle(
@@ -5887,7 +5896,8 @@ TEST(BasicImportExportParsing) {
     // And that parsing a script does not.
     {
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::ParseInfo info(script);
+      i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+      i::ParseInfo info(&zone, script);
       CHECK(!i::parsing::ParseProgram(&info));
       isolate->clear_pending_exception();
     }
@@ -5977,7 +5987,8 @@ TEST(ImportExportParsingErrors) {
         factory->NewStringFromAsciiChecked(kErrorSources[i]);
 
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::ParseInfo info(script);
+    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+    i::ParseInfo info(&zone, script);
     info.set_module();
     CHECK(!i::parsing::ParseProgram(&info));
     isolate->clear_pending_exception();
@@ -6013,7 +6024,8 @@ TEST(ModuleTopLevelFunctionDecl) {
         factory->NewStringFromAsciiChecked(kErrorSources[i]);
 
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::ParseInfo info(script);
+    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+    i::ParseInfo info(&zone, script);
     info.set_module();
     CHECK(!i::parsing::ParseProgram(&info));
     isolate->clear_pending_exception();
@@ -6210,7 +6222,8 @@ TEST(ModuleParsingInternals) {
       "export {foob};";
   i::Handle<i::String> source = factory->NewStringFromAsciiChecked(kSource);
   i::Handle<i::Script> script = factory->NewScript(source);
-  i::ParseInfo info(script);
+  i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+  i::ParseInfo info(&zone, script);
   info.set_module();
   CHECK(i::parsing::ParseProgram(&info));
   CHECK(i::Compiler::Analyze(&info));
@@ -6469,7 +6482,8 @@ void TestLanguageMode(const char* source,
 
   i::Handle<i::Script> script =
       factory->NewScript(factory->NewStringFromAsciiChecked(source));
-  i::ParseInfo info(script);
+  i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
+  i::ParseInfo info(&zone, script);
   i::parsing::ParseProgram(&info);
   CHECK(info.literal() != NULL);
   CHECK_EQ(expected_language_mode, info.literal()->language_mode());
@@ -8942,7 +8956,8 @@ TEST(NoPessimisticContextAllocation) {
       printf("\n");
 
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::ParseInfo info(script);
+      i::Zone zone(isolate->allocator(), ZONE_NAME);
+      i::ParseInfo info(&zone, script);
 
       CHECK(i::parsing::ParseProgram(&info));
       CHECK(i::Compiler::Analyze(&info));

test/fuzzer/parser.cc

@@ -35,7 +35,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
   v8::internal::Handle<v8::internal::Script> script =
       factory->NewScript(source.ToHandleChecked());
-  v8::internal::ParseInfo info(script);
+  v8::internal::Zone zone(i_isolate->allocator(), ZONE_NAME);
+  v8::internal::ParseInfo info(&zone, script);
   v8::internal::parsing::ParseProgram(&info);
   isolate->RequestGarbageCollectionForTesting(
       v8::Isolate::kFullGarbageCollection);

tools/parser-shell.cc

@@ -94,7 +94,8 @@ std::pair<v8::base::TimeDelta, v8::base::TimeDelta> RunBaselineParser(
   i::ScriptData* cached_data_impl = NULL;
   // First round of parsing (produce data to cache).
   {
-    ParseInfo info(script);
+    Zone zone(reinterpret_cast<i::Isolate*>(isolate)->allocator(), ZONE_NAME);
+    ParseInfo info(&zone, script);
     info.set_cached_data(&cached_data_impl);
     info.set_compile_options(v8::ScriptCompiler::kProduceParserCache);
     v8::base::ElapsedTimer timer;
@@ -108,7 +109,8 @@ std::pair<v8::base::TimeDelta, v8::base::TimeDelta> RunBaselineParser(
   }
   // Second round of parsing (consume cached data).
   {
-    ParseInfo info(script);
+    Zone zone(reinterpret_cast<i::Isolate*>(isolate)->allocator(), ZONE_NAME);
+    ParseInfo info(&zone, script);
     info.set_cached_data(&cached_data_impl);
     info.set_compile_options(v8::ScriptCompiler::kConsumeParserCache);
     v8::base::ElapsedTimer timer;