Reland: [Parse] ParseInfo owns the parsing Zone.

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 786 matching lines @@
       int kProgramByteSize = i::StrLength(surroundings[j].prefix) +
                              i::StrLength(surroundings[j].suffix) +
                              i::StrLength(source_data[i].body);
       i::ScopedVector<char> program(kProgramByteSize + 1);
       i::SNPrintF(program, "%s%s%s", surroundings[j].prefix,
                   source_data[i].body, surroundings[j].suffix);
       i::Handle<i::String> source =
           factory->NewStringFromUtf8(i::CStrVector(program.start()))
               .ToHandleChecked();
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-      i::ParseInfo info(&zone, script);
+      i::ParseInfo info(script);
       // The information we're checking is only produced when eager parsing.
       info.set_allow_lazy_parsing(false);
       CHECK(i::parsing::ParseProgram(&info));
       CHECK(i::Rewriter::Rewrite(&info));
       i::DeclarationScope::Analyze(&info, i::AnalyzeMode::kRegular);
       CHECK(info.literal() != NULL);
 
       i::DeclarationScope* script_scope = info.literal()->scope();
       CHECK(script_scope->is_script_scope());
 
@@ skipping 35 matching lines @@
   std::string full_source = "function f() { return ";
   full_source += source;
   full_source += "; }";
 
   i::Handle<i::String> source_code =
       factory->NewStringFromUtf8(i::CStrVector(full_source.c_str()))
           .ToHandleChecked();
 
   i::Handle<i::Script> script = factory->NewScript(source_code);
 
-  i::ParseInfo info(handles.main_zone(), script);
+  i::ParseInfo info(script);
   i::Parser parser(&info);
   info.set_allow_lazy_parsing(false);
   info.set_toplevel(true);
 
   CHECK(i::Compiler::ParseAndAnalyze(&info));
 
   CHECK_EQ(1, info.scope()->declarations()->LengthForTest());
   i::Declaration* decl = info.scope()->declarations()->AtForTest(0);
   i::FunctionLiteral* fun = decl->AsFunctionDeclaration()->fun();
   CHECK(fun->body()->length() == 1);
@@ skipping 277 matching lines @@
     i::SNPrintF(program, "%s%s%s",
                          source_data[i].outer_prefix,
                          source_data[i].inner_source,
                          source_data[i].outer_suffix);
 
     // Parse program source.
     i::Handle<i::String> source = factory->NewStringFromUtf8(
         i::CStrVector(program.start())).ToHandleChecked();
     CHECK_EQ(source->length(), kProgramSize);
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-    i::ParseInfo info(&zone, script);
+    i::ParseInfo info(script);
     info.set_language_mode(source_data[i].language_mode);
     i::parsing::ParseProgram(&info);
     CHECK_NOT_NULL(info.literal());
 
     // Check scope types and positions.
     i::Scope* scope = info.literal()->scope();
     CHECK(scope->is_script_scope());
     CHECK_EQ(scope->start_position(), 0);
     CHECK_EQ(scope->end_position(), kProgramSize);
 
@@ skipping 25 matching lines @@
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
   v8::HandleScope handles(CcTest::isolate());
   i::FunctionLiteral* function;
 
   for (int i = 0; discard_sources[i]; i++) {
     const char* source = discard_sources[i];
     i::Handle<i::String> source_code =
         factory->NewStringFromUtf8(i::CStrVector(source)).ToHandleChecked();
     i::Handle<i::Script> script = factory->NewScript(source_code);
-    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-    i::ParseInfo info(&zone, script);
+    i::ParseInfo info(script);
     i::parsing::ParseProgram(&info);
     function = info.literal();
     CHECK_NOT_NULL(function);
     CHECK_NOT_NULL(function->body());
     CHECK_EQ(1, function->body()->length());
     i::FunctionLiteral* inner =
         function->body()->first()->AsExpressionStatement()->expression()->
         AsCall()->expression()->AsFunctionLiteral();
     i::Scope* inner_scope = inner->scope();
     i::FunctionLiteral* fun = nullptr;
@@ skipping 109 matching lines @@
     scanner.Initialize(stream.get());
     i::PreParser::PreParseResult result =
         preparser.PreParseProgram(&preparser_materialized_literals, is_module);
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   }
 
   // Parse the data
   i::FunctionLiteral* function;
   {
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-    i::ParseInfo info(&zone, script);
+    i::ParseInfo info(script);
     info.set_allow_lazy_parsing(flags.Contains(kAllowLazy));
     SetGlobalFlags(flags);
     if (is_module) info.set_module();
     i::parsing::ParseProgram(&info);
     function = info.literal();
     if (function) {
       parser_materialized_literals = function->materialized_literal_count();
     }
   }
 
