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