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/allocation.h"
9#include "src/ast/ast.h"
10#include "src/ast/scopes.h"
11#include "src/compiler.h"  // TODO(titzer): remove this include dependency
12#include "src/parsing/parser-base.h"
13#include "src/parsing/preparse-data.h"
14#include "src/parsing/preparse-data-format.h"
15#include "src/parsing/preparser.h"
16#include "src/pending-compilation-error-handler.h"
17
18namespace v8 {
19
20class ScriptCompiler;
21
22namespace internal {
23
24class Target;
25
26// A container for the inputs, configuration options, and outputs of parsing.
27class ParseInfo {
28 public:
29  explicit ParseInfo(Zone* zone);
30  ParseInfo(Zone* zone, Handle<JSFunction> function);
31  ParseInfo(Zone* zone, Handle<Script> script);
32  // TODO(all) Only used via Debug::FindSharedFunctionInfoInScript, remove?
33  ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared);
34
35  ~ParseInfo() {
36    if (ast_value_factory_owned()) {
37      delete ast_value_factory_;
38      set_ast_value_factory_owned(false);
39    }
40    ast_value_factory_ = nullptr;
41  }
42
43  Zone* zone() { return zone_; }
44
45// Convenience accessor methods for flags.
46#define FLAG_ACCESSOR(flag, getter, setter)     \
47  bool getter() const { return GetFlag(flag); } \
48  void setter() { SetFlag(flag); }              \
49  void setter(bool val) { SetFlag(flag, val); }
50
51  FLAG_ACCESSOR(kToplevel, is_toplevel, set_toplevel)
52  FLAG_ACCESSOR(kLazy, is_lazy, set_lazy)
53  FLAG_ACCESSOR(kEval, is_eval, set_eval)
54  FLAG_ACCESSOR(kGlobal, is_global, set_global)
55  FLAG_ACCESSOR(kStrictMode, is_strict_mode, set_strict_mode)
56  FLAG_ACCESSOR(kStrongMode, is_strong_mode, set_strong_mode)
57  FLAG_ACCESSOR(kNative, is_native, set_native)
58  FLAG_ACCESSOR(kModule, is_module, set_module)
59  FLAG_ACCESSOR(kAllowLazyParsing, allow_lazy_parsing, set_allow_lazy_parsing)
60  FLAG_ACCESSOR(kAstValueFactoryOwned, ast_value_factory_owned,
61                set_ast_value_factory_owned)
62
63#undef FLAG_ACCESSOR
64
65  void set_parse_restriction(ParseRestriction restriction) {
66    SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION);
67  }
68
69  ParseRestriction parse_restriction() const {
70    return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL
71                                      : NO_PARSE_RESTRICTION;
72  }
73
74  ScriptCompiler::ExternalSourceStream* source_stream() {
75    return source_stream_;
76  }
77  void set_source_stream(ScriptCompiler::ExternalSourceStream* source_stream) {
78    source_stream_ = source_stream;
79  }
80
81  ScriptCompiler::StreamedSource::Encoding source_stream_encoding() {
82    return source_stream_encoding_;
83  }
84  void set_source_stream_encoding(
85      ScriptCompiler::StreamedSource::Encoding source_stream_encoding) {
86    source_stream_encoding_ = source_stream_encoding;
87  }
88
89  v8::Extension* extension() { return extension_; }
90  void set_extension(v8::Extension* extension) { extension_ = extension; }
91
92  ScriptData** cached_data() { return cached_data_; }
93  void set_cached_data(ScriptData** cached_data) { cached_data_ = cached_data; }
94
95  ScriptCompiler::CompileOptions compile_options() { return compile_options_; }
96  void set_compile_options(ScriptCompiler::CompileOptions compile_options) {
97    compile_options_ = compile_options;
98  }
99
100  Scope* script_scope() { return script_scope_; }
101  void set_script_scope(Scope* script_scope) { script_scope_ = script_scope; }
102
103  AstValueFactory* ast_value_factory() { return ast_value_factory_; }
104  void set_ast_value_factory(AstValueFactory* ast_value_factory) {
105    ast_value_factory_ = ast_value_factory;
106  }
107
108  FunctionLiteral* literal() { return literal_; }
109  void set_literal(FunctionLiteral* literal) { literal_ = literal; }
110
111  Scope* scope() { return scope_; }
112  void set_scope(Scope* scope) { scope_ = scope; }
113
114  UnicodeCache* unicode_cache() { return unicode_cache_; }
115  void set_unicode_cache(UnicodeCache* unicode_cache) {
116    unicode_cache_ = unicode_cache;
117  }
118
119  uintptr_t stack_limit() { return stack_limit_; }
120  void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; }
121
122  uint32_t hash_seed() { return hash_seed_; }
123  void set_hash_seed(uint32_t hash_seed) { hash_seed_ = hash_seed; }
124
125  //--------------------------------------------------------------------------
126  // TODO(titzer): these should not be part of ParseInfo.
127  //--------------------------------------------------------------------------
128  Isolate* isolate() { return isolate_; }
129  Handle<JSFunction> closure() { return closure_; }
130  Handle<SharedFunctionInfo> shared_info() { return shared_; }
131  Handle<Script> script() { return script_; }
132  Handle<Context> context() { return context_; }
133  void clear_script() { script_ = Handle<Script>::null(); }
134  void set_isolate(Isolate* isolate) { isolate_ = isolate; }
135  void set_context(Handle<Context> context) { context_ = context; }
136  void set_script(Handle<Script> script) { script_ = script; }
137  //--------------------------------------------------------------------------
138
139  LanguageMode language_mode() {
140    return construct_language_mode(is_strict_mode(), is_strong_mode());
141  }
142  void set_language_mode(LanguageMode language_mode) {
143    STATIC_ASSERT(LANGUAGE_END == 3);
144    set_strict_mode(language_mode & STRICT_BIT);
145    set_strong_mode(language_mode & STRONG_BIT);
146  }
147
148  void ReopenHandlesInNewHandleScope() {
149    closure_ = Handle<JSFunction>(*closure_);
150    shared_ = Handle<SharedFunctionInfo>(*shared_);
151    script_ = Handle<Script>(*script_);
152    context_ = Handle<Context>(*context_);
153  }
154
155#ifdef DEBUG
156  bool script_is_native() { return script_->type() == Script::TYPE_NATIVE; }
157#endif  // DEBUG
158
159 private:
160  // Various configuration flags for parsing.
161  enum Flag {
162    // ---------- Input flags ---------------------------
163    kToplevel = 1 << 0,
164    kLazy = 1 << 1,
165    kEval = 1 << 2,
166    kGlobal = 1 << 3,
167    kStrictMode = 1 << 4,
168    kStrongMode = 1 << 5,
169    kNative = 1 << 6,
170    kParseRestriction = 1 << 7,
171    kModule = 1 << 8,
172    kAllowLazyParsing = 1 << 9,
173    // ---------- Output flags --------------------------
174    kAstValueFactoryOwned = 1 << 10
175  };
176
177  //------------- Inputs to parsing and scope analysis -----------------------
178  Zone* zone_;
179  unsigned flags_;
180  ScriptCompiler::ExternalSourceStream* source_stream_;
181  ScriptCompiler::StreamedSource::Encoding source_stream_encoding_;
182  v8::Extension* extension_;
183  ScriptCompiler::CompileOptions compile_options_;
184  Scope* script_scope_;
185  UnicodeCache* unicode_cache_;
186  uintptr_t stack_limit_;
187  uint32_t hash_seed_;
188
189  // TODO(titzer): Move handles and isolate out of ParseInfo.
190  Isolate* isolate_;
191  Handle<JSFunction> closure_;
192  Handle<SharedFunctionInfo> shared_;
193  Handle<Script> script_;
194  Handle<Context> context_;
195
196  //----------- Inputs+Outputs of parsing and scope analysis -----------------
197  ScriptData** cached_data_;  // used if available, populated if requested.
198  AstValueFactory* ast_value_factory_;  // used if available, otherwise new.
199
200  //----------- Outputs of parsing and scope analysis ------------------------
201  FunctionLiteral* literal_;  // produced by full parser.
202  Scope* scope_;              // produced by scope analysis.
203
204  void SetFlag(Flag f) { flags_ |= f; }
205  void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
206  bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
207
208  void set_shared_info(Handle<SharedFunctionInfo> shared) { shared_ = shared; }
209  void set_closure(Handle<JSFunction> closure) { closure_ = closure; }
210};
211
212class FunctionEntry BASE_EMBEDDED {
213 public:
214  enum {
215    kStartPositionIndex,
216    kEndPositionIndex,
217    kLiteralCountIndex,
218    kPropertyCountIndex,
219    kLanguageModeIndex,
220    kUsesSuperPropertyIndex,
221    kCallsEvalIndex,
222    kSize
223  };
224
225  explicit FunctionEntry(Vector<unsigned> backing)
226    : backing_(backing) { }
227
228  FunctionEntry() : backing_() { }
229
230  int start_pos() { return backing_[kStartPositionIndex]; }
231  int end_pos() { return backing_[kEndPositionIndex]; }
232  int literal_count() { return backing_[kLiteralCountIndex]; }
233  int property_count() { return backing_[kPropertyCountIndex]; }
234  LanguageMode language_mode() {
235    DCHECK(is_valid_language_mode(backing_[kLanguageModeIndex]));
236    return static_cast<LanguageMode>(backing_[kLanguageModeIndex]);
237  }
238  bool uses_super_property() { return backing_[kUsesSuperPropertyIndex]; }
239  bool calls_eval() { return backing_[kCallsEvalIndex]; }
240
241  bool is_valid() { return !backing_.is_empty(); }
242
243 private:
244  Vector<unsigned> backing_;
245};
246
247
248// Wrapper around ScriptData to provide parser-specific functionality.
249class ParseData {
250 public:
251  static ParseData* FromCachedData(ScriptData* cached_data) {
252    ParseData* pd = new ParseData(cached_data);
253    if (pd->IsSane()) return pd;
254    cached_data->Reject();
255    delete pd;
256    return NULL;
257  }
258
259  void Initialize();
260  FunctionEntry GetFunctionEntry(int start);
261  int FunctionCount();
262
263  bool HasError();
264
265  unsigned* Data() {  // Writable data as unsigned int array.
266    return reinterpret_cast<unsigned*>(const_cast<byte*>(script_data_->data()));
267  }
268
269  void Reject() { script_data_->Reject(); }
270
271  bool rejected() const { return script_data_->rejected(); }
272
273 private:
274  explicit ParseData(ScriptData* script_data) : script_data_(script_data) {}
275
276  bool IsSane();
277  unsigned Magic();
278  unsigned Version();
279  int FunctionsSize();
280  int Length() const {
281    // Script data length is already checked to be a multiple of unsigned size.
282    return script_data_->length() / sizeof(unsigned);
283  }
284
285  ScriptData* script_data_;
286  int function_index_;
287
288  DISALLOW_COPY_AND_ASSIGN(ParseData);
289};
290
291// ----------------------------------------------------------------------------
292// JAVASCRIPT PARSING
293
294class Parser;
295class SingletonLogger;
296
297
298struct ParserFormalParameters : FormalParametersBase {
299  struct Parameter {
300    Parameter(const AstRawString* name, Expression* pattern,
301              Expression* initializer, int initializer_end_position,
302              bool is_rest)
303        : name(name),
304          pattern(pattern),
305          initializer(initializer),
306          initializer_end_position(initializer_end_position),
307          is_rest(is_rest) {}
308    const AstRawString* name;
309    Expression* pattern;
310    Expression* initializer;
311    int initializer_end_position;
312    bool is_rest;
313    bool is_simple() const {
314      return pattern->IsVariableProxy() && initializer == nullptr && !is_rest;
315    }
316  };
317
318  explicit ParserFormalParameters(Scope* scope)
319      : FormalParametersBase(scope), params(4, scope->zone()) {}
320  ZoneList<Parameter> params;
321
322  int Arity() const { return params.length(); }
323  const Parameter& at(int i) const { return params[i]; }
324};
325
326
327class ParserTraits {
328 public:
329  struct Type {
330    // TODO(marja): To be removed. The Traits object should contain all the data
331    // it needs.
332    typedef v8::internal::Parser* Parser;
333
334    typedef Variable GeneratorVariable;
335
336    typedef v8::internal::AstProperties AstProperties;
337
338    // Return types for traversing functions.
339    typedef const AstRawString* Identifier;
340    typedef v8::internal::Expression* Expression;
341    typedef Yield* YieldExpression;
342    typedef v8::internal::FunctionLiteral* FunctionLiteral;
343    typedef v8::internal::ClassLiteral* ClassLiteral;
344    typedef v8::internal::Literal* Literal;
345    typedef ObjectLiteral::Property* ObjectLiteralProperty;
346    typedef ZoneList<v8::internal::Expression*>* ExpressionList;
347    typedef ZoneList<ObjectLiteral::Property*>* PropertyList;
348    typedef ParserFormalParameters::Parameter FormalParameter;
349    typedef ParserFormalParameters FormalParameters;
350    typedef ZoneList<v8::internal::Statement*>* StatementList;
351
352    // For constructing objects returned by the traversing functions.
353    typedef AstNodeFactory Factory;
354  };
355
356  explicit ParserTraits(Parser* parser) : parser_(parser) {}
357
358  // Helper functions for recursive descent.
359  bool IsEval(const AstRawString* identifier) const;
360  bool IsArguments(const AstRawString* identifier) const;
361  bool IsEvalOrArguments(const AstRawString* identifier) const;
362  bool IsUndefined(const AstRawString* identifier) const;
363  V8_INLINE bool IsFutureStrictReserved(const AstRawString* identifier) const;
364
365  // Returns true if the expression is of type "this.foo".
366  static bool IsThisProperty(Expression* expression);
367
368  static bool IsIdentifier(Expression* expression);
369
370  bool IsPrototype(const AstRawString* identifier) const;
371
372  bool IsConstructor(const AstRawString* identifier) const;
373
374  static const AstRawString* AsIdentifier(Expression* expression) {
375    DCHECK(IsIdentifier(expression));
376    return expression->AsVariableProxy()->raw_name();
377  }
378
379  static bool IsBoilerplateProperty(ObjectLiteral::Property* property) {
380    return ObjectLiteral::IsBoilerplateProperty(property);
381  }
382
383  static bool IsArrayIndex(const AstRawString* string, uint32_t* index) {
384    return string->AsArrayIndex(index);
385  }
386
387  static Expression* GetPropertyValue(ObjectLiteral::Property* property) {
388    return property->value();
389  }
390
391  // Functions for encapsulating the differences between parsing and preparsing;
392  // operations interleaved with the recursive descent.
393  static void PushLiteralName(FuncNameInferrer* fni, const AstRawString* id) {
394    fni->PushLiteralName(id);
395  }
396
397  void PushPropertyName(FuncNameInferrer* fni, Expression* expression);
398
399  static void InferFunctionName(FuncNameInferrer* fni,
400                                FunctionLiteral* func_to_infer) {
401    fni->AddFunction(func_to_infer);
402  }
403
404  static void CheckFunctionLiteralInsideTopLevelObjectLiteral(
405      Scope* scope, ObjectLiteralProperty* property, bool* has_function) {
406    Expression* value = property->value();
407    if (scope->DeclarationScope()->is_script_scope() &&
408        value->AsFunctionLiteral() != NULL) {
409      *has_function = true;
410      value->AsFunctionLiteral()->set_pretenure();
411    }
412  }
413
414  // If we assign a function literal to a property we pretenure the
415  // literal so it can be added as a constant function property.
416  static void CheckAssigningFunctionLiteralToProperty(Expression* left,
417                                                      Expression* right);
418
419  // Determine if the expression is a variable proxy and mark it as being used
420  // in an assignment or with a increment/decrement operator.
421  static Expression* MarkExpressionAsAssigned(Expression* expression);
422
423  // Returns true if we have a binary expression between two numeric
424  // literals. In that case, *x will be changed to an expression which is the
425  // computed value.
426  bool ShortcutNumericLiteralBinaryExpression(Expression** x, Expression* y,
427                                              Token::Value op, int pos,
428                                              AstNodeFactory* factory);
429
430  // Rewrites the following types of unary expressions:
431  // not <literal> -> true / false
432  // + <numeric literal> -> <numeric literal>
433  // - <numeric literal> -> <numeric literal with value negated>
434  // ! <literal> -> true / false
435  // The following rewriting rules enable the collection of type feedback
436  // without any special stub and the multiplication is removed later in
437  // Crankshaft's canonicalization pass.
438  // + foo -> foo * 1
439  // - foo -> foo * (-1)
440  // ~ foo -> foo ^(~0)
441  Expression* BuildUnaryExpression(Expression* expression, Token::Value op,
442                                   int pos, AstNodeFactory* factory);
443
444  // Generate AST node that throws a ReferenceError with the given type.
445  Expression* NewThrowReferenceError(MessageTemplate::Template message,
446                                     int pos);
447
448  // Generate AST node that throws a SyntaxError with the given
449  // type. The first argument may be null (in the handle sense) in
450  // which case no arguments are passed to the constructor.
451  Expression* NewThrowSyntaxError(MessageTemplate::Template message,
452                                  const AstRawString* arg, int pos);
453
454  // Generate AST node that throws a TypeError with the given
455  // type. Both arguments must be non-null (in the handle sense).
456  Expression* NewThrowTypeError(MessageTemplate::Template message,
457                                const AstRawString* arg, int pos);
458
459  // Generic AST generator for throwing errors from compiled code.
460  Expression* NewThrowError(Runtime::FunctionId function_id,
461                            MessageTemplate::Template message,
462                            const AstRawString* arg, int pos);
463
464  // Reporting errors.
465  void ReportMessageAt(Scanner::Location source_location,
466                       MessageTemplate::Template message,
467                       const char* arg = NULL,
468                       ParseErrorType error_type = kSyntaxError);
469  void ReportMessage(MessageTemplate::Template message, const char* arg = NULL,
470                     ParseErrorType error_type = kSyntaxError);
471  void ReportMessage(MessageTemplate::Template message, const AstRawString* arg,
472                     ParseErrorType error_type = kSyntaxError);
473  void ReportMessageAt(Scanner::Location source_location,
474                       MessageTemplate::Template message,
475                       const AstRawString* arg,
476                       ParseErrorType error_type = kSyntaxError);
477
478  // "null" return type creators.
479  static const AstRawString* EmptyIdentifier() {
480    return NULL;
481  }
482  static Expression* EmptyExpression() {
483    return NULL;
484  }
485  static Literal* EmptyLiteral() {
486    return NULL;
487  }
488  static ObjectLiteralProperty* EmptyObjectLiteralProperty() { return NULL; }
489  static FunctionLiteral* EmptyFunctionLiteral() { return NULL; }
490
491  // Used in error return values.
492  static ZoneList<Expression*>* NullExpressionList() {
493    return NULL;
494  }
495  static const AstRawString* EmptyFormalParameter() { return NULL; }
496
497  // Non-NULL empty string.
498  V8_INLINE const AstRawString* EmptyIdentifierString();
499
500  // Odd-ball literal creators.
501  Literal* GetLiteralTheHole(int position, AstNodeFactory* factory);
502
503  // Producing data during the recursive descent.
504  const AstRawString* GetSymbol(Scanner* scanner);
505  const AstRawString* GetNextSymbol(Scanner* scanner);
506  const AstRawString* GetNumberAsSymbol(Scanner* scanner);
507
508  Expression* ThisExpression(Scope* scope, AstNodeFactory* factory,
509                             int pos = RelocInfo::kNoPosition);
510  Expression* SuperPropertyReference(Scope* scope, AstNodeFactory* factory,
511                                     int pos);
512  Expression* SuperCallReference(Scope* scope, AstNodeFactory* factory,
513                                 int pos);
514  Expression* NewTargetExpression(Scope* scope, AstNodeFactory* factory,
515                                  int pos);
516  Expression* DefaultConstructor(bool call_super, Scope* scope, int pos,
517                                 int end_pos, LanguageMode language_mode);
518  Literal* ExpressionFromLiteral(Token::Value token, int pos, Scanner* scanner,
519                                 AstNodeFactory* factory);
520  Expression* ExpressionFromIdentifier(const AstRawString* name,
521                                       int start_position, int end_position,
522                                       Scope* scope, AstNodeFactory* factory);
523  Expression* ExpressionFromString(int pos, Scanner* scanner,
524                                   AstNodeFactory* factory);
525  Expression* GetIterator(Expression* iterable, AstNodeFactory* factory,
526                          int pos);
527  ZoneList<v8::internal::Expression*>* NewExpressionList(int size, Zone* zone) {
528    return new(zone) ZoneList<v8::internal::Expression*>(size, zone);
529  }
530  ZoneList<ObjectLiteral::Property*>* NewPropertyList(int size, Zone* zone) {
531    return new(zone) ZoneList<ObjectLiteral::Property*>(size, zone);
532  }
533  ZoneList<v8::internal::Statement*>* NewStatementList(int size, Zone* zone) {
534    return new(zone) ZoneList<v8::internal::Statement*>(size, zone);
535  }
536
537  V8_INLINE void AddParameterInitializationBlock(
538      const ParserFormalParameters& parameters,
539      ZoneList<v8::internal::Statement*>* body, bool* ok);
540
541  V8_INLINE Scope* NewScope(Scope* parent_scope, ScopeType scope_type,
542                            FunctionKind kind = kNormalFunction);
543
544  V8_INLINE void AddFormalParameter(ParserFormalParameters* parameters,
545                                    Expression* pattern,
546                                    Expression* initializer,
547                                    int initializer_end_position, bool is_rest);
548  V8_INLINE void DeclareFormalParameter(
549      Scope* scope, const ParserFormalParameters::Parameter& parameter,
550      ExpressionClassifier* classifier);
551  void ParseArrowFunctionFormalParameters(ParserFormalParameters* parameters,
552                                          Expression* params,
553                                          const Scanner::Location& params_loc,
554                                          bool* ok);
555  void ParseArrowFunctionFormalParameterList(
556      ParserFormalParameters* parameters, Expression* params,
557      const Scanner::Location& params_loc,
558      Scanner::Location* duplicate_loc, bool* ok);
559
560  V8_INLINE DoExpression* ParseDoExpression(bool* ok);
561
562  void ReindexLiterals(const ParserFormalParameters& parameters);
563
564  // Temporary glue; these functions will move to ParserBase.
565  Expression* ParseV8Intrinsic(bool* ok);
566  FunctionLiteral* ParseFunctionLiteral(
567      const AstRawString* name, Scanner::Location function_name_location,
568      FunctionNameValidity function_name_validity, FunctionKind kind,
569      int function_token_position, FunctionLiteral::FunctionType type,
570      FunctionLiteral::ArityRestriction arity_restriction,
571      LanguageMode language_mode, bool* ok);
572  V8_INLINE void SkipLazyFunctionBody(
573      int* materialized_literal_count, int* expected_property_count, bool* ok,
574      Scanner::BookmarkScope* bookmark = nullptr);
575  V8_INLINE ZoneList<Statement*>* ParseEagerFunctionBody(
576      const AstRawString* name, int pos,
577      const ParserFormalParameters& parameters, FunctionKind kind,
578      FunctionLiteral::FunctionType function_type, bool* ok);
579
580  ClassLiteral* ParseClassLiteral(const AstRawString* name,
581                                  Scanner::Location class_name_location,
582                                  bool name_is_strict_reserved, int pos,
583                                  bool* ok);
584
585  V8_INLINE void CheckConflictingVarDeclarations(v8::internal::Scope* scope,
586                                                 bool* ok);
587
588  class TemplateLiteral : public ZoneObject {
589   public:
590    TemplateLiteral(Zone* zone, int pos)
591        : cooked_(8, zone), raw_(8, zone), expressions_(8, zone), pos_(pos) {}
592
593    const ZoneList<Expression*>* cooked() const { return &cooked_; }
594    const ZoneList<Expression*>* raw() const { return &raw_; }
595    const ZoneList<Expression*>* expressions() const { return &expressions_; }
596    int position() const { return pos_; }
597
598    void AddTemplateSpan(Literal* cooked, Literal* raw, int end, Zone* zone) {
599      DCHECK_NOT_NULL(cooked);
600      DCHECK_NOT_NULL(raw);
601      cooked_.Add(cooked, zone);
602      raw_.Add(raw, zone);
603    }
604
605    void AddExpression(Expression* expression, Zone* zone) {
606      DCHECK_NOT_NULL(expression);
607      expressions_.Add(expression, zone);
608    }
609
610   private:
611    ZoneList<Expression*> cooked_;
612    ZoneList<Expression*> raw_;
613    ZoneList<Expression*> expressions_;
614    int pos_;
615  };
616
617  typedef TemplateLiteral* TemplateLiteralState;
618
619  V8_INLINE TemplateLiteralState OpenTemplateLiteral(int pos);
620  V8_INLINE void AddTemplateSpan(TemplateLiteralState* state, bool tail);
621  V8_INLINE void AddTemplateExpression(TemplateLiteralState* state,
622                                       Expression* expression);
623  V8_INLINE Expression* CloseTemplateLiteral(TemplateLiteralState* state,
624                                             int start, Expression* tag);
625  V8_INLINE Expression* NoTemplateTag() { return NULL; }
626  V8_INLINE static bool IsTaggedTemplate(const Expression* tag) {
627    return tag != NULL;
628  }
629
630  V8_INLINE ZoneList<v8::internal::Expression*>* PrepareSpreadArguments(
631      ZoneList<v8::internal::Expression*>* list);
632  V8_INLINE void MaterializeUnspreadArgumentsLiterals(int count) {}
633  V8_INLINE Expression* SpreadCall(Expression* function,
634                                   ZoneList<v8::internal::Expression*>* args,
635                                   int pos);
636  V8_INLINE Expression* SpreadCallNew(Expression* function,
637                                      ZoneList<v8::internal::Expression*>* args,
638                                      int pos);
639
640  // Rewrite all DestructuringAssignments in the current FunctionState.
641  V8_INLINE void RewriteDestructuringAssignments();
642
643  V8_INLINE void QueueDestructuringAssignmentForRewriting(
644      Expression* assignment);
645
646  void SetFunctionNameFromPropertyName(ObjectLiteralProperty* property,
647                                       const AstRawString* name);
648
649  void SetFunctionNameFromIdentifierRef(Expression* value,
650                                        Expression* identifier);
651
652  // Rewrite expressions that are not used as patterns
653  V8_INLINE Expression* RewriteNonPattern(
654      Expression* expr, const ExpressionClassifier* classifier, bool* ok);
655  V8_INLINE ZoneList<Expression*>* RewriteNonPatternArguments(
656      ZoneList<Expression*>* args, const ExpressionClassifier* classifier,
657      bool* ok);
658  V8_INLINE ObjectLiteralProperty* RewriteNonPatternObjectLiteralProperty(
659      ObjectLiteralProperty* property, const ExpressionClassifier* classifier,
660      bool* ok);
661
662 private:
663  Parser* parser_;
664};
665
666
667class Parser : public ParserBase<ParserTraits> {
668 public:
669  explicit Parser(ParseInfo* info);
670  ~Parser() {
671    delete reusable_preparser_;
672    reusable_preparser_ = NULL;
673    delete cached_parse_data_;
674    cached_parse_data_ = NULL;
675  }
676
677  // Parses the source code represented by the compilation info and sets its
678  // function literal.  Returns false (and deallocates any allocated AST
679  // nodes) if parsing failed.
680  static bool ParseStatic(ParseInfo* info);
681  bool Parse(ParseInfo* info);
682  void ParseOnBackground(ParseInfo* info);
683
684  // Handle errors detected during parsing, move statistics to Isolate,
685  // internalize strings (move them to the heap).
686  void Internalize(Isolate* isolate, Handle<Script> script, bool error);
687  void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
688
689 private:
690  friend class ParserTraits;
691
692  // Limit the allowed number of local variables in a function. The hard limit
693  // is that offsets computed by FullCodeGenerator::StackOperand and similar
694  // functions are ints, and they should not overflow. In addition, accessing
695  // local variables creates user-controlled constants in the generated code,
696  // and we don't want too much user-controlled memory inside the code (this was
697  // the reason why this limit was introduced in the first place; see
698  // https://codereview.chromium.org/7003030/ ).
699  static const int kMaxNumFunctionLocals = 4194303;  // 2^22-1
700
701  // Returns NULL if parsing failed.
702  FunctionLiteral* ParseProgram(Isolate* isolate, ParseInfo* info);
703
704  FunctionLiteral* ParseLazy(Isolate* isolate, ParseInfo* info);
705  FunctionLiteral* ParseLazy(Isolate* isolate, ParseInfo* info,
706                             Utf16CharacterStream* source);
707
708  // Called by ParseProgram after setting up the scanner.
709  FunctionLiteral* DoParseProgram(ParseInfo* info);
710
711  void SetCachedData(ParseInfo* info);
712
713  ScriptCompiler::CompileOptions compile_options() const {
714    return compile_options_;
715  }
716  bool consume_cached_parse_data() const {
717    return compile_options_ == ScriptCompiler::kConsumeParserCache &&
718           cached_parse_data_ != NULL;
719  }
720  bool produce_cached_parse_data() const {
721    return compile_options_ == ScriptCompiler::kProduceParserCache;
722  }
723
724  // All ParseXXX functions take as the last argument an *ok parameter
725  // which is set to false if parsing failed; it is unchanged otherwise.
726  // By making the 'exception handling' explicit, we are forced to check
727  // for failure at the call sites.
728  void* ParseStatementList(ZoneList<Statement*>* body, int end_token, bool* ok);
729  Statement* ParseStatementListItem(bool* ok);
730  void* ParseModuleItemList(ZoneList<Statement*>* body, bool* ok);
731  Statement* ParseModuleItem(bool* ok);
732  const AstRawString* ParseModuleSpecifier(bool* ok);
733  Statement* ParseImportDeclaration(bool* ok);
734  Statement* ParseExportDeclaration(bool* ok);
735  Statement* ParseExportDefault(bool* ok);
736  void* ParseExportClause(ZoneList<const AstRawString*>* export_names,
737                          ZoneList<Scanner::Location>* export_locations,
738                          ZoneList<const AstRawString*>* local_names,
739                          Scanner::Location* reserved_loc, bool* ok);
740  ZoneList<ImportDeclaration*>* ParseNamedImports(int pos, bool* ok);
741  Statement* ParseStatement(ZoneList<const AstRawString*>* labels, bool* ok);
742  Statement* ParseSubStatement(ZoneList<const AstRawString*>* labels, bool* ok);
743  Statement* ParseStatementAsUnlabelled(ZoneList<const AstRawString*>* labels,
744                                   bool* ok);
745  Statement* ParseFunctionDeclaration(ZoneList<const AstRawString*>* names,
746                                      bool* ok);
747  Statement* ParseClassDeclaration(ZoneList<const AstRawString*>* names,
748                                   bool* ok);
749  Statement* ParseNativeDeclaration(bool* ok);
750  Block* ParseBlock(ZoneList<const AstRawString*>* labels, bool* ok);
751  Block* ParseBlock(ZoneList<const AstRawString*>* labels,
752                    bool finalize_block_scope, bool* ok);
753  Block* ParseVariableStatement(VariableDeclarationContext var_context,
754                                ZoneList<const AstRawString*>* names,
755                                bool* ok);
756  DoExpression* ParseDoExpression(bool* ok);
757
758  struct DeclarationDescriptor {
759    enum Kind { NORMAL, PARAMETER };
760    Parser* parser;
761    Scope* scope;
762    Scope* hoist_scope;
763    VariableMode mode;
764    bool needs_init;
765    int declaration_pos;
766    int initialization_pos;
767    Kind declaration_kind;
768  };
769
770  struct DeclarationParsingResult {
771    struct Declaration {
772      Declaration(Expression* pattern, int initializer_position,
773                  Expression* initializer)
774          : pattern(pattern),
775            initializer_position(initializer_position),
776            initializer(initializer) {}
777
778      Expression* pattern;
779      int initializer_position;
780      Expression* initializer;
781    };
782
783    DeclarationParsingResult()
784        : declarations(4),
785          first_initializer_loc(Scanner::Location::invalid()),
786          bindings_loc(Scanner::Location::invalid()) {}
787
788    Block* BuildInitializationBlock(ZoneList<const AstRawString*>* names,
789                                    bool* ok);
790
791    DeclarationDescriptor descriptor;
792    List<Declaration> declarations;
793    Scanner::Location first_initializer_loc;
794    Scanner::Location bindings_loc;
795  };
796
797  class PatternRewriter : private AstVisitor {
798   public:
799    static void DeclareAndInitializeVariables(
800        Block* block, const DeclarationDescriptor* declaration_descriptor,
801        const DeclarationParsingResult::Declaration* declaration,
802        ZoneList<const AstRawString*>* names, bool* ok);
803
804    static void RewriteDestructuringAssignment(
805        Parser* parser, RewritableAssignmentExpression* expr, Scope* Scope);
806
807    static Expression* RewriteDestructuringAssignment(Parser* parser,
808                                                      Assignment* assignment,
809                                                      Scope* scope);
810
811    void set_initializer_position(int pos) { initializer_position_ = pos; }
812
813   private:
814    PatternRewriter() {}
815
816#define DECLARE_VISIT(type) void Visit##type(v8::internal::type* node) override;
817    // Visiting functions for AST nodes make this an AstVisitor.
818    AST_NODE_LIST(DECLARE_VISIT)
819#undef DECLARE_VISIT
820    void Visit(AstNode* node) override;
821
822    enum PatternContext {
823      BINDING,
824      INITIALIZER,
825      ASSIGNMENT,
826      ASSIGNMENT_INITIALIZER
827    };
828
829    PatternContext context() const { return context_; }
830    void set_context(PatternContext context) { context_ = context; }
831
832    void RecurseIntoSubpattern(AstNode* pattern, Expression* value) {
833      Expression* old_value = current_value_;
834      current_value_ = value;
835      recursion_level_++;
836      pattern->Accept(this);
837      recursion_level_--;
838      current_value_ = old_value;
839    }
840
841    void VisitObjectLiteral(ObjectLiteral* node, Variable** temp_var);
842    void VisitArrayLiteral(ArrayLiteral* node, Variable** temp_var);
843
844    bool IsBindingContext() const { return IsBindingContext(context_); }
845    bool IsInitializerContext() const { return context_ != ASSIGNMENT; }
846    bool IsAssignmentContext() const { return IsAssignmentContext(context_); }
847    bool IsAssignmentContext(PatternContext c) const;
848    bool IsBindingContext(PatternContext c) const;
849    bool IsSubPattern() const { return recursion_level_ > 1; }
850    PatternContext SetAssignmentContextIfNeeded(Expression* node);
851    PatternContext SetInitializerContextIfNeeded(Expression* node);
852
853    Variable* CreateTempVar(Expression* value = nullptr);
854
855    AstNodeFactory* factory() const { return parser_->factory(); }
856    AstValueFactory* ast_value_factory() const {
857      return parser_->ast_value_factory();
858    }
859    Zone* zone() const { return parser_->zone(); }
860    Scope* scope() const { return scope_; }
861
862    Scope* scope_;
863    Parser* parser_;
864    PatternContext context_;
865    Expression* pattern_;
866    int initializer_position_;
867    Block* block_;
868    const DeclarationDescriptor* descriptor_;
869    ZoneList<const AstRawString*>* names_;
870    Expression* current_value_;
871    int recursion_level_;
872    bool* ok_;
873  };
874
875
876  void ParseVariableDeclarations(VariableDeclarationContext var_context,
877                                 DeclarationParsingResult* parsing_result,
878                                 bool* ok);
879  Statement* ParseExpressionOrLabelledStatement(
880      ZoneList<const AstRawString*>* labels, bool* ok);
881  IfStatement* ParseIfStatement(ZoneList<const AstRawString*>* labels,
882                                bool* ok);
883  Statement* ParseContinueStatement(bool* ok);
884  Statement* ParseBreakStatement(ZoneList<const AstRawString*>* labels,
885                                 bool* ok);
886  Statement* ParseReturnStatement(bool* ok);
887  Statement* ParseWithStatement(ZoneList<const AstRawString*>* labels,
888                                bool* ok);
889  CaseClause* ParseCaseClause(bool* default_seen_ptr, bool* ok);
890  Statement* ParseSwitchStatement(ZoneList<const AstRawString*>* labels,
891                                  bool* ok);
892  DoWhileStatement* ParseDoWhileStatement(ZoneList<const AstRawString*>* labels,
893                                          bool* ok);
894  WhileStatement* ParseWhileStatement(ZoneList<const AstRawString*>* labels,
895                                      bool* ok);
896  Statement* ParseForStatement(ZoneList<const AstRawString*>* labels, bool* ok);
897  Statement* ParseThrowStatement(bool* ok);
898  Expression* MakeCatchContext(Handle<String> id, VariableProxy* value);
899  TryStatement* ParseTryStatement(bool* ok);
900  DebuggerStatement* ParseDebuggerStatement(bool* ok);
901
902  // !%_IsJSReceiver(result = iterator.next()) &&
903  //     %ThrowIteratorResultNotAnObject(result)
904  Expression* BuildIteratorNextResult(Expression* iterator, Variable* result,
905                                      int pos);
906
907
908  // Initialize the components of a for-in / for-of statement.
909  void InitializeForEachStatement(ForEachStatement* stmt, Expression* each,
910                                  Expression* subject, Statement* body,
911                                  bool is_destructuring);
912  Statement* DesugarLexicalBindingsInForStatement(
913      Scope* inner_scope, bool is_const, ZoneList<const AstRawString*>* names,
914      ForStatement* loop, Statement* init, Expression* cond, Statement* next,
915      Statement* body, bool* ok);
916
917  void RewriteDoExpression(Expression* expr, bool* ok);
918
919  FunctionLiteral* ParseFunctionLiteral(
920      const AstRawString* name, Scanner::Location function_name_location,
921      FunctionNameValidity function_name_validity, FunctionKind kind,
922      int function_token_position, FunctionLiteral::FunctionType type,
923      FunctionLiteral::ArityRestriction arity_restriction,
924      LanguageMode language_mode, bool* ok);
925
926
927  ClassLiteral* ParseClassLiteral(const AstRawString* name,
928                                  Scanner::Location class_name_location,
929                                  bool name_is_strict_reserved, int pos,
930                                  bool* ok);
931
932  // Magical syntax support.
933  Expression* ParseV8Intrinsic(bool* ok);
934
935  // Get odd-ball literals.
936  Literal* GetLiteralUndefined(int position);
937
938  // Check if the scope has conflicting var/let declarations from different
939  // scopes. This covers for example
940  //
941  // function f() { { { var x; } let x; } }
942  // function g() { { var x; let x; } }
943  //
944  // The var declarations are hoisted to the function scope, but originate from
945  // a scope where the name has also been let bound or the var declaration is
946  // hoisted over such a scope.
947  void CheckConflictingVarDeclarations(Scope* scope, bool* ok);
948
949  // Insert initializer statements for var-bindings shadowing parameter bindings
950  // from a non-simple parameter list.
951  void InsertShadowingVarBindingInitializers(Block* block);
952
953  // Implement sloppy block-scoped functions, ES2015 Annex B 3.3
954  void InsertSloppyBlockFunctionVarBindings(Scope* scope, bool* ok);
955
956  // Parser support
957  VariableProxy* NewUnresolved(const AstRawString* name, VariableMode mode);
958  Variable* Declare(Declaration* declaration,
959                    DeclarationDescriptor::Kind declaration_kind, bool resolve,
960                    bool* ok, Scope* declaration_scope = nullptr);
961
962  bool TargetStackContainsLabel(const AstRawString* label);
963  BreakableStatement* LookupBreakTarget(const AstRawString* label, bool* ok);
964  IterationStatement* LookupContinueTarget(const AstRawString* label, bool* ok);
965
966  Statement* BuildAssertIsCoercible(Variable* var);
967
968  // Factory methods.
969  FunctionLiteral* DefaultConstructor(bool call_super, Scope* scope, int pos,
970                                      int end_pos, LanguageMode language_mode);
971
972  // Skip over a lazy function, either using cached data if we have it, or
973  // by parsing the function with PreParser. Consumes the ending }.
974  //
975  // If bookmark is set, the (pre-)parser may decide to abort skipping
976  // in order to force the function to be eagerly parsed, after all.
977  // In this case, it'll reset the scanner using the bookmark.
978  void SkipLazyFunctionBody(int* materialized_literal_count,
979                            int* expected_property_count, bool* ok,
980                            Scanner::BookmarkScope* bookmark = nullptr);
981
982  PreParser::PreParseResult ParseLazyFunctionBodyWithPreParser(
983      SingletonLogger* logger, Scanner::BookmarkScope* bookmark = nullptr);
984
985  Block* BuildParameterInitializationBlock(
986      const ParserFormalParameters& parameters, bool* ok);
987
988  // Consumes the ending }.
989  ZoneList<Statement*>* ParseEagerFunctionBody(
990      const AstRawString* function_name, int pos,
991      const ParserFormalParameters& parameters, FunctionKind kind,
992      FunctionLiteral::FunctionType function_type, bool* ok);
993
994  void ThrowPendingError(Isolate* isolate, Handle<Script> script);
995
996  TemplateLiteralState OpenTemplateLiteral(int pos);
997  void AddTemplateSpan(TemplateLiteralState* state, bool tail);
998  void AddTemplateExpression(TemplateLiteralState* state,
999                             Expression* expression);
1000  Expression* CloseTemplateLiteral(TemplateLiteralState* state, int start,
1001                                   Expression* tag);
1002  uint32_t ComputeTemplateLiteralHash(const TemplateLiteral* lit);
1003
1004  ZoneList<v8::internal::Expression*>* PrepareSpreadArguments(
1005      ZoneList<v8::internal::Expression*>* list);
1006  Expression* SpreadCall(Expression* function,
1007                         ZoneList<v8::internal::Expression*>* args, int pos);
1008  Expression* SpreadCallNew(Expression* function,
1009                            ZoneList<v8::internal::Expression*>* args, int pos);
1010
1011  void SetLanguageMode(Scope* scope, LanguageMode mode);
1012  void RaiseLanguageMode(LanguageMode mode);
1013
1014  V8_INLINE void RewriteDestructuringAssignments();
1015
1016  V8_INLINE Expression* RewriteNonPattern(
1017      Expression* expr, const ExpressionClassifier* classifier, bool* ok);
1018  V8_INLINE ZoneList<Expression*>* RewriteNonPatternArguments(
1019      ZoneList<Expression*>* args, const ExpressionClassifier* classifier,
1020      bool* ok);
1021  V8_INLINE ObjectLiteralProperty* RewriteNonPatternObjectLiteralProperty(
1022      ObjectLiteralProperty* property, const ExpressionClassifier* classifier,
1023      bool* ok);
1024
1025  friend class InitializerRewriter;
1026  void RewriteParameterInitializer(Expression* expr, Scope* scope);
1027
1028  Scanner scanner_;
1029  PreParser* reusable_preparser_;
1030  Scope* original_scope_;  // for ES5 function declarations in sloppy eval
1031  Target* target_stack_;  // for break, continue statements
1032  ScriptCompiler::CompileOptions compile_options_;
1033  ParseData* cached_parse_data_;
1034
1035  PendingCompilationErrorHandler pending_error_handler_;
1036
1037  // Other information which will be stored in Parser and moved to Isolate after
1038  // parsing.
1039  int use_counts_[v8::Isolate::kUseCounterFeatureCount];
1040  int total_preparse_skipped_;
1041  HistogramTimer* pre_parse_timer_;
1042
1043  bool parsing_on_main_thread_;
1044};
1045
1046
1047bool ParserTraits::IsFutureStrictReserved(
1048    const AstRawString* identifier) const {
1049  return parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
1050}
1051
1052
1053Scope* ParserTraits::NewScope(Scope* parent_scope, ScopeType scope_type,
1054                              FunctionKind kind) {
1055  return parser_->NewScope(parent_scope, scope_type, kind);
1056}
1057
1058
1059const AstRawString* ParserTraits::EmptyIdentifierString() {
1060  return parser_->ast_value_factory()->empty_string();
1061}
1062
1063
1064void ParserTraits::SkipLazyFunctionBody(int* materialized_literal_count,
1065                                        int* expected_property_count, bool* ok,
1066                                        Scanner::BookmarkScope* bookmark) {
1067  return parser_->SkipLazyFunctionBody(materialized_literal_count,
1068                                       expected_property_count, ok, bookmark);
1069}
1070
1071
1072ZoneList<Statement*>* ParserTraits::ParseEagerFunctionBody(
1073    const AstRawString* name, int pos, const ParserFormalParameters& parameters,
1074    FunctionKind kind, FunctionLiteral::FunctionType function_type, bool* ok) {
1075  return parser_->ParseEagerFunctionBody(name, pos, parameters, kind,
1076                                         function_type, ok);
1077}
1078
1079
1080void ParserTraits::CheckConflictingVarDeclarations(v8::internal::Scope* scope,
1081                                                   bool* ok) {
1082  parser_->CheckConflictingVarDeclarations(scope, ok);
1083}
1084
1085
1086// Support for handling complex values (array and object literals) that
1087// can be fully handled at compile time.
1088class CompileTimeValue: public AllStatic {
1089 public:
1090  enum LiteralType {
1091    OBJECT_LITERAL_FAST_ELEMENTS,
1092    OBJECT_LITERAL_SLOW_ELEMENTS,
1093    ARRAY_LITERAL
1094  };
1095
1096  static bool IsCompileTimeValue(Expression* expression);
1097
1098  // Get the value as a compile time value.
1099  static Handle<FixedArray> GetValue(Isolate* isolate, Expression* expression);
1100
1101  // Get the type of a compile time value returned by GetValue().
1102  static LiteralType GetLiteralType(Handle<FixedArray> value);
1103
1104  // Get the elements array of a compile time value returned by GetValue().
1105  static Handle<FixedArray> GetElements(Handle<FixedArray> value);
1106
1107 private:
1108  static const int kLiteralTypeSlot = 0;
1109  static const int kElementsSlot = 1;
1110
1111  DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
1112};
1113
1114
1115ParserTraits::TemplateLiteralState ParserTraits::OpenTemplateLiteral(int pos) {
1116  return parser_->OpenTemplateLiteral(pos);
1117}
1118
1119
1120void ParserTraits::AddTemplateSpan(TemplateLiteralState* state, bool tail) {
1121  parser_->AddTemplateSpan(state, tail);
1122}
1123
1124
1125void ParserTraits::AddTemplateExpression(TemplateLiteralState* state,
1126                                         Expression* expression) {
1127  parser_->AddTemplateExpression(state, expression);
1128}
1129
1130
1131Expression* ParserTraits::CloseTemplateLiteral(TemplateLiteralState* state,
1132                                               int start, Expression* tag) {
1133  return parser_->CloseTemplateLiteral(state, start, tag);
1134}
1135
1136
1137ZoneList<v8::internal::Expression*>* ParserTraits::PrepareSpreadArguments(
1138    ZoneList<v8::internal::Expression*>* list) {
1139  return parser_->PrepareSpreadArguments(list);
1140}
1141
1142
1143Expression* ParserTraits::SpreadCall(Expression* function,
1144                                     ZoneList<v8::internal::Expression*>* args,
1145                                     int pos) {
1146  return parser_->SpreadCall(function, args, pos);
1147}
1148
1149
1150Expression* ParserTraits::SpreadCallNew(
1151    Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
1152  return parser_->SpreadCallNew(function, args, pos);
1153}
1154
1155
1156void ParserTraits::AddFormalParameter(ParserFormalParameters* parameters,
1157                                      Expression* pattern,
1158                                      Expression* initializer,
1159                                      int initializer_end_position,
1160                                      bool is_rest) {
1161  bool is_simple = pattern->IsVariableProxy() && initializer == nullptr;
1162  const AstRawString* name = is_simple
1163                                 ? pattern->AsVariableProxy()->raw_name()
1164                                 : parser_->ast_value_factory()->empty_string();
1165  parameters->params.Add(
1166      ParserFormalParameters::Parameter(name, pattern, initializer,
1167                                        initializer_end_position, is_rest),
1168      parameters->scope->zone());
1169}
1170
1171
1172void ParserTraits::DeclareFormalParameter(
1173    Scope* scope, const ParserFormalParameters::Parameter& parameter,
1174    ExpressionClassifier* classifier) {
1175  bool is_duplicate = false;
1176  bool is_simple = classifier->is_simple_parameter_list();
1177  auto name = is_simple || parameter.is_rest
1178                  ? parameter.name
1179                  : parser_->ast_value_factory()->empty_string();
1180  auto mode = is_simple || parameter.is_rest ? VAR : TEMPORARY;
1181  if (!is_simple) scope->SetHasNonSimpleParameters();
1182  bool is_optional = parameter.initializer != nullptr;
1183  Variable* var = scope->DeclareParameter(
1184      name, mode, is_optional, parameter.is_rest, &is_duplicate);
1185  if (is_duplicate) {
1186    classifier->RecordDuplicateFormalParameterError(
1187        parser_->scanner()->location());
1188  }
1189  if (is_sloppy(scope->language_mode())) {
1190    // TODO(sigurds) Mark every parameter as maybe assigned. This is a
1191    // conservative approximation necessary to account for parameters
1192    // that are assigned via the arguments array.
1193    var->set_maybe_assigned();
1194  }
1195}
1196
1197
1198void ParserTraits::AddParameterInitializationBlock(
1199    const ParserFormalParameters& parameters,
1200    ZoneList<v8::internal::Statement*>* body, bool* ok) {
1201  if (!parameters.is_simple) {
1202    auto* init_block =
1203        parser_->BuildParameterInitializationBlock(parameters, ok);
1204    if (!*ok) return;
1205    if (init_block != nullptr) {
1206      body->Add(init_block, parser_->zone());
1207    }
1208  }
1209}
1210
1211
1212DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
1213  return parser_->ParseDoExpression(ok);
1214}
1215
1216
1217}  // namespace internal
1218}  // namespace v8
1219
1220#endif  // V8_PARSING_PARSER_H_
1221