@@ skipping 1106 matching lines @@
     {"function lazy() { var x = {get foo(){} } }", 1},
     {NULL, 0}
   };
 
   for (int i = 0; test_cases[i].program; i++) {
     const char* program = test_cases[i].program;
     i::Factory* factory = CcTest::i_isolate()->factory();
     i::Handle<i::String> source =
         factory->NewStringFromUtf8(i::CStrVector(program)).ToHandleChecked();
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-    i::ParseInfo info(&zone, script);
+    i::ParseInfo info(script);
     i::ScriptData* sd = NULL;
     info.set_cached_data(&sd);
     info.set_compile_options(v8::ScriptCompiler::kProduceParserCache);
     i::parsing::ParseProgram(&info);
     i::ParseData* pd = i::ParseData::FromCachedData(sd);
 
     if (pd->FunctionCount() != test_cases[i].functions) {
       v8::base::OS::Print(
           "Expected preparse data for program:\n"
           "\t%s\n"
@@ skipping 866 matching lines @@
         if (outers[i].strict && inners[j].with) continue;
         const char* inner = inners[j].source;
         int inner_len = Utf8LengthHelper(inner);
 
         int len = prefix_len + outer_len + midfix_len + inner_len + suffix_len;
         i::ScopedVector<char> program(len + 1);
 
         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());
           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(&zone, shared));
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(shared));
           CHECK(i::parsing::ParseFunction(info.get()));
         } else {
           i::Handle<i::String> source =
               factory->InternalizeUtf8String(program.start());
           source->PrintOn(stdout);
           printf("\n");
           i::Handle<i::Script> script = factory->NewScript(source);
-          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(&zone, script));
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(script));
           info->set_allow_lazy_parsing(false);
           CHECK(i::parsing::ParseProgram(info.get()));
         }
         CHECK(i::Compiler::Analyze(info.get()));
         CHECK(info->literal() != NULL);
 
         i::Scope* scope = info->literal()->scope();
         if (!lazy) {
           scope = scope->inner_scope();
         }
@@ skipping 78 matching lines @@
 
   const char* suffix = "; f";
 
   for (unsigned i = 0; i < arraysize(tests); ++i) {
     bool assigned = tests[i].arg_assigned;
     const char* source = tests[i].source;
     for (unsigned allow_lazy = 0; allow_lazy < 2; ++allow_lazy) {
       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(&zone, shared));
+      info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(shared));
       info->set_allow_lazy_parsing(allow_lazy);
       CHECK(i::parsing::ParseFunction(info.get()));
       CHECK(i::Compiler::Analyze(info.get()));
       CHECK_NOT_NULL(info->literal());
 
       i::Scope* scope = info->literal()->scope();
       CHECK(!scope->AsDeclarationScope()->was_lazily_parsed());
       CHECK_NULL(scope->sibling());
       CHECK(scope->is_function_scope());
       const i::AstRawString* var_name =
           info->ast_value_factory()->GetOneByteString("arg");
       i::Variable* var = scope->Lookup(var_name);
       CHECK(var->is_used() || !assigned);
       bool is_maybe_assigned = var->maybe_assigned() == i::kMaybeAssigned;
       CHECK_EQ(is_maybe_assigned, assigned);
     }
   }
 }
 
 struct Input {
   bool assigned;
   std::string source;
   std::vector<unsigned> location;  // "Directions" to the relevant scope.
 };
 
-static void TestMaybeAssigned(i::Zone* zone, Input input, const char* variable,
-                              bool module, bool allow_lazy_parsing) {
+static void TestMaybeAssigned(Input input, const char* variable, bool module,
+                              bool allow_lazy_parsing) {
   i::Factory* factory = CcTest::i_isolate()->factory();
   i::Handle<i::String> string =
       factory->InternalizeUtf8String(input.source.c_str());
   string->PrintOn(stdout);
   printf("\n");
   i::Handle<i::Script> script = factory->NewScript(string);
 
   std::unique_ptr<i::ParseInfo> info;
-  info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(zone, script));
+  info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(script));
   info->set_module(module);
   info->set_allow_lazy_parsing(allow_lazy_parsing);
 
   CHECK(i::parsing::ParseProgram(info.get()));
   CHECK(i::Compiler::Analyze(info.get()));
 
   CHECK_NOT_NULL(info->literal());
   i::Scope* scope = info->literal()->scope();
   CHECK(!scope->AsDeclarationScope()->was_lazily_parsed());
   CHECK_NULL(scope->sibling());
@@ skipping 28 matching lines @@
   for (auto n : input.location) {
     result.location.push_back(n);
   }
   return result;
 }
 
 TEST(MaybeAssignedInsideLoop) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::HandleScope scope(isolate);
   LocalContext env;
