Parser: store parameters in a ThreadedList instead of ZoneList.

src/parsing/parser-base.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 39 matching lines @@
   lhs = lhs | rhs;
   return lhs;
 }
 
 static inline bool operator&(ParseFunctionFlags bitfield,
                              ParseFunctionFlags mask) {
   typedef unsigned char T;
   return static_cast<T>(bitfield) & static_cast<T>(mask);
 }
 
-struct FormalParametersBase {
+struct FormalParametersBase : public ZoneObject {
   explicit FormalParametersBase(DeclarationScope* scope) : scope(scope) {}
 
   int num_parameters() const {
     // Don't include the rest parameter into the function's formal parameter
     // count (esp. the SharedFunctionInfo::internal_formal_parameter_count,
     // which says whether we need to create an arguments adaptor frame).
     return arity - has_rest;
   }
 
   void UpdateArityAndFunctionLength(bool is_optional, bool is_rest) {
@@ skipping 2580 matching lines @@
     DeclarationScope* scope =
         NewFunctionScope(is_async ? FunctionKind::kAsyncArrowFunction
                                   : FunctionKind::kArrowFunction);
     // Because the arrow's parameters were parsed in the outer scope, any
     // usage flags that might have been triggered there need to be copied
     // to the arrow scope.
     this->scope()->PropagateUsageFlagsToScope(scope);
 
     scope_snapshot.Reparent(scope);
 
-    FormalParametersT parameters(scope);
+    FormalParametersT* parameters = new (zone()) FormalParametersT(scope);
     if (!classifier()->is_simple_parameter_list()) {
       scope->SetHasNonSimpleParameters();
-      parameters.is_simple = false;
+      parameters->is_simple = false;
     }
 
-    checkpoint.Restore(&parameters.materialized_literals_count);
+    checkpoint.Restore(&parameters->materialized_literals_count);
 
     scope->set_start_position(lhs_beg_pos);
     Scanner::Location duplicate_loc = Scanner::Location::invalid();
-    impl()->DeclareArrowFunctionFormalParameters(&parameters, expression, loc,
+    impl()->DeclareArrowFunctionFormalParameters(parameters, expression, loc,
                                                  &duplicate_loc, CHECK_OK);
     if (duplicate_loc.IsValid()) {
       classifier()->RecordDuplicateFormalParameterError(duplicate_loc);
     }
-    expression = ParseArrowFunctionLiteral(accept_IN, parameters, CHECK_OK);
+    expression = ParseArrowFunctionLiteral(accept_IN, *parameters, CHECK_OK);
     impl()->Discard();
     classifier()->RecordPatternError(arrow_loc,
                                      MessageTemplate::kUnexpectedToken,
                                      Token::String(Token::ARROW));
 
     if (fni_ != nullptr) fni_->Infer();
 
     return expression;
   }
 
@@ skipping 806 matching lines @@
         break;
       }
       if (!Check(Token::COMMA)) break;
       if (allow_harmony_trailing_commas() && peek() == Token::RPAREN) {
         // allow the trailing comma
         break;
       }
     }
   }
 
-  for (int i = 0; i < parameters->arity; ++i) {
-    auto parameter = parameters->at(i);
-    impl()->DeclareFormalParameter(parameters->scope, parameter);
-  }
+  impl()->DeclareFormalParameters(parameters->scope, parameters->params);
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::BlockT ParserBase<Impl>::ParseVariableDeclarations(
     VariableDeclarationContext var_context,
     DeclarationParsingResult* parsing_result,
     ZoneList<const AstRawString*>* names, bool* ok) {
   // VariableDeclarations ::
   //   ('var' | 'const' | 'let') (Identifier ('=' AssignmentExpression)?)+[',']
   //
@@ skipping 1940 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H