LCOV - code coverage report
Current view: top level - src/parsing - preparser.h (source / functions) Hit Total Coverage
Test: app.info Lines: 234 239 97.9 %
Date: 2017-04-26 Functions: 40 41 97.6 %

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_PARSING_PREPARSER_H
       6             : #define V8_PARSING_PREPARSER_H
       7             : 
       8             : #include "src/ast/ast.h"
       9             : #include "src/ast/scopes.h"
      10             : #include "src/parsing/parser-base.h"
      11             : #include "src/parsing/preparse-data.h"
      12             : #include "src/pending-compilation-error-handler.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : // Whereas the Parser generates AST during the recursive descent,
      18             : // the PreParser doesn't create a tree. Instead, it passes around minimal
      19             : // data objects (PreParserExpression, PreParserIdentifier etc.) which contain
      20             : // just enough data for the upper layer functions. PreParserFactory is
      21             : // responsible for creating these dummy objects. It provides a similar kind of
      22             : // interface as AstNodeFactory, so ParserBase doesn't need to care which one is
      23             : // used.
      24             : 
      25             : class PreParserIdentifier {
      26             :  public:
      27             :   PreParserIdentifier() : type_(kUnknownIdentifier) {}
      28      924890 :   static PreParserIdentifier Default() {
      29      924890 :     return PreParserIdentifier(kUnknownIdentifier);
      30             :   }
      31     2211516 :   static PreParserIdentifier Empty() {
      32     2211516 :     return PreParserIdentifier(kEmptyIdentifier);
      33             :   }
      34             :   static PreParserIdentifier Eval() {
      35             :     return PreParserIdentifier(kEvalIdentifier);
      36             :   }
      37             :   static PreParserIdentifier Arguments() {
      38             :     return PreParserIdentifier(kArgumentsIdentifier);
      39             :   }
      40             :   static PreParserIdentifier Undefined() {
      41             :     return PreParserIdentifier(kUndefinedIdentifier);
      42             :   }
      43             :   static PreParserIdentifier FutureReserved() {
      44             :     return PreParserIdentifier(kFutureReservedIdentifier);
      45             :   }
      46             :   static PreParserIdentifier FutureStrictReserved() {
      47             :     return PreParserIdentifier(kFutureStrictReservedIdentifier);
      48             :   }
      49             :   static PreParserIdentifier Let() {
      50             :     return PreParserIdentifier(kLetIdentifier);
      51             :   }
      52             :   static PreParserIdentifier Static() {
      53             :     return PreParserIdentifier(kStaticIdentifier);
      54             :   }
      55             :   static PreParserIdentifier Yield() {
      56             :     return PreParserIdentifier(kYieldIdentifier);
      57             :   }
      58             :   static PreParserIdentifier Prototype() {
      59             :     return PreParserIdentifier(kPrototypeIdentifier);
      60             :   }
      61             :   static PreParserIdentifier Constructor() {
      62             :     return PreParserIdentifier(kConstructorIdentifier);
      63             :   }
      64             :   static PreParserIdentifier Enum() {
      65             :     return PreParserIdentifier(kEnumIdentifier);
      66             :   }
      67             :   static PreParserIdentifier Await() {
      68             :     return PreParserIdentifier(kAwaitIdentifier);
      69             :   }
      70             :   static PreParserIdentifier Async() {
      71             :     return PreParserIdentifier(kAsyncIdentifier);
      72             :   }
      73             :   static PreParserIdentifier Name() {
      74             :     return PreParserIdentifier(kNameIdentifier);
      75             :   }
      76           0 :   bool IsEmpty() const { return type_ == kEmptyIdentifier; }
      77     1773439 :   bool IsEval() const { return type_ == kEvalIdentifier; }
      78             :   bool IsArguments() const { return type_ == kArgumentsIdentifier; }
      79    30317349 :   bool IsEvalOrArguments() const { return IsEval() || IsArguments(); }
      80             :   bool IsUndefined() const { return type_ == kUndefinedIdentifier; }
      81             :   bool IsLet() const { return type_ == kLetIdentifier; }
      82             :   bool IsStatic() const { return type_ == kStaticIdentifier; }
      83             :   bool IsYield() const { return type_ == kYieldIdentifier; }
      84             :   bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
      85       14424 :   bool IsConstructor() const { return type_ == kConstructorIdentifier; }
      86             :   bool IsEnum() const { return type_ == kEnumIdentifier; }
      87             :   bool IsAwait() const { return type_ == kAwaitIdentifier; }
      88       10887 :   bool IsName() const { return type_ == kNameIdentifier; }
      89             : 
      90             :   // Allow identifier->name()[->length()] to work. The preparser
      91             :   // does not need the actual positions/lengths of the identifiers.
      92             :   const PreParserIdentifier* operator->() const { return this; }
      93             :   const PreParserIdentifier raw_name() const { return *this; }
      94             : 
      95             :   int position() const { return 0; }
      96             :   int length() const { return 0; }
      97             : 
      98             :  private:
      99             :   enum Type {
     100             :     kEmptyIdentifier,
     101             :     kUnknownIdentifier,
     102             :     kFutureReservedIdentifier,
     103             :     kFutureStrictReservedIdentifier,
     104             :     kLetIdentifier,
     105             :     kStaticIdentifier,
     106             :     kYieldIdentifier,
     107             :     kEvalIdentifier,
     108             :     kArgumentsIdentifier,
     109             :     kUndefinedIdentifier,
     110             :     kPrototypeIdentifier,
     111             :     kConstructorIdentifier,
     112             :     kEnumIdentifier,
     113             :     kAwaitIdentifier,
     114             :     kAsyncIdentifier,
     115             :     kNameIdentifier
     116             :   };
     117             : 
     118             :   explicit PreParserIdentifier(Type type) : type_(type), string_(nullptr) {}
     119             :   Type type_;
     120             :   // Only non-nullptr when PreParser.track_unresolved_variables_ is true.
     121             :   const AstRawString* string_;
     122             :   friend class PreParserExpression;
     123             :   friend class PreParser;
     124             :   friend class PreParserFactory;
     125             : };
     126             : 
     127             : 
     128             : class PreParserExpression {
     129             :  public:
     130             :   PreParserExpression()
     131     3450389 :       : code_(TypeField::encode(kEmpty)), variables_(nullptr) {}
     132             : 
     133    32039765 :   static PreParserExpression Empty() { return PreParserExpression(); }
     134             : 
     135    12141781 :   static PreParserExpression Default(
     136             :       ZoneList<VariableProxy*>* variables = nullptr) {
     137    12141781 :     return PreParserExpression(TypeField::encode(kExpression), variables);
     138             :   }
     139             : 
     140             :   static PreParserExpression Spread(PreParserExpression expression) {
     141             :     return PreParserExpression(TypeField::encode(kSpreadExpression),
     142             :                                expression.variables_);
     143             :   }
     144             : 
     145    28362985 :   static PreParserExpression FromIdentifier(PreParserIdentifier id,
     146             :                                             VariableProxy* variable,
     147             :                                             Zone* zone) {
     148             :     PreParserExpression expression(TypeField::encode(kIdentifierExpression) |
     149    56725970 :                                    IdentifierTypeField::encode(id.type_));
     150    28362985 :     expression.AddVariable(variable, zone);
     151    28362977 :     return expression;
     152             :   }
     153             : 
     154     3736173 :   static PreParserExpression BinaryOperation(PreParserExpression left,
     155             :                                              Token::Value op,
     156             :                                              PreParserExpression right,
     157             :                                              Zone* zone) {
     158     3736173 :     if (op == Token::COMMA) {
     159             :       // Possibly an arrow function parameter list.
     160      202419 :       if (left.variables_ == nullptr) {
     161             :         return PreParserExpression(TypeField::encode(kExpression),
     162      193063 :                                    right.variables_);
     163             :       }
     164        9356 :       if (right.variables_ != nullptr) {
     165       19697 :         for (auto variable : *right.variables_) {
     166             :           left.variables_->Add(variable, zone);
     167             :         }
     168             :       }
     169             :       return PreParserExpression(TypeField::encode(kExpression),
     170        9356 :                                  left.variables_);
     171             :     }
     172     3533754 :     return PreParserExpression(TypeField::encode(kExpression));
     173             :   }
     174             : 
     175             :   static PreParserExpression Assignment(ZoneList<VariableProxy*>* variables) {
     176             :     return PreParserExpression(TypeField::encode(kExpression) |
     177             :                                    ExpressionTypeField::encode(kAssignment),
     178             :                                variables);
     179             :   }
     180             : 
     181        4268 :   static PreParserExpression NewTargetExpression() {
     182             :     return PreParserExpression(TypeField::encode(kExpression) |
     183        4268 :                                ExpressionTypeField::encode(kNewTarget));
     184             :   }
     185             : 
     186             :   static PreParserExpression ObjectLiteral(
     187             :       ZoneList<VariableProxy*>* variables) {
     188             :     return PreParserExpression(TypeField::encode(kObjectLiteralExpression),
     189             :                                variables);
     190             :   }
     191             : 
     192             :   static PreParserExpression ArrayLiteral(ZoneList<VariableProxy*>* variables) {
     193             :     return PreParserExpression(TypeField::encode(kArrayLiteralExpression),
     194             :                                variables);
     195             :   }
     196             : 
     197     3090024 :   static PreParserExpression StringLiteral() {
     198     3090024 :     return PreParserExpression(TypeField::encode(kStringLiteralExpression));
     199             :   }
     200             : 
     201      233029 :   static PreParserExpression UseStrictStringLiteral() {
     202             :     return PreParserExpression(TypeField::encode(kStringLiteralExpression) |
     203      233029 :                                IsUseStrictField::encode(true));
     204             :   }
     205             : 
     206             :   static PreParserExpression UseAsmStringLiteral() {
     207             :     return PreParserExpression(TypeField::encode(kStringLiteralExpression) |
     208             :                                IsUseAsmField::encode(true));
     209             :   }
     210             : 
     211      175561 :   static PreParserExpression This(ZoneList<VariableProxy*>* variables) {
     212             :     return PreParserExpression(TypeField::encode(kExpression) |
     213             :                                    ExpressionTypeField::encode(kThisExpression),
     214      175561 :                                variables);
     215             :   }
     216             : 
     217             :   static PreParserExpression ThisProperty() {
     218             :     return PreParserExpression(
     219             :         TypeField::encode(kExpression) |
     220             :         ExpressionTypeField::encode(kThisPropertyExpression));
     221             :   }
     222             : 
     223             :   static PreParserExpression Property() {
     224             :     return PreParserExpression(
     225             :         TypeField::encode(kExpression) |
     226             :         ExpressionTypeField::encode(kPropertyExpression));
     227             :   }
     228             : 
     229             :   static PreParserExpression Call() {
     230             :     return PreParserExpression(TypeField::encode(kExpression) |
     231             :                                ExpressionTypeField::encode(kCallExpression));
     232             :   }
     233             : 
     234             :   static PreParserExpression CallEval() {
     235             :     return PreParserExpression(
     236             :         TypeField::encode(kExpression) |
     237             :         ExpressionTypeField::encode(kCallEvalExpression));
     238             :   }
     239             : 
     240         146 :   static PreParserExpression SuperCallReference() {
     241             :     return PreParserExpression(
     242             :         TypeField::encode(kExpression) |
     243         146 :         ExpressionTypeField::encode(kSuperCallReference));
     244             :   }
     245             : 
     246       32357 :   static PreParserExpression NoTemplateTag() {
     247             :     return PreParserExpression(
     248             :         TypeField::encode(kExpression) |
     249       32357 :         ExpressionTypeField::encode(kNoTemplateTagExpression));
     250             :   }
     251             : 
     252    33396132 :   bool IsEmpty() const { return TypeField::decode(code_) == kEmpty; }
     253             : 
     254    65102101 :   bool IsIdentifier() const {
     255   130204202 :     return TypeField::decode(code_) == kIdentifierExpression;
     256             :   }
     257             : 
     258     7972711 :   PreParserIdentifier AsIdentifier() const {
     259             :     DCHECK(IsIdentifier());
     260    15945422 :     return PreParserIdentifier(IdentifierTypeField::decode(code_));
     261             :   }
     262             : 
     263             :   bool IsAssignment() const {
     264     5706574 :     return TypeField::decode(code_) == kExpression &&
     265             :            ExpressionTypeField::decode(code_) == kAssignment;
     266             :   }
     267             : 
     268             :   bool IsObjectLiteral() const {
     269             :     return TypeField::decode(code_) == kObjectLiteralExpression;
     270             :   }
     271             : 
     272             :   bool IsArrayLiteral() const {
     273             :     return TypeField::decode(code_) == kArrayLiteralExpression;
     274             :   }
     275             : 
     276             :   bool IsStringLiteral() const {
     277             :     return TypeField::decode(code_) == kStringLiteralExpression;
     278             :   }
     279             : 
     280             :   bool IsUseStrictLiteral() const {
     281     6078730 :     return TypeField::decode(code_) == kStringLiteralExpression &&
     282             :            IsUseStrictField::decode(code_);
     283             :   }
     284             : 
     285             :   bool IsUseAsmLiteral() const {
     286     5613056 :     return TypeField::decode(code_) == kStringLiteralExpression &&
     287             :            IsUseAsmField::decode(code_);
     288             :   }
     289             : 
     290             :   bool IsThis() const {
     291     8033442 :     return TypeField::decode(code_) == kExpression &&
     292             :            ExpressionTypeField::decode(code_) == kThisExpression;
     293             :   }
     294             : 
     295     4102747 :   bool IsThisProperty() const {
     296    11024177 :     return TypeField::decode(code_) == kExpression &&
     297     4102747 :            ExpressionTypeField::decode(code_) == kThisPropertyExpression;
     298             :   }
     299             : 
     300             :   bool IsProperty() const {
     301    49446976 :     return TypeField::decode(code_) == kExpression &&
     302    16240267 :            (ExpressionTypeField::decode(code_) == kPropertyExpression ||
     303             :             ExpressionTypeField::decode(code_) == kThisPropertyExpression);
     304             :   }
     305             : 
     306             :   bool IsCall() const {
     307       22438 :     return TypeField::decode(code_) == kExpression &&
     308        9434 :            (ExpressionTypeField::decode(code_) == kCallExpression ||
     309             :             ExpressionTypeField::decode(code_) == kCallEvalExpression);
     310             :   }
     311             : 
     312             :   bool IsSuperCallReference() const {
     313     5015375 :     return TypeField::decode(code_) == kExpression &&
     314             :            ExpressionTypeField::decode(code_) == kSuperCallReference;
     315             :   }
     316             : 
     317             :   bool IsValidReferenceExpression() const {
     318     7427776 :     return IsIdentifier() || IsProperty();
     319             :   }
     320             : 
     321             :   // At the moment PreParser doesn't track these expression types.
     322             :   bool IsFunctionLiteral() const { return false; }
     323             :   bool IsCallNew() const { return false; }
     324             : 
     325             :   bool IsNoTemplateTag() const {
     326             :     return TypeField::decode(code_) == kExpression &&
     327             :            ExpressionTypeField::decode(code_) == kNoTemplateTagExpression;
     328             :   }
     329             : 
     330             :   bool IsSpread() const {
     331             :     return TypeField::decode(code_) == kSpreadExpression;
     332             :   }
     333             : 
     334             :   PreParserExpression AsFunctionLiteral() { return *this; }
     335             : 
     336             :   // Dummy implementation for making expression->somefunc() work in both Parser
     337             :   // and PreParser.
     338             :   PreParserExpression* operator->() { return this; }
     339             : 
     340             :   // More dummy implementations of things PreParser doesn't need to track:
     341             :   void SetShouldEagerCompile() {}
     342             :   void set_should_be_used_once_hint() {}
     343             : 
     344             :   int position() const { return kNoSourcePosition; }
     345             :   void set_function_token_position(int position) {}
     346             : 
     347             :  private:
     348             :   enum Type {
     349             :     kEmpty,
     350             :     kExpression,
     351             :     kIdentifierExpression,
     352             :     kStringLiteralExpression,
     353             :     kSpreadExpression,
     354             :     kObjectLiteralExpression,
     355             :     kArrayLiteralExpression
     356             :   };
     357             : 
     358             :   enum ExpressionType {
     359             :     kThisExpression,
     360             :     kThisPropertyExpression,
     361             :     kPropertyExpression,
     362             :     kCallExpression,
     363             :     kCallEvalExpression,
     364             :     kSuperCallReference,
     365             :     kNoTemplateTagExpression,
     366             :     kAssignment,
     367             :     kNewTarget
     368             :   };
     369             : 
     370             :   explicit PreParserExpression(uint32_t expression_code,
     371             :                                ZoneList<VariableProxy*>* variables = nullptr)
     372    28362985 :       : code_(expression_code), variables_(variables) {}
     373             : 
     374    29956344 :   void AddVariable(VariableProxy* variable, Zone* zone) {
     375    29956344 :     if (variable == nullptr) {
     376    29956334 :       return;
     377             :     }
     378    10717820 :     if (variables_ == nullptr) {
     379    10717814 :       variables_ = new (zone) ZoneList<VariableProxy*>(1, zone);
     380             :     }
     381    10717812 :     variables_->Add(variable, zone);
     382             :   }
     383             : 
     384             :   // The first three bits are for the Type.
     385             :   typedef BitField<Type, 0, 3> TypeField;
     386             : 
     387             :   // The high order bit applies only to nodes which would inherit from the
     388             :   // Expression ASTNode --- This is by necessity, due to the fact that
     389             :   // Expression nodes may be represented as multiple Types, not exclusively
     390             :   // through kExpression.
     391             :   // TODO(caitp, adamk): clean up PreParserExpression bitfields.
     392             :   typedef BitField<bool, 31, 1> ParenthesizedField;
     393             : 
     394             :   // The rest of the bits are interpreted depending on the value
     395             :   // of the Type field, so they can share the storage.
     396             :   typedef BitField<ExpressionType, TypeField::kNext, 4> ExpressionTypeField;
     397             :   typedef BitField<bool, TypeField::kNext, 1> IsUseStrictField;
     398             :   typedef BitField<bool, IsUseStrictField::kNext, 1> IsUseAsmField;
     399             :   typedef BitField<PreParserIdentifier::Type, TypeField::kNext, 10>
     400             :       IdentifierTypeField;
     401             :   typedef BitField<bool, TypeField::kNext, 1> HasCoverInitializedNameField;
     402             : 
     403             :   uint32_t code_;
     404             :   // If the PreParser is used in the variable tracking mode, PreParserExpression
     405             :   // accumulates variables in that expression.
     406             :   ZoneList<VariableProxy*>* variables_;
     407             : 
     408             :   friend class PreParser;
     409             :   friend class PreParserFactory;
     410             :   template <typename T>
     411             :   friend class PreParserList;
     412             : };
     413             : 
     414             : 
     415             : // The pre-parser doesn't need to build lists of expressions, identifiers, or
     416             : // the like. If the PreParser is used in variable tracking mode, it needs to
     417             : // build lists of variables though.
     418             : template <typename T>
     419             : class PreParserList {
     420             :  public:
     421             :   // These functions make list->Add(some_expression) work (and do nothing).
     422     7517531 :   PreParserList() : length_(0), variables_(nullptr) {}
     423             :   PreParserList* operator->() { return this; }
     424             :   void Add(const T& element, Zone* zone);
     425             :   int length() const { return length_; }
     426       84590 :   static PreParserList Null() { return PreParserList(-1); }
     427             :   bool IsNull() const { return length_ == -1; }
     428             :   void Set(int index, const T& element) {}
     429             : 
     430             :  private:
     431             :   explicit PreParserList(int n) : length_(n), variables_(nullptr) {}
     432             :   int length_;
     433             :   ZoneList<VariableProxy*>* variables_;
     434             : 
     435             :   friend class PreParser;
     436             :   friend class PreParserFactory;
     437             : };
     438             : 
     439             : template <>
     440     9854080 : inline void PreParserList<PreParserExpression>::Add(
     441             :     const PreParserExpression& expression, Zone* zone) {
     442     9854080 :   if (expression.variables_ != nullptr) {
     443             :     DCHECK(FLAG_lazy_inner_functions);
     444             :     DCHECK(zone != nullptr);
     445     1411458 :     if (variables_ == nullptr) {
     446     1174320 :       variables_ = new (zone) ZoneList<VariableProxy*>(1, zone);
     447             :     }
     448     4254710 :     for (auto identifier : (*expression.variables_)) {
     449     1421626 :       variables_->Add(identifier, zone);
     450             :     }
     451             :   }
     452     9854080 :   ++length_;
     453     9854080 : }
     454             : 
     455             : template <typename T>
     456             : void PreParserList<T>::Add(const T& element, Zone* zone) {
     457       22794 :   ++length_;
     458             : }
     459             : 
     460             : typedef PreParserList<PreParserExpression> PreParserExpressionList;
     461             : 
     462             : class PreParserStatement;
     463             : typedef PreParserList<PreParserStatement> PreParserStatementList;
     464             : 
     465             : class PreParserStatement {
     466             :  public:
     467      973329 :   static PreParserStatement Default() {
     468      973329 :     return PreParserStatement(kUnknownStatement);
     469             :   }
     470             : 
     471     8223937 :   static PreParserStatement Null() {
     472     8223937 :     return PreParserStatement(kNullStatement);
     473             :   }
     474             : 
     475             :   static PreParserStatement Empty() {
     476             :     return PreParserStatement(kEmptyStatement);
     477             :   }
     478             : 
     479       65586 :   static PreParserStatement Jump() {
     480       65586 :     return PreParserStatement(kJumpStatement);
     481             :   }
     482             : 
     483             :   // Creates expression statement from expression.
     484             :   // Preserves being an unparenthesized string literal, possibly
     485             :   // "use strict".
     486     5841693 :   static PreParserStatement ExpressionStatement(
     487             :       PreParserExpression expression) {
     488     5841693 :     if (expression.IsUseStrictLiteral()) {
     489      232837 :       return PreParserStatement(kUseStrictExpressionStatement);
     490             :     }
     491     5608856 :     if (expression.IsUseAsmLiteral()) {
     492           0 :       return PreParserStatement(kUseAsmExpressionStatement);
     493             :     }
     494     5608856 :     if (expression.IsStringLiteral()) {
     495        4200 :       return PreParserStatement(kStringLiteralExpressionStatement);
     496             :     }
     497             :     return Default();
     498             :   }
     499             : 
     500        4455 :   bool IsStringLiteral() {
     501        4455 :     return code_ == kStringLiteralExpressionStatement || IsUseStrictLiteral() ||
     502        4455 :            IsUseAsmLiteral();
     503             :   }
     504             : 
     505      237115 :   bool IsUseStrictLiteral() {
     506      237115 :     return code_ == kUseStrictExpressionStatement;
     507             :   }
     508             : 
     509        4455 :   bool IsUseAsmLiteral() { return code_ == kUseAsmExpressionStatement; }
     510             : 
     511             :   bool IsJumpStatement() {
     512             :     return code_ == kJumpStatement;
     513             :   }
     514             : 
     515    12831267 :   bool IsNullStatement() { return code_ == kNullStatement; }
     516             : 
     517    12499892 :   bool IsEmptyStatement() { return code_ == kEmptyStatement; }
     518             : 
     519             :   // Dummy implementation for making statement->somefunc() work in both Parser
     520             :   // and PreParser.
     521             :   PreParserStatement* operator->() { return this; }
     522             : 
     523             :   PreParserStatementList statements() { return PreParserStatementList(); }
     524             :   void set_scope(Scope* scope) {}
     525             :   void Initialize(PreParserExpression cond, PreParserStatement body) {}
     526             :   void Initialize(PreParserStatement init, PreParserExpression cond,
     527             :                   PreParserStatement next, PreParserStatement body) {}
     528             : 
     529             :  private:
     530             :   enum Type {
     531             :     kNullStatement,
     532             :     kEmptyStatement,
     533             :     kUnknownStatement,
     534             :     kJumpStatement,
     535             :     kStringLiteralExpressionStatement,
     536             :     kUseStrictExpressionStatement,
     537             :     kUseAsmExpressionStatement,
     538             :   };
     539             : 
     540             :   explicit PreParserStatement(Type code) : code_(code) {}
     541             :   Type code_;
     542             : };
     543             : 
     544             : 
     545             : class PreParserFactory {
     546             :  public:
     547      405607 :   explicit PreParserFactory(AstValueFactory* ast_value_factory)
     548             :       : ast_value_factory_(ast_value_factory),
     549      811214 :         zone_(ast_value_factory->zone()) {}
     550             : 
     551     3790454 :   void set_zone(Zone* zone) { zone_ = zone; }
     552             : 
     553     5241332 :   PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
     554             :                                        int pos) {
     555             :     // This is needed for object literal property names. Property names are
     556             :     // normalized to string literals during object literal parsing.
     557     5241332 :     PreParserExpression expression = PreParserExpression::Default();
     558     5241332 :     if (identifier.string_ != nullptr) {
     559             :       DCHECK(FLAG_lazy_inner_functions);
     560             :       AstNodeFactory factory(ast_value_factory_);
     561     1593362 :       factory.set_zone(zone_);
     562             :       VariableProxy* variable =
     563             :           factory.NewVariableProxy(identifier.string_, NORMAL_VARIABLE);
     564     1593362 :       expression.AddVariable(variable, zone_);
     565             :     }
     566     5241331 :     return expression;
     567             :   }
     568             :   PreParserExpression NewNumberLiteral(double number,
     569             :                                        int pos) {
     570             :     return PreParserExpression::Default();
     571             :   }
     572             :   PreParserExpression NewUndefinedLiteral(int pos) {
     573             :     return PreParserExpression::Default();
     574             :   }
     575             :   PreParserExpression NewRegExpLiteral(PreParserIdentifier js_pattern,
     576             :                                        int js_flags, int pos) {
     577             :     return PreParserExpression::Default();
     578             :   }
     579             :   PreParserExpression NewArrayLiteral(PreParserExpressionList values,
     580             :                                       int first_spread_index, int pos) {
     581             :     return PreParserExpression::ArrayLiteral(values.variables_);
     582             :   }
     583             :   PreParserExpression NewClassLiteralProperty(PreParserExpression key,
     584             :                                               PreParserExpression value,
     585             :                                               ClassLiteralProperty::Kind kind,
     586             :                                               bool is_static,
     587             :                                               bool is_computed_name) {
     588             :     return PreParserExpression::Default();
     589             :   }
     590             :   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
     591             :                                                PreParserExpression value,
     592             :                                                ObjectLiteralProperty::Kind kind,
     593             :                                                bool is_computed_name) {
     594             :     return PreParserExpression::Default(value.variables_);
     595             :   }
     596             :   PreParserExpression NewObjectLiteralProperty(PreParserExpression key,
     597             :                                                PreParserExpression value,
     598             :                                                bool is_computed_name) {
     599             :     return PreParserExpression::Default(value.variables_);
     600             :   }
     601             :   PreParserExpression NewObjectLiteral(PreParserExpressionList properties,
     602             :                                        int boilerplate_properties, int pos,
     603             :                                        bool has_rest_property) {
     604             :     return PreParserExpression::ObjectLiteral(properties.variables_);
     605             :   }
     606             :   PreParserExpression NewVariableProxy(void* variable) {
     607             :     return PreParserExpression::Default();
     608             :   }
     609             :   PreParserExpression NewProperty(PreParserExpression obj,
     610             :                                   PreParserExpression key,
     611             :                                   int pos) {
     612     6960348 :     if (obj.IsThis()) {
     613             :       return PreParserExpression::ThisProperty();
     614             :     }
     615             :     return PreParserExpression::Property();
     616             :   }
     617             :   PreParserExpression NewUnaryOperation(Token::Value op,
     618             :                                         PreParserExpression expression,
     619             :                                         int pos) {
     620             :     return PreParserExpression::Default();
     621             :   }
     622             :   PreParserExpression NewBinaryOperation(Token::Value op,
     623             :                                          PreParserExpression left,
     624             :                                          PreParserExpression right, int pos) {
     625     3736173 :     return PreParserExpression::BinaryOperation(left, op, right, zone_);
     626             :   }
     627             :   PreParserExpression NewCompareOperation(Token::Value op,
     628             :                                           PreParserExpression left,
     629             :                                           PreParserExpression right, int pos) {
     630             :     return PreParserExpression::Default();
     631             :   }
     632             :   PreParserExpression NewRewritableExpression(PreParserExpression expression) {
     633             :     return expression;
     634             :   }
     635             :   PreParserExpression NewAssignment(Token::Value op,
     636             :                                     PreParserExpression left,
     637             :                                     PreParserExpression right,
     638             :                                     int pos) {
     639             :     // Identifiers need to be tracked since this might be a parameter with a
     640             :     // default value inside an arrow function parameter list.
     641             :     return PreParserExpression::Assignment(left.variables_);
     642             :   }
     643             :   PreParserExpression NewSuspend(PreParserExpression generator_object,
     644             :                                  PreParserExpression expression, int pos,
     645             :                                  Suspend::OnException on_exception,
     646             :                                  SuspendFlags flags) {
     647             :     return PreParserExpression::Default();
     648             :   }
     649             :   PreParserExpression NewConditional(PreParserExpression condition,
     650             :                                      PreParserExpression then_expression,
     651             :                                      PreParserExpression else_expression,
     652             :                                      int pos) {
     653             :     return PreParserExpression::Default();
     654             :   }
     655             :   PreParserExpression NewCountOperation(Token::Value op,
     656             :                                         bool is_prefix,
     657             :                                         PreParserExpression expression,
     658             :                                         int pos) {
     659             :     return PreParserExpression::Default();
     660             :   }
     661        1272 :   PreParserExpression NewCall(
     662             :       PreParserExpression expression, PreParserExpressionList arguments,
     663             :       int pos, Call::PossiblyEval possibly_eval = Call::NOT_EVAL) {
     664     3394453 :     if (possibly_eval == Call::IS_POSSIBLY_EVAL) {
     665             :       DCHECK(expression.IsIdentifier() && expression.AsIdentifier().IsEval());
     666             :       return PreParserExpression::CallEval();
     667             :     }
     668             :     return PreParserExpression::Call();
     669             :   }
     670          21 :   PreParserExpression NewCallNew(PreParserExpression expression,
     671             :                                  PreParserExpressionList arguments,
     672             :                                  int pos) {
     673          21 :     return PreParserExpression::Default();
     674             :   }
     675             :   PreParserStatement NewReturnStatement(PreParserExpression expression,
     676             :                                         int pos) {
     677             :     return PreParserStatement::Jump();
     678             :   }
     679             :   PreParserStatement NewAsyncReturnStatement(PreParserExpression expression,
     680             :                                              int pos) {
     681             :     return PreParserStatement::Jump();
     682             :   }
     683             :   PreParserExpression NewFunctionLiteral(
     684             :       PreParserIdentifier name, Scope* scope, PreParserStatementList body,
     685             :       int expected_property_count, int parameter_count, int function_length,
     686             :       FunctionLiteral::ParameterFlag has_duplicate_parameters,
     687             :       FunctionLiteral::FunctionType function_type,
     688             :       FunctionLiteral::EagerCompileHint eager_compile_hint, int position,
     689             :       bool has_braces, int function_literal_id) {
     690             :     return PreParserExpression::Default();
     691             :   }
     692             : 
     693             :   PreParserExpression NewSpread(PreParserExpression expression, int pos,
     694             :                                 int expr_pos) {
     695             :     return PreParserExpression::Spread(expression);
     696             :   }
     697             : 
     698             :   PreParserExpression NewEmptyParentheses(int pos) {
     699             :     return PreParserExpression::Default();
     700             :   }
     701             : 
     702             :   PreParserStatement NewEmptyStatement(int pos) {
     703             :     return PreParserStatement::Default();
     704             :   }
     705             : 
     706             :   PreParserStatement NewBlock(ZoneList<const AstRawString*>* labels,
     707             :                               int capacity, bool ignore_completion_value,
     708             :                               int pos) {
     709             :     return PreParserStatement::Default();
     710             :   }
     711             : 
     712             :   PreParserStatement NewDebuggerStatement(int pos) {
     713             :     return PreParserStatement::Default();
     714             :   }
     715             : 
     716             :   PreParserStatement NewExpressionStatement(PreParserExpression expr, int pos) {
     717     5841693 :     return PreParserStatement::ExpressionStatement(expr);
     718             :   }
     719             : 
     720             :   PreParserStatement NewIfStatement(PreParserExpression condition,
     721             :                                     PreParserStatement then_statement,
     722             :                                     PreParserStatement else_statement,
     723             :                                     int pos) {
     724             :     // This must return a jump statement iff both clauses are jump statements.
     725     1386637 :     return else_statement.IsJumpStatement() ? then_statement : else_statement;
     726             :   }
     727             : 
     728             :   PreParserStatement NewBreakStatement(PreParserStatement target, int pos) {
     729             :     return PreParserStatement::Jump();
     730             :   }
     731             : 
     732             :   PreParserStatement NewContinueStatement(PreParserStatement target, int pos) {
     733             :     return PreParserStatement::Jump();
     734             :   }
     735             : 
     736             :   PreParserStatement NewWithStatement(Scope* scope,
     737             :                                       PreParserExpression expression,
     738             :                                       PreParserStatement statement, int pos) {
     739             :     return PreParserStatement::Default();
     740             :   }
     741             : 
     742             :   PreParserStatement NewDoWhileStatement(ZoneList<const AstRawString*>* labels,
     743             :                                          int pos) {
     744             :     return PreParserStatement::Default();
     745             :   }
     746             : 
     747             :   PreParserStatement NewWhileStatement(ZoneList<const AstRawString*>* labels,
     748             :                                        int pos) {
     749             :     return PreParserStatement::Default();
     750             :   }
     751             : 
     752             :   PreParserStatement NewSwitchStatement(ZoneList<const AstRawString*>* labels,
     753             :                                         int pos) {
     754             :     return PreParserStatement::Default();
     755             :   }
     756             : 
     757             :   PreParserStatement NewCaseClause(PreParserExpression label,
     758             :                                    PreParserStatementList statements, int pos) {
     759             :     return PreParserStatement::Default();
     760             :   }
     761             : 
     762             :   PreParserStatement NewForStatement(ZoneList<const AstRawString*>* labels,
     763             :                                      int pos) {
     764             :     return PreParserStatement::Default();
     765             :   }
     766             : 
     767             :   PreParserStatement NewForEachStatement(ForEachStatement::VisitMode visit_mode,
     768             :                                          ZoneList<const AstRawString*>* labels,
     769             :                                          int pos) {
     770             :     return PreParserStatement::Default();
     771             :   }
     772             : 
     773             :   PreParserStatement NewForOfStatement(ZoneList<const AstRawString*>* labels,
     774             :                                        int pos) {
     775             :     return PreParserStatement::Default();
     776             :   }
     777             : 
     778             :   PreParserExpression NewCallRuntime(Runtime::FunctionId id,
     779             :                                      ZoneList<PreParserExpression>* arguments,
     780             :                                      int pos) {
     781             :     return PreParserExpression::Default();
     782             :   }
     783             : 
     784             :   PreParserExpression NewImportCallExpression(PreParserExpression args,
     785             :                                               int pos) {
     786             :     return PreParserExpression::Default();
     787             :   }
     788             : 
     789             :   // Return the object itself as AstVisitor and implement the needed
     790             :   // dummy method right in this class.
     791             :   PreParserFactory* visitor() { return this; }
     792             :   int* ast_properties() {
     793             :     static int dummy = 42;
     794             :     return &dummy;
     795             :   }
     796             : 
     797             :  private:
     798             :   AstValueFactory* ast_value_factory_;
     799             :   Zone* zone_;
     800             : };
     801             : 
     802             : 
     803             : struct PreParserFormalParameters : FormalParametersBase {
     804             :   struct Parameter : public ZoneObject {
     805      645097 :     Parameter(ZoneList<VariableProxy*>* variables, bool is_rest)
     806      645097 :         : variables_(variables), is_rest(is_rest) {}
     807             :     Parameter** next() { return &next_parameter; }
     808             :     Parameter* const* next() const { return &next_parameter; }
     809             : 
     810             :     ZoneList<VariableProxy*>* variables_;
     811             :     Parameter* next_parameter = nullptr;
     812             :     bool is_rest : 1;
     813             :   };
     814             :   explicit PreParserFormalParameters(DeclarationScope* scope)
     815             :       : FormalParametersBase(scope) {}
     816             : 
     817             :   ThreadedList<Parameter> params;
     818             : };
     819             : 
     820             : 
     821             : class PreParser;
     822             : 
     823             : class PreParserTarget {
     824             :  public:
     825             :   PreParserTarget(ParserBase<PreParser>* preparser,
     826             :                   PreParserStatement statement) {}
     827             : };
     828             : 
     829             : class PreParserTargetScope {
     830             :  public:
     831             :   explicit PreParserTargetScope(ParserBase<PreParser>* preparser) {}
     832             : };
     833             : 
     834             : template <>
     835             : struct ParserTypes<PreParser> {
     836             :   typedef ParserBase<PreParser> Base;
     837             :   typedef PreParser Impl;
     838             : 
     839             :   // PreParser doesn't need to store generator variables.
     840             :   typedef void Variable;
     841             : 
     842             :   // Return types for traversing functions.
     843             :   typedef PreParserIdentifier Identifier;
     844             :   typedef PreParserExpression Expression;
     845             :   typedef PreParserExpression FunctionLiteral;
     846             :   typedef PreParserExpression ObjectLiteralProperty;
     847             :   typedef PreParserExpression ClassLiteralProperty;
     848             :   typedef PreParserExpression Suspend;
     849             :   typedef PreParserExpressionList ExpressionList;
     850             :   typedef PreParserExpressionList ObjectPropertyList;
     851             :   typedef PreParserExpressionList ClassPropertyList;
     852             :   typedef PreParserFormalParameters FormalParameters;
     853             :   typedef PreParserStatement Statement;
     854             :   typedef PreParserStatementList StatementList;
     855             :   typedef PreParserStatement Block;
     856             :   typedef PreParserStatement BreakableStatement;
     857             :   typedef PreParserStatement IterationStatement;
     858             : 
     859             :   // For constructing objects returned by the traversing functions.
     860             :   typedef PreParserFactory Factory;
     861             : 
     862             :   typedef PreParserTarget Target;
     863             :   typedef PreParserTargetScope TargetScope;
     864             : };
     865             : 
     866             : 
     867             : // Preparsing checks a JavaScript program and emits preparse-data that helps
     868             : // a later parsing to be faster.
     869             : // See preparse-data-format.h for the data format.
     870             : 
     871             : // The PreParser checks that the syntax follows the grammar for JavaScript,
     872             : // and collects some information about the program along the way.
     873             : // The grammar check is only performed in order to understand the program
     874             : // sufficiently to deduce some information about it, that can be used
     875             : // to speed up later parsing. Finding errors is not the goal of pre-parsing,
     876             : // rather it is to speed up properly written and correct programs.
     877             : // That means that contextual checks (like a label being declared where
     878             : // it is used) are generally omitted.
     879             : class PreParser : public ParserBase<PreParser> {
     880             :   friend class ParserBase<PreParser>;
     881             :   friend class v8::internal::ExpressionClassifier<ParserTypes<PreParser>>;
     882             : 
     883             :  public:
     884             :   typedef PreParserIdentifier Identifier;
     885             :   typedef PreParserExpression Expression;
     886             :   typedef PreParserStatement Statement;
     887             : 
     888             :   enum PreParseResult {
     889             :     kPreParseStackOverflow,
     890             :     kPreParseAbort,
     891             :     kPreParseSuccess
     892             :   };
     893             : 
     894      405607 :   PreParser(Zone* zone, Scanner* scanner, uintptr_t stack_limit,
     895             :             AstValueFactory* ast_value_factory,
     896             :             PendingCompilationErrorHandler* pending_error_handler,
     897             :             RuntimeCallStats* runtime_call_stats,
     898             :             PreParsedScopeData* preparsed_scope_data = nullptr,
     899             :             bool parsing_on_main_thread = true)
     900             :       : ParserBase<PreParser>(zone, scanner, stack_limit, nullptr,
     901             :                               ast_value_factory, runtime_call_stats,
     902             :                               preparsed_scope_data, parsing_on_main_thread),
     903             :         use_counts_(nullptr),
     904             :         preparse_data_(FLAG_use_parse_tasks ? new PreParseData() : nullptr),
     905             :         track_unresolved_variables_(false),
     906     1216821 :         pending_error_handler_(pending_error_handler) {}
     907             : 
     908             :   static bool IsPreParser() { return true; }
     909             : 
     910             :   PreParserLogger* logger() { return &log_; }
     911             : 
     912             :   // Pre-parse the program from the character stream; returns true on
     913             :   // success (even if parsing failed, the pre-parse data successfully
     914             :   // captured the syntax error), and false if a stack-overflow happened
     915             :   // during parsing.
     916             :   PreParseResult PreParseProgram(bool is_module = false,
     917             :                                  int* use_counts = nullptr);
     918             : 
     919             :   // Parses a single function literal, from the opening parentheses before
     920             :   // parameters to the closing brace after the body.
     921             :   // Returns a FunctionEntry describing the body of the function in enough
     922             :   // detail that it can be lazily compiled.
     923             :   // The scanner is expected to have matched the "function" or "function*"
     924             :   // keyword and parameters, and have consumed the initial '{'.
     925             :   // At return, unless an error occurred, the scanner is positioned before the
     926             :   // the final '}'.
     927             :   PreParseResult PreParseFunction(FunctionKind kind,
     928             :                                   DeclarationScope* function_scope,
     929             :                                   bool parsing_module,
     930             :                                   bool track_unresolved_variables,
     931             :                                   bool may_abort, int* use_counts);
     932             : 
     933             :   const PreParseData* preparse_data() const { return preparse_data_.get(); }
     934             : 
     935             :  private:
     936             :   // These types form an algebra over syntactic categories that is just
     937             :   // rich enough to let us recognize and propagate the constructs that
     938             :   // are either being counted in the preparser data, or is important
     939             :   // to throw the correct syntax error exceptions.
     940             : 
     941             :   // All ParseXXX functions take as the last argument an *ok parameter
     942             :   // which is set to false if parsing failed; it is unchanged otherwise.
     943             :   // By making the 'exception handling' explicit, we are forced to check
     944             :   // for failure at the call sites.
     945             : 
     946             :   // Indicates that we won't switch from the preparser to the preparser; we'll
     947             :   // just stay where we are.
     948             :   bool AllowsLazyParsingWithoutUnresolvedVariables() const { return false; }
     949             :   bool parse_lazily() const { return false; }
     950             : 
     951             :   V8_INLINE LazyParsingResult SkipFunction(FunctionKind kind,
     952             :                                            DeclarationScope* function_scope,
     953             :                                            int* num_parameters,
     954             :                                            bool is_inner_function,
     955             :                                            bool may_abort, bool* ok) {
     956             :     UNREACHABLE();
     957             :     return kLazyParsingComplete;
     958             :   }
     959             :   Expression ParseFunctionLiteral(
     960             :       Identifier name, Scanner::Location function_name_location,
     961             :       FunctionNameValidity function_name_validity, FunctionKind kind,
     962             :       int function_token_pos, FunctionLiteral::FunctionType function_type,
     963             :       LanguageMode language_mode, bool* ok);
     964             :   LazyParsingResult ParseStatementListAndLogFunction(
     965             :       PreParserFormalParameters* formals, bool maybe_abort, bool* ok);
     966             : 
     967             :   struct TemplateLiteralState {};
     968             : 
     969             :   V8_INLINE TemplateLiteralState OpenTemplateLiteral(int pos) {
     970             :     return TemplateLiteralState();
     971             :   }
     972             :   V8_INLINE void AddTemplateExpression(TemplateLiteralState* state,
     973             :                                        PreParserExpression expression) {}
     974             :   V8_INLINE void AddTemplateSpan(TemplateLiteralState* state, bool should_cook,
     975             :                                  bool tail) {}
     976             :   V8_INLINE PreParserExpression CloseTemplateLiteral(
     977             :       TemplateLiteralState* state, int start, PreParserExpression tag);
     978             :   V8_INLINE void CheckConflictingVarDeclarations(Scope* scope, bool* ok) {}
     979             : 
     980             :   V8_INLINE void SetLanguageMode(Scope* scope, LanguageMode mode) {
     981     9545573 :     scope->SetLanguageMode(mode);
     982             :   }
     983             :   V8_INLINE void SetAsmModule() {}
     984             : 
     985             :   V8_INLINE void MarkCollectedTailCallExpressions() {}
     986             :   V8_INLINE void MarkTailPosition(PreParserExpression expression) {}
     987             : 
     988             :   V8_INLINE PreParserExpression SpreadCall(PreParserExpression function,
     989             :                                            PreParserExpressionList args,
     990             :                                            int pos,
     991             :                                            Call::PossiblyEval possibly_eval);
     992             :   V8_INLINE PreParserExpression SpreadCallNew(PreParserExpression function,
     993             :                                               PreParserExpressionList args,
     994             :                                               int pos);
     995             : 
     996             :   V8_INLINE void RewriteDestructuringAssignments() {}
     997             : 
     998             :   V8_INLINE PreParserExpression RewriteExponentiation(PreParserExpression left,
     999             :                                                       PreParserExpression right,
    1000             :                                                       int pos) {
    1001             :     return left;
    1002             :   }
    1003             :   V8_INLINE PreParserExpression RewriteAssignExponentiation(
    1004             :       PreParserExpression left, PreParserExpression right, int pos) {
    1005             :     return left;
    1006             :   }
    1007             : 
    1008             :   V8_INLINE PreParserExpression
    1009             :   RewriteAwaitExpression(PreParserExpression value, int pos) {
    1010             :     return value;
    1011             :   }
    1012             :   V8_INLINE void PrepareAsyncFunctionBody(PreParserStatementList body,
    1013             :                                           FunctionKind kind, int pos) {}
    1014             :   V8_INLINE void RewriteAsyncFunctionBody(PreParserStatementList body,
    1015             :                                           PreParserStatement block,
    1016             :                                           PreParserExpression return_value,
    1017             :                                           bool* ok) {}
    1018             :   V8_INLINE PreParserExpression RewriteYieldStar(PreParserExpression generator,
    1019             :                                                  PreParserExpression expression,
    1020             :                                                  int pos) {
    1021        3687 :     return PreParserExpression::Default();
    1022             :   }
    1023    49555962 :   V8_INLINE void RewriteNonPattern(bool* ok) { ValidateExpression(ok); }
    1024             : 
    1025             :   void DeclareAndInitializeVariables(
    1026             :       PreParserStatement block,
    1027             :       const DeclarationDescriptor* declaration_descriptor,
    1028             :       const DeclarationParsingResult::Declaration* declaration,
    1029             :       ZoneList<const AstRawString*>* names, bool* ok);
    1030             : 
    1031             :   V8_INLINE ZoneList<const AstRawString*>* DeclareLabel(
    1032             :       ZoneList<const AstRawString*>* labels, PreParserExpression expr,
    1033             :       bool* ok) {
    1034             :     DCHECK(!expr.AsIdentifier().IsEnum());
    1035             :     DCHECK(!parsing_module_ || !expr.AsIdentifier().IsAwait());
    1036             :     DCHECK(IsIdentifier(expr));
    1037             :     return labels;
    1038             :   }
    1039             : 
    1040             :   // TODO(nikolaos): The preparser currently does not keep track of labels.
    1041             :   V8_INLINE bool ContainsLabel(ZoneList<const AstRawString*>* labels,
    1042             :                                PreParserIdentifier label) {
    1043             :     return false;
    1044             :   }
    1045             : 
    1046             :   V8_INLINE PreParserExpression RewriteReturn(PreParserExpression return_value,
    1047             :                                               int pos) {
    1048             :     return return_value;
    1049             :   }
    1050             :   V8_INLINE PreParserStatement RewriteSwitchStatement(
    1051             :       PreParserExpression tag, PreParserStatement switch_statement,
    1052             :       PreParserStatementList cases, Scope* scope) {
    1053       94305 :     return PreParserStatement::Default();
    1054             :   }
    1055             : 
    1056             :   V8_INLINE void RewriteCatchPattern(CatchInfo* catch_info, bool* ok) {
    1057      107652 :     if (track_unresolved_variables_) {
    1058       22139 :       if (catch_info->name.string_ != nullptr) {
    1059             :         // Unlike in the parser, we need to declare the catch variable as LET
    1060             :         // variable, so that it won't get hoisted out of the scope.
    1061       22115 :         catch_info->scope->DeclareVariableName(catch_info->name.string_, LET);
    1062             :       }
    1063       22139 :       if (catch_info->pattern.variables_ != nullptr) {
    1064          66 :         for (auto variable : *catch_info->pattern.variables_) {
    1065          42 :           scope()->DeclareVariableName(variable->raw_name(), LET);
    1066             :         }
    1067             :       }
    1068             :     }
    1069             :   }
    1070             : 
    1071             :   V8_INLINE void ValidateCatchBlock(const CatchInfo& catch_info, bool* ok) {}
    1072             :   V8_INLINE PreParserStatement RewriteTryStatement(
    1073             :       PreParserStatement try_block, PreParserStatement catch_block,
    1074             :       PreParserStatement finally_block, const CatchInfo& catch_info, int pos) {
    1075      114482 :     return PreParserStatement::Default();
    1076             :   }
    1077             : 
    1078             :   V8_INLINE void ParseAndRewriteGeneratorFunctionBody(
    1079             :       int pos, FunctionKind kind, PreParserStatementList body, bool* ok) {
    1080       68375 :     ParseStatementList(body, Token::RBRACE, ok);
    1081             :   }
    1082             :   V8_INLINE void CreateFunctionNameAssignment(
    1083             :       PreParserIdentifier function_name, int pos,
    1084             :       FunctionLiteral::FunctionType function_type,
    1085             :       DeclarationScope* function_scope, PreParserStatementList result,
    1086             :       int index) {}
    1087             : 
    1088             :   V8_INLINE PreParserExpression RewriteDoExpression(PreParserStatement body,
    1089             :                                                     int pos, bool* ok) {
    1090         495 :     return PreParserExpression::Default();
    1091             :   }
    1092             : 
    1093             :   // TODO(nikolaos): The preparser currently does not keep track of labels
    1094             :   // and targets.
    1095             :   V8_INLINE PreParserStatement LookupBreakTarget(PreParserIdentifier label,
    1096             :                                                  bool* ok) {
    1097       98017 :     return PreParserStatement::Default();
    1098             :   }
    1099             :   V8_INLINE PreParserStatement LookupContinueTarget(PreParserIdentifier label,
    1100             :                                                     bool* ok) {
    1101       36764 :     return PreParserStatement::Default();
    1102             :   }
    1103             : 
    1104             :   V8_INLINE PreParserStatement DeclareFunction(
    1105             :       PreParserIdentifier variable_name, PreParserExpression function,
    1106             :       VariableMode mode, int pos, bool is_sloppy_block_function,
    1107             :       ZoneList<const AstRawString*>* names, bool* ok) {
    1108             :     DCHECK_NULL(names);
    1109      175014 :     if (variable_name.string_ != nullptr) {
    1110             :       DCHECK(track_unresolved_variables_);
    1111       20020 :       scope()->DeclareVariableName(variable_name.string_, mode);
    1112       18576 :       if (is_sloppy_block_function) {
    1113             :         GetDeclarationScope()->DeclareSloppyBlockFunction(variable_name.string_,
    1114        2888 :                                                           scope());
    1115             :       }
    1116             :     }
    1117      175014 :     return Statement::Default();
    1118             :   }
    1119             : 
    1120             :   V8_INLINE PreParserStatement
    1121             :   DeclareClass(PreParserIdentifier variable_name, PreParserExpression value,
    1122             :                ZoneList<const AstRawString*>* names, int class_token_pos,
    1123             :                int end_pos, bool* ok) {
    1124             :     // Preparser shouldn't be used in contexts where we need to track the names.
    1125             :     DCHECK_NULL(names);
    1126       15702 :     if (variable_name.string_ != nullptr) {
    1127             :       DCHECK(track_unresolved_variables_);
    1128          70 :       scope()->DeclareVariableName(variable_name.string_, LET);
    1129             :     }
    1130       15702 :     return PreParserStatement::Default();
    1131             :   }
    1132             :   V8_INLINE void DeclareClassVariable(PreParserIdentifier name,
    1133             :                                       ClassInfo* class_info,
    1134             :                                       int class_token_pos, bool* ok) {}
    1135             :   V8_INLINE void DeclareClassProperty(PreParserIdentifier class_name,
    1136             :                                       PreParserExpression property,
    1137             :                                       ClassLiteralProperty::Kind kind,
    1138             :                                       bool is_static, bool is_constructor,
    1139             :                                       ClassInfo* class_info, bool* ok) {
    1140             :   }
    1141             :   V8_INLINE PreParserExpression RewriteClassLiteral(PreParserIdentifier name,
    1142             :                                                     ClassInfo* class_info,
    1143             :                                                     int pos, bool* ok) {
    1144             :     bool has_default_constructor = !class_info->has_seen_constructor;
    1145             :     // Account for the default constructor.
    1146       32337 :     if (has_default_constructor) GetNextFunctionLiteralId();
    1147       32337 :     return PreParserExpression::Default();
    1148             :   }
    1149             : 
    1150             :   V8_INLINE PreParserStatement DeclareNative(PreParserIdentifier name, int pos,
    1151             :                                              bool* ok) {
    1152             :     return PreParserStatement::Default();
    1153             :   }
    1154             : 
    1155             :   V8_INLINE void QueueDestructuringAssignmentForRewriting(
    1156             :       PreParserExpression assignment) {}
    1157             :   V8_INLINE void QueueNonPatternForRewriting(PreParserExpression expr,
    1158             :                                              bool* ok) {}
    1159             : 
    1160             :   // Helper functions for recursive descent.
    1161             :   V8_INLINE bool IsEval(PreParserIdentifier identifier) const {
    1162     1773439 :     return identifier.IsEval();
    1163             :   }
    1164             : 
    1165             :   V8_INLINE bool IsArguments(PreParserIdentifier identifier) const {
    1166             :     return identifier.IsArguments();
    1167             :   }
    1168             : 
    1169             :   V8_INLINE bool IsEvalOrArguments(PreParserIdentifier identifier) const {
    1170    30317349 :     return identifier.IsEvalOrArguments();
    1171             :   }
    1172             : 
    1173             :   V8_INLINE bool IsUndefined(PreParserIdentifier identifier) const {
    1174             :     return identifier.IsUndefined();
    1175             :   }
    1176             : 
    1177             :   V8_INLINE bool IsAwait(PreParserIdentifier identifier) const {
    1178             :     return identifier.IsAwait();
    1179             :   }
    1180             : 
    1181             :   // Returns true if the expression is of type "this.foo".
    1182             :   V8_INLINE static bool IsThisProperty(PreParserExpression expression) {
    1183     4102747 :     return expression.IsThisProperty();
    1184             :   }
    1185             : 
    1186             :   V8_INLINE static bool IsIdentifier(PreParserExpression expression) {
    1187    65102108 :     return expression.IsIdentifier();
    1188             :   }
    1189             : 
    1190             :   V8_INLINE static PreParserIdentifier AsIdentifier(
    1191             :       PreParserExpression expression) {
    1192     7972711 :     return expression.AsIdentifier();
    1193             :   }
    1194             : 
    1195             :   V8_INLINE static PreParserExpression AsIdentifierExpression(
    1196             :       PreParserExpression expression) {
    1197             :     return expression;
    1198             :   }
    1199             : 
    1200             :   V8_INLINE bool IsPrototype(PreParserIdentifier identifier) const {
    1201             :     return identifier.IsPrototype();
    1202             :   }
    1203             : 
    1204             :   V8_INLINE bool IsConstructor(PreParserIdentifier identifier) const {
    1205       14424 :     return identifier.IsConstructor();
    1206             :   }
    1207             : 
    1208             :   V8_INLINE bool IsName(PreParserIdentifier identifier) const {
    1209       10887 :     return identifier.IsName();
    1210             :   }
    1211             : 
    1212             :   V8_INLINE static bool IsBoilerplateProperty(PreParserExpression property) {
    1213             :     // PreParser doesn't count boilerplate properties.
    1214             :     return false;
    1215             :   }
    1216             : 
    1217             :   V8_INLINE bool IsNative(PreParserExpression expr) const {
    1218             :     // Preparsing is disabled for extensions (because the extension
    1219             :     // details aren't passed to lazily compiled functions), so we
    1220             :     // don't accept "native function" in the preparser and there is
    1221             :     // no need to keep track of "native".
    1222             :     return false;
    1223             :   }
    1224             : 
    1225             :   V8_INLINE static bool IsArrayIndex(PreParserIdentifier string,
    1226             :                                      uint32_t* index) {
    1227             :     return false;
    1228             :   }
    1229             : 
    1230             :   V8_INLINE bool IsUseStrictDirective(PreParserStatement statement) const {
    1231      237115 :     return statement.IsUseStrictLiteral();
    1232             :   }
    1233             : 
    1234             :   V8_INLINE bool IsUseAsmDirective(PreParserStatement statement) const {
    1235        4455 :     return statement.IsUseAsmLiteral();
    1236             :   }
    1237             : 
    1238             :   V8_INLINE bool IsStringLiteral(PreParserStatement statement) const {
    1239        4455 :     return statement.IsStringLiteral();
    1240             :   }
    1241             : 
    1242             :   V8_INLINE static PreParserExpression GetPropertyValue(
    1243             :       PreParserExpression property) {
    1244             :     return PreParserExpression::Default();
    1245             :   }
    1246             : 
    1247             :   V8_INLINE static void GetDefaultStrings(
    1248             :       PreParserIdentifier* default_string,
    1249             :       PreParserIdentifier* star_default_star_string) {}
    1250             : 
    1251             :   // Functions for encapsulating the differences between parsing and preparsing;
    1252             :   // operations interleaved with the recursive descent.
    1253             :   V8_INLINE static void PushLiteralName(PreParserIdentifier id) {}
    1254             :   V8_INLINE static void PushVariableName(PreParserIdentifier id) {}
    1255             :   V8_INLINE void PushPropertyName(PreParserExpression expression) {}
    1256             :   V8_INLINE void PushEnclosingName(PreParserIdentifier name) {}
    1257             :   V8_INLINE static void AddFunctionForNameInference(
    1258             :       PreParserExpression expression) {}
    1259             :   V8_INLINE static void InferFunctionName() {}
    1260             : 
    1261             :   V8_INLINE static void CheckAssigningFunctionLiteralToProperty(
    1262             :       PreParserExpression left, PreParserExpression right) {}
    1263             : 
    1264             :   V8_INLINE void MarkExpressionAsAssigned(PreParserExpression expression) {
    1265             :     // TODO(marja): To be able to produce the same errors, the preparser needs
    1266             :     // to start tracking which expressions are variables and which are assigned.
    1267     4768166 :     if (expression.variables_ != nullptr) {
    1268             :       DCHECK(FLAG_lazy_inner_functions);
    1269             :       DCHECK(track_unresolved_variables_);
    1270     1373949 :       for (auto variable : *expression.variables_) {
    1271      687138 :         variable->set_is_assigned();
    1272             :       }
    1273             :     }
    1274             :   }
    1275             : 
    1276             :   V8_INLINE bool ShortcutNumericLiteralBinaryExpression(PreParserExpression* x,
    1277             :                                                         PreParserExpression y,
    1278             :                                                         Token::Value op,
    1279             :                                                         int pos) {
    1280             :     return false;
    1281             :   }
    1282             : 
    1283             :   V8_INLINE PreParserExpression BuildUnaryExpression(
    1284             :       PreParserExpression expression, Token::Value op, int pos) {
    1285      849705 :     return PreParserExpression::Default();
    1286             :   }
    1287             : 
    1288             :   V8_INLINE PreParserExpression BuildIteratorResult(PreParserExpression value,
    1289             :                                                     bool done) {
    1290       21918 :     return PreParserExpression::Default();
    1291             :   }
    1292             : 
    1293             :   V8_INLINE PreParserStatement
    1294             :   BuildInitializationBlock(DeclarationParsingResult* parsing_result,
    1295             :                            ZoneList<const AstRawString*>* names, bool* ok) {
    1296      390417 :     for (auto declaration : parsing_result->declarations) {
    1297             :       DeclareAndInitializeVariables(PreParserStatement::Default(),
    1298             :                                     &(parsing_result->descriptor), &declaration,
    1299      199940 :                                     names, ok);
    1300             :     }
    1301      190477 :     return PreParserStatement::Default();
    1302             :   }
    1303             : 
    1304             :   V8_INLINE PreParserStatement
    1305             :   InitializeForEachStatement(PreParserStatement stmt, PreParserExpression each,
    1306             :                              PreParserExpression subject,
    1307             :                              PreParserStatement body, int each_keyword_pos) {
    1308             :     MarkExpressionAsAssigned(each);
    1309             :     return stmt;
    1310             :   }
    1311             : 
    1312             :   V8_INLINE PreParserStatement InitializeForOfStatement(
    1313             :       PreParserStatement stmt, PreParserExpression each,
    1314             :       PreParserExpression iterable, PreParserStatement body, bool finalize,
    1315             :       IteratorType type, int next_result_pos = kNoSourcePosition) {
    1316             :     MarkExpressionAsAssigned(each);
    1317             :     return stmt;
    1318             :   }
    1319             : 
    1320             :   V8_INLINE PreParserStatement RewriteForVarInLegacy(const ForInfo& for_info) {
    1321       30834 :     return PreParserStatement::Null();
    1322             :   }
    1323             : 
    1324             :   V8_INLINE void DesugarBindingInForEachStatement(
    1325             :       ForInfo* for_info, PreParserStatement* body_block,
    1326             :       PreParserExpression* each_variable, bool* ok) {
    1327       81329 :     if (track_unresolved_variables_) {
    1328             :       DCHECK(for_info->parsing_result.declarations.length() == 1);
    1329             :       bool is_for_var_of =
    1330        9409 :           for_info->mode == ForEachStatement::ITERATE &&
    1331        1813 :           for_info->parsing_result.descriptor.mode == VariableMode::VAR;
    1332             :       bool collect_names =
    1333        7596 :           IsLexicalVariableMode(for_info->parsing_result.descriptor.mode) ||
    1334             :           is_for_var_of;
    1335             : 
    1336             :       DeclareAndInitializeVariables(
    1337             :           PreParserStatement::Default(), &for_info->parsing_result.descriptor,
    1338        7596 :           &for_info->parsing_result.declarations[0],
    1339       15192 :           collect_names ? &for_info->bound_names : nullptr, ok);
    1340             :     }
    1341             :   }
    1342             : 
    1343             :   V8_INLINE PreParserStatement CreateForEachStatementTDZ(
    1344             :       PreParserStatement init_block, const ForInfo& for_info, bool* ok) {
    1345       81329 :     if (track_unresolved_variables_) {
    1346        7596 :       if (IsLexicalVariableMode(for_info.parsing_result.descriptor.mode)) {
    1347        4590 :         for (auto name : for_info.bound_names) {
    1348        2532 :           scope()->DeclareVariableName(name, LET);
    1349             :         }
    1350        2058 :         return PreParserStatement::Default();
    1351             :       }
    1352             :     }
    1353             :     return init_block;
    1354             :   }
    1355             : 
    1356             :   V8_INLINE StatementT DesugarLexicalBindingsInForStatement(
    1357             :       PreParserStatement loop, PreParserStatement init,
    1358             :       PreParserExpression cond, PreParserStatement next,
    1359             :       PreParserStatement body, Scope* inner_scope, const ForInfo& for_info,
    1360             :       bool* ok) {
    1361             :     // See Parser::DesugarLexicalBindingsInForStatement.
    1362         149 :     if (track_unresolved_variables_) {
    1363         298 :       for (auto name : for_info.bound_names) {
    1364             :         inner_scope->DeclareVariableName(
    1365         149 :             name, for_info.parsing_result.descriptor.mode);
    1366             :       }
    1367             :     }
    1368             :     return loop;
    1369             :   }
    1370             : 
    1371             :   V8_INLINE PreParserStatement BuildParameterInitializationBlock(
    1372             :       const PreParserFormalParameters& parameters, bool* ok) {
    1373       38974 :     return PreParserStatement::Default();
    1374             :   }
    1375             : 
    1376             :   V8_INLINE PreParserStatement
    1377             :   BuildRejectPromiseOnException(PreParserStatement init_block) {
    1378           0 :     return PreParserStatement::Default();
    1379             :   }
    1380             : 
    1381             :   V8_INLINE void InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope) {
    1382      232576 :     scope->HoistSloppyBlockFunctions(nullptr);
    1383             :   }
    1384             : 
    1385             :   V8_INLINE void InsertShadowingVarBindingInitializers(
    1386             :       PreParserStatement block) {}
    1387             : 
    1388             :   V8_INLINE PreParserExpression
    1389             :   NewThrowReferenceError(MessageTemplate::Template message, int pos) {
    1390        1278 :     return PreParserExpression::Default();
    1391             :   }
    1392             : 
    1393             :   V8_INLINE PreParserExpression NewThrowSyntaxError(
    1394             :       MessageTemplate::Template message, PreParserIdentifier arg, int pos) {
    1395             :     return PreParserExpression::Default();
    1396             :   }
    1397             : 
    1398             :   V8_INLINE PreParserExpression NewThrowTypeError(
    1399             :       MessageTemplate::Template message, PreParserIdentifier arg, int pos) {
    1400             :     return PreParserExpression::Default();
    1401             :   }
    1402             : 
    1403             :   // Reporting errors.
    1404             :   V8_INLINE void ReportMessageAt(Scanner::Location source_location,
    1405             :                                  MessageTemplate::Template message,
    1406             :                                  const char* arg = NULL,
    1407             :                                  ParseErrorType error_type = kSyntaxError) {
    1408             :     pending_error_handler_->ReportMessageAt(source_location.beg_pos,
    1409             :                                             source_location.end_pos, message,
    1410      501290 :                                             arg, error_type);
    1411             :   }
    1412             : 
    1413             :   V8_INLINE void ReportMessageAt(Scanner::Location source_location,
    1414             :                                  MessageTemplate::Template message,
    1415             :                                  PreParserIdentifier arg,
    1416             :                                  ParseErrorType error_type = kSyntaxError) {
    1417           0 :     UNREACHABLE();
    1418             :   }
    1419             : 
    1420             :   // "null" return type creators.
    1421             :   V8_INLINE static PreParserIdentifier EmptyIdentifier() {
    1422     2211516 :     return PreParserIdentifier::Empty();
    1423             :   }
    1424             :   V8_INLINE static bool IsEmptyIdentifier(PreParserIdentifier name) {
    1425           0 :     return name.IsEmpty();
    1426             :   }
    1427             :   V8_INLINE static PreParserExpression EmptyExpression() {
    1428    32039766 :     return PreParserExpression::Empty();
    1429             :   }
    1430             :   V8_INLINE static PreParserExpression EmptyLiteral() {
    1431             :     return PreParserExpression::Default();
    1432             :   }
    1433             :   V8_INLINE static PreParserExpression EmptyObjectLiteralProperty() {
    1434       46162 :     return PreParserExpression::Default();
    1435             :   }
    1436             :   V8_INLINE static PreParserExpression EmptyClassLiteralProperty() {
    1437       11256 :     return PreParserExpression::Default();
    1438             :   }
    1439             :   V8_INLINE static PreParserExpression EmptyFunctionLiteral() {
    1440       45046 :     return PreParserExpression::Default();
    1441             :   }
    1442             : 
    1443             :   V8_INLINE static bool IsEmptyExpression(PreParserExpression expr) {
    1444    15113140 :     return expr.IsEmpty();
    1445             :   }
    1446             : 
    1447             :   V8_INLINE static PreParserExpressionList NullExpressionList() {
    1448        4120 :     return PreParserExpressionList::Null();
    1449             :   }
    1450             : 
    1451             :   V8_INLINE static bool IsNullExpressionList(PreParserExpressionList exprs) {
    1452             :     return exprs.IsNull();
    1453             :   }
    1454             : 
    1455             :   V8_INLINE static PreParserStatementList NullStatementList() {
    1456       80470 :     return PreParserStatementList::Null();
    1457             :   }
    1458             : 
    1459             :   V8_INLINE static bool IsNullStatementList(PreParserStatementList stmts) {
    1460             :     return stmts.IsNull();
    1461             :   }
    1462             : 
    1463             :   V8_INLINE static PreParserStatement NullStatement() {
    1464     2471690 :     return PreParserStatement::Null();
    1465             :   }
    1466             : 
    1467             :   V8_INLINE bool IsNullStatement(PreParserStatement stmt) {
    1468    12831269 :     return stmt.IsNullStatement();
    1469             :   }
    1470             : 
    1471             :   V8_INLINE bool IsEmptyStatement(PreParserStatement stmt) {
    1472    12499894 :     return stmt.IsEmptyStatement();
    1473             :   }
    1474             : 
    1475             :   V8_INLINE static PreParserStatement NullBlock() {
    1476     5508126 :     return PreParserStatement::Null();
    1477             :   }
    1478             : 
    1479             :   V8_INLINE PreParserIdentifier EmptyIdentifierString() const {
    1480       81250 :     return PreParserIdentifier::Default();
    1481             :   }
    1482             : 
    1483             :   // Odd-ball literal creators.
    1484             :   V8_INLINE PreParserExpression GetLiteralTheHole(int position) {
    1485     1433435 :     return PreParserExpression::Default();
    1486             :   }
    1487             : 
    1488             :   V8_INLINE PreParserExpression GetLiteralUndefined(int position) {
    1489      183770 :     return PreParserExpression::Default();
    1490             :   }
    1491             : 
    1492             :   // Producing data during the recursive descent.
    1493             :   PreParserIdentifier GetSymbol() const;
    1494             : 
    1495             :   V8_INLINE PreParserIdentifier GetNextSymbol() const {
    1496       30906 :     return PreParserIdentifier::Default();
    1497             :   }
    1498             : 
    1499             :   V8_INLINE PreParserIdentifier GetNumberAsSymbol() const {
    1500      812734 :     return PreParserIdentifier::Default();
    1501             :   }
    1502             : 
    1503             :   V8_INLINE PreParserExpression ThisExpression(int pos = kNoSourcePosition) {
    1504             :     ZoneList<VariableProxy*>* variables = nullptr;
    1505      175561 :     if (track_unresolved_variables_) {
    1506       12794 :       AstNodeFactory factory(ast_value_factory());
    1507             :       // Setting the Zone is necessary because zone_ might be the temp Zone, and
    1508             :       // AstValueFactory doesn't know about it.
    1509       12794 :       factory.set_zone(zone());
    1510             :       VariableProxy* proxy = scope()->NewUnresolved(
    1511       12794 :           &factory, ast_value_factory()->this_string(), pos, THIS_VARIABLE);
    1512             : 
    1513       12794 :       variables = new (zone()) ZoneList<VariableProxy*>(1, zone());
    1514       12794 :       variables->Add(proxy, zone());
    1515             :     }
    1516      175561 :     return PreParserExpression::This(variables);
    1517             :   }
    1518             : 
    1519             :   V8_INLINE PreParserExpression NewSuperPropertyReference(int pos) {
    1520        1733 :     return PreParserExpression::Default();
    1521             :   }
    1522             : 
    1523             :   V8_INLINE PreParserExpression NewSuperCallReference(int pos) {
    1524         146 :     return PreParserExpression::SuperCallReference();
    1525             :   }
    1526             : 
    1527             :   V8_INLINE PreParserExpression NewTargetExpression(int pos) {
    1528        4268 :     return PreParserExpression::NewTargetExpression();
    1529             :   }
    1530             : 
    1531             :   V8_INLINE PreParserExpression FunctionSentExpression(int pos) {
    1532          58 :     return PreParserExpression::Default();
    1533             :   }
    1534             : 
    1535             :   V8_INLINE PreParserExpression ExpressionFromLiteral(Token::Value token,
    1536             :                                                       int pos) {
    1537     9492855 :     return PreParserExpression::Default();
    1538             :   }
    1539             : 
    1540             :   PreParserExpression ExpressionFromIdentifier(
    1541             :       PreParserIdentifier name, int start_position,
    1542             :       InferName infer = InferName::kYes);
    1543             : 
    1544             :   V8_INLINE PreParserExpression ExpressionFromString(int pos) {
    1545     3323053 :     if (scanner()->IsUseStrict()) {
    1546      233029 :       return PreParserExpression::UseStrictStringLiteral();
    1547             :     }
    1548     3090024 :     return PreParserExpression::StringLiteral();
    1549             :   }
    1550             : 
    1551             :   V8_INLINE PreParserExpressionList NewExpressionList(int size) const {
    1552     3980431 :     return PreParserExpressionList();
    1553             :   }
    1554             : 
    1555             :   V8_INLINE PreParserExpressionList NewObjectPropertyList(int size) const {
    1556      707192 :     return PreParserExpressionList();
    1557             :   }
    1558             : 
    1559             :   V8_INLINE PreParserExpressionList NewClassPropertyList(int size) const {
    1560       44854 :     return PreParserExpressionList();
    1561             :   }
    1562             : 
    1563             :   V8_INLINE PreParserStatementList NewStatementList(int size) const {
    1564     1006419 :     return PreParserStatementList();
    1565             :   }
    1566             : 
    1567             :   PreParserStatementList NewCaseClauseList(int size) {
    1568             :     return PreParserStatementList();
    1569             :   }
    1570             : 
    1571             :   V8_INLINE PreParserExpression
    1572             :   NewV8Intrinsic(PreParserIdentifier name, PreParserExpressionList arguments,
    1573             :                  int pos, bool* ok) {
    1574       17846 :     return PreParserExpression::Default();
    1575             :   }
    1576             : 
    1577             :   V8_INLINE PreParserStatement NewThrowStatement(PreParserExpression exception,
    1578             :                                                  int pos) {
    1579       65586 :     return PreParserStatement::Jump();
    1580             :   }
    1581             : 
    1582             :   V8_INLINE void AddParameterInitializationBlock(
    1583             :       const PreParserFormalParameters& parameters, PreParserStatementList body,
    1584             :       bool is_async, bool* ok) {}
    1585             : 
    1586             :   V8_INLINE void AddFormalParameter(PreParserFormalParameters* parameters,
    1587             :                                     PreParserExpression pattern,
    1588             :                                     PreParserExpression initializer,
    1589             :                                     int initializer_end_position,
    1590             :                                     bool is_rest) {
    1591     1584926 :     if (track_unresolved_variables_) {
    1592             :       DCHECK(FLAG_lazy_inner_functions);
    1593             :       parameters->params.Add(new (zone()) PreParserFormalParameters::Parameter(
    1594      645097 :           pattern.variables_, is_rest));
    1595             :     }
    1596     1584926 :     parameters->UpdateArityAndFunctionLength(!initializer.IsEmpty(), is_rest);
    1597             :   }
    1598             : 
    1599             :   V8_INLINE void DeclareFormalParameters(
    1600             :       DeclarationScope* scope,
    1601             :       const ThreadedList<PreParserFormalParameters::Parameter>& parameters) {
    1602     2402874 :     bool is_simple = classifier()->is_simple_parameter_list();
    1603     1751746 :     if (!is_simple) scope->SetHasNonSimpleParameters();
    1604     1751746 :     if (track_unresolved_variables_) {
    1605             :       DCHECK(FLAG_lazy_inner_functions);
    1606     1199193 :       for (auto parameter : parameters) {
    1607      644413 :         if (parameter->variables_ != nullptr) {
    1608     1295401 :           for (auto variable : (*parameter->variables_)) {
    1609             :             scope->DeclareParameterName(
    1610      651128 :                 variable->raw_name(), parameter->is_rest, ast_value_factory());
    1611             :           }
    1612             :         }
    1613             :       }
    1614             :     }
    1615             :   }
    1616             : 
    1617             :   V8_INLINE void DeclareArrowFunctionFormalParameters(
    1618             :       PreParserFormalParameters* parameters, PreParserExpression params,
    1619             :       const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
    1620             :       bool* ok) {
    1621             :     // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect
    1622             :     // parameter lists that are too long.
    1623       83542 :     if (track_unresolved_variables_) {
    1624             :       DCHECK(FLAG_lazy_inner_functions);
    1625       12252 :       if (params.variables_ != nullptr) {
    1626       16391 :         for (auto variable : *params.variables_) {
    1627       10817 :           parameters->scope->DeclareVariableName(variable->raw_name(), VAR);
    1628             :         }
    1629             :       }
    1630             :     }
    1631             :   }
    1632             : 
    1633             :   V8_INLINE PreParserExpression NoTemplateTag() {
    1634       32357 :     return PreParserExpression::NoTemplateTag();
    1635             :   }
    1636             : 
    1637             :   V8_INLINE static bool IsTaggedTemplate(const PreParserExpression tag) {
    1638             :     return !tag.IsNoTemplateTag();
    1639             :   }
    1640             : 
    1641             :   V8_INLINE PreParserExpression
    1642             :   ExpressionListToExpression(PreParserExpressionList args) {
    1643         200 :     return PreParserExpression::Default(args.variables_);
    1644             :   }
    1645             : 
    1646             :   V8_INLINE void AddAccessorPrefixToFunctionName(bool is_get,
    1647             :                                                  PreParserExpression function,
    1648             :                                                  PreParserIdentifier name) {}
    1649             :   V8_INLINE void SetFunctionNameFromPropertyName(PreParserExpression property,
    1650             :                                                  PreParserIdentifier name) {}
    1651             :   V8_INLINE void SetFunctionNameFromIdentifierRef(
    1652             :       PreParserExpression value, PreParserExpression identifier) {}
    1653             : 
    1654             :   V8_INLINE ZoneList<typename ExpressionClassifier::Error>*
    1655             :   GetReportedErrorList() const {
    1656    73521557 :     return function_state_->GetReportedErrorList();
    1657             :   }
    1658             : 
    1659             :   V8_INLINE ZoneList<PreParserExpression>* GetNonPatternList() const {
    1660    73521558 :     return function_state_->non_patterns_to_rewrite();
    1661             :   }
    1662             : 
    1663             :   V8_INLINE void CountUsage(v8::Isolate::UseCounterFeature feature) {
    1664        1278 :     if (use_counts_ != nullptr) ++use_counts_[feature];
    1665             :   }
    1666             : 
    1667             :   V8_INLINE bool ParsingDynamicFunctionDeclaration() const { return false; }
    1668             : 
    1669             :   // Preparser's private field members.
    1670             : 
    1671             :   int* use_counts_;
    1672             :   std::unique_ptr<PreParseData> preparse_data_;
    1673             :   bool track_unresolved_variables_;
    1674             :   PreParserLogger log_;
    1675             :   PendingCompilationErrorHandler* pending_error_handler_;
    1676             : };
    1677             : 
    1678             : PreParserExpression PreParser::SpreadCall(PreParserExpression function,
    1679             :                                           PreParserExpressionList args, int pos,
    1680             :                                           Call::PossiblyEval possibly_eval) {
    1681        1272 :   return factory()->NewCall(function, args, pos, possibly_eval);
    1682             : }
    1683             : 
    1684             : PreParserExpression PreParser::SpreadCallNew(PreParserExpression function,
    1685             :                                              PreParserExpressionList args,
    1686             :                                              int pos) {
    1687          21 :   return factory()->NewCallNew(function, args, pos);
    1688             : }
    1689             : 
    1690             : PreParserExpression PreParser::CloseTemplateLiteral(TemplateLiteralState* state,
    1691             :                                                     int start,
    1692             :                                                     PreParserExpression tag) {
    1693             :   return EmptyExpression();
    1694             : }
    1695             : 
    1696             : }  // namespace internal
    1697             : }  // namespace v8
    1698             : 
    1699             : #endif  // V8_PARSING_PREPARSER_H

Generated by: LCOV version 1.10