-  i::Zone zone(isolate->allocator(), ZONE_NAME);
 
   std::vector<unsigned> top;  // Can't use {} in initializers below.
 
   Input module_and_script_tests[] = {
       {1, "for (j=x; j<10; ++j) { foo = j }", top},
       {1, "for (j=x; j<10; ++j) { [foo] = [j] }", top},
       {1, "for (j=x; j<10; ++j) { var foo = j }", top},
       {1, "for (j=x; j<10; ++j) { var [foo] = [j] }", top},
       {0, "for (j=x; j<10; ++j) { let foo = j }", {0}},
       {0, "for (j=x; j<10; ++j) { let [foo] = [j] }", {0}},
@@ skipping 257 matching lines @@
       {1, "for (const {j} in x) { function foo() {return j} }", top},
       {1, "while (j) { function foo() {return j} }", top},
       {1, "do { function foo() {return j} } while (j)", top},
   };
 
   for (unsigned i = 0; i < arraysize(module_and_script_tests); ++i) {
     Input input = module_and_script_tests[i];
     for (unsigned module = 0; module <= 1; ++module) {
       for (unsigned allow_lazy_parsing = 0; allow_lazy_parsing <= 1;
            ++allow_lazy_parsing) {
-        TestMaybeAssigned(&zone, input, "foo", module, allow_lazy_parsing);
+        TestMaybeAssigned(input, "foo", module, allow_lazy_parsing);
       }
-      TestMaybeAssigned(&zone, wrap(input), "foo", module, false);
+      TestMaybeAssigned(wrap(input), "foo", module, false);
     }
   }
 
   for (unsigned i = 0; i < arraysize(script_only_tests); ++i) {
     Input input = script_only_tests[i];
     for (unsigned allow_lazy_parsing = 0; allow_lazy_parsing <= 1;
          ++allow_lazy_parsing) {
-      TestMaybeAssigned(&zone, input, "foo", false, allow_lazy_parsing);
+      TestMaybeAssigned(input, "foo", false, allow_lazy_parsing);
     }
-    TestMaybeAssigned(&zone, wrap(input), "foo", false, false);
+    TestMaybeAssigned(wrap(input), "foo", false, false);
   }
 }
 
 TEST(MaybeAssignedTopLevel) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::HandleScope scope(isolate);
   LocalContext env;
   i::Factory* factory = isolate->factory();
 
   const char* prefixes[] = {
@@ skipping 11 matching lines @@
       "function* bar() {eval(ext)}; ext(bar); ext(foo)",
   };
 
   for (unsigned i = 0; i < arraysize(prefixes); ++i) {
     const char* prefix = prefixes[i];
     for (unsigned j = 0; j < arraysize(sources); ++j) {
       const char* source = sources[j];
       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());
       string->PrintOn(stdout);
       printf("\n");
       i::Handle<i::Script> script = factory->NewScript(string);
 
       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(&zone, script));
+          info = std::unique_ptr<i::ParseInfo>(new i::ParseInfo(script));
           info->set_module(module);
           info->set_allow_lazy_parsing(allow_lazy);
 
           CHECK(i::parsing::ParseProgram(info.get()));
           CHECK(i::Compiler::Analyze(info.get()));
 
           CHECK_NOT_NULL(info->literal());
           i::Scope* scope = info->literal()->scope();
           CHECK(!scope->AsDeclarationScope()->was_lazily_parsed());
           CHECK_NULL(scope->sibling());
