Reland: [Parse] ParseInfo owns the parsing Zone.

test/cctest/asmjs/test-asm-typer.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 <cstring>
 #include <functional>
 #include <iostream>
 #include <memory>
 
 #include "src/asmjs/asm-typer.h"
@@ skipping 27 matching lines @@
   ValidateExpression,
 };
 }  // namespace
 
 class AsmTyperHarnessBuilder {
  public:
   AsmTyperHarnessBuilder(const char* source, ValidationType type)
       : 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_)) {
-    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);
+        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)) {
+    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) {
       fun_scope_.reset(new AsmTyper::FunctionScope(typer_.get()));
 
       for (Declaration* decl : *module_->scope()->declarations()) {
         if (FunctionDeclaration* fun_decl = decl->AsFunctionDeclaration()) {
           fun_decl_ = fun_decl;
           break;
         }
@@ skipping 12 matching lines @@
     const VariableMode mode_;
   };
 
   AsmTyperHarnessBuilder* WithLocal(VariableName var_name, AsmType* type) {
     CHECK(validation_type_ == ValidateStatement ||
           validation_type_ == ValidateExpression);
     auto* var = DeclareVariable(var_name);
     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;
   }
 
   AsmTyperHarnessBuilder* WithGlobal(VariableName var_name, AsmType* type) {
     auto* var = DeclareVariable(var_name);
     if (var->IsUnallocated()) {
       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));
     }
     return this;
   }
 
   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);
     auto* var_info = typer_->Lookup(DeclareVariable(var_name));
     CHECK(var_info);
     MessageLocation location;
     var_info->SetFirstForwardUse(location);
     return this;
   }
 
   AsmTyperHarnessBuilder* WithImport(VariableName var_name,
                                      AsmTyper::StandardMember standard_member) {
     auto* var = DeclareVariable(var_name);
     if (var->IsUnallocated()) {
       var->AllocateTo(VariableLocation::LOCAL, -1);
     }
     AsmTyper::VariableInfo* var_info = nullptr;
     auto* stdlib_map = &typer_->stdlib_math_types_;
     switch (standard_member) {
       case AsmTyper::kHeap:
       case AsmTyper::kStdlib:
       case AsmTyper::kModule:
       case AsmTyper::kNone:
         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:
       case AsmTyper::kNaN:
         stdlib_map = &typer_->stdlib_types_;
       default:
         break;
     }
 
     if (var_info == nullptr) {
       for (auto iter : *stdlib_map) {
         if (iter.second->standard_member() == standard_member) {
           var_info = iter.second;
           break;
         }
       }
 
       CHECK(var_info != nullptr);
-      var_info = var_info->Clone(zone_);
+      var_info = var_info->Clone(zone());
     }
 
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
 
   AsmTyperHarnessBuilder* WithReturnType(AsmType* type) {
     CHECK(type->IsReturnType());
     CHECK(typer_->return_type_ == AsmType::None());
     typer_->return_type_ = type;
     return this;
   }
 
   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;
   }
 
   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;
   }
 
   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;
   }
 
   bool Succeeds() {
     CHECK(validation_type_ == ValidateModule ||
           validation_type_ == ValidateGlobals ||
           validation_type_ == ValidateFunctionTables ||
           validation_type_ == ValidateExport ||
           validation_type_ == ValidateFunction ||
@@ skipping 75 matching lines @@
     ast_value_factory_.Internalize(isolate_);
     return var_name.mode_ == DYNAMIC_GLOBAL
                ? outer_scope_->DeclareDynamicGlobal(name_ast_string,
                                                     NORMAL_VARIABLE)
                : module_->scope()->DeclareLocal(name_ast_string, VAR,
                                                 kCreatedInitialized,
                                                 NORMAL_VARIABLE);
   }
 
   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;
       }
     }
     return true;
   }
 
   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()) {
       if (auto* expr_stmt = curr->AsExpressionStatement()) {
         last_was_expression_statement = true;
         if ((ret = typer_->ValidateExpression(expr_stmt->expression())) ==
             AsmType::None()) {
           break;
         }
       } else {
         ret = AsmType::None();
         last_was_expression_statement = true;
         if (typer_->ValidateStatement(curr) == AsmType::None()) {
           break;
         }
       }
     }
     CHECK(last_was_expression_statement || ret == AsmType::None());
     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_;
   FunctionDeclaration* fun_decl_;
   std::unique_ptr<AsmTyper> typer_;
   std::unique_ptr<AsmTyper::FunctionScope> fun_scope_;
 };
 
 }  // namespace wasm
 }  // namespace internal
@@ skipping 1719 matching lines @@
     if (!ValidationOf(Module(kTests[ii]))
              ->FailsWithMessage(
                  "Constant in return must be signed, float, or double.")) {
       std::cerr << "Test:\n" << kTests[ii];
       CHECK(false);
     }
   }
 }
 
 }  // namespace