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