@@ skipping 2432 matching lines @@
   isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
                                         128 * 1024);
 
   for (unsigned i = 0; i < arraysize(kSources); ++i) {
     i::Handle<i::String> source =
         factory->NewStringFromAsciiChecked(kSources[i]);
 
     // Show that parsing as a module works
     {
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-      i::ParseInfo info(&zone, script);
+      i::ParseInfo info(script);
       info.set_module();
       if (!i::parsing::ParseProgram(&info)) {
         i::Handle<i::JSObject> exception_handle(
             i::JSObject::cast(isolate->pending_exception()));
         i::Handle<i::String> message_string = i::Handle<i::String>::cast(
             i::JSReceiver::GetProperty(isolate, exception_handle, "message")
                 .ToHandleChecked());
         isolate->clear_pending_exception();
 
         v8::base::OS::Print(
             "Parser failed on:\n"
             "\t%s\n"
             "with error:\n"
             "\t%s\n"
             "However, we expected no error.",
             source->ToCString().get(), message_string->ToCString().get());
         CHECK(false);
       }
     }
 
     // And that parsing a script does not.
     {
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-      i::ParseInfo info(&zone, script);
+      i::ParseInfo info(script);
       CHECK(!i::parsing::ParseProgram(&info));
       isolate->clear_pending_exception();
     }
   }
 }
 
 
 TEST(ImportExportParsingErrors) {
   // clang-format off
   const char* kErrorSources[] = {
@@ skipping 69 matching lines @@
   v8::Context::Scope context_scope(context);
 
   isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
                                         128 * 1024);
 
   for (unsigned i = 0; i < arraysize(kErrorSources); ++i) {
     i::Handle<i::String> source =
         factory->NewStringFromAsciiChecked(kErrorSources[i]);
 
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-    i::ParseInfo info(&zone, script);
+    i::ParseInfo info(script);
     info.set_module();
     CHECK(!i::parsing::ParseProgram(&info));
     isolate->clear_pending_exception();
   }
 }
 
 TEST(ModuleTopLevelFunctionDecl) {
   // clang-format off
   const char* kErrorSources[] = {
       "function f() {} function f() {}",
@@ skipping 15 matching lines @@
   v8::Context::Scope context_scope(context);
 
   isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
                                         128 * 1024);
 
   for (unsigned i = 0; i < arraysize(kErrorSources); ++i) {
     i::Handle<i::String> source =
         factory->NewStringFromAsciiChecked(kErrorSources[i]);
 
     i::Handle<i::Script> script = factory->NewScript(source);
-    i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-    i::ParseInfo info(&zone, script);
+    i::ParseInfo info(script);
     info.set_module();
     CHECK(!i::parsing::ParseProgram(&info));
     isolate->clear_pending_exception();
   }
 }
 
 TEST(ModuleAwaitReserved) {
   // clang-format off
   const char* kErrorSources[] = {
       "await;",
@@ skipping 176 matching lines @@
       "import 'q.js';"
       "let nonexport = 42;"
       "import {m as mm} from 'm.js';"
       "import {aa} from 'm.js';"
       "export {aa as bb, x};"
       "import * as loo from 'bar.js';"
       "import * as foob from 'bar.js';"
       "export {foob};";
   i::Handle<i::String> source = factory->NewStringFromAsciiChecked(kSource);
   i::Handle<i::Script> script = factory->NewScript(source);
-  i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-  i::ParseInfo info(&zone, script);
+  i::ParseInfo info(script);
   info.set_module();
   CHECK(i::parsing::ParseProgram(&info));
   CHECK(i::Compiler::Analyze(&info));
   i::FunctionLiteral* func = info.literal();
   i::ModuleScope* module_scope = func->scope()->AsModuleScope();
   i::Scope* outer_scope = module_scope->outer_scope();
   CHECK(outer_scope->is_script_scope());
   CHECK_NULL(outer_scope->outer_scope());
   CHECK(module_scope->is_module_scope());
   const i::ModuleDescriptor::Entry* entry;
@@ skipping 238 matching lines @@
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
   v8::HandleScope handles(CcTest::isolate());
   v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
   v8::Context::Scope context_scope(context);
   isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
                                         128 * 1024);
 
   i::Handle<i::Script> script =
       factory->NewScript(factory->NewStringFromAsciiChecked(source));
-  i::Zone zone(CcTest::i_isolate()->allocator(), ZONE_NAME);
-  i::ParseInfo info(&zone, script);
+  i::ParseInfo info(script);
   i::parsing::ParseProgram(&info);
   CHECK(info.literal() != NULL);
   CHECK_EQ(expected_language_mode, info.literal()->language_mode());
 }
 
 
 TEST(LanguageModeDirectives) {
   TestLanguageMode("\"use nothing\"", i::SLOPPY);
   TestLanguageMode("\"use strict\"", i::STRICT);
 
@@ skipping 2453 matching lines @@
       i::SNPrintF(
           program + prefix_len + inner_function_len + params_len + source_len,
           "%s", suffix);
 
       i::Handle<i::String> source =
           factory->InternalizeUtf8String(program.start());
       source->PrintOn(stdout);
       printf("\n");
 
       i::Handle<i::Script> script = factory->NewScript(source);
-      i::Zone zone(isolate->allocator(), ZONE_NAME);
-      i::ParseInfo info(&zone, script);
+      i::ParseInfo info(script);
 
       CHECK(i::parsing::ParseProgram(&info));
       CHECK(i::Compiler::Analyze(&info));
       CHECK(info.literal() != NULL);
 
       i::Scope* scope = info.literal()->scope()->inner_scope();
       DCHECK_NOT_NULL(scope);
       DCHECK_NULL(scope->sibling());
       DCHECK(scope->is_function_scope());
       const i::AstRawString* var_name =
           info.ast_value_factory()->GetOneByteString("my_var");
       i::Variable* var = scope->Lookup(var_name);
       CHECK_EQ(inners[i].ctxt_allocate,
                i::ScopeTestHelper::MustAllocateInContext(var));
     }
   }
 }