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