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_PARSER_H_
6 #define V8_PARSING_PARSER_H_
7 
8 #include "src/ast/ast.h"
9 #include "src/ast/scopes.h"
10 #include "src/base/compiler-specific.h"
11 #include "src/globals.h"
12 #include "src/parsing/parser-base.h"
13 #include "src/parsing/parsing.h"
14 #include "src/parsing/preparse-data-format.h"
15 #include "src/parsing/preparse-data.h"
16 #include "src/parsing/preparser.h"
17 #include "src/pending-compilation-error-handler.h"
18 #include "src/utils.h"
19 
20 namespace v8 {
21 
22 class ScriptCompiler;
23 
24 namespace internal {
25 
26 class ParseInfo;
27 class ScriptData;
28 class ParserTarget;
29 class ParserTargetScope;
30 class PreParsedScopeData;
31 
32 class FunctionEntry BASE_EMBEDDED {
33  public:
34   enum {
35     kStartPositionIndex,
36     kEndPositionIndex,
37     kNumParametersIndex,
38     kFunctionLengthIndex,
39     kPropertyCountIndex,
40     kFlagsIndex,
41     kNumInnerFunctionsIndex,
42     kSize
43   };
44 
FunctionEntry(Vector<unsigned> backing)45   explicit FunctionEntry(Vector<unsigned> backing)
46     : backing_(backing) { }
47 
FunctionEntry()48   FunctionEntry() : backing_() { }
49 
50   class LanguageModeField : public BitField<LanguageMode, 0, 1> {};
51   class UsesSuperPropertyField
52       : public BitField<bool, LanguageModeField::kNext, 1> {};
53   class CallsEvalField
54       : public BitField<bool, UsesSuperPropertyField::kNext, 1> {};
55   class HasDuplicateParametersField
56       : public BitField<bool, CallsEvalField::kNext, 1> {};
57 
EncodeFlags(LanguageMode language_mode,bool uses_super_property,bool calls_eval,bool has_duplicate_parameters)58   static uint32_t EncodeFlags(LanguageMode language_mode,
59                               bool uses_super_property, bool calls_eval,
60                               bool has_duplicate_parameters) {
61     return LanguageModeField::encode(language_mode) |
62            UsesSuperPropertyField::encode(uses_super_property) |
63            CallsEvalField::encode(calls_eval) |
64            HasDuplicateParametersField::encode(has_duplicate_parameters);
65   }
66 
start_pos()67   int start_pos() const { return backing_[kStartPositionIndex]; }
end_pos()68   int end_pos() const { return backing_[kEndPositionIndex]; }
num_parameters()69   int num_parameters() const { return backing_[kNumParametersIndex]; }
function_length()70   int function_length() const { return backing_[kFunctionLengthIndex]; }
property_count()71   int property_count() const { return backing_[kPropertyCountIndex]; }
language_mode()72   LanguageMode language_mode() const {
73     return LanguageModeField::decode(backing_[kFlagsIndex]);
74   }
uses_super_property()75   bool uses_super_property() const {
76     return UsesSuperPropertyField::decode(backing_[kFlagsIndex]);
77   }
calls_eval()78   bool calls_eval() const {
79     return CallsEvalField::decode(backing_[kFlagsIndex]);
80   }
has_duplicate_parameters()81   bool has_duplicate_parameters() const {
82     return HasDuplicateParametersField::decode(backing_[kFlagsIndex]);
83   }
num_inner_functions()84   int num_inner_functions() const { return backing_[kNumInnerFunctionsIndex]; }
85 
is_valid()86   bool is_valid() const { return !backing_.is_empty(); }
87 
88  private:
89   Vector<unsigned> backing_;
90 };
91 
92 
93 // Wrapper around ScriptData to provide parser-specific functionality.
94 class ParseData {
95  public:
FromCachedData(ScriptData * cached_data)96   static ParseData* FromCachedData(ScriptData* cached_data) {
97     ParseData* pd = new ParseData(cached_data);
98     if (pd->IsSane()) return pd;
99     cached_data->Reject();
100     delete pd;
101     return NULL;
102   }
103 
104   void Initialize();
105   FunctionEntry GetFunctionEntry(int start);
106   int FunctionCount();
107 
Data()108   unsigned* Data() {  // Writable data as unsigned int array.
109     return reinterpret_cast<unsigned*>(const_cast<byte*>(script_data_->data()));
110   }
111 
Reject()112   void Reject() { script_data_->Reject(); }
113 
rejected()114   bool rejected() const { return script_data_->rejected(); }
115 
116  private:
ParseData(ScriptData * script_data)117   explicit ParseData(ScriptData* script_data) : script_data_(script_data) {}
118 
119   bool IsSane();
120   unsigned Magic();
121   unsigned Version();
122   int FunctionsSize();
Length()123   int Length() const {
124     // Script data length is already checked to be a multiple of unsigned size.
125     return script_data_->length() / sizeof(unsigned);
126   }
127 
128   ScriptData* script_data_;
129   int function_index_;
130 
131   DISALLOW_COPY_AND_ASSIGN(ParseData);
132 };
133 
134 // ----------------------------------------------------------------------------
135 // JAVASCRIPT PARSING
136 
137 class Parser;
138 
139 
140 struct ParserFormalParameters : FormalParametersBase {
141   struct Parameter : public ZoneObject {
ParameterParserFormalParameters::Parameter142     Parameter(const AstRawString* name, Expression* pattern,
143               Expression* initializer, int initializer_end_position,
144               bool is_rest)
145         : name(name),
146           pattern(pattern),
147           initializer(initializer),
148           initializer_end_position(initializer_end_position),
149           is_rest(is_rest) {}
150     const AstRawString* name;
151     Expression* pattern;
152     Expression* initializer;
153     int initializer_end_position;
154     bool is_rest;
155     Parameter* next_parameter = nullptr;
is_simpleParserFormalParameters::Parameter156     bool is_simple() const {
157       return pattern->IsVariableProxy() && initializer == nullptr && !is_rest;
158     }
159 
is_nondestructuring_restParserFormalParameters::Parameter160     bool is_nondestructuring_rest() const {
161       DCHECK_IMPLIES(is_rest, initializer == nullptr);
162       return is_rest && pattern->IsVariableProxy();
163     }
164 
nextParserFormalParameters::Parameter165     Parameter** next() { return &next_parameter; }
nextParserFormalParameters::Parameter166     Parameter* const* next() const { return &next_parameter; }
167   };
168 
ParserFormalParametersParserFormalParameters169   explicit ParserFormalParameters(DeclarationScope* scope)
170       : FormalParametersBase(scope) {}
171   ThreadedList<Parameter> params;
172 };
173 
174 template <>
175 struct ParserTypes<Parser> {
176   typedef ParserBase<Parser> Base;
177   typedef Parser Impl;
178 
179   typedef v8::internal::Variable Variable;
180 
181   // Return types for traversing functions.
182   typedef const AstRawString* Identifier;
183   typedef v8::internal::Expression* Expression;
184   typedef v8::internal::FunctionLiteral* FunctionLiteral;
185   typedef ObjectLiteral::Property* ObjectLiteralProperty;
186   typedef ClassLiteral::Property* ClassLiteralProperty;
187   typedef ZoneList<v8::internal::Expression*>* ExpressionList;
188   typedef ZoneList<ObjectLiteral::Property*>* ObjectPropertyList;
189   typedef ZoneList<ClassLiteral::Property*>* ClassPropertyList;
190   typedef ParserFormalParameters FormalParameters;
191   typedef v8::internal::Statement* Statement;
192   typedef ZoneList<v8::internal::Statement*>* StatementList;
193   typedef v8::internal::Block* Block;
194   typedef v8::internal::BreakableStatement* BreakableStatement;
195   typedef v8::internal::IterationStatement* IterationStatement;
196 
197   // For constructing objects returned by the traversing functions.
198   typedef AstNodeFactory Factory;
199 
200   typedef ParserTarget Target;
201   typedef ParserTargetScope TargetScope;
202 };
203 
204 class V8_EXPORT_PRIVATE Parser : public NON_EXPORTED_BASE(ParserBase<Parser>) {
205  public:
206   explicit Parser(ParseInfo* info);
207   ~Parser() {
208     delete reusable_preparser_;
209     reusable_preparser_ = NULL;
210     delete cached_parse_data_;
211     cached_parse_data_ = NULL;
212   }
213 
214   static bool const IsPreParser() { return false; }
215 
216   void ParseOnBackground(ParseInfo* info);
217 
218   // Deserialize the scope chain prior to parsing in which the script is going
219   // to be executed. If the script is a top-level script, or the scope chain
220   // consists of only a native context, maybe_outer_scope_info should be an
221   // empty handle.
222   //
223   // This only deserializes the scope chain, but doesn't connect the scopes to
224   // their corresponding scope infos. Therefore, looking up variables in the
225   // deserialized scopes is not possible.
226   void DeserializeScopeChain(ParseInfo* info,
227                              MaybeHandle<ScopeInfo> maybe_outer_scope_info);
228 
229   // Handle errors detected during parsing
230   void ReportErrors(Isolate* isolate, Handle<Script> script);
231   // Move statistics to Isolate
232   void UpdateStatistics(Isolate* isolate, Handle<Script> script);
233   void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
234 
235  private:
236   friend class ParserBase<Parser>;
237   friend class v8::internal::ExpressionClassifier<ParserTypes<Parser>>;
238   friend bool v8::internal::parsing::ParseProgram(ParseInfo*, bool);
239   friend bool v8::internal::parsing::ParseFunction(ParseInfo*, bool);
240 
241   bool AllowsLazyParsingWithoutUnresolvedVariables() const {
242     return scope()->AllowsLazyParsingWithoutUnresolvedVariables(
243         original_scope_);
244   }
245 
246   bool parse_lazily() const { return mode_ == PARSE_LAZILY; }
247   enum Mode { PARSE_LAZILY, PARSE_EAGERLY };
248 
249   class ParsingModeScope BASE_EMBEDDED {
250    public:
251     ParsingModeScope(Parser* parser, Mode mode)
252         : parser_(parser), old_mode_(parser->mode_) {
253       parser_->mode_ = mode;
254     }
255     ~ParsingModeScope() { parser_->mode_ = old_mode_; }
256 
257    private:
258     Parser* parser_;
259     Mode old_mode_;
260   };
261 
262   // Runtime encoding of different completion modes.
263   enum CompletionKind {
264     kNormalCompletion,
265     kThrowCompletion,
266     kAbruptCompletion
267   };
268 
269   Variable* NewTemporary(const AstRawString* name) {
270     return scope()->NewTemporary(name);
271   }
272 
273   void PrepareGeneratorVariables();
274 
275   // Limit the allowed number of local variables in a function. The hard limit
276   // is that offsets computed by FullCodeGenerator::StackOperand and similar
277   // functions are ints, and they should not overflow. In addition, accessing
278   // local variables creates user-controlled constants in the generated code,
279   // and we don't want too much user-controlled memory inside the code (this was
280   // the reason why this limit was introduced in the first place; see
281   // https://codereview.chromium.org/7003030/ ).
282   static const int kMaxNumFunctionLocals = 4194303;  // 2^22-1
283 
284   // Returns NULL if parsing failed.
285   FunctionLiteral* ParseProgram(Isolate* isolate, ParseInfo* info);
286 
287   FunctionLiteral* ParseFunction(Isolate* isolate, ParseInfo* info);
288   FunctionLiteral* DoParseFunction(ParseInfo* info,
289                                    const AstRawString* raw_name,
290                                    Utf16CharacterStream* source);
291 
292   // Called by ParseProgram after setting up the scanner.
293   FunctionLiteral* DoParseProgram(ParseInfo* info);
294 
295   void SetCachedData(ParseInfo* info);
296 
297   ScriptCompiler::CompileOptions compile_options() const {
298     return compile_options_;
299   }
300   bool consume_cached_parse_data() const {
301     return compile_options_ == ScriptCompiler::kConsumeParserCache;
302   }
303   bool produce_cached_parse_data() const {
304     return compile_options_ == ScriptCompiler::kProduceParserCache;
305   }
306 
307   void ParseModuleItemList(ZoneList<Statement*>* body, bool* ok);
308   Statement* ParseModuleItem(bool* ok);
309   const AstRawString* ParseModuleSpecifier(bool* ok);
310   void ParseImportDeclaration(bool* ok);
311   Statement* ParseExportDeclaration(bool* ok);
312   Statement* ParseExportDefault(bool* ok);
313   void ParseExportClause(ZoneList<const AstRawString*>* export_names,
314                          ZoneList<Scanner::Location>* export_locations,
315                          ZoneList<const AstRawString*>* local_names,
316                          Scanner::Location* reserved_loc, bool* ok);
317   struct NamedImport : public ZoneObject {
318     const AstRawString* import_name;
319     const AstRawString* local_name;
320     const Scanner::Location location;
321     NamedImport(const AstRawString* import_name, const AstRawString* local_name,
322                 Scanner::Location location)
323         : import_name(import_name),
324           local_name(local_name),
325           location(location) {}
326   };
327   ZoneList<const NamedImport*>* ParseNamedImports(int pos, bool* ok);
328   Block* BuildInitializationBlock(DeclarationParsingResult* parsing_result,
329                                   ZoneList<const AstRawString*>* names,
330                                   bool* ok);
331   void DeclareAndInitializeVariables(
332       Block* block, const DeclarationDescriptor* declaration_descriptor,
333       const DeclarationParsingResult::Declaration* declaration,
334       ZoneList<const AstRawString*>* names, bool* ok);
335   ZoneList<const AstRawString*>* DeclareLabel(
336       ZoneList<const AstRawString*>* labels, VariableProxy* expr, bool* ok);
337   bool ContainsLabel(ZoneList<const AstRawString*>* labels,
338                      const AstRawString* label);
339   Expression* RewriteReturn(Expression* return_value, int pos);
340   Statement* RewriteSwitchStatement(Expression* tag,
341                                     SwitchStatement* switch_statement,
342                                     ZoneList<CaseClause*>* cases, Scope* scope);
343   void RewriteCatchPattern(CatchInfo* catch_info, bool* ok);
344   void ValidateCatchBlock(const CatchInfo& catch_info, bool* ok);
345   Statement* RewriteTryStatement(Block* try_block, Block* catch_block,
346                                  Block* finally_block,
347                                  const CatchInfo& catch_info, int pos);
348 
349   void ParseAndRewriteGeneratorFunctionBody(int pos, FunctionKind kind,
350                                             ZoneList<Statement*>* body,
351                                             bool* ok);
352   void CreateFunctionNameAssignment(const AstRawString* function_name, int pos,
353                                     FunctionLiteral::FunctionType function_type,
354                                     DeclarationScope* function_scope,
355                                     ZoneList<Statement*>* result, int index);
356 
357   Statement* DeclareFunction(const AstRawString* variable_name,
358                              FunctionLiteral* function, VariableMode mode,
359                              int pos, bool is_sloppy_block_function,
360                              ZoneList<const AstRawString*>* names, bool* ok);
361   V8_INLINE Statement* DeclareClass(const AstRawString* variable_name,
362                                     Expression* value,
363                                     ZoneList<const AstRawString*>* names,
364                                     int class_token_pos, int end_pos, bool* ok);
365   V8_INLINE void DeclareClassVariable(const AstRawString* name,
366                                       ClassInfo* class_info,
367                                       int class_token_pos, bool* ok);
368   V8_INLINE void DeclareClassProperty(const AstRawString* class_name,
369                                       ClassLiteralProperty* property,
370                                       ClassLiteralProperty::Kind kind,
371                                       bool is_static, bool is_constructor,
372                                       ClassInfo* class_info, bool* ok);
373   V8_INLINE Expression* RewriteClassLiteral(const AstRawString* name,
374                                             ClassInfo* class_info, int pos,
375                                             bool* ok);
376   V8_INLINE Statement* DeclareNative(const AstRawString* name, int pos,
377                                      bool* ok);
378 
379   class PatternRewriter final : public AstVisitor<PatternRewriter> {
380    public:
381     static void DeclareAndInitializeVariables(
382         Parser* parser, Block* block,
383         const DeclarationDescriptor* declaration_descriptor,
384         const DeclarationParsingResult::Declaration* declaration,
385         ZoneList<const AstRawString*>* names, bool* ok);
386 
387     static void RewriteDestructuringAssignment(Parser* parser,
388                                                RewritableExpression* expr,
389                                                Scope* Scope);
390 
391     static Expression* RewriteDestructuringAssignment(Parser* parser,
392                                                       Assignment* assignment,
393                                                       Scope* scope);
394 
395    private:
396     PatternRewriter() {}
397 
398 #define DECLARE_VISIT(type) void Visit##type(v8::internal::type* node);
399     // Visiting functions for AST nodes make this an AstVisitor.
400     AST_NODE_LIST(DECLARE_VISIT)
401 #undef DECLARE_VISIT
402 
403     enum PatternContext {
404       BINDING,
405       INITIALIZER,
406       ASSIGNMENT,
407       ASSIGNMENT_INITIALIZER
408     };
409 
410     PatternContext context() const { return context_; }
411     void set_context(PatternContext context) { context_ = context; }
412 
413     void RecurseIntoSubpattern(AstNode* pattern, Expression* value) {
414       Expression* old_value = current_value_;
415       current_value_ = value;
416       recursion_level_++;
417       Visit(pattern);
418       recursion_level_--;
419       current_value_ = old_value;
420     }
421 
422     void VisitObjectLiteral(ObjectLiteral* node, Variable** temp_var);
423     void VisitArrayLiteral(ArrayLiteral* node, Variable** temp_var);
424 
425     bool IsBindingContext() const {
426       return context_ == BINDING || context_ == INITIALIZER;
427     }
428     bool IsInitializerContext() const { return context_ != ASSIGNMENT; }
429     bool IsAssignmentContext() const {
430       return context_ == ASSIGNMENT || context_ == ASSIGNMENT_INITIALIZER;
431     }
432     bool IsSubPattern() const { return recursion_level_ > 1; }
433     PatternContext SetAssignmentContextIfNeeded(Expression* node);
434     PatternContext SetInitializerContextIfNeeded(Expression* node);
435 
436     bool DeclaresParameterContainingSloppyEval() const;
437     void RewriteParameterScopes(Expression* expr);
438 
439     Variable* CreateTempVar(Expression* value = nullptr);
440 
441     AstNodeFactory* factory() const { return parser_->factory(); }
442     AstValueFactory* ast_value_factory() const {
443       return parser_->ast_value_factory();
444     }
445     Zone* zone() const { return parser_->zone(); }
446     Scope* scope() const { return scope_; }
447 
448     Scope* scope_;
449     Parser* parser_;
450     PatternContext context_;
451     Expression* pattern_;
452     int initializer_position_;
453     Block* block_;
454     const DeclarationDescriptor* descriptor_;
455     ZoneList<const AstRawString*>* names_;
456     Expression* current_value_;
457     int recursion_level_;
458     bool* ok_;
459 
460     DEFINE_AST_VISITOR_MEMBERS_WITHOUT_STACKOVERFLOW()
461   };
462 
463   // [if (IteratorType == kAsync)]
464   //     !%_IsJSReceiver(result = Await(iterator.next()) &&
465   //         %ThrowIteratorResultNotAnObject(result)
466   // [else]
467   //     !%_IsJSReceiver(result = iterator.next()) &&
468   //         %ThrowIteratorResultNotAnObject(result)
469   // [endif]
470   Expression* BuildIteratorNextResult(Expression* iterator, Variable* result,
471                                       IteratorType type, int pos);
472 
473   // Initialize the components of a for-in / for-of statement.
474   Statement* InitializeForEachStatement(ForEachStatement* stmt,
475                                         Expression* each, Expression* subject,
476                                         Statement* body, int each_keyword_pos);
477   Statement* InitializeForOfStatement(ForOfStatement* stmt, Expression* each,
478                                       Expression* iterable, Statement* body,
479                                       bool finalize, IteratorType type,
480                                       int next_result_pos = kNoSourcePosition);
481 
482   Block* RewriteForVarInLegacy(const ForInfo& for_info);
483   void DesugarBindingInForEachStatement(ForInfo* for_info, Block** body_block,
484                                         Expression** each_variable, bool* ok);
485   Block* CreateForEachStatementTDZ(Block* init_block, const ForInfo& for_info,
486                                    bool* ok);
487 
488   Statement* DesugarLexicalBindingsInForStatement(
489       ForStatement* loop, Statement* init, Expression* cond, Statement* next,
490       Statement* body, Scope* inner_scope, const ForInfo& for_info, bool* ok);
491 
492   Expression* RewriteDoExpression(Block* body, int pos, bool* ok);
493 
494   FunctionLiteral* ParseFunctionLiteral(
495       const AstRawString* name, Scanner::Location function_name_location,
496       FunctionNameValidity function_name_validity, FunctionKind kind,
497       int function_token_position, FunctionLiteral::FunctionType type,
498       LanguageMode language_mode, bool* ok);
499 
500   // Get odd-ball literals.
501   Literal* GetLiteralUndefined(int position);
502 
503   // Check if the scope has conflicting var/let declarations from different
504   // scopes. This covers for example
505   //
506   // function f() { { { var x; } let x; } }
507   // function g() { { var x; let x; } }
508   //
509   // The var declarations are hoisted to the function scope, but originate from
510   // a scope where the name has also been let bound or the var declaration is
511   // hoisted over such a scope.
512   void CheckConflictingVarDeclarations(Scope* scope, bool* ok);
513 
514   // Insert initializer statements for var-bindings shadowing parameter bindings
515   // from a non-simple parameter list.
516   void InsertShadowingVarBindingInitializers(Block* block);
517 
518   // Implement sloppy block-scoped functions, ES2015 Annex B 3.3
519   void InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope);
520 
521   VariableProxy* NewUnresolved(const AstRawString* name, int begin_pos,
522                                VariableKind kind = NORMAL_VARIABLE);
523   VariableProxy* NewUnresolved(const AstRawString* name);
524   Variable* Declare(Declaration* declaration,
525                     DeclarationDescriptor::Kind declaration_kind,
526                     VariableMode mode, InitializationFlag init, bool* ok,
527                     Scope* declaration_scope = nullptr,
528                     int var_end_pos = kNoSourcePosition);
529   Declaration* DeclareVariable(const AstRawString* name, VariableMode mode,
530                                int pos, bool* ok);
531   Declaration* DeclareVariable(const AstRawString* name, VariableMode mode,
532                                InitializationFlag init, int pos, bool* ok);
533 
534   bool TargetStackContainsLabel(const AstRawString* label);
535   BreakableStatement* LookupBreakTarget(const AstRawString* label, bool* ok);
536   IterationStatement* LookupContinueTarget(const AstRawString* label, bool* ok);
537 
538   Statement* BuildAssertIsCoercible(Variable* var);
539 
540   // Factory methods.
541   FunctionLiteral* DefaultConstructor(const AstRawString* name, bool call_super,
542                                       int pos, int end_pos);
543 
544   // Skip over a lazy function, either using cached data if we have it, or
545   // by parsing the function with PreParser. Consumes the ending }.
546   // If may_abort == true, the (pre-)parser may decide to abort skipping
547   // in order to force the function to be eagerly parsed, after all.
548   LazyParsingResult SkipFunction(FunctionKind kind,
549                                  DeclarationScope* function_scope,
550                                  int* num_parameters, int* function_length,
551                                  bool* has_duplicate_parameters,
552                                  int* expected_property_count,
553                                  bool is_inner_function, bool may_abort,
554                                  bool* ok);
555 
556   Block* BuildParameterInitializationBlock(
557       const ParserFormalParameters& parameters, bool* ok);
558   Block* BuildRejectPromiseOnException(Block* block);
559 
560   ZoneList<Statement*>* ParseFunction(
561       const AstRawString* function_name, int pos, FunctionKind kind,
562       FunctionLiteral::FunctionType function_type,
563       DeclarationScope* function_scope, int* num_parameters,
564       int* function_length, bool* has_duplicate_parameters,
565       int* expected_property_count, bool* ok);
566 
567   void ThrowPendingError(Isolate* isolate, Handle<Script> script);
568 
569   class TemplateLiteral : public ZoneObject {
570    public:
571     TemplateLiteral(Zone* zone, int pos)
572         : cooked_(8, zone), raw_(8, zone), expressions_(8, zone), pos_(pos) {}
573 
574     const ZoneList<Expression*>* cooked() const { return &cooked_; }
575     const ZoneList<Expression*>* raw() const { return &raw_; }
576     const ZoneList<Expression*>* expressions() const { return &expressions_; }
577     int position() const { return pos_; }
578 
579     void AddTemplateSpan(Literal* cooked, Literal* raw, int end, Zone* zone) {
580       DCHECK_NOT_NULL(cooked);
581       DCHECK_NOT_NULL(raw);
582       cooked_.Add(cooked, zone);
583       raw_.Add(raw, zone);
584     }
585 
586     void AddExpression(Expression* expression, Zone* zone) {
587       DCHECK_NOT_NULL(expression);
588       expressions_.Add(expression, zone);
589     }
590 
591    private:
592     ZoneList<Expression*> cooked_;
593     ZoneList<Expression*> raw_;
594     ZoneList<Expression*> expressions_;
595     int pos_;
596   };
597 
598   typedef TemplateLiteral* TemplateLiteralState;
599 
600   TemplateLiteralState OpenTemplateLiteral(int pos);
601   // "should_cook" means that the span can be "cooked": in tagged template
602   // literals, both the raw and "cooked" representations are available to user
603   // code ("cooked" meaning that escape sequences are converted to their
604   // interpreted values). With the --harmony-template-escapes flag, invalid
605   // escape sequences cause the cooked span to be represented by undefined,
606   // instead of being a syntax error.
607   // "tail" indicates that this span is the last in the literal.
608   void AddTemplateSpan(TemplateLiteralState* state, bool should_cook,
609                        bool tail);
610   void AddTemplateExpression(TemplateLiteralState* state,
611                              Expression* expression);
612   Expression* CloseTemplateLiteral(TemplateLiteralState* state, int start,
613                                    Expression* tag);
614   uint32_t ComputeTemplateLiteralHash(const TemplateLiteral* lit);
615 
616   ZoneList<Expression*>* PrepareSpreadArguments(ZoneList<Expression*>* list);
617   Expression* SpreadCall(Expression* function, ZoneList<Expression*>* args,
618                          int pos, Call::PossiblyEval is_possibly_eval);
619   Expression* SpreadCallNew(Expression* function, ZoneList<Expression*>* args,
620                             int pos);
621   Expression* RewriteSuperCall(Expression* call_expression);
622 
623   void SetLanguageMode(Scope* scope, LanguageMode mode);
624   void SetAsmModule();
625 
626   V8_INLINE void MarkCollectedTailCallExpressions();
627   V8_INLINE void MarkTailPosition(Expression* expression);
628 
629   // Rewrite all DestructuringAssignments in the current FunctionState.
630   V8_INLINE void RewriteDestructuringAssignments();
631 
632   V8_INLINE Expression* RewriteExponentiation(Expression* left,
633                                               Expression* right, int pos);
634   V8_INLINE Expression* RewriteAssignExponentiation(Expression* left,
635                                                     Expression* right, int pos);
636 
637   friend class NonPatternRewriter;
638   V8_INLINE Expression* RewriteSpreads(ArrayLiteral* lit);
639 
640   // Rewrite expressions that are not used as patterns
641   V8_INLINE void RewriteNonPattern(bool* ok);
642 
643   V8_INLINE void QueueDestructuringAssignmentForRewriting(
644       Expression* assignment);
645   V8_INLINE void QueueNonPatternForRewriting(Expression* expr, bool* ok);
646 
647   friend class InitializerRewriter;
648   void RewriteParameterInitializer(Expression* expr, Scope* scope);
649 
650   Expression* BuildInitialYield(int pos, FunctionKind kind);
651   Assignment* BuildCreateJSGeneratorObject(int pos, FunctionKind kind);
652   Expression* BuildResolvePromise(Expression* value, int pos);
653   Expression* BuildRejectPromise(Expression* value, int pos);
654   Variable* PromiseVariable();
655 
656   // Generic AST generator for throwing errors from compiled code.
657   Expression* NewThrowError(Runtime::FunctionId function_id,
658                             MessageTemplate::Template message,
659                             const AstRawString* arg, int pos);
660 
661   void FinalizeIteratorUse(Scope* use_scope, Variable* completion,
662                            Expression* condition, Variable* iter,
663                            Block* iterator_use, Block* result,
664                            IteratorType type);
665 
666   Statement* FinalizeForOfStatement(ForOfStatement* loop, Variable* completion,
667                                     IteratorType type, int pos);
668   void BuildIteratorClose(ZoneList<Statement*>* statements, Variable* iterator,
669                           Variable* input, Variable* output);
670   void BuildIteratorCloseForCompletion(Scope* scope,
671                                        ZoneList<Statement*>* statements,
672                                        Variable* iterator,
673                                        Expression* completion,
674                                        IteratorType type);
675   Statement* CheckCallable(Variable* var, Expression* error, int pos);
676 
677   V8_INLINE Expression* RewriteAwaitExpression(Expression* value, int pos);
678   V8_INLINE void PrepareAsyncFunctionBody(ZoneList<Statement*>* body,
679                                           FunctionKind kind, int pos);
680   V8_INLINE void RewriteAsyncFunctionBody(ZoneList<Statement*>* body,
681                                           Block* block,
682                                           Expression* return_value, bool* ok);
683 
684   Expression* RewriteYieldStar(Expression* generator, Expression* expression,
685                                int pos);
686 
687   void AddArrowFunctionFormalParameters(ParserFormalParameters* parameters,
688                                         Expression* params, int end_pos,
689                                         bool* ok);
690   void SetFunctionName(Expression* value, const AstRawString* name);
691 
692   // Helper functions for recursive descent.
693   V8_INLINE bool IsEval(const AstRawString* identifier) const {
694     return identifier == ast_value_factory()->eval_string();
695   }
696 
697   V8_INLINE bool IsArguments(const AstRawString* identifier) const {
698     return identifier == ast_value_factory()->arguments_string();
699   }
700 
701   V8_INLINE bool IsEvalOrArguments(const AstRawString* identifier) const {
702     return IsEval(identifier) || IsArguments(identifier);
703   }
704 
705   V8_INLINE bool IsUndefined(const AstRawString* identifier) const {
706     return identifier == ast_value_factory()->undefined_string();
707   }
708 
709   // Returns true if the expression is of type "this.foo".
710   V8_INLINE static bool IsThisProperty(Expression* expression) {
711     DCHECK(expression != NULL);
712     Property* property = expression->AsProperty();
713     return property != NULL && property->obj()->IsVariableProxy() &&
714            property->obj()->AsVariableProxy()->is_this();
715   }
716 
717   // This returns true if the expression is an indentifier (wrapped
718   // inside a variable proxy).  We exclude the case of 'this', which
719   // has been converted to a variable proxy.
720   V8_INLINE static bool IsIdentifier(Expression* expression) {
721     DCHECK_NOT_NULL(expression);
722     VariableProxy* operand = expression->AsVariableProxy();
723     return operand != nullptr && !operand->is_this();
724   }
725 
726   V8_INLINE static const AstRawString* AsIdentifier(Expression* expression) {
727     DCHECK(IsIdentifier(expression));
728     return expression->AsVariableProxy()->raw_name();
729   }
730 
731   V8_INLINE VariableProxy* AsIdentifierExpression(Expression* expression) {
732     return expression->AsVariableProxy();
733   }
734 
735   V8_INLINE bool IsPrototype(const AstRawString* identifier) const {
736     return identifier == ast_value_factory()->prototype_string();
737   }
738 
739   V8_INLINE bool IsConstructor(const AstRawString* identifier) const {
740     return identifier == ast_value_factory()->constructor_string();
741   }
742 
743   V8_INLINE bool IsName(const AstRawString* identifier) const {
744     return identifier == ast_value_factory()->name_string();
745   }
746 
747   V8_INLINE static bool IsBoilerplateProperty(
748       ObjectLiteral::Property* property) {
749     return ObjectLiteral::IsBoilerplateProperty(property);
750   }
751 
752   V8_INLINE bool IsNative(Expression* expr) const {
753     DCHECK_NOT_NULL(expr);
754     return expr->IsVariableProxy() &&
755            expr->AsVariableProxy()->raw_name() ==
756                ast_value_factory()->native_string();
757   }
758 
759   V8_INLINE static bool IsArrayIndex(const AstRawString* string,
760                                      uint32_t* index) {
761     return string->AsArrayIndex(index);
762   }
763 
764   V8_INLINE bool IsUseStrictDirective(Statement* statement) const {
765     return IsStringLiteral(statement, ast_value_factory()->use_strict_string());
766   }
767 
768   V8_INLINE bool IsUseAsmDirective(Statement* statement) const {
769     return IsStringLiteral(statement, ast_value_factory()->use_asm_string());
770   }
771 
772   // Returns true if the statement is an expression statement containing
773   // a single string literal.  If a second argument is given, the literal
774   // is also compared with it and the result is true only if they are equal.
775   V8_INLINE bool IsStringLiteral(Statement* statement,
776                                  const AstRawString* arg = nullptr) const {
777     ExpressionStatement* e_stat = statement->AsExpressionStatement();
778     if (e_stat == nullptr) return false;
779     Literal* literal = e_stat->expression()->AsLiteral();
780     if (literal == nullptr || !literal->raw_value()->IsString()) return false;
781     return arg == nullptr || literal->raw_value()->AsString() == arg;
782   }
783 
784   V8_INLINE static Expression* GetPropertyValue(LiteralProperty* property) {
785     return property->value();
786   }
787 
788   V8_INLINE void GetDefaultStrings(
789       const AstRawString** default_string,
790       const AstRawString** star_default_star_string) {
791     *default_string = ast_value_factory()->default_string();
792     *star_default_star_string = ast_value_factory()->star_default_star_string();
793   }
794 
795   // Functions for encapsulating the differences between parsing and preparsing;
796   // operations interleaved with the recursive descent.
797   V8_INLINE void PushLiteralName(const AstRawString* id) {
798     DCHECK_NOT_NULL(fni_);
799     fni_->PushLiteralName(id);
800   }
801 
802   V8_INLINE void PushVariableName(const AstRawString* id) {
803     DCHECK_NOT_NULL(fni_);
804     fni_->PushVariableName(id);
805   }
806 
807   V8_INLINE void PushPropertyName(Expression* expression) {
808     DCHECK_NOT_NULL(fni_);
809     if (expression->IsPropertyName()) {
810       fni_->PushLiteralName(expression->AsLiteral()->AsRawPropertyName());
811     } else {
812       fni_->PushLiteralName(ast_value_factory()->anonymous_function_string());
813     }
814   }
815 
816   V8_INLINE void PushEnclosingName(const AstRawString* name) {
817     DCHECK_NOT_NULL(fni_);
818     fni_->PushEnclosingName(name);
819   }
820 
821   V8_INLINE void AddFunctionForNameInference(FunctionLiteral* func_to_infer) {
822     DCHECK_NOT_NULL(fni_);
823     fni_->AddFunction(func_to_infer);
824   }
825 
826   V8_INLINE void InferFunctionName() {
827     DCHECK_NOT_NULL(fni_);
828     fni_->Infer();
829   }
830 
831   // If we assign a function literal to a property we pretenure the
832   // literal so it can be added as a constant function property.
833   V8_INLINE static void CheckAssigningFunctionLiteralToProperty(
834       Expression* left, Expression* right) {
835     DCHECK(left != NULL);
836     if (left->IsProperty() && right->IsFunctionLiteral()) {
837       right->AsFunctionLiteral()->set_pretenure();
838     }
839   }
840 
841   // Determine if the expression is a variable proxy and mark it as being used
842   // in an assignment or with a increment/decrement operator.
843   V8_INLINE static void MarkExpressionAsAssigned(Expression* expression) {
844     DCHECK_NOT_NULL(expression);
845     if (expression->IsVariableProxy()) {
846       expression->AsVariableProxy()->set_is_assigned();
847     }
848   }
849 
850   // Returns true if we have a binary expression between two numeric
851   // literals. In that case, *x will be changed to an expression which is the
852   // computed value.
853   bool ShortcutNumericLiteralBinaryExpression(Expression** x, Expression* y,
854                                               Token::Value op, int pos);
855 
856   // Rewrites the following types of unary expressions:
857   // not <literal> -> true / false
858   // + <numeric literal> -> <numeric literal>
859   // - <numeric literal> -> <numeric literal with value negated>
860   // ! <literal> -> true / false
861   // The following rewriting rules enable the collection of type feedback
862   // without any special stub and the multiplication is removed later in
863   // Crankshaft's canonicalization pass.
864   // + foo -> foo * 1
865   // - foo -> foo * (-1)
866   // ~ foo -> foo ^(~0)
867   Expression* BuildUnaryExpression(Expression* expression, Token::Value op,
868                                    int pos);
869 
870   Expression* BuildIteratorResult(Expression* value, bool done);
871 
872   // Generate AST node that throws a ReferenceError with the given type.
873   V8_INLINE Expression* NewThrowReferenceError(
874       MessageTemplate::Template message, int pos) {
875     return NewThrowError(Runtime::kNewReferenceError, message,
876                          ast_value_factory()->empty_string(), pos);
877   }
878 
879   // Generate AST node that throws a SyntaxError with the given
880   // type. The first argument may be null (in the handle sense) in
881   // which case no arguments are passed to the constructor.
882   V8_INLINE Expression* NewThrowSyntaxError(MessageTemplate::Template message,
883                                             const AstRawString* arg, int pos) {
884     return NewThrowError(Runtime::kNewSyntaxError, message, arg, pos);
885   }
886 
887   // Generate AST node that throws a TypeError with the given
888   // type. Both arguments must be non-null (in the handle sense).
889   V8_INLINE Expression* NewThrowTypeError(MessageTemplate::Template message,
890                                           const AstRawString* arg, int pos) {
891     return NewThrowError(Runtime::kNewTypeError, message, arg, pos);
892   }
893 
894   // Reporting errors.
895   V8_INLINE void ReportMessageAt(Scanner::Location source_location,
896                                  MessageTemplate::Template message,
897                                  const char* arg = NULL,
898                                  ParseErrorType error_type = kSyntaxError) {
899     if (stack_overflow()) {
900       // Suppress the error message (syntax error or such) in the presence of a
901       // stack overflow. The isolate allows only one pending exception at at
902       // time
903       // and we want to report the stack overflow later.
904       return;
905     }
906     pending_error_handler_.ReportMessageAt(source_location.beg_pos,
907                                            source_location.end_pos, message,
908                                            arg, error_type);
909   }
910 
911   V8_INLINE void ReportMessageAt(Scanner::Location source_location,
912                                  MessageTemplate::Template message,
913                                  const AstRawString* arg,
914                                  ParseErrorType error_type = kSyntaxError) {
915     if (stack_overflow()) {
916       // Suppress the error message (syntax error or such) in the presence of a
917       // stack overflow. The isolate allows only one pending exception at at
918       // time
919       // and we want to report the stack overflow later.
920       return;
921     }
922     pending_error_handler_.ReportMessageAt(source_location.beg_pos,
923                                            source_location.end_pos, message,
924                                            arg, error_type);
925   }
926 
927   // "null" return type creators.
928   V8_INLINE static const AstRawString* EmptyIdentifier() { return nullptr; }
929   V8_INLINE static bool IsEmptyIdentifier(const AstRawString* name) {
930     return name == nullptr;
931   }
932   V8_INLINE static Expression* EmptyExpression() { return nullptr; }
933   V8_INLINE static Literal* EmptyLiteral() { return nullptr; }
934   V8_INLINE static ObjectLiteralProperty* EmptyObjectLiteralProperty() {
935     return nullptr;
936   }
937   V8_INLINE static ClassLiteralProperty* EmptyClassLiteralProperty() {
938     return nullptr;
939   }
940   V8_INLINE static FunctionLiteral* EmptyFunctionLiteral() { return nullptr; }
941   V8_INLINE static Block* NullBlock() { return nullptr; }
942 
943   V8_INLINE static bool IsEmptyExpression(Expression* expr) {
944     return expr == nullptr;
945   }
946 
947   // Used in error return values.
948   V8_INLINE static ZoneList<Expression*>* NullExpressionList() {
949     return nullptr;
950   }
951   V8_INLINE static bool IsNullExpressionList(ZoneList<Expression*>* exprs) {
952     return exprs == nullptr;
953   }
954   V8_INLINE static ZoneList<Statement*>* NullStatementList() { return nullptr; }
955   V8_INLINE static bool IsNullStatementList(ZoneList<Statement*>* stmts) {
956     return stmts == nullptr;
957   }
958   V8_INLINE static Statement* NullStatement() { return nullptr; }
959   V8_INLINE bool IsNullStatement(Statement* stmt) { return stmt == nullptr; }
960   V8_INLINE bool IsEmptyStatement(Statement* stmt) {
961     DCHECK_NOT_NULL(stmt);
962     return stmt->IsEmpty();
963   }
964 
965   // Non-NULL empty string.
966   V8_INLINE const AstRawString* EmptyIdentifierString() const {
967     return ast_value_factory()->empty_string();
968   }
969 
970   // Odd-ball literal creators.
971   V8_INLINE Literal* GetLiteralTheHole(int position) {
972     return factory()->NewTheHoleLiteral(kNoSourcePosition);
973   }
974 
975   // Producing data during the recursive descent.
976   V8_INLINE const AstRawString* GetSymbol() const {
977     const AstRawString* result = scanner()->CurrentSymbol(ast_value_factory());
978     DCHECK(result != NULL);
979     return result;
980   }
981 
982   V8_INLINE const AstRawString* GetNextSymbol() const {
983     return scanner()->NextSymbol(ast_value_factory());
984   }
985 
986   V8_INLINE const AstRawString* GetNumberAsSymbol() const {
987     double double_value = scanner()->DoubleValue();
988     char array[100];
989     const char* string = DoubleToCString(double_value, ArrayVector(array));
990     return ast_value_factory()->GetOneByteString(string);
991   }
992 
993   V8_INLINE Expression* ThisExpression(int pos = kNoSourcePosition) {
994     return NewUnresolved(ast_value_factory()->this_string(), pos,
995                          THIS_VARIABLE);
996   }
997 
998   Expression* NewSuperPropertyReference(int pos);
999   Expression* NewSuperCallReference(int pos);
1000   Expression* NewTargetExpression(int pos);
1001   Expression* FunctionSentExpression(int pos);
1002 
1003   Literal* ExpressionFromLiteral(Token::Value token, int pos);
1004 
1005   V8_INLINE Expression* ExpressionFromIdentifier(
1006       const AstRawString* name, int start_position,
1007       InferName infer = InferName::kYes) {
1008     if (infer == InferName::kYes) {
1009       fni_->PushVariableName(name);
1010     }
1011     return NewUnresolved(name, start_position);
1012   }
1013 
1014   V8_INLINE Expression* ExpressionFromString(int pos) {
1015     const AstRawString* symbol = GetSymbol();
1016     fni_->PushLiteralName(symbol);
1017     return factory()->NewStringLiteral(symbol, pos);
1018   }
1019 
1020   V8_INLINE ZoneList<Expression*>* NewExpressionList(int size) const {
1021     return new (zone()) ZoneList<Expression*>(size, zone());
1022   }
1023   V8_INLINE ZoneList<ObjectLiteral::Property*>* NewObjectPropertyList(
1024       int size) const {
1025     return new (zone()) ZoneList<ObjectLiteral::Property*>(size, zone());
1026   }
1027   V8_INLINE ZoneList<ClassLiteral::Property*>* NewClassPropertyList(
1028       int size) const {
1029     return new (zone()) ZoneList<ClassLiteral::Property*>(size, zone());
1030   }
1031   V8_INLINE ZoneList<Statement*>* NewStatementList(int size) const {
1032     return new (zone()) ZoneList<Statement*>(size, zone());
1033   }
1034   V8_INLINE ZoneList<CaseClause*>* NewCaseClauseList(int size) const {
1035     return new (zone()) ZoneList<CaseClause*>(size, zone());
1036   }
1037 
1038   V8_INLINE Expression* NewV8Intrinsic(const AstRawString* name,
1039                                        ZoneList<Expression*>* args, int pos,
1040                                        bool* ok);
1041 
1042   V8_INLINE Statement* NewThrowStatement(Expression* exception, int pos) {
1043     return factory()->NewExpressionStatement(
1044         factory()->NewThrow(exception, pos), pos);
1045   }
1046 
1047   V8_INLINE void AddParameterInitializationBlock(
1048       const ParserFormalParameters& parameters, ZoneList<Statement*>* body,
1049       bool is_async, bool* ok) {
1050     if (parameters.is_simple) return;
1051     auto* init_block = BuildParameterInitializationBlock(parameters, ok);
1052     if (!*ok) return;
1053     if (is_async) {
1054       init_block = BuildRejectPromiseOnException(init_block);
1055     }
1056     if (init_block != nullptr) body->Add(init_block, zone());
1057   }
1058 
1059   V8_INLINE void AddFormalParameter(ParserFormalParameters* parameters,
1060                                     Expression* pattern,
1061                                     Expression* initializer,
1062                                     int initializer_end_position,
1063                                     bool is_rest) {
1064     parameters->UpdateArityAndFunctionLength(initializer != nullptr, is_rest);
1065     bool has_simple_name = pattern->IsVariableProxy() && initializer == nullptr;
1066     const AstRawString* name = has_simple_name
1067                                    ? pattern->AsVariableProxy()->raw_name()
1068                                    : ast_value_factory()->empty_string();
1069     auto parameter =
1070         new (parameters->scope->zone()) ParserFormalParameters::Parameter(
1071             name, pattern, initializer, initializer_end_position, is_rest);
1072 
1073     parameters->params.Add(parameter);
1074   }
1075 
1076   V8_INLINE void DeclareFormalParameters(
1077       DeclarationScope* scope,
1078       const ThreadedList<ParserFormalParameters::Parameter>& parameters) {
1079     bool is_simple = classifier()->is_simple_parameter_list();
1080     if (!is_simple) scope->SetHasNonSimpleParameters();
1081     for (auto parameter : parameters) {
1082       bool is_duplicate = false;
1083       bool use_name = is_simple || parameter->is_nondestructuring_rest();
1084       bool is_optional = parameter->initializer != nullptr;
1085       scope->DeclareParameter(
1086           use_name ? parameter->name : ast_value_factory()->empty_string(),
1087           use_name ? VAR : TEMPORARY, is_optional, parameter->is_rest,
1088           &is_duplicate, ast_value_factory());
1089       if (is_duplicate &&
1090           classifier()->is_valid_formal_parameter_list_without_duplicates()) {
1091         classifier()->RecordDuplicateFormalParameterError(
1092             scanner()->location());
1093       }
1094     }
1095   }
1096 
1097   void DeclareArrowFunctionFormalParameters(ParserFormalParameters* parameters,
1098                                             Expression* params,
1099                                             const Scanner::Location& params_loc,
1100                                             Scanner::Location* duplicate_loc,
1101                                             bool* ok);
1102 
1103   V8_INLINE Expression* NoTemplateTag() { return NULL; }
1104   V8_INLINE static bool IsTaggedTemplate(const Expression* tag) {
1105     return tag != NULL;
1106   }
1107 
1108   Expression* ExpressionListToExpression(ZoneList<Expression*>* args);
1109 
1110   void AddAccessorPrefixToFunctionName(bool is_get, FunctionLiteral* function,
1111                                        const AstRawString* name);
1112 
1113   void SetFunctionNameFromPropertyName(ObjectLiteralProperty* property,
1114                                        const AstRawString* name);
1115 
1116   void SetFunctionNameFromIdentifierRef(Expression* value,
1117                                         Expression* identifier);
1118 
1119   V8_INLINE ZoneList<typename ExpressionClassifier::Error>*
1120   GetReportedErrorList() const {
1121     return function_state_->GetReportedErrorList();
1122   }
1123 
1124   V8_INLINE ZoneList<Expression*>* GetNonPatternList() const {
1125     return function_state_->non_patterns_to_rewrite();
1126   }
1127 
1128   V8_INLINE void CountUsage(v8::Isolate::UseCounterFeature feature) {
1129     ++use_counts_[feature];
1130   }
1131 
1132   // Returns true iff we're parsing the first function literal during
1133   // CreateDynamicFunction().
1134   V8_INLINE bool ParsingDynamicFunctionDeclaration() const {
1135     return parameters_end_pos_ != kNoSourcePosition;
1136   }
1137 
1138   // Parser's private field members.
1139   friend class DiscardableZoneScope;  // Uses reusable_preparser_.
1140   // FIXME(marja): Make reusable_preparser_ always use its own temp Zone (call
1141   // DeleteAll after each function), so this won't be needed.
1142 
1143   Scanner scanner_;
1144   PreParser* reusable_preparser_;
1145   Scope* original_scope_;  // for ES5 function declarations in sloppy eval
1146   Mode mode_;
1147 
1148   friend class ParserTarget;
1149   friend class ParserTargetScope;
1150   ParserTarget* target_stack_;  // for break, continue statements
1151 
1152   ScriptCompiler::CompileOptions compile_options_;
1153   ParseData* cached_parse_data_;
1154 
1155   PendingCompilationErrorHandler pending_error_handler_;
1156 
1157   // Other information which will be stored in Parser and moved to Isolate after
1158   // parsing.
1159   int use_counts_[v8::Isolate::kUseCounterFeatureCount];
1160   int total_preparse_skipped_;
1161   bool allow_lazy_;
1162   bool temp_zoned_;
1163   ParserLogger* log_;
1164 
1165   PreParsedScopeData* preparsed_scope_data_;
1166 
1167   // If not kNoSourcePosition, indicates that the first function literal
1168   // encountered is a dynamic function, see CreateDynamicFunction(). This field
1169   // indicates the correct position of the ')' that closes the parameter list.
1170   // After that ')' is encountered, this field is reset to kNoSourcePosition.
1171   int parameters_end_pos_;
1172 };
1173 
1174 // ----------------------------------------------------------------------------
1175 // Target is a support class to facilitate manipulation of the
1176 // Parser's target_stack_ (the stack of potential 'break' and
1177 // 'continue' statement targets). Upon construction, a new target is
1178 // added; it is removed upon destruction.
1179 
1180 class ParserTarget BASE_EMBEDDED {
1181  public:
1182   ParserTarget(ParserBase<Parser>* parser, BreakableStatement* statement)
1183       : variable_(&parser->impl()->target_stack_),
1184         statement_(statement),
1185         previous_(parser->impl()->target_stack_) {
1186     parser->impl()->target_stack_ = this;
1187   }
1188 
1189   ~ParserTarget() { *variable_ = previous_; }
1190 
1191   ParserTarget* previous() { return previous_; }
1192   BreakableStatement* statement() { return statement_; }
1193 
1194  private:
1195   ParserTarget** variable_;
1196   BreakableStatement* statement_;
1197   ParserTarget* previous_;
1198 };
1199 
1200 class ParserTargetScope BASE_EMBEDDED {
1201  public:
1202   explicit ParserTargetScope(ParserBase<Parser>* parser)
1203       : variable_(&parser->impl()->target_stack_),
1204         previous_(parser->impl()->target_stack_) {
1205     parser->impl()->target_stack_ = nullptr;
1206   }
1207 
1208   ~ParserTargetScope() { *variable_ = previous_; }
1209 
1210  private:
1211   ParserTarget** variable_;
1212   ParserTarget* previous_;
1213 };
1214 
1215 }  // namespace internal
1216 }  // namespace v8
1217 
1218 #endif  // V8_PARSING_PARSER_H_
1219