| // Copyright 2012 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_PARSING_PARSER_BASE_H_ |
| #define V8_PARSING_PARSER_BASE_H_ |
| |
| #include <vector> |
| |
| #include "src/ast/ast-source-ranges.h" |
| #include "src/ast/ast.h" |
| #include "src/ast/scopes.h" |
| #include "src/bailout-reason.h" |
| #include "src/base/hashmap.h" |
| #include "src/base/v8-fallthrough.h" |
| #include "src/counters.h" |
| #include "src/globals.h" |
| #include "src/log.h" |
| #include "src/messages.h" |
| #include "src/parsing/expression-classifier.h" |
| #include "src/parsing/func-name-inferrer.h" |
| #include "src/parsing/scanner.h" |
| #include "src/parsing/token.h" |
| #include "src/zone/zone-chunk-list.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| enum FunctionNameValidity { |
| kFunctionNameIsStrictReserved, |
| kSkipFunctionNameCheck, |
| kFunctionNameValidityUnknown |
| }; |
| |
| enum AllowLabelledFunctionStatement { |
| kAllowLabelledFunctionStatement, |
| kDisallowLabelledFunctionStatement, |
| }; |
| |
| enum class ParseFunctionFlags { |
| kIsNormal = 0, |
| kIsGenerator = 1, |
| kIsAsync = 2, |
| kIsDefault = 4 |
| }; |
| |
| static inline ParseFunctionFlags operator|(ParseFunctionFlags lhs, |
| ParseFunctionFlags rhs) { |
| typedef unsigned char T; |
| return static_cast<ParseFunctionFlags>(static_cast<T>(lhs) | |
| static_cast<T>(rhs)); |
| } |
| |
| static inline ParseFunctionFlags& operator|=(ParseFunctionFlags& lhs, |
| const ParseFunctionFlags& rhs) { |
| lhs = lhs | rhs; |
| return lhs; |
| } |
| |
| static inline bool operator&(ParseFunctionFlags bitfield, |
| ParseFunctionFlags mask) { |
| typedef unsigned char T; |
| return static_cast<T>(bitfield) & static_cast<T>(mask); |
| } |
| |
| struct FormalParametersBase { |
| explicit FormalParametersBase(DeclarationScope* scope) : scope(scope) {} |
| |
| int num_parameters() const { |
| // Don't include the rest parameter into the function's formal parameter |
| // count (esp. the SharedFunctionInfo::internal_formal_parameter_count, |
| // which says whether we need to create an arguments adaptor frame). |
| return arity - has_rest; |
| } |
| |
| void UpdateArityAndFunctionLength(bool is_optional, bool is_rest) { |
| if (!is_optional && !is_rest && function_length == arity) { |
| ++function_length; |
| } |
| ++arity; |
| } |
| |
| DeclarationScope* scope; |
| bool has_rest = false; |
| bool is_simple = true; |
| int function_length = 0; |
| int arity = 0; |
| }; |
| |
| // Stack-allocated scope to collect source ranges from the parser. |
| class SourceRangeScope final { |
| public: |
| enum PositionKind { |
| POSITION_BEG, |
| POSITION_END, |
| PEEK_POSITION_BEG, |
| PEEK_POSITION_END, |
| }; |
| |
| SourceRangeScope(Scanner* scanner, SourceRange* range, |
| PositionKind pre_kind = PEEK_POSITION_BEG, |
| PositionKind post_kind = POSITION_END) |
| : scanner_(scanner), range_(range), post_kind_(post_kind) { |
| range_->start = GetPosition(pre_kind); |
| DCHECK_NE(range_->start, kNoSourcePosition); |
| } |
| |
| ~SourceRangeScope() { Finalize(); } |
| |
| const SourceRange& Finalize() { |
| if (is_finalized_) return *range_; |
| is_finalized_ = true; |
| range_->end = GetPosition(post_kind_); |
| DCHECK_NE(range_->end, kNoSourcePosition); |
| return *range_; |
| } |
| |
| private: |
| int32_t GetPosition(PositionKind kind) { |
| switch (kind) { |
| case POSITION_BEG: |
| return scanner_->location().beg_pos; |
| case POSITION_END: |
| return scanner_->location().end_pos; |
| case PEEK_POSITION_BEG: |
| return scanner_->peek_location().beg_pos; |
| case PEEK_POSITION_END: |
| return scanner_->peek_location().end_pos; |
| default: |
| UNREACHABLE(); |
| } |
| } |
| |
| Scanner* scanner_; |
| SourceRange* range_; |
| PositionKind post_kind_; |
| bool is_finalized_ = false; |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(SourceRangeScope); |
| }; |
| |
| // ---------------------------------------------------------------------------- |
| // The CHECK_OK macro is a convenient macro to enforce error |
| // handling for functions that may fail (by returning !*ok). |
| // |
| // CAUTION: This macro appends extra statements after a call, |
| // thus it must never be used where only a single statement |
| // is correct (e.g. an if statement branch w/o braces)! |
| |
| #define CHECK_OK_CUSTOM(x, ...) ok); \ |
| if (!*ok) return impl()->x(__VA_ARGS__); \ |
| ((void)0 |
| #define DUMMY ) // to make indentation work |
| #undef DUMMY |
| |
| // Used in functions where the return type is ExpressionT. |
| #define CHECK_OK CHECK_OK_CUSTOM(NullExpression) |
| |
| #define CHECK_OK_VOID ok); \ |
| if (!*ok) return; \ |
| ((void)0 |
| #define DUMMY ) // to make indentation work |
| #undef DUMMY |
| |
| // Common base class template shared between parser and pre-parser. |
| // The Impl parameter is the actual class of the parser/pre-parser, |
| // following the Curiously Recurring Template Pattern (CRTP). |
| // The structure of the parser objects is roughly the following: |
| // |
| // // A structure template containing type definitions, needed to |
| // // avoid a cyclic dependency. |
| // template <typename Impl> |
| // struct ParserTypes; |
| // |
| // // The parser base object, which should just implement pure |
| // // parser behavior. The Impl parameter is the actual derived |
| // // class (according to CRTP), which implements impure parser |
| // // behavior. |
| // template <typename Impl> |
| // class ParserBase { ... }; |
| // |
| // // And then, for each parser variant (e.g., parser, preparser, etc): |
| // class Parser; |
| // |
| // template <> |
| // class ParserTypes<Parser> { ... }; |
| // |
| // class Parser : public ParserBase<Parser> { ... }; |
| // |
| // The parser base object implements pure parsing, according to the |
| // language grammar. Different parser implementations may exhibit |
| // different parser-driven behavior that is not considered as pure |
| // parsing, e.g., early error detection and reporting, AST generation, etc. |
| |
| // The ParserTypes structure encapsulates the differences in the |
| // types used in parsing methods. E.g., Parser methods use Expression* |
| // and PreParser methods use PreParserExpression. For any given parser |
| // implementation class Impl, it is expected to contain the following typedefs: |
| // |
| // template <> |
| // struct ParserTypes<Impl> { |
| // // Synonyms for ParserBase<Impl> and Impl, respectively. |
| // typedef Base; |
| // typedef Impl; |
| // // Return types for traversing functions. |
| // typedef Identifier; |
| // typedef Expression; |
| // typedef FunctionLiteral; |
| // typedef ObjectLiteralProperty; |
| // typedef ClassLiteralProperty; |
| // typedef ExpressionList; |
| // typedef ObjectPropertyList; |
| // typedef ClassPropertyList; |
| // typedef FormalParameters; |
| // typedef Statement; |
| // typedef StatementList; |
| // typedef Block; |
| // typedef BreakableStatement; |
| // typedef ForStatement; |
| // typedef IterationStatement; |
| // // For constructing objects returned by the traversing functions. |
| // typedef Factory; |
| // // For other implementation-specific tasks. |
| // typedef Target; |
| // typedef TargetScope; |
| // }; |
| |
| template <typename Impl> |
| struct ParserTypes; |
| |
| template <typename Impl> |
| class ParserBase { |
| public: |
| // Shorten type names defined by ParserTypes<Impl>. |
| typedef ParserTypes<Impl> Types; |
| typedef typename Types::Identifier IdentifierT; |
| typedef typename Types::Expression ExpressionT; |
| typedef typename Types::FunctionLiteral FunctionLiteralT; |
| typedef typename Types::ObjectLiteralProperty ObjectLiteralPropertyT; |
| typedef typename Types::ClassLiteralProperty ClassLiteralPropertyT; |
| typedef typename Types::Suspend SuspendExpressionT; |
| typedef typename Types::RewritableExpression RewritableExpressionT; |
| typedef typename Types::ExpressionList ExpressionListT; |
| typedef typename Types::FormalParameters FormalParametersT; |
| typedef typename Types::Statement StatementT; |
| typedef typename Types::StatementList StatementListT; |
| typedef typename Types::Block BlockT; |
| typedef typename Types::ForStatement ForStatementT; |
| typedef typename v8::internal::ExpressionClassifier<Types> |
| ExpressionClassifier; |
| |
| // All implementation-specific methods must be called through this. |
| Impl* impl() { return static_cast<Impl*>(this); } |
| const Impl* impl() const { return static_cast<const Impl*>(this); } |
| |
| ParserBase(Zone* zone, Scanner* scanner, uintptr_t stack_limit, |
| v8::Extension* extension, AstValueFactory* ast_value_factory, |
| PendingCompilationErrorHandler* pending_error_handler, |
| RuntimeCallStats* runtime_call_stats, Logger* logger, |
| int script_id, bool parsing_module, bool parsing_on_main_thread) |
| : scope_(nullptr), |
| original_scope_(nullptr), |
| function_state_(nullptr), |
| extension_(extension), |
| fni_(nullptr), |
| ast_value_factory_(ast_value_factory), |
| ast_node_factory_(ast_value_factory, zone), |
| runtime_call_stats_(runtime_call_stats), |
| logger_(logger), |
| parsing_on_main_thread_(parsing_on_main_thread), |
| parsing_module_(parsing_module), |
| stack_limit_(stack_limit), |
| pending_error_handler_(pending_error_handler), |
| zone_(zone), |
| classifier_(nullptr), |
| scanner_(scanner), |
| default_eager_compile_hint_(FunctionLiteral::kShouldLazyCompile), |
| function_literal_id_(0), |
| script_id_(script_id), |
| allow_natives_(false), |
| allow_harmony_do_expressions_(false), |
| allow_harmony_public_fields_(false), |
| allow_harmony_static_fields_(false), |
| allow_harmony_dynamic_import_(false), |
| allow_harmony_import_meta_(false), |
| allow_harmony_private_fields_(false), |
| allow_eval_cache_(true) {} |
| |
| #define ALLOW_ACCESSORS(name) \ |
| bool allow_##name() const { return allow_##name##_; } \ |
| void set_allow_##name(bool allow) { allow_##name##_ = allow; } |
| |
| ALLOW_ACCESSORS(natives); |
| ALLOW_ACCESSORS(harmony_do_expressions); |
| ALLOW_ACCESSORS(harmony_public_fields); |
| ALLOW_ACCESSORS(harmony_static_fields); |
| ALLOW_ACCESSORS(harmony_dynamic_import); |
| ALLOW_ACCESSORS(harmony_import_meta); |
| ALLOW_ACCESSORS(eval_cache); |
| |
| #undef ALLOW_ACCESSORS |
| |
| bool allow_harmony_bigint() const { |
| return scanner()->allow_harmony_bigint(); |
| } |
| void set_allow_harmony_bigint(bool allow) { |
| scanner()->set_allow_harmony_bigint(allow); |
| } |
| bool allow_harmony_numeric_separator() const { |
| return scanner()->allow_harmony_numeric_separator(); |
| } |
| void set_allow_harmony_numeric_separator(bool allow) { |
| scanner()->set_allow_harmony_numeric_separator(allow); |
| } |
| |
| bool allow_harmony_private_fields() const { |
| return scanner()->allow_harmony_private_fields(); |
| } |
| void set_allow_harmony_private_fields(bool allow) { |
| scanner()->set_allow_harmony_private_fields(allow); |
| } |
| |
| uintptr_t stack_limit() const { return stack_limit_; } |
| |
| void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; } |
| |
| void set_default_eager_compile_hint( |
| FunctionLiteral::EagerCompileHint eager_compile_hint) { |
| default_eager_compile_hint_ = eager_compile_hint; |
| } |
| |
| FunctionLiteral::EagerCompileHint default_eager_compile_hint() const { |
| return default_eager_compile_hint_; |
| } |
| |
| int GetNextFunctionLiteralId() { return ++function_literal_id_; } |
| int GetLastFunctionLiteralId() const { return function_literal_id_; } |
| |
| void SkipFunctionLiterals(int delta) { function_literal_id_ += delta; } |
| |
| void ResetFunctionLiteralId() { function_literal_id_ = 0; } |
| |
| // The Zone where the parsing outputs are stored. |
| Zone* main_zone() const { return ast_value_factory()->zone(); } |
| |
| // The current Zone, which might be the main zone or a temporary Zone. |
| Zone* zone() const { return zone_; } |
| |
| protected: |
| friend class v8::internal::ExpressionClassifier<ParserTypes<Impl>>; |
| |
| enum AllowRestrictedIdentifiers { |
| kAllowRestrictedIdentifiers, |
| kDontAllowRestrictedIdentifiers |
| }; |
| |
| enum LazyParsingResult { kLazyParsingComplete, kLazyParsingAborted }; |
| |
| enum VariableDeclarationContext { |
| kStatementListItem, |
| kStatement, |
| kForStatement |
| }; |
| |
| class ClassLiteralChecker; |
| class ObjectLiteralChecker; |
| |
| // --------------------------------------------------------------------------- |
| // BlockState and FunctionState implement the parser's scope stack. |
| // The parser's current scope is in scope_. BlockState and FunctionState |
| // constructors push on the scope stack and the destructors pop. They are also |
| // used to hold the parser's per-funcion state. |
| class BlockState BASE_EMBEDDED { |
| public: |
| BlockState(Scope** scope_stack, Scope* scope) |
| : scope_stack_(scope_stack), outer_scope_(*scope_stack) { |
| *scope_stack_ = scope; |
| } |
| |
| BlockState(Zone* zone, Scope** scope_stack) |
| : BlockState(scope_stack, |
| new (zone) Scope(zone, *scope_stack, BLOCK_SCOPE)) {} |
| |
| ~BlockState() { *scope_stack_ = outer_scope_; } |
| |
| private: |
| Scope** const scope_stack_; |
| Scope* const outer_scope_; |
| }; |
| |
| class FunctionState final : public BlockState { |
| public: |
| FunctionState(FunctionState** function_state_stack, Scope** scope_stack, |
| DeclarationScope* scope); |
| ~FunctionState(); |
| |
| DeclarationScope* scope() const { return scope_->AsDeclarationScope(); } |
| |
| void AddProperty() { expected_property_count_++; } |
| int expected_property_count() { return expected_property_count_; } |
| |
| void DisableOptimization(BailoutReason reason) { |
| dont_optimize_reason_ = reason; |
| } |
| BailoutReason dont_optimize_reason() { return dont_optimize_reason_; } |
| |
| void AddSuspend() { suspend_count_++; } |
| int suspend_count() const { return suspend_count_; } |
| bool CanSuspend() const { return suspend_count_ > 0; } |
| |
| FunctionKind kind() const { return scope()->function_kind(); } |
| |
| void RewindDestructuringAssignments(int pos) { |
| destructuring_assignments_to_rewrite_.Rewind(pos); |
| } |
| |
| void AdoptDestructuringAssignmentsFromParentState(int pos) { |
| const auto& outer_assignments = |
| outer_function_state_->destructuring_assignments_to_rewrite_; |
| DCHECK_GE(outer_assignments.size(), pos); |
| auto it = outer_assignments.begin(); |
| it.Advance(pos); |
| for (; it != outer_assignments.end(); ++it) { |
| auto expr = *it; |
| expr->set_scope(scope_); |
| destructuring_assignments_to_rewrite_.push_back(expr); |
| } |
| outer_function_state_->RewindDestructuringAssignments(pos); |
| } |
| |
| const ZoneChunkList<RewritableExpressionT>& |
| destructuring_assignments_to_rewrite() const { |
| return destructuring_assignments_to_rewrite_; |
| } |
| |
| ZoneVector<typename ExpressionClassifier::Error>* GetReportedErrorList() { |
| return &reported_errors_; |
| } |
| |
| bool next_function_is_likely_called() const { |
| return next_function_is_likely_called_; |
| } |
| |
| bool previous_function_was_likely_called() const { |
| return previous_function_was_likely_called_; |
| } |
| |
| void set_next_function_is_likely_called() { |
| next_function_is_likely_called_ = true; |
| } |
| |
| void RecordFunctionOrEvalCall() { contains_function_or_eval_ = true; } |
| bool contains_function_or_eval() const { |
| return contains_function_or_eval_; |
| } |
| |
| class FunctionOrEvalRecordingScope { |
| public: |
| explicit FunctionOrEvalRecordingScope(FunctionState* state) |
| : state_(state) { |
| prev_value_ = state->contains_function_or_eval_; |
| state->contains_function_or_eval_ = false; |
| } |
| ~FunctionOrEvalRecordingScope() { |
| bool found = state_->contains_function_or_eval_; |
| if (!found) { |
| state_->contains_function_or_eval_ = prev_value_; |
| } |
| } |
| |
| private: |
| FunctionState* state_; |
| bool prev_value_; |
| }; |
| |
| private: |
| void AddDestructuringAssignment(RewritableExpressionT expr) { |
| destructuring_assignments_to_rewrite_.push_back(expr); |
| } |
| |
| // Properties count estimation. |
| int expected_property_count_; |
| |
| // How many suspends are needed for this function. |
| int suspend_count_; |
| |
| FunctionState** function_state_stack_; |
| FunctionState* outer_function_state_; |
| DeclarationScope* scope_; |
| |
| ZoneChunkList<RewritableExpressionT> destructuring_assignments_to_rewrite_; |
| |
| // We use a ZoneVector here because we need to do a lot of random access. |
| ZoneVector<typename ExpressionClassifier::Error> reported_errors_; |
| |
| // A reason, if any, why this function should not be optimized. |
| BailoutReason dont_optimize_reason_; |
| |
| // Record whether the next (=== immediately following) function literal is |
| // preceded by a parenthesis / exclamation mark. Also record the previous |
| // state. |
| // These are managed by the FunctionState constructor; the caller may only |
| // call set_next_function_is_likely_called. |
| bool next_function_is_likely_called_; |
| bool previous_function_was_likely_called_; |
| |
| // Track if a function or eval occurs within this FunctionState |
| bool contains_function_or_eval_; |
| |
| friend Impl; |
| }; |
| |
| struct DeclarationDescriptor { |
| enum Kind { NORMAL, PARAMETER, FOR_EACH }; |
| Scope* scope; |
| VariableMode mode; |
| int declaration_pos; |
| int initialization_pos; |
| Kind declaration_kind; |
| }; |
| |
| struct DeclarationParsingResult { |
| struct Declaration { |
| Declaration(ExpressionT pattern, int initializer_position, |
| ExpressionT initializer) |
| : pattern(pattern), |
| initializer_position(initializer_position), |
| initializer(initializer) {} |
| |
| ExpressionT pattern; |
| int initializer_position; |
| int value_beg_position = kNoSourcePosition; |
| ExpressionT initializer; |
| }; |
| |
| DeclarationParsingResult() |
| : first_initializer_loc(Scanner::Location::invalid()), |
| bindings_loc(Scanner::Location::invalid()) {} |
| |
| DeclarationDescriptor descriptor; |
| std::vector<Declaration> declarations; |
| Scanner::Location first_initializer_loc; |
| Scanner::Location bindings_loc; |
| }; |
| |
| struct CatchInfo { |
| public: |
| explicit CatchInfo(ParserBase* parser) |
| : name(parser->impl()->NullIdentifier()), |
| pattern(parser->impl()->NullExpression()), |
| scope(nullptr), |
| init_block(parser->impl()->NullStatement()), |
| inner_block(parser->impl()->NullStatement()), |
| bound_names(1, parser->zone()) {} |
| IdentifierT name; |
| ExpressionT pattern; |
| Scope* scope; |
| BlockT init_block; |
| BlockT inner_block; |
| ZonePtrList<const AstRawString> bound_names; |
| }; |
| |
| struct ForInfo { |
| public: |
| explicit ForInfo(ParserBase* parser) |
| : bound_names(1, parser->zone()), |
| mode(ForEachStatement::ENUMERATE), |
| position(kNoSourcePosition), |
| parsing_result() {} |
| ZonePtrList<const AstRawString> bound_names; |
| ForEachStatement::VisitMode mode; |
| int position; |
| DeclarationParsingResult parsing_result; |
| }; |
| |
| struct ClassInfo { |
| public: |
| explicit ClassInfo(ParserBase* parser) |
| : variable(nullptr), |
| extends(parser->impl()->NullExpression()), |
| properties(parser->impl()->NewClassPropertyList(4)), |
| static_fields(parser->impl()->NewClassPropertyList(4)), |
| instance_fields(parser->impl()->NewClassPropertyList(4)), |
| constructor(parser->impl()->NullExpression()), |
| has_seen_constructor(false), |
| has_name_static_property(false), |
| has_static_computed_names(false), |
| has_static_class_fields(false), |
| has_instance_class_fields(false), |
| is_anonymous(false), |
| static_fields_scope(nullptr), |
| instance_fields_scope(nullptr), |
| computed_field_count(0) {} |
| Variable* variable; |
| ExpressionT extends; |
| typename Types::ClassPropertyList properties; |
| typename Types::ClassPropertyList static_fields; |
| typename Types::ClassPropertyList instance_fields; |
| FunctionLiteralT constructor; |
| |
| bool has_seen_constructor; |
| bool has_name_static_property; |
| bool has_static_computed_names; |
| bool has_static_class_fields; |
| bool has_instance_class_fields; |
| bool is_anonymous; |
| DeclarationScope* static_fields_scope; |
| DeclarationScope* instance_fields_scope; |
| int computed_field_count; |
| }; |
| |
| const AstRawString* ClassFieldVariableName(AstValueFactory* ast_value_factory, |
| int index) { |
| std::string name = ".class-field-" + std::to_string(index); |
| return ast_value_factory->GetOneByteString(name.c_str()); |
| } |
| |
| DeclarationScope* NewScriptScope() const { |
| return new (zone()) DeclarationScope(zone(), ast_value_factory()); |
| } |
| |
| DeclarationScope* NewVarblockScope() const { |
| return new (zone()) DeclarationScope(zone(), scope(), BLOCK_SCOPE); |
| } |
| |
| ModuleScope* NewModuleScope(DeclarationScope* parent) const { |
| return new (zone()) ModuleScope(parent, ast_value_factory()); |
| } |
| |
| DeclarationScope* NewEvalScope(Scope* parent) const { |
| return new (zone()) DeclarationScope(zone(), parent, EVAL_SCOPE); |
| } |
| |
| Scope* NewScope(ScopeType scope_type) const { |
| return NewScopeWithParent(scope(), scope_type); |
| } |
| |
| // This constructor should only be used when absolutely necessary. Most scopes |
| // should automatically use scope() as parent, and be fine with |
| // NewScope(ScopeType) above. |
| Scope* NewScopeWithParent(Scope* parent, ScopeType scope_type) const { |
| // Must always use the specific constructors for the blacklisted scope |
| // types. |
| DCHECK_NE(FUNCTION_SCOPE, scope_type); |
| DCHECK_NE(SCRIPT_SCOPE, scope_type); |
| DCHECK_NE(MODULE_SCOPE, scope_type); |
| DCHECK_NOT_NULL(parent); |
| return new (zone()) Scope(zone(), parent, scope_type); |
| } |
| |
| // Creates a function scope that always allocates in zone(). The function |
| // scope itself is either allocated in zone() or in target_zone if one is |
| // passed in. |
| DeclarationScope* NewFunctionScope(FunctionKind kind, |
| Zone* target_zone = nullptr) const { |
| DCHECK(ast_value_factory()); |
| if (target_zone == nullptr) target_zone = zone(); |
| DeclarationScope* result = new (target_zone) |
| DeclarationScope(zone(), scope(), FUNCTION_SCOPE, kind); |
| |
| // Record presence of an inner function scope |
| function_state_->RecordFunctionOrEvalCall(); |
| |
| // TODO(verwaest): Move into the DeclarationScope constructor. |
| if (!IsArrowFunction(kind)) { |
| result->DeclareDefaultFunctionVariables(ast_value_factory()); |
| } |
| return result; |
| } |
| |
| V8_INLINE DeclarationScope* GetDeclarationScope() const { |
| return scope()->GetDeclarationScope(); |
| } |
| V8_INLINE DeclarationScope* GetClosureScope() const { |
| return scope()->GetClosureScope(); |
| } |
| |
| Scanner* scanner() const { return scanner_; } |
| AstValueFactory* ast_value_factory() const { return ast_value_factory_; } |
| int position() const { return scanner_->location().beg_pos; } |
| int peek_position() const { return scanner_->peek_location().beg_pos; } |
| bool stack_overflow() const { |
| return pending_error_handler()->stack_overflow(); |
| } |
| void set_stack_overflow() { pending_error_handler()->set_stack_overflow(); } |
| int script_id() { return script_id_; } |
| void set_script_id(int id) { script_id_ = id; } |
| |
| V8_INLINE Token::Value peek() { |
| if (stack_overflow()) return Token::ILLEGAL; |
| return scanner()->peek(); |
| } |
| |
| // Returns the position past the following semicolon (if it exists), and the |
| // position past the end of the current token otherwise. |
| int PositionAfterSemicolon() { |
| return (peek() == Token::SEMICOLON) ? scanner_->peek_location().end_pos |
| : scanner_->location().end_pos; |
| } |
| |
| V8_INLINE Token::Value PeekAhead() { |
| if (stack_overflow()) return Token::ILLEGAL; |
| return scanner()->PeekAhead(); |
| } |
| |
| V8_INLINE Token::Value Next() { |
| if (stack_overflow()) return Token::ILLEGAL; |
| { |
| if (GetCurrentStackPosition() < stack_limit_) { |
| // Any further calls to Next or peek will return the illegal token. |
| // The current call must return the next token, which might already |
| // have been peek'ed. |
| set_stack_overflow(); |
| } |
| } |
| return scanner()->Next(); |
| } |
| |
| void Consume(Token::Value token) { |
| Token::Value next = Next(); |
| USE(next); |
| USE(token); |
| DCHECK(next == token); |
| } |
| |
| bool Check(Token::Value token) { |
| Token::Value next = peek(); |
| if (next == token) { |
| Consume(next); |
| return true; |
| } |
| return false; |
| } |
| |
| void Expect(Token::Value token, bool* ok) { |
| Token::Value next = Next(); |
| if (next != token) { |
| ReportUnexpectedToken(next); |
| *ok = false; |
| } |
| } |
| |
| void ExpectSemicolon(bool* ok) { |
| // Check for automatic semicolon insertion according to |
| // the rules given in ECMA-262, section 7.9, page 21. |
| Token::Value tok = peek(); |
| if (tok == Token::SEMICOLON) { |
| Next(); |
| return; |
| } |
| if (scanner()->HasLineTerminatorBeforeNext() || tok == Token::RBRACE || |
| tok == Token::EOS) { |
| return; |
| } |
| |
| Token::Value current = scanner()->current_token(); |
| Scanner::Location current_location = scanner()->location(); |
| Token::Value next = Next(); |
| |
| if (next == Token::SEMICOLON) { |
| return; |
| } |
| |
| *ok = false; |
| if (current == Token::AWAIT && !is_async_function()) { |
| ReportMessageAt(current_location, |
| MessageTemplate::kAwaitNotInAsyncFunction, kSyntaxError); |
| return; |
| } |
| |
| ReportUnexpectedToken(next); |
| } |
| |
| // Dummy functions, just useful as arguments to CHECK_OK_CUSTOM. |
| static void Void() {} |
| template <typename T> |
| static T Return(T result) { |
| return result; |
| } |
| |
| bool is_any_identifier(Token::Value token) { |
| return token == Token::IDENTIFIER || token == Token::ENUM || |
| token == Token::AWAIT || token == Token::ASYNC || |
| token == Token::ESCAPED_STRICT_RESERVED_WORD || |
| token == Token::FUTURE_STRICT_RESERVED_WORD || token == Token::LET || |
| token == Token::STATIC || token == Token::YIELD; |
| } |
| bool peek_any_identifier() { return is_any_identifier(peek()); } |
| |
| bool CheckContextualKeyword(Token::Value token) { |
| if (PeekContextualKeyword(token)) { |
| Consume(Token::IDENTIFIER); |
| return true; |
| } |
| return false; |
| } |
| |
| bool PeekContextualKeyword(Token::Value token) { |
| DCHECK(Token::IsContextualKeyword(token)); |
| return peek() == Token::IDENTIFIER && |
| scanner()->next_contextual_token() == token; |
| } |
| |
| void ExpectMetaProperty(Token::Value property_name, const char* full_name, |
| int pos, bool* ok); |
| |
| void ExpectContextualKeyword(Token::Value token, bool* ok) { |
| DCHECK(Token::IsContextualKeyword(token)); |
| Expect(Token::IDENTIFIER, CHECK_OK_CUSTOM(Void)); |
| if (scanner()->current_contextual_token() != token) { |
| ReportUnexpectedToken(scanner()->current_token()); |
| *ok = false; |
| } |
| } |
| |
| bool CheckInOrOf(ForEachStatement::VisitMode* visit_mode) { |
| if (Check(Token::IN)) { |
| *visit_mode = ForEachStatement::ENUMERATE; |
| return true; |
| } else if (CheckContextualKeyword(Token::OF)) { |
| *visit_mode = ForEachStatement::ITERATE; |
| return true; |
| } |
| return false; |
| } |
| |
| bool PeekInOrOf() { |
| return peek() == Token::IN || PeekContextualKeyword(Token::OF); |
| } |
| |
| // Checks whether an octal literal was last seen between beg_pos and end_pos. |
| // Only called for strict mode strings. |
| void CheckStrictOctalLiteral(int beg_pos, int end_pos, bool* ok) { |
| Scanner::Location octal = scanner()->octal_position(); |
| if (octal.IsValid() && beg_pos <= octal.beg_pos && |
| octal.end_pos <= end_pos) { |
| MessageTemplate::Template message = scanner()->octal_message(); |
| DCHECK_NE(message, MessageTemplate::kNone); |
| impl()->ReportMessageAt(octal, message); |
| scanner()->clear_octal_position(); |
| if (message == MessageTemplate::kStrictDecimalWithLeadingZero) { |
| impl()->CountUsage(v8::Isolate::kDecimalWithLeadingZeroInStrictMode); |
| } |
| *ok = false; |
| } |
| } |
| |
| // Checks if an octal literal or an invalid hex or unicode escape sequence |
| // appears in the current template literal token. In the presence of such, |
| // either returns false or reports an error, depending on should_throw. |
| // Otherwise returns true. |
| inline bool CheckTemplateEscapes(bool should_throw, bool* ok) { |
| DCHECK(scanner()->current_token() == Token::TEMPLATE_SPAN || |
| scanner()->current_token() == Token::TEMPLATE_TAIL); |
| if (!scanner()->has_invalid_template_escape()) { |
| return true; |
| } |
| |
| // Handle error case(s) |
| if (should_throw) { |
| impl()->ReportMessageAt(scanner()->invalid_template_escape_location(), |
| scanner()->invalid_template_escape_message()); |
| *ok = false; |
| } |
| return false; |
| } |
| |
| void CheckDestructuringElement(ExpressionT element, int beg_pos, int end_pos); |
| |
| // Checking the name of a function literal. This has to be done after parsing |
| // the function, since the function can declare itself strict. |
| void CheckFunctionName(LanguageMode language_mode, IdentifierT function_name, |
| FunctionNameValidity function_name_validity, |
| const Scanner::Location& function_name_loc, bool* ok) { |
| if (impl()->IsNull(function_name)) return; |
| if (function_name_validity == kSkipFunctionNameCheck) return; |
| // The function name needs to be checked in strict mode. |
| if (is_sloppy(language_mode)) return; |
| |
| if (impl()->IsEvalOrArguments(function_name)) { |
| impl()->ReportMessageAt(function_name_loc, |
| MessageTemplate::kStrictEvalArguments); |
| *ok = false; |
| return; |
| } |
| if (function_name_validity == kFunctionNameIsStrictReserved) { |
| impl()->ReportMessageAt(function_name_loc, |
| MessageTemplate::kUnexpectedStrictReserved); |
| *ok = false; |
| return; |
| } |
| } |
| |
| // Determine precedence of given token. |
| static int Precedence(Token::Value token, bool accept_IN) { |
| if (token == Token::IN && !accept_IN) |
| return 0; // 0 precedence will terminate binary expression parsing |
| return Token::Precedence(token); |
| } |
| |
| typename Types::Factory* factory() { return &ast_node_factory_; } |
| |
| DeclarationScope* GetReceiverScope() const { |
| return scope()->GetReceiverScope(); |
| } |
| LanguageMode language_mode() { return scope()->language_mode(); } |
| void RaiseLanguageMode(LanguageMode mode) { |
| LanguageMode old = scope()->language_mode(); |
| impl()->SetLanguageMode(scope(), old > mode ? old : mode); |
| } |
| bool is_generator() const { |
| return IsGeneratorFunction(function_state_->kind()); |
| } |
| bool is_async_function() const { |
| return IsAsyncFunction(function_state_->kind()); |
| } |
| bool is_async_generator() const { |
| return IsAsyncGeneratorFunction(function_state_->kind()); |
| } |
| bool is_resumable() const { |
| return IsResumableFunction(function_state_->kind()); |
| } |
| |
| const PendingCompilationErrorHandler* pending_error_handler() const { |
| return pending_error_handler_; |
| } |
| PendingCompilationErrorHandler* pending_error_handler() { |
| return pending_error_handler_; |
| } |
| |
| // Report syntax errors. |
| void ReportMessage(MessageTemplate::Template message) { |
| Scanner::Location source_location = scanner()->location(); |
| impl()->ReportMessageAt(source_location, message, |
| static_cast<const char*>(nullptr), kSyntaxError); |
| } |
| |
| template <typename T> |
| void ReportMessage(MessageTemplate::Template message, T arg, |
| ParseErrorType error_type = kSyntaxError) { |
| Scanner::Location source_location = scanner()->location(); |
| impl()->ReportMessageAt(source_location, message, arg, error_type); |
| } |
| |
| void ReportMessageAt(Scanner::Location location, |
| MessageTemplate::Template message, |
| ParseErrorType error_type) { |
| impl()->ReportMessageAt(location, message, |
| static_cast<const char*>(nullptr), error_type); |
| } |
| |
| void GetUnexpectedTokenMessage( |
| Token::Value token, MessageTemplate::Template* message, |
| Scanner::Location* location, const char** arg, |
| MessageTemplate::Template default_ = MessageTemplate::kUnexpectedToken); |
| |
| void ReportUnexpectedToken(Token::Value token); |
| void ReportUnexpectedTokenAt( |
| Scanner::Location location, Token::Value token, |
| MessageTemplate::Template message = MessageTemplate::kUnexpectedToken); |
| |
| void ReportClassifierError( |
| const typename ExpressionClassifier::Error& error) { |
| impl()->ReportMessageAt(error.location, error.message, error.arg); |
| } |
| |
| void ValidateExpression(bool* ok) { |
| if (!classifier()->is_valid_expression()) { |
| ReportClassifierError(classifier()->expression_error()); |
| *ok = false; |
| } |
| } |
| |
| void ValidateFormalParameterInitializer(bool* ok) { |
| if (!classifier()->is_valid_formal_parameter_initializer()) { |
| ReportClassifierError(classifier()->formal_parameter_initializer_error()); |
| *ok = false; |
| } |
| } |
| |
| void ValidateBindingPattern(bool* ok) { |
| if (!classifier()->is_valid_binding_pattern()) { |
| ReportClassifierError(classifier()->binding_pattern_error()); |
| *ok = false; |
| } |
| } |
| |
| void ValidateAssignmentPattern(bool* ok) { |
| if (!classifier()->is_valid_assignment_pattern()) { |
| ReportClassifierError(classifier()->assignment_pattern_error()); |
| *ok = false; |
| } |
| } |
| |
| void ValidateFormalParameters(LanguageMode language_mode, |
| bool allow_duplicates, bool* ok) { |
| if (!allow_duplicates && |
| !classifier()->is_valid_formal_parameter_list_without_duplicates()) { |
| ReportClassifierError(classifier()->duplicate_formal_parameter_error()); |
| *ok = false; |
| } else if (is_strict(language_mode) && |
| !classifier()->is_valid_strict_mode_formal_parameters()) { |
| ReportClassifierError(classifier()->strict_mode_formal_parameter_error()); |
| *ok = false; |
| } |
| } |
| |
| bool IsValidArrowFormalParametersStart(Token::Value token) { |
| return is_any_identifier(token) || token == Token::LPAREN; |
| } |
| |
| void ValidateArrowFormalParameters(ExpressionT expr, |
| bool parenthesized_formals, bool is_async, |
| bool* ok) { |
| if (classifier()->is_valid_binding_pattern()) { |
| // A simple arrow formal parameter: IDENTIFIER => BODY. |
| if (!impl()->IsIdentifier(expr)) { |
| impl()->ReportMessageAt(scanner()->location(), |
| MessageTemplate::kUnexpectedToken, |
| Token::String(scanner()->current_token())); |
| *ok = false; |
| } |
| } else if (!classifier()->is_valid_arrow_formal_parameters()) { |
| // If after parsing the expr, we see an error but the expression is |
| // neither a valid binding pattern nor a valid parenthesized formal |
| // parameter list, show the "arrow formal parameters" error if the formals |
| // started with a parenthesis, and the binding pattern error otherwise. |
| const typename ExpressionClassifier::Error& error = |
| parenthesized_formals ? classifier()->arrow_formal_parameters_error() |
| : classifier()->binding_pattern_error(); |
| ReportClassifierError(error); |
| *ok = false; |
| } |
| if (is_async && !classifier()->is_valid_async_arrow_formal_parameters()) { |
| const typename ExpressionClassifier::Error& error = |
| classifier()->async_arrow_formal_parameters_error(); |
| ReportClassifierError(error); |
| *ok = false; |
| } |
| } |
| |
| void ValidateLetPattern(bool* ok) { |
| if (!classifier()->is_valid_let_pattern()) { |
| ReportClassifierError(classifier()->let_pattern_error()); |
| *ok = false; |
| } |
| } |
| |
| void BindingPatternUnexpectedToken() { |
| MessageTemplate::Template message = MessageTemplate::kUnexpectedToken; |
| const char* arg; |
| Scanner::Location location = scanner()->peek_location(); |
| GetUnexpectedTokenMessage(peek(), &message, &location, &arg); |
| classifier()->RecordBindingPatternError(location, message, arg); |
| } |
| |
| void ArrowFormalParametersUnexpectedToken() { |
| MessageTemplate::Template message = MessageTemplate::kUnexpectedToken; |
| const char* arg; |
| Scanner::Location location = scanner()->peek_location(); |
| GetUnexpectedTokenMessage(peek(), &message, &location, &arg); |
| classifier()->RecordArrowFormalParametersError(location, message, arg); |
| } |
| |
| // Recursive descent functions. |
| // All ParseXXX functions take as the last argument an *ok parameter |
| // which is set to false if parsing failed; it is unchanged otherwise. |
| // By making the 'exception handling' explicit, we are forced to check |
| // for failure at the call sites. The family of CHECK_OK* macros can |
| // be useful for this. |
| |
| // Parses an identifier that is valid for the current scope, in particular it |
| // fails on strict mode future reserved keywords in a strict scope. If |
| // allow_eval_or_arguments is kAllowEvalOrArguments, we allow "eval" or |
| // "arguments" as identifier even in strict mode (this is needed in cases like |
| // "var foo = eval;"). |
| IdentifierT ParseIdentifier(AllowRestrictedIdentifiers, bool* ok); |
| IdentifierT ParseAndClassifyIdentifier(bool* ok); |
| // Parses an identifier or a strict mode future reserved word, and indicate |
| // whether it is strict mode future reserved. Allows passing in function_kind |
| // for the case of parsing the identifier in a function expression, where the |
| // relevant "function_kind" bit is of the function being parsed, not the |
| // containing function. |
| IdentifierT ParseIdentifierOrStrictReservedWord(FunctionKind function_kind, |
| bool* is_strict_reserved, |
| bool* is_await, bool* ok); |
| IdentifierT ParseIdentifierOrStrictReservedWord(bool* is_strict_reserved, |
| bool* is_await, bool* ok) { |
| return ParseIdentifierOrStrictReservedWord( |
| function_state_->kind(), is_strict_reserved, is_await, ok); |
| } |
| |
| V8_INLINE IdentifierT ParseIdentifierName(bool* ok); |
| |
| ExpressionT ParseIdentifierNameOrPrivateName(bool* ok); |
| |
| ExpressionT ParseRegExpLiteral(bool* ok); |
| |
| ExpressionT ParsePrimaryExpression(bool* is_async, bool* ok); |
| ExpressionT ParsePrimaryExpression(bool* ok) { |
| bool is_async; |
| return ParsePrimaryExpression(&is_async, ok); |
| } |
| |
| // Use when parsing an expression that is known to not be a pattern or part |
| // of a pattern. |
| V8_INLINE ExpressionT ParseExpression(bool accept_IN, bool* ok); |
| |
| // This method does not wrap the parsing of the expression inside a |
| // new expression classifier; it uses the top-level classifier instead. |
| // It should be used whenever we're parsing something with the "cover" |
| // grammar that recognizes both patterns and non-patterns (which roughly |
| // corresponds to what's inside the parentheses generated by the symbol |
| // "CoverParenthesizedExpressionAndArrowParameterList" in the ES 2017 |
| // specification). |
| ExpressionT ParseExpressionCoverGrammar(bool accept_IN, bool* ok); |
| |
| ExpressionT ParseArrayLiteral(bool* ok); |
| |
| enum class PropertyKind { |
| kAccessorProperty, |
| kValueProperty, |
| kShorthandProperty, |
| kMethodProperty, |
| kClassField, |
| kSpreadProperty, |
| kNotSet |
| }; |
| |
| bool SetPropertyKindFromToken(Token::Value token, PropertyKind* kind); |
| ExpressionT ParsePropertyName(IdentifierT* name, PropertyKind* kind, |
| bool* is_generator, bool* is_get, bool* is_set, |
| bool* is_async, bool* is_computed_name, |
| bool* ok); |
| ExpressionT ParseObjectLiteral(bool* ok); |
| ClassLiteralPropertyT ParseClassPropertyDefinition( |
| ClassLiteralChecker* checker, ClassInfo* class_info, |
| IdentifierT* property_name, bool has_extends, bool* is_computed_name, |
| ClassLiteralProperty::Kind* property_kind, bool* is_static, bool* ok); |
| ExpressionT ParseClassFieldInitializer(ClassInfo* class_info, bool is_static, |
| bool* ok); |
| ObjectLiteralPropertyT ParseObjectPropertyDefinition( |
| ObjectLiteralChecker* checker, bool* is_computed_name, |
| bool* is_rest_property, bool* ok); |
| ExpressionListT ParseArguments(Scanner::Location* first_spread_pos, |
| bool maybe_arrow, |
| bool* is_simple_parameter_list, bool* ok); |
| ExpressionListT ParseArguments(Scanner::Location* first_spread_pos, |
| bool* ok) { |
| return ParseArguments(first_spread_pos, false, nullptr, ok); |
| } |
| |
| ExpressionT ParseAssignmentExpression(bool accept_IN, bool* ok); |
| ExpressionT ParseYieldExpression(bool accept_IN, bool* ok); |
| V8_INLINE ExpressionT ParseConditionalExpression(bool accept_IN, bool* ok); |
| ExpressionT ParseBinaryExpression(int prec, bool accept_IN, bool* ok); |
| ExpressionT ParseUnaryExpression(bool* ok); |
| V8_INLINE ExpressionT ParsePostfixExpression(bool* ok); |
| V8_INLINE ExpressionT ParseLeftHandSideExpression(bool* ok); |
| ExpressionT ParseMemberWithNewPrefixesExpression(bool* is_async, bool* ok); |
| V8_INLINE ExpressionT ParseMemberExpression(bool* is_async, bool* ok); |
| V8_INLINE ExpressionT ParseMemberExpressionContinuation( |
| ExpressionT expression, bool* is_async, bool* ok); |
| |
| // `rewritable_length`: length of the destructuring_assignments_to_rewrite() |
| // queue in the parent function state, prior to parsing of formal parameters. |
| // If the arrow function is lazy, any items added during formal parameter |
| // parsing are removed from the queue. |
| ExpressionT ParseArrowFunctionLiteral(bool accept_IN, |
| const FormalParametersT& parameters, |
| int rewritable_length, bool* ok); |
| void ParseSingleExpressionFunctionBody(StatementListT body, bool is_async, |
| bool accept_IN, bool* ok); |
| void ParseAsyncFunctionBody(Scope* scope, StatementListT body, bool* ok); |
| ExpressionT ParseAsyncFunctionLiteral(bool* ok); |
| ExpressionT ParseClassLiteral(IdentifierT name, |
| Scanner::Location class_name_location, |
| bool name_is_strict_reserved, |
| int class_token_pos, bool* ok); |
| ExpressionT ParseTemplateLiteral(ExpressionT tag, int start, bool tagged, |
| bool* ok); |
| ExpressionT ParseSuperExpression(bool is_new, bool* ok); |
| ExpressionT ParseImportExpressions(bool* ok); |
| ExpressionT ParseNewTargetExpression(bool* ok); |
| |
| V8_INLINE void ParseFormalParameter(FormalParametersT* parameters, bool* ok); |
| void ParseFormalParameterList(FormalParametersT* parameters, bool* ok); |
| void CheckArityRestrictions(int param_count, FunctionKind function_type, |
| bool has_rest, int formals_start_pos, |
| int formals_end_pos, bool* ok); |
| |
| BlockT ParseVariableDeclarations(VariableDeclarationContext var_context, |
| DeclarationParsingResult* parsing_result, |
| ZonePtrList<const AstRawString>* names, |
| bool* ok); |
| StatementT ParseAsyncFunctionDeclaration( |
| ZonePtrList<const AstRawString>* names, bool default_export, bool* ok); |
| StatementT ParseFunctionDeclaration(bool* ok); |
| StatementT ParseHoistableDeclaration(ZonePtrList<const AstRawString>* names, |
| bool default_export, bool* ok); |
| StatementT ParseHoistableDeclaration(int pos, ParseFunctionFlags flags, |
| ZonePtrList<const AstRawString>* names, |
| bool default_export, bool* ok); |
| StatementT ParseClassDeclaration(ZonePtrList<const AstRawString>* names, |
| bool default_export, bool* ok); |
| StatementT ParseNativeDeclaration(bool* ok); |
| |
| // Consumes the ending }. |
| void ParseFunctionBody(StatementListT result, IdentifierT function_name, |
| int pos, const FormalParametersT& parameters, |
| FunctionKind kind, |
| FunctionLiteral::FunctionType function_type, bool* ok); |
| |
| // Under some circumstances, we allow preparsing to abort if the preparsed |
| // function is "long and trivial", and fully parse instead. Our current |
| // definition of "long and trivial" is: |
| // - over kLazyParseTrialLimit statements |
| // - all starting with an identifier (i.e., no if, for, while, etc.) |
| static const int kLazyParseTrialLimit = 200; |
| |
| // TODO(nikolaos, marja): The first argument should not really be passed |
| // by value. The method is expected to add the parsed statements to the |
| // list. This works because in the case of the parser, StatementListT is |
| // a pointer whereas the preparser does not really modify the body. |
| V8_INLINE void ParseStatementList(StatementListT body, Token::Value end_token, |
| bool* ok) { |
| LazyParsingResult result = ParseStatementList(body, end_token, false, ok); |
| USE(result); |
| DCHECK_EQ(result, kLazyParsingComplete); |
| } |
| V8_INLINE LazyParsingResult ParseStatementList(StatementListT body, |
| Token::Value end_token, |
| bool may_abort, bool* ok); |
| StatementT ParseStatementListItem(bool* ok); |
| |
| StatementT ParseStatement(ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| bool* ok) { |
| return ParseStatement(labels, own_labels, |
| kDisallowLabelledFunctionStatement, ok); |
| } |
| StatementT ParseStatement(ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| AllowLabelledFunctionStatement allow_function, |
| bool* ok); |
| BlockT ParseBlock(ZonePtrList<const AstRawString>* labels, bool* ok); |
| |
| // Parse a SubStatement in strict mode, or with an extra block scope in |
| // sloppy mode to handle |
| // ES#sec-functiondeclarations-in-ifstatement-statement-clauses |
| StatementT ParseScopedStatement(ZonePtrList<const AstRawString>* labels, |
| bool* ok); |
| |
| StatementT ParseVariableStatement(VariableDeclarationContext var_context, |
| ZonePtrList<const AstRawString>* names, |
| bool* ok); |
| |
| // Magical syntax support. |
| ExpressionT ParseV8Intrinsic(bool* ok); |
| |
| ExpressionT ParseDoExpression(bool* ok); |
| |
| StatementT ParseDebuggerStatement(bool* ok); |
| |
| StatementT ParseExpressionOrLabelledStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| AllowLabelledFunctionStatement allow_function, bool* ok); |
| StatementT ParseIfStatement(ZonePtrList<const AstRawString>* labels, |
| bool* ok); |
| StatementT ParseContinueStatement(bool* ok); |
| StatementT ParseBreakStatement(ZonePtrList<const AstRawString>* labels, |
| bool* ok); |
| StatementT ParseReturnStatement(bool* ok); |
| StatementT ParseWithStatement(ZonePtrList<const AstRawString>* labels, |
| bool* ok); |
| StatementT ParseDoWhileStatement(ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| bool* ok); |
| StatementT ParseWhileStatement(ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| bool* ok); |
| StatementT ParseThrowStatement(bool* ok); |
| StatementT ParseSwitchStatement(ZonePtrList<const AstRawString>* labels, |
| bool* ok); |
| V8_INLINE StatementT ParseTryStatement(bool* ok); |
| StatementT ParseForStatement(ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| bool* ok); |
| StatementT ParseForEachStatementWithDeclarations( |
| int stmt_pos, ForInfo* for_info, ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, Scope* inner_block_scope, |
| bool* ok); |
| StatementT ParseForEachStatementWithoutDeclarations( |
| int stmt_pos, ExpressionT expression, int lhs_beg_pos, int lhs_end_pos, |
| ForInfo* for_info, ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok); |
| |
| // Parse a C-style for loop: 'for (<init>; <cond>; <next>) { ... }' |
| // "for (<init>;" is assumed to have been parser already. |
| ForStatementT ParseStandardForLoop( |
| int stmt_pos, ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, ExpressionT* cond, |
| StatementT* next, StatementT* body, bool* ok); |
| // Same as the above, but handles those cases where <init> is a |
| // lexical variable declaration. |
| StatementT ParseStandardForLoopWithLexicalDeclarations( |
| int stmt_pos, StatementT init, ForInfo* for_info, |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok); |
| StatementT ParseForAwaitStatement(ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| bool* ok); |
| |
| bool IsNextLetKeyword(); |
| bool IsTrivialExpression(); |
| |
| // Checks if the expression is a valid reference expression (e.g., on the |
| // left-hand side of assignments). Although ruled out by ECMA as early errors, |
| // we allow calls for web compatibility and rewrite them to a runtime throw. |
| ExpressionT CheckAndRewriteReferenceExpression( |
| ExpressionT expression, int beg_pos, int end_pos, |
| MessageTemplate::Template message, bool* ok); |
| ExpressionT CheckAndRewriteReferenceExpression( |
| ExpressionT expression, int beg_pos, int end_pos, |
| MessageTemplate::Template message, ParseErrorType type, bool* ok); |
| |
| bool IsValidReferenceExpression(ExpressionT expression); |
| |
| bool IsAssignableIdentifier(ExpressionT expression) { |
| if (!impl()->IsIdentifier(expression)) return false; |
| if (is_strict(language_mode()) && |
| impl()->IsEvalOrArguments(impl()->AsIdentifier(expression))) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool IsValidPattern(ExpressionT expression) { |
| return expression->IsObjectLiteral() || expression->IsArrayLiteral(); |
| } |
| |
| // Due to hoisting, the value of a 'var'-declared variable may actually change |
| // even if the code contains only the "initial" assignment, namely when that |
| // assignment occurs inside a loop. For example: |
| // |
| // let i = 10; |
| // do { var x = i } while (i--): |
| // |
| // As a simple and very conservative approximation of this, we explicitly mark |
| // as maybe-assigned any non-lexical variable whose initializing "declaration" |
| // does not syntactically occur in the function scope. (In the example above, |
| // it occurs in a block scope.) |
| // |
| // Note that non-lexical variables include temporaries, which may also get |
| // assigned inside a loop due to the various rewritings that the parser |
| // performs. |
| // |
| // This also handles marking of loop variables in for-in and for-of loops, |
| // as determined by declaration_kind. |
| // |
| static void MarkLoopVariableAsAssigned( |
| Scope* scope, Variable* var, |
| typename DeclarationDescriptor::Kind declaration_kind); |
| |
| FunctionKind FunctionKindForImpl(bool is_method, bool is_generator, |
| bool is_async) { |
| static const FunctionKind kFunctionKinds[][2][2] = { |
| { |
| // is_method=false |
| {// is_generator=false |
| FunctionKind::kNormalFunction, FunctionKind::kAsyncFunction}, |
| {// is_generator=true |
| FunctionKind::kGeneratorFunction, |
| FunctionKind::kAsyncGeneratorFunction}, |
| }, |
| { |
| // is_method=true |
| {// is_generator=false |
| FunctionKind::kConciseMethod, FunctionKind::kAsyncConciseMethod}, |
| {// is_generator=true |
| FunctionKind::kConciseGeneratorMethod, |
| FunctionKind::kAsyncConciseGeneratorMethod}, |
| }}; |
| return kFunctionKinds[is_method][is_generator][is_async]; |
| } |
| |
| inline FunctionKind FunctionKindFor(bool is_generator, bool is_async) { |
| const bool kIsMethod = false; |
| return FunctionKindForImpl(kIsMethod, is_generator, is_async); |
| } |
| |
| inline FunctionKind MethodKindFor(bool is_generator, bool is_async) { |
| const bool kIsMethod = true; |
| return FunctionKindForImpl(kIsMethod, is_generator, is_async); |
| } |
| |
| // Keep track of eval() calls since they disable all local variable |
| // optimizations. This checks if expression is an eval call, and if yes, |
| // forwards the information to scope. |
| Call::PossiblyEval CheckPossibleEvalCall(ExpressionT expression, |
| Scope* scope) { |
| if (impl()->IsIdentifier(expression) && |
| impl()->IsEval(impl()->AsIdentifier(expression))) { |
| scope->RecordInnerScopeEvalCall(); |
| function_state_->RecordFunctionOrEvalCall(); |
| if (is_sloppy(scope->language_mode())) { |
| // For sloppy scopes we also have to record the call at function level, |
| // in case it includes declarations that will be hoisted. |
| scope->GetDeclarationScope()->RecordEvalCall(); |
| } |
| |
| // This call is only necessary to track evals that may be |
| // inside arrow function parameter lists. In that case, |
| // Scope::Snapshot::Reparent will move this bit down into |
| // the arrow function's scope. |
| scope->RecordEvalCall(); |
| |
| return Call::IS_POSSIBLY_EVAL; |
| } |
| return Call::NOT_EVAL; |
| } |
| |
| // Convenience method which determines the type of return statement to emit |
| // depending on the current function type. |
| inline StatementT BuildReturnStatement(ExpressionT expr, int pos, |
| int end_pos = kNoSourcePosition) { |
| if (impl()->IsNull(expr)) { |
| expr = factory()->NewUndefinedLiteral(kNoSourcePosition); |
| } else if (is_async_generator()) { |
| // In async generators, if there is an explicit operand to the return |
| // statement, await the operand. |
| expr = factory()->NewAwait(expr, kNoSourcePosition); |
| function_state_->AddSuspend(); |
| } |
| if (is_async_function()) { |
| return factory()->NewAsyncReturnStatement(expr, pos, end_pos); |
| } |
| return factory()->NewReturnStatement(expr, pos, end_pos); |
| } |
| |
| // Validation per ES6 object literals. |
| class ObjectLiteralChecker { |
| public: |
| explicit ObjectLiteralChecker(ParserBase* parser) |
| : parser_(parser), has_seen_proto_(false) {} |
| |
| void CheckDuplicateProto(Token::Value property); |
| |
| private: |
| bool IsProto() const { |
| return this->scanner()->CurrentMatchesContextualEscaped( |
| Token::PROTO_UNDERSCORED); |
| } |
| |
| ParserBase* parser() const { return parser_; } |
| Scanner* scanner() const { return parser_->scanner(); } |
| |
| ParserBase* parser_; |
| bool has_seen_proto_; |
| }; |
| |
| // Validation per ES6 class literals. |
| class ClassLiteralChecker { |
| public: |
| explicit ClassLiteralChecker(ParserBase* parser) |
| : parser_(parser), has_seen_constructor_(false) {} |
| |
| void CheckClassMethodName(Token::Value property, PropertyKind type, |
| bool is_generator, bool is_async, bool is_static, |
| bool* ok); |
| void CheckClassFieldName(bool is_static, bool* ok); |
| |
| private: |
| bool IsConstructor() { |
| return this->scanner()->CurrentMatchesContextualEscaped( |
| Token::CONSTRUCTOR); |
| } |
| bool IsPrivateConstructor() { |
| return this->scanner()->CurrentMatchesContextualEscaped( |
| Token::PRIVATE_CONSTRUCTOR); |
| } |
| bool IsPrototype() { |
| return this->scanner()->CurrentMatchesContextualEscaped(Token::PROTOTYPE); |
| } |
| |
| ParserBase* parser() const { return parser_; } |
| Scanner* scanner() const { return parser_->scanner(); } |
| |
| ParserBase* parser_; |
| bool has_seen_constructor_; |
| }; |
| |
| ModuleDescriptor* module() const { |
| return scope()->AsModuleScope()->module(); |
| } |
| Scope* scope() const { return scope_; } |
| |
| // Stack of expression classifiers. |
| // The top of the stack is always pointed to by classifier(). |
| V8_INLINE ExpressionClassifier* classifier() const { |
| DCHECK_NOT_NULL(classifier_); |
| return classifier_; |
| } |
| |
| // Accumulates the classifier that is on top of the stack (inner) to |
| // the one that is right below (outer) and pops the inner. |
| V8_INLINE void Accumulate(unsigned productions) { |
| DCHECK_NOT_NULL(classifier_); |
| ExpressionClassifier* previous = classifier_->previous(); |
| DCHECK_NOT_NULL(previous); |
| previous->Accumulate(classifier_, productions); |
| classifier_ = previous; |
| } |
| |
| V8_INLINE void AccumulateNonBindingPatternErrors() { |
| this->Accumulate(ExpressionClassifier::AllProductions & |
| ~(ExpressionClassifier::BindingPatternProduction | |
| ExpressionClassifier::LetPatternProduction)); |
| } |
| |
| // Pops and discards the classifier that is on top of the stack |
| // without accumulating. |
| V8_INLINE void DiscardExpressionClassifier() { |
| DCHECK_NOT_NULL(classifier_); |
| classifier_->Discard(); |
| classifier_ = classifier_->previous(); |
| } |
| |
| // Accumulate errors that can be arbitrarily deep in an expression. |
| // These correspond to the ECMAScript spec's 'Contains' operation |
| // on productions. This includes: |
| // |
| // - YieldExpression is disallowed in arrow parameters in a generator. |
| // - AwaitExpression is disallowed in arrow parameters in an async function. |
| // - AwaitExpression is disallowed in async arrow parameters. |
| // |
| V8_INLINE void AccumulateFormalParameterContainmentErrors() { |
| Accumulate(ExpressionClassifier::FormalParameterInitializerProduction | |
| ExpressionClassifier::AsyncArrowFormalParametersProduction); |
| } |
| |
| // Parser base's protected field members. |
| |
| Scope* scope_; // Scope stack. |
| Scope* original_scope_; // The top scope for the current parsing item. |
| FunctionState* function_state_; // Function state stack. |
| v8::Extension* extension_; |
| FuncNameInferrer* fni_; |
| AstValueFactory* ast_value_factory_; // Not owned. |
| typename Types::Factory ast_node_factory_; |
| RuntimeCallStats* runtime_call_stats_; |
| internal::Logger* logger_; |
| bool parsing_on_main_thread_; |
| const bool parsing_module_; |
| uintptr_t stack_limit_; |
| PendingCompilationErrorHandler* pending_error_handler_; |
| |
| // Parser base's private field members. |
| |
| private: |
| Zone* zone_; |
| ExpressionClassifier* classifier_; |
| |
| Scanner* scanner_; |
| |
| FunctionLiteral::EagerCompileHint default_eager_compile_hint_; |
| |
| int function_literal_id_; |
| int script_id_; |
| |
| bool allow_natives_; |
| bool allow_harmony_do_expressions_; |
| bool allow_harmony_public_fields_; |
| bool allow_harmony_static_fields_; |
| bool allow_harmony_dynamic_import_; |
| bool allow_harmony_import_meta_; |
| bool allow_harmony_private_fields_; |
| bool allow_eval_cache_; |
| |
| friend class DiscardableZoneScope; |
| }; |
| |
| template <typename Impl> |
| ParserBase<Impl>::FunctionState::FunctionState( |
| FunctionState** function_state_stack, Scope** scope_stack, |
| DeclarationScope* scope) |
| : BlockState(scope_stack, scope), |
| expected_property_count_(0), |
| suspend_count_(0), |
| function_state_stack_(function_state_stack), |
| outer_function_state_(*function_state_stack), |
| scope_(scope), |
| destructuring_assignments_to_rewrite_(scope->zone()), |
| reported_errors_(scope_->zone()), |
| dont_optimize_reason_(BailoutReason::kNoReason), |
| next_function_is_likely_called_(false), |
| previous_function_was_likely_called_(false), |
| contains_function_or_eval_(false) { |
| *function_state_stack = this; |
| reported_errors_.reserve(16); |
| if (outer_function_state_) { |
| outer_function_state_->previous_function_was_likely_called_ = |
| outer_function_state_->next_function_is_likely_called_; |
| outer_function_state_->next_function_is_likely_called_ = false; |
| } |
| } |
| |
| template <typename Impl> |
| ParserBase<Impl>::FunctionState::~FunctionState() { |
| *function_state_stack_ = outer_function_state_; |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::GetUnexpectedTokenMessage( |
| Token::Value token, MessageTemplate::Template* message, |
| Scanner::Location* location, const char** arg, |
| MessageTemplate::Template default_) { |
| *arg = nullptr; |
| switch (token) { |
| case Token::EOS: |
| *message = MessageTemplate::kUnexpectedEOS; |
| break; |
| case Token::SMI: |
| case Token::NUMBER: |
| case Token::BIGINT: |
| *message = MessageTemplate::kUnexpectedTokenNumber; |
| break; |
| case Token::STRING: |
| *message = MessageTemplate::kUnexpectedTokenString; |
| break; |
| case Token::PRIVATE_NAME: |
| case Token::IDENTIFIER: |
| *message = MessageTemplate::kUnexpectedTokenIdentifier; |
| break; |
| case Token::AWAIT: |
| case Token::ENUM: |
| *message = MessageTemplate::kUnexpectedReserved; |
| break; |
| case Token::LET: |
| case Token::STATIC: |
| case Token::YIELD: |
| case Token::FUTURE_STRICT_RESERVED_WORD: |
| *message = is_strict(language_mode()) |
| ? MessageTemplate::kUnexpectedStrictReserved |
| : MessageTemplate::kUnexpectedTokenIdentifier; |
| break; |
| case Token::TEMPLATE_SPAN: |
| case Token::TEMPLATE_TAIL: |
| *message = MessageTemplate::kUnexpectedTemplateString; |
| break; |
| case Token::ESCAPED_STRICT_RESERVED_WORD: |
| case Token::ESCAPED_KEYWORD: |
| *message = MessageTemplate::kInvalidEscapedReservedWord; |
| break; |
| case Token::ILLEGAL: |
| if (scanner()->has_error()) { |
| *message = scanner()->error(); |
| *location = scanner()->error_location(); |
| } else { |
| *message = MessageTemplate::kInvalidOrUnexpectedToken; |
| } |
| break; |
| case Token::REGEXP_LITERAL: |
| *message = MessageTemplate::kUnexpectedTokenRegExp; |
| break; |
| default: |
| const char* name = Token::String(token); |
| DCHECK_NOT_NULL(name); |
| *arg = name; |
| break; |
| } |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ReportUnexpectedToken(Token::Value token) { |
| return ReportUnexpectedTokenAt(scanner_->location(), token); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ReportUnexpectedTokenAt( |
| Scanner::Location source_location, Token::Value token, |
| MessageTemplate::Template message) { |
| const char* arg; |
| GetUnexpectedTokenMessage(token, &message, &source_location, &arg); |
| impl()->ReportMessageAt(source_location, message, arg); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::IdentifierT ParserBase<Impl>::ParseIdentifier( |
| AllowRestrictedIdentifiers allow_restricted_identifiers, bool* ok) { |
| ExpressionClassifier classifier(this); |
| auto result = ParseAndClassifyIdentifier(CHECK_OK_CUSTOM(NullIdentifier)); |
| |
| if (allow_restricted_identifiers == kDontAllowRestrictedIdentifiers) { |
| ValidateAssignmentPattern(CHECK_OK_CUSTOM(NullIdentifier)); |
| ValidateBindingPattern(CHECK_OK_CUSTOM(NullIdentifier)); |
| } |
| |
| return result; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::IdentifierT |
| ParserBase<Impl>::ParseAndClassifyIdentifier(bool* ok) { |
| Token::Value next = Next(); |
| if (next == Token::IDENTIFIER || next == Token::ASYNC || |
| (next == Token::AWAIT && !parsing_module_ && !is_async_function())) { |
| IdentifierT name = impl()->GetSymbol(); |
| |
| if (impl()->IsArguments(name) && scope()->ShouldBanArguments()) { |
| ReportMessage(MessageTemplate::kArgumentsDisallowedInInitializer); |
| *ok = false; |
| return impl()->NullIdentifier(); |
| } |
| |
| // When this function is used to read a formal parameter, we don't always |
| // know whether the function is going to be strict or sloppy. Indeed for |
| // arrow functions we don't always know that the identifier we are reading |
| // is actually a formal parameter. Therefore besides the errors that we |
| // must detect because we know we're in strict mode, we also record any |
| // error that we might make in the future once we know the language mode. |
| if (impl()->IsEvalOrArguments(name)) { |
| classifier()->RecordStrictModeFormalParameterError( |
| scanner()->location(), MessageTemplate::kStrictEvalArguments); |
| if (is_strict(language_mode())) { |
| classifier()->RecordBindingPatternError( |
| scanner()->location(), MessageTemplate::kStrictEvalArguments); |
| } |
| } else if (next == Token::AWAIT) { |
| classifier()->RecordAsyncArrowFormalParametersError( |
| scanner()->location(), MessageTemplate::kAwaitBindingIdentifier); |
| } |
| |
| if (classifier()->duplicate_finder() != nullptr && |
| scanner()->IsDuplicateSymbol(classifier()->duplicate_finder(), |
| ast_value_factory())) { |
| classifier()->RecordDuplicateFormalParameterError(scanner()->location()); |
| } |
| return name; |
| } else if (is_sloppy(language_mode()) && |
| (next == Token::FUTURE_STRICT_RESERVED_WORD || |
| next == Token::ESCAPED_STRICT_RESERVED_WORD || |
| next == Token::LET || next == Token::STATIC || |
| (next == Token::YIELD && !is_generator()))) { |
| classifier()->RecordStrictModeFormalParameterError( |
| scanner()->location(), MessageTemplate::kUnexpectedStrictReserved); |
| if (next == Token::ESCAPED_STRICT_RESERVED_WORD && |
| is_strict(language_mode())) { |
| ReportUnexpectedToken(next); |
| *ok = false; |
| return impl()->NullIdentifier(); |
| } |
| if (scanner()->IsLet()) { |
| classifier()->RecordLetPatternError( |
| scanner()->location(), MessageTemplate::kLetInLexicalBinding); |
| } |
| return impl()->GetSymbol(); |
| } else { |
| ReportUnexpectedToken(next); |
| *ok = false; |
| return impl()->NullIdentifier(); |
| } |
| } |
| |
| template <class Impl> |
| typename ParserBase<Impl>::IdentifierT |
| ParserBase<Impl>::ParseIdentifierOrStrictReservedWord( |
| FunctionKind function_kind, bool* is_strict_reserved, bool* is_await, |
| bool* ok) { |
| Token::Value next = Next(); |
| if (next == Token::IDENTIFIER || (next == Token::AWAIT && !parsing_module_ && |
| !IsAsyncFunction(function_kind)) || |
| next == Token::ASYNC) { |
| *is_strict_reserved = false; |
| *is_await = next == Token::AWAIT; |
| } else if (next == Token::ESCAPED_STRICT_RESERVED_WORD || |
| next == Token::FUTURE_STRICT_RESERVED_WORD || next == Token::LET || |
| next == Token::STATIC || |
| (next == Token::YIELD && !IsGeneratorFunction(function_kind))) { |
| *is_strict_reserved = true; |
| } else { |
| ReportUnexpectedToken(next); |
| *ok = false; |
| return impl()->NullIdentifier(); |
| } |
| |
| return impl()->GetSymbol(); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::IdentifierT ParserBase<Impl>::ParseIdentifierName( |
| bool* ok) { |
| Token::Value next = Next(); |
| if (next != Token::IDENTIFIER && next != Token::ASYNC && |
| next != Token::ENUM && next != Token::AWAIT && next != Token::LET && |
| next != Token::STATIC && next != Token::YIELD && |
| next != Token::FUTURE_STRICT_RESERVED_WORD && |
| next != Token::ESCAPED_KEYWORD && |
| next != Token::ESCAPED_STRICT_RESERVED_WORD && !Token::IsKeyword(next)) { |
| ReportUnexpectedToken(next); |
| *ok = false; |
| return impl()->NullIdentifier(); |
| } |
| |
| return impl()->GetSymbol(); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseIdentifierNameOrPrivateName(bool* ok) { |
| int pos = position(); |
| IdentifierT name; |
| ExpressionT key; |
| if (allow_harmony_private_fields() && peek() == Token::PRIVATE_NAME) { |
| Consume(Token::PRIVATE_NAME); |
| name = impl()->GetSymbol(); |
| auto key_proxy = |
| impl()->ExpressionFromIdentifier(name, pos, InferName::kNo); |
| key_proxy->set_is_private_field(); |
| key = key_proxy; |
| } else { |
| name = ParseIdentifierName(CHECK_OK); |
| key = factory()->NewStringLiteral(name, pos); |
| } |
| impl()->PushLiteralName(name); |
| return key; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseRegExpLiteral( |
| bool* ok) { |
| int pos = peek_position(); |
| if (!scanner()->ScanRegExpPattern()) { |
| Next(); |
| ReportMessage(MessageTemplate::kUnterminatedRegExp); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| IdentifierT js_pattern = impl()->GetNextSymbol(); |
| Maybe<RegExp::Flags> flags = scanner()->ScanRegExpFlags(); |
| if (flags.IsNothing()) { |
| Next(); |
| ReportMessage(MessageTemplate::kMalformedRegExpFlags); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| int js_flags = flags.FromJust(); |
| Next(); |
| return factory()->NewRegExpLiteral(js_pattern, js_flags, pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParsePrimaryExpression( |
| bool* is_async, bool* ok) { |
| // PrimaryExpression :: |
| // 'this' |
| // 'null' |
| // 'true' |
| // 'false' |
| // Identifier |
| // Number |
| // String |
| // ArrayLiteral |
| // ObjectLiteral |
| // RegExpLiteral |
| // ClassLiteral |
| // '(' Expression ')' |
| // TemplateLiteral |
| // do Block |
| // AsyncFunctionLiteral |
| |
| int beg_pos = peek_position(); |
| switch (peek()) { |
| case Token::THIS: { |
| BindingPatternUnexpectedToken(); |
| Consume(Token::THIS); |
| return impl()->ThisExpression(beg_pos); |
| } |
| |
| case Token::NULL_LITERAL: |
| case Token::TRUE_LITERAL: |
| case Token::FALSE_LITERAL: |
| case Token::SMI: |
| case Token::NUMBER: |
| case Token::BIGINT: |
| BindingPatternUnexpectedToken(); |
| return impl()->ExpressionFromLiteral(Next(), beg_pos); |
| |
| case Token::ASYNC: |
| if (!scanner()->HasLineTerminatorAfterNext() && |
| PeekAhead() == Token::FUNCTION) { |
| BindingPatternUnexpectedToken(); |
| Consume(Token::ASYNC); |
| return ParseAsyncFunctionLiteral(CHECK_OK); |
| } |
| // CoverCallExpressionAndAsyncArrowHead |
| *is_async = true; |
| V8_FALLTHROUGH; |
| case Token::IDENTIFIER: |
| case Token::LET: |
| case Token::STATIC: |
| case Token::YIELD: |
| case Token::AWAIT: |
| case Token::ESCAPED_STRICT_RESERVED_WORD: |
| case Token::FUTURE_STRICT_RESERVED_WORD: { |
| // Using eval or arguments in this context is OK even in strict mode. |
| IdentifierT name = ParseAndClassifyIdentifier(CHECK_OK); |
| return impl()->ExpressionFromIdentifier(name, beg_pos); |
| } |
| |
| case Token::STRING: { |
| BindingPatternUnexpectedToken(); |
| Consume(Token::STRING); |
| return impl()->ExpressionFromString(beg_pos); |
| } |
| |
| case Token::ASSIGN_DIV: |
| case Token::DIV: |
| classifier()->RecordBindingPatternError( |
| scanner()->peek_location(), MessageTemplate::kUnexpectedTokenRegExp); |
| return ParseRegExpLiteral(ok); |
| |
| case Token::LBRACK: |
| return ParseArrayLiteral(ok); |
| |
| case Token::LBRACE: |
| return ParseObjectLiteral(ok); |
| |
| case Token::LPAREN: { |
| // Arrow function formal parameters are either a single identifier or a |
| // list of BindingPattern productions enclosed in parentheses. |
| // Parentheses are not valid on the LHS of a BindingPattern, so we use the |
| // is_valid_binding_pattern() check to detect multiple levels of |
| // parenthesization. |
| bool pattern_error = !classifier()->is_valid_binding_pattern(); |
| classifier()->RecordPatternError(scanner()->peek_location(), |
| MessageTemplate::kUnexpectedToken, |
| Token::String(Token::LPAREN)); |
| if (pattern_error) ArrowFormalParametersUnexpectedToken(); |
| Consume(Token::LPAREN); |
| if (Check(Token::RPAREN)) { |
| // ()=>x. The continuation that looks for the => is in |
| // ParseAssignmentExpression. |
| classifier()->RecordExpressionError(scanner()->location(), |
| MessageTemplate::kUnexpectedToken, |
| Token::String(Token::RPAREN)); |
| return factory()->NewEmptyParentheses(beg_pos); |
| } |
| // Heuristically try to detect immediately called functions before |
| // seeing the call parentheses. |
| if (peek() == Token::FUNCTION || |
| (peek() == Token::ASYNC && PeekAhead() == Token::FUNCTION)) { |
| function_state_->set_next_function_is_likely_called(); |
| } |
| ExpressionT expr = ParseExpressionCoverGrammar(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| return expr; |
| } |
| |
| case Token::CLASS: { |
| BindingPatternUnexpectedToken(); |
| Consume(Token::CLASS); |
| int class_token_pos = position(); |
| IdentifierT name = impl()->NullIdentifier(); |
| bool is_strict_reserved_name = false; |
| Scanner::Location class_name_location = Scanner::Location::invalid(); |
| if (peek_any_identifier()) { |
| bool is_await = false; |
| name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name, |
| &is_await, CHECK_OK); |
| class_name_location = scanner()->location(); |
| if (is_await) { |
| classifier()->RecordAsyncArrowFormalParametersError( |
| scanner()->location(), MessageTemplate::kAwaitBindingIdentifier); |
| } |
| } |
| return ParseClassLiteral(name, class_name_location, |
| is_strict_reserved_name, class_token_pos, ok); |
| } |
| |
| case Token::TEMPLATE_SPAN: |
| case Token::TEMPLATE_TAIL: |
| BindingPatternUnexpectedToken(); |
| return ParseTemplateLiteral(impl()->NullExpression(), beg_pos, false, ok); |
| |
| case Token::MOD: |
| if (allow_natives() || extension_ != nullptr) { |
| BindingPatternUnexpectedToken(); |
| return ParseV8Intrinsic(ok); |
| } |
| break; |
| |
| case Token::DO: |
| if (allow_harmony_do_expressions()) { |
| BindingPatternUnexpectedToken(); |
| return ParseDoExpression(ok); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseExpression( |
| bool accept_IN, bool* ok) { |
| ExpressionClassifier classifier(this); |
| ExpressionT result = ParseExpressionCoverGrammar(accept_IN, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| return result; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseExpressionCoverGrammar(bool accept_IN, bool* ok) { |
| // Expression :: |
| // AssignmentExpression |
| // Expression ',' AssignmentExpression |
| |
| ExpressionT result = impl()->NullExpression(); |
| while (true) { |
| int comma_pos = position(); |
| ExpressionClassifier binding_classifier(this); |
| ExpressionT right; |
| if (Check(Token::ELLIPSIS)) { |
| // 'x, y, ...z' in CoverParenthesizedExpressionAndArrowParameterList only |
| // as the formal parameters of'(x, y, ...z) => foo', and is not itself a |
| // valid expression. |
| classifier()->RecordExpressionError(scanner()->location(), |
| MessageTemplate::kUnexpectedToken, |
| Token::String(Token::ELLIPSIS)); |
| int ellipsis_pos = position(); |
| int pattern_pos = peek_position(); |
| ExpressionT pattern = ParsePrimaryExpression(CHECK_OK); |
| if (peek() == Token::ASSIGN) { |
| ReportMessage(MessageTemplate::kRestDefaultInitializer); |
| *ok = false; |
| return result; |
| } |
| ValidateBindingPattern(CHECK_OK); |
| right = factory()->NewSpread(pattern, ellipsis_pos, pattern_pos); |
| } else { |
| right = ParseAssignmentExpression(accept_IN, CHECK_OK); |
| } |
| // No need to accumulate binding pattern-related errors, since |
| // an Expression can't be a binding pattern anyway. |
| AccumulateNonBindingPatternErrors(); |
| if (!impl()->IsIdentifier(right)) classifier()->RecordNonSimpleParameter(); |
| if (impl()->IsNull(result)) { |
| // First time through the loop. |
| result = right; |
| } else if (impl()->CollapseNaryExpression(&result, right, Token::COMMA, |
| comma_pos, |
| SourceRange::Empty())) { |
| // Do nothing, "result" is already updated. |
| } else { |
| result = |
| factory()->NewBinaryOperation(Token::COMMA, result, right, comma_pos); |
| } |
| |
| if (!Check(Token::COMMA)) break; |
| |
| if (right->IsSpread()) { |
| classifier()->RecordArrowFormalParametersError( |
| scanner()->location(), MessageTemplate::kParamAfterRest); |
| } |
| |
| if (peek() == Token::RPAREN && PeekAhead() == Token::ARROW) { |
| // a trailing comma is allowed at the end of an arrow parameter list |
| break; |
| } |
| |
| // Pass on the 'set_next_function_is_likely_called' flag if we have |
| // several function literals separated by comma. |
| if (peek() == Token::FUNCTION && |
| function_state_->previous_function_was_likely_called()) { |
| function_state_->set_next_function_is_likely_called(); |
| } |
| } |
| |
| return result; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseArrayLiteral( |
| bool* ok) { |
| // ArrayLiteral :: |
| // '[' Expression? (',' Expression?)* ']' |
| |
| int pos = peek_position(); |
| ExpressionListT values = impl()->NewExpressionList(4); |
| int first_spread_index = -1; |
| Expect(Token::LBRACK, CHECK_OK); |
| while (peek() != Token::RBRACK) { |
| ExpressionT elem; |
| if (peek() == Token::COMMA) { |
| elem = factory()->NewTheHoleLiteral(); |
| } else if (peek() == Token::ELLIPSIS) { |
| int start_pos = peek_position(); |
| Consume(Token::ELLIPSIS); |
| int expr_pos = peek_position(); |
| ExpressionT argument = ParseAssignmentExpression(true, CHECK_OK); |
| elem = factory()->NewSpread(argument, start_pos, expr_pos); |
| |
| if (first_spread_index < 0) { |
| first_spread_index = values->length(); |
| } |
| |
| if (argument->IsAssignment()) { |
| classifier()->RecordPatternError( |
| Scanner::Location(start_pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidDestructuringTarget); |
| } else { |
| CheckDestructuringElement(argument, start_pos, |
| scanner()->location().end_pos); |
| } |
| |
| if (peek() == Token::COMMA) { |
| classifier()->RecordPatternError( |
| Scanner::Location(start_pos, scanner()->location().end_pos), |
| MessageTemplate::kElementAfterRest); |
| } |
| } else { |
| int beg_pos = peek_position(); |
| elem = ParseAssignmentExpression(true, CHECK_OK); |
| CheckDestructuringElement(elem, beg_pos, scanner()->location().end_pos); |
| } |
| values->Add(elem, zone_); |
| if (peek() != Token::RBRACK) { |
| Expect(Token::COMMA, CHECK_OK); |
| } |
| } |
| Expect(Token::RBRACK, CHECK_OK); |
| |
| return factory()->NewArrayLiteral(values, first_spread_index, pos); |
| } |
| |
| template <class Impl> |
| bool ParserBase<Impl>::SetPropertyKindFromToken(Token::Value token, |
| PropertyKind* kind) { |
| // This returns true, setting the property kind, iff the given token is one |
| // which must occur after a property name, indicating that the previous token |
| // was in fact a name and not a modifier (like the "get" in "get x"). |
| switch (token) { |
| case Token::COLON: |
| *kind = PropertyKind::kValueProperty; |
| return true; |
| case Token::COMMA: |
| case Token::RBRACE: |
| case Token::ASSIGN: |
| *kind = PropertyKind::kShorthandProperty; |
| return true; |
| case Token::LPAREN: |
| *kind = PropertyKind::kMethodProperty; |
| return true; |
| case Token::MUL: |
| case Token::SEMICOLON: |
| *kind = PropertyKind::kClassField; |
| return true; |
| case Token::PRIVATE_NAME: |
| *kind = PropertyKind::kClassField; |
| return true; |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| template <class Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParsePropertyName( |
| IdentifierT* name, PropertyKind* kind, bool* is_generator, bool* is_get, |
| bool* is_set, bool* is_async, bool* is_computed_name, bool* ok) { |
| DCHECK_EQ(*kind, PropertyKind::kNotSet); |
| DCHECK(!*is_generator); |
| DCHECK(!*is_get); |
| DCHECK(!*is_set); |
| DCHECK(!*is_async); |
| DCHECK(!*is_computed_name); |
| |
| *is_generator = Check(Token::MUL); |
| if (*is_generator) { |
| *kind = PropertyKind::kMethodProperty; |
| } |
| |
| Token::Value token = peek(); |
| int pos = peek_position(); |
| |
| if (!*is_generator && token == Token::ASYNC && |
| !scanner()->HasLineTerminatorAfterNext()) { |
| Consume(Token::ASYNC); |
| token = peek(); |
| if (token == Token::MUL && !scanner()->HasLineTerminatorBeforeNext()) { |
| Consume(Token::MUL); |
| token = peek(); |
| *is_generator = true; |
| } else if (SetPropertyKindFromToken(token, kind)) { |
| *name = impl()->GetSymbol(); // TODO(bakkot) specialize on 'async' |
| impl()->PushLiteralName(*name); |
| return factory()->NewStringLiteral(*name, pos); |
| } |
| *kind = PropertyKind::kMethodProperty; |
| *is_async = true; |
| pos = peek_position(); |
| } |
| |
| if (token == Token::IDENTIFIER && !*is_generator && !*is_async) { |
| // This is checking for 'get' and 'set' in particular. |
| Consume(Token::IDENTIFIER); |
| token = peek(); |
| if (SetPropertyKindFromToken(token, kind) || |
| !scanner()->IsGetOrSet(is_get, is_set)) { |
| *name = impl()->GetSymbol(); |
| impl()->PushLiteralName(*name); |
| return factory()->NewStringLiteral(*name, pos); |
| } |
| *kind = PropertyKind::kAccessorProperty; |
| pos = peek_position(); |
| } |
| |
| // For non computed property names we normalize the name a bit: |
| // |
| // "12" -> 12 |
| // 12.3 -> "12.3" |
| // 12.30 -> "12.3" |
| // identifier -> "identifier" |
| // |
| // This is important because we use the property name as a key in a hash |
| // table when we compute constant properties. |
| ExpressionT expression = impl()->NullExpression(); |
| switch (token) { |
| case Token::STRING: |
| Consume(Token::STRING); |
| *name = impl()->GetSymbol(); |
| break; |
| |
| case Token::SMI: |
| Consume(Token::SMI); |
| *name = impl()->GetNumberAsSymbol(); |
| break; |
| |
| case Token::NUMBER: |
| Consume(Token::NUMBER); |
| *name = impl()->GetNumberAsSymbol(); |
| break; |
| |
| case Token::LBRACK: { |
| *name = impl()->NullIdentifier(); |
| *is_computed_name = true; |
| Consume(Token::LBRACK); |
| ExpressionClassifier computed_name_classifier(this); |
| expression = ParseAssignmentExpression(true, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| AccumulateFormalParameterContainmentErrors(); |
| Expect(Token::RBRACK, CHECK_OK); |
| break; |
| } |
| |
| case Token::ELLIPSIS: |
| if (!*is_generator && !*is_async && !*is_get && !*is_set) { |
| *name = impl()->NullIdentifier(); |
| Consume(Token::ELLIPSIS); |
| expression = ParseAssignmentExpression(true, CHECK_OK); |
| *kind = PropertyKind::kSpreadProperty; |
| |
| if (!impl()->IsIdentifier(expression)) { |
| classifier()->RecordBindingPatternError( |
| scanner()->location(), |
| MessageTemplate::kInvalidRestBindingPattern); |
| } |
| |
| if (!expression->IsValidReferenceExpression()) { |
| classifier()->RecordAssignmentPatternError( |
| scanner()->location(), |
| MessageTemplate::kInvalidRestAssignmentPattern); |
| } |
| |
| if (peek() != Token::RBRACE) { |
| classifier()->RecordPatternError(scanner()->location(), |
| MessageTemplate::kElementAfterRest); |
| } |
| return expression; |
| } |
| V8_FALLTHROUGH; |
| |
| default: |
| *name = ParseIdentifierName(CHECK_OK); |
| break; |
| } |
| |
| if (*kind == PropertyKind::kNotSet) { |
| SetPropertyKindFromToken(peek(), kind); |
| } |
| |
| if (*is_computed_name) { |
| return expression; |
| } |
| |
| impl()->PushLiteralName(*name); |
| |
| uint32_t index; |
| return impl()->IsArrayIndex(*name, &index) |
| ? factory()->NewNumberLiteral(index, pos) |
| : factory()->NewStringLiteral(*name, pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ClassLiteralPropertyT |
| ParserBase<Impl>::ParseClassPropertyDefinition( |
| ClassLiteralChecker* checker, ClassInfo* class_info, IdentifierT* name, |
| bool has_extends, bool* is_computed_name, |
| ClassLiteralProperty::Kind* property_kind, bool* is_static, bool* ok) { |
| DCHECK_NOT_NULL(class_info); |
| bool is_get = false; |
| bool is_set = false; |
| bool is_generator = false; |
| bool is_async = false; |
| *is_static = false; |
| *property_kind = ClassLiteralProperty::METHOD; |
| PropertyKind kind = PropertyKind::kNotSet; |
| |
| Token::Value name_token = peek(); |
| DCHECK_IMPLIES(name_token == Token::PRIVATE_NAME, |
| allow_harmony_private_fields()); |
| |
| int name_token_position = scanner()->peek_location().beg_pos; |
| *name = impl()->NullIdentifier(); |
| ExpressionT name_expression; |
| if (name_token == Token::STATIC) { |
| Consume(Token::STATIC); |
| name_token_position = scanner()->peek_location().beg_pos; |
| if (peek() == Token::LPAREN) { |
| kind = PropertyKind::kMethodProperty; |
| *name = impl()->GetSymbol(); // TODO(bakkot) specialize on 'static' |
| name_expression = factory()->NewStringLiteral(*name, position()); |
| } else if (peek() == Token::ASSIGN || peek() == Token::SEMICOLON || |
| peek() == Token::RBRACE) { |
| *name = impl()->GetSymbol(); // TODO(bakkot) specialize on 'static' |
| name_expression = factory()->NewStringLiteral(*name, position()); |
| } else if (peek() == Token::PRIVATE_NAME) { |
| DCHECK(allow_harmony_private_fields()); |
| // TODO(gsathya): Make a better error message for this. |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullLiteralProperty(); |
| } else { |
| *is_static = true; |
| name_expression = ParsePropertyName(name, &kind, &is_generator, &is_get, |
| &is_set, &is_async, is_computed_name, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| } |
| } else if (name_token == Token::PRIVATE_NAME) { |
| Consume(Token::PRIVATE_NAME); |
| *name = impl()->GetSymbol(); |
| name_expression = factory()->NewStringLiteral(*name, position()); |
| } else { |
| name_expression = ParsePropertyName(name, &kind, &is_generator, &is_get, |
| &is_set, &is_async, is_computed_name, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| } |
| |
| if (!class_info->has_name_static_property && *is_static && |
| impl()->IsName(*name)) { |
| class_info->has_name_static_property = true; |
| } |
| |
| switch (kind) { |
| case PropertyKind::kClassField: |
| case PropertyKind::kNotSet: // This case is a name followed by a name or |
| // other property. Here we have to assume |
| // that's an uninitialized field followed by a |
| // linebreak followed by a property, with ASI |
| // adding the semicolon. If not, there will be |
| // a syntax error after parsing the first name |
| // as an uninitialized field. |
| case PropertyKind::kShorthandProperty: |
| case PropertyKind::kValueProperty: |
| if (allow_harmony_public_fields() || allow_harmony_private_fields()) { |
| *property_kind = name_token == Token::PRIVATE_NAME |
| ? ClassLiteralProperty::PRIVATE_FIELD |
| : ClassLiteralProperty::PUBLIC_FIELD; |
| if (*is_static && !allow_harmony_static_fields()) { |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullLiteralProperty(); |
| } |
| if (!*is_computed_name) { |
| checker->CheckClassFieldName(*is_static, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| } |
| ExpressionT initializer = ParseClassFieldInitializer( |
| class_info, *is_static, CHECK_OK_CUSTOM(NullLiteralProperty)); |
| ExpectSemicolon(CHECK_OK_CUSTOM(NullLiteralProperty)); |
| ClassLiteralPropertyT result = factory()->NewClassLiteralProperty( |
| name_expression, initializer, *property_kind, *is_static, |
| *is_computed_name); |
| impl()->SetFunctionNameFromPropertyName(result, *name); |
| return result; |
| |
| } else { |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullLiteralProperty(); |
| } |
| |
| case PropertyKind::kMethodProperty: { |
| DCHECK(!is_get && !is_set); |
| |
| // MethodDefinition |
| // PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}' |
| // '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}' |
| // async PropertyName '(' StrictFormalParameters ')' |
| // '{' FunctionBody '}' |
| // async '*' PropertyName '(' StrictFormalParameters ')' |
| // '{' FunctionBody '}' |
| |
| if (!*is_computed_name) { |
| checker->CheckClassMethodName(name_token, PropertyKind::kMethodProperty, |
| is_generator, is_async, *is_static, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| } |
| |
| FunctionKind kind = MethodKindFor(is_generator, is_async); |
| |
| if (!*is_static && impl()->IsConstructor(*name)) { |
| class_info->has_seen_constructor = true; |
| kind = has_extends ? FunctionKind::kDerivedConstructor |
| : FunctionKind::kBaseConstructor; |
| } |
| |
| ExpressionT value = impl()->ParseFunctionLiteral( |
| *name, scanner()->location(), kSkipFunctionNameCheck, kind, |
| FLAG_harmony_function_tostring ? name_token_position |
| : kNoSourcePosition, |
| FunctionLiteral::kAccessorOrMethod, language_mode(), nullptr, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| |
| *property_kind = ClassLiteralProperty::METHOD; |
| ClassLiteralPropertyT result = factory()->NewClassLiteralProperty( |
| name_expression, value, *property_kind, *is_static, |
| *is_computed_name); |
| impl()->SetFunctionNameFromPropertyName(result, *name); |
| return result; |
| } |
| |
| case PropertyKind::kAccessorProperty: { |
| DCHECK((is_get || is_set) && !is_generator && !is_async); |
| |
| if (!*is_computed_name) { |
| checker->CheckClassMethodName( |
| name_token, PropertyKind::kAccessorProperty, false, false, |
| *is_static, CHECK_OK_CUSTOM(NullLiteralProperty)); |
| // Make sure the name expression is a string since we need a Name for |
| // Runtime_DefineAccessorPropertyUnchecked and since we can determine |
| // this statically we can skip the extra runtime check. |
| name_expression = |
| factory()->NewStringLiteral(*name, name_expression->position()); |
| } |
| |
| FunctionKind kind = is_get ? FunctionKind::kGetterFunction |
| : FunctionKind::kSetterFunction; |
| |
| FunctionLiteralT value = impl()->ParseFunctionLiteral( |
| *name, scanner()->location(), kSkipFunctionNameCheck, kind, |
| FLAG_harmony_function_tostring ? name_token_position |
| : kNoSourcePosition, |
| FunctionLiteral::kAccessorOrMethod, language_mode(), nullptr, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| |
| *property_kind = |
| is_get ? ClassLiteralProperty::GETTER : ClassLiteralProperty::SETTER; |
| ClassLiteralPropertyT result = factory()->NewClassLiteralProperty( |
| name_expression, value, *property_kind, *is_static, |
| *is_computed_name); |
| const AstRawString* prefix = |
| is_get ? ast_value_factory()->get_space_string() |
| : ast_value_factory()->set_space_string(); |
| impl()->SetFunctionNameFromPropertyName(result, *name, prefix); |
| return result; |
| } |
| case PropertyKind::kSpreadProperty: |
| ReportUnexpectedTokenAt( |
| Scanner::Location(name_token_position, name_expression->position()), |
| name_token); |
| *ok = false; |
| return impl()->NullLiteralProperty(); |
| } |
| UNREACHABLE(); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseClassFieldInitializer(ClassInfo* class_info, |
| bool is_static, bool* ok) { |
| DeclarationScope* initializer_scope = is_static |
| ? class_info->static_fields_scope |
| : class_info->instance_fields_scope; |
| |
| if (initializer_scope == nullptr) { |
| initializer_scope = |
| NewFunctionScope(FunctionKind::kClassFieldsInitializerFunction); |
| // TODO(gsathya): Make scopes be non contiguous. |
| initializer_scope->set_start_position(scanner()->location().end_pos); |
| initializer_scope->SetLanguageMode(LanguageMode::kStrict); |
| } |
| |
| ExpressionT initializer; |
| if (Check(Token::ASSIGN)) { |
| FunctionState initializer_state(&function_state_, &scope_, |
| initializer_scope); |
| ExpressionClassifier expression_classifier(this); |
| |
| initializer = |
| ParseAssignmentExpression(true, CHECK_OK_CUSTOM(NullExpression)); |
| ValidateExpression(CHECK_OK_CUSTOM(NullExpression)); |
| } else { |
| initializer = factory()->NewUndefinedLiteral(kNoSourcePosition); |
| } |
| |
| initializer_scope->set_end_position(scanner()->location().end_pos); |
| if (is_static) { |
| class_info->static_fields_scope = initializer_scope; |
| class_info->has_static_class_fields = true; |
| } else { |
| class_info->instance_fields_scope = initializer_scope; |
| class_info->has_instance_class_fields = true; |
| } |
| |
| return initializer; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ObjectLiteralPropertyT |
| ParserBase<Impl>::ParseObjectPropertyDefinition(ObjectLiteralChecker* checker, |
| bool* is_computed_name, |
| bool* is_rest_property, |
| bool* ok) { |
| bool is_get = false; |
| bool is_set = false; |
| bool is_generator = false; |
| bool is_async = false; |
| PropertyKind kind = PropertyKind::kNotSet; |
| |
| IdentifierT name = impl()->NullIdentifier(); |
| Token::Value name_token = peek(); |
| int next_beg_pos = scanner()->peek_location().beg_pos; |
| int next_end_pos = scanner()->peek_location().end_pos; |
| |
| ExpressionT name_expression = ParsePropertyName( |
| &name, &kind, &is_generator, &is_get, &is_set, &is_async, |
| is_computed_name, CHECK_OK_CUSTOM(NullLiteralProperty)); |
| |
| switch (kind) { |
| case PropertyKind::kSpreadProperty: |
| DCHECK(!is_get && !is_set && !is_generator && !is_async && |
| !*is_computed_name); |
| DCHECK(name_token == Token::ELLIPSIS); |
| |
| *is_computed_name = true; |
| *is_rest_property = true; |
| |
| return factory()->NewObjectLiteralProperty( |
| factory()->NewTheHoleLiteral(), name_expression, |
| ObjectLiteralProperty::SPREAD, true); |
| |
| case PropertyKind::kValueProperty: { |
| DCHECK(!is_get && !is_set && !is_generator && !is_async); |
| |
| if (!*is_computed_name) { |
| checker->CheckDuplicateProto(name_token); |
| } |
| Consume(Token::COLON); |
| int beg_pos = peek_position(); |
| ExpressionT value = |
| ParseAssignmentExpression(true, CHECK_OK_CUSTOM(NullLiteralProperty)); |
| CheckDestructuringElement(value, beg_pos, scanner()->location().end_pos); |
| |
| ObjectLiteralPropertyT result = factory()->NewObjectLiteralProperty( |
| name_expression, value, *is_computed_name); |
| impl()->SetFunctionNameFromPropertyName(result, name); |
| return result; |
| } |
| |
| case PropertyKind::kShorthandProperty: { |
| // PropertyDefinition |
| // IdentifierReference |
| // CoverInitializedName |
| // |
| // CoverInitializedName |
| // IdentifierReference Initializer? |
| DCHECK(!is_get && !is_set && !is_generator && !is_async); |
| |
| if (!Token::IsIdentifier(name_token, language_mode(), |
| this->is_generator(), |
| parsing_module_ || is_async_function())) { |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullLiteralProperty(); |
| } |
| |
| DCHECK(!*is_computed_name); |
| |
| if (classifier()->duplicate_finder() != nullptr && |
| scanner()->IsDuplicateSymbol(classifier()->duplicate_finder(), |
| ast_value_factory())) { |
| classifier()->RecordDuplicateFormalParameterError( |
| scanner()->location()); |
| } |
| |
| if (impl()->IsEvalOrArguments(name) && is_strict(language_mode())) { |
| classifier()->RecordBindingPatternError( |
| scanner()->location(), MessageTemplate::kStrictEvalArguments); |
| } |
| |
| if (name_token == Token::LET) { |
| classifier()->RecordLetPatternError( |
| scanner()->location(), MessageTemplate::kLetInLexicalBinding); |
| } |
| if (name_token == Token::AWAIT) { |
| DCHECK(!is_async_function()); |
| classifier()->RecordAsyncArrowFormalParametersError( |
| Scanner::Location(next_beg_pos, next_end_pos), |
| MessageTemplate::kAwaitBindingIdentifier); |
| } |
| ExpressionT lhs = impl()->ExpressionFromIdentifier(name, next_beg_pos); |
| CheckDestructuringElement(lhs, next_beg_pos, next_end_pos); |
| |
| ExpressionT value; |
| if (peek() == Token::ASSIGN) { |
| Consume(Token::ASSIGN); |
| ExpressionClassifier rhs_classifier(this); |
| ExpressionT rhs = ParseAssignmentExpression( |
| true, CHECK_OK_CUSTOM(NullLiteralProperty)); |
| ValidateExpression(CHECK_OK_CUSTOM(NullLiteralProperty)); |
| AccumulateFormalParameterContainmentErrors(); |
| value = factory()->NewAssignment(Token::ASSIGN, lhs, rhs, |
| kNoSourcePosition); |
| classifier()->RecordExpressionError( |
| Scanner::Location(next_beg_pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidCoverInitializedName); |
| |
| impl()->SetFunctionNameFromIdentifierRef(rhs, lhs); |
| } else { |
| value = lhs; |
| } |
| |
| ObjectLiteralPropertyT result = factory()->NewObjectLiteralProperty( |
| name_expression, value, ObjectLiteralProperty::COMPUTED, false); |
| impl()->SetFunctionNameFromPropertyName(result, name); |
| return result; |
| } |
| |
| case PropertyKind::kMethodProperty: { |
| DCHECK(!is_get && !is_set); |
| |
| // MethodDefinition |
| // PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}' |
| // '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}' |
| |
| classifier()->RecordPatternError( |
| Scanner::Location(next_beg_pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidDestructuringTarget); |
| |
| FunctionKind kind = MethodKindFor(is_generator, is_async); |
| |
| ExpressionT value = impl()->ParseFunctionLiteral( |
| name, scanner()->location(), kSkipFunctionNameCheck, kind, |
| FLAG_harmony_function_tostring ? next_beg_pos : kNoSourcePosition, |
| FunctionLiteral::kAccessorOrMethod, language_mode(), nullptr, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| |
| ObjectLiteralPropertyT result = factory()->NewObjectLiteralProperty( |
| name_expression, value, ObjectLiteralProperty::COMPUTED, |
| *is_computed_name); |
| impl()->SetFunctionNameFromPropertyName(result, name); |
| return result; |
| } |
| |
| case PropertyKind::kAccessorProperty: { |
| DCHECK((is_get || is_set) && !(is_set && is_get) && !is_generator && |
| !is_async); |
| |
| classifier()->RecordPatternError( |
| Scanner::Location(next_beg_pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidDestructuringTarget); |
| |
| if (!*is_computed_name) { |
| // Make sure the name expression is a string since we need a Name for |
| // Runtime_DefineAccessorPropertyUnchecked and since we can determine |
| // this statically we can skip the extra runtime check. |
| name_expression = |
| factory()->NewStringLiteral(name, name_expression->position()); |
| } |
| |
| FunctionKind kind = is_get ? FunctionKind::kGetterFunction |
| : FunctionKind::kSetterFunction; |
| |
| FunctionLiteralT value = impl()->ParseFunctionLiteral( |
| name, scanner()->location(), kSkipFunctionNameCheck, kind, |
| FLAG_harmony_function_tostring ? next_beg_pos : kNoSourcePosition, |
| FunctionLiteral::kAccessorOrMethod, language_mode(), nullptr, |
| CHECK_OK_CUSTOM(NullLiteralProperty)); |
| |
| ObjectLiteralPropertyT result = factory()->NewObjectLiteralProperty( |
| name_expression, value, |
| is_get ? ObjectLiteralProperty::GETTER |
| : ObjectLiteralProperty::SETTER, |
| *is_computed_name); |
| const AstRawString* prefix = |
| is_get ? ast_value_factory()->get_space_string() |
| : ast_value_factory()->set_space_string(); |
| impl()->SetFunctionNameFromPropertyName(result, name, prefix); |
| return result; |
| } |
| |
| case PropertyKind::kClassField: |
| case PropertyKind::kNotSet: |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullLiteralProperty(); |
| } |
| UNREACHABLE(); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseObjectLiteral( |
| bool* ok) { |
| // ObjectLiteral :: |
| // '{' (PropertyDefinition (',' PropertyDefinition)* ','? )? '}' |
| |
| int pos = peek_position(); |
| typename Types::ObjectPropertyList properties = |
| impl()->NewObjectPropertyList(4); |
| int number_of_boilerplate_properties = 0; |
| |
| bool has_computed_names = false; |
| bool has_rest_property = false; |
| ObjectLiteralChecker checker(this); |
| |
| Expect(Token::LBRACE, CHECK_OK); |
| |
| while (peek() != Token::RBRACE) { |
| FuncNameInferrer::State fni_state(fni_); |
| |
| bool is_computed_name = false; |
| bool is_rest_property = false; |
| ObjectLiteralPropertyT property = ParseObjectPropertyDefinition( |
| &checker, &is_computed_name, &is_rest_property, CHECK_OK); |
| |
| if (is_computed_name) { |
| has_computed_names = true; |
| } |
| |
| if (is_rest_property) { |
| has_rest_property = true; |
| } |
| |
| if (impl()->IsBoilerplateProperty(property) && !has_computed_names) { |
| // Count CONSTANT or COMPUTED properties to maintain the enumeration |
| // order. |
| number_of_boilerplate_properties++; |
| } |
| |
| properties->Add(property, zone()); |
| |
| if (peek() != Token::RBRACE) { |
| // Need {} because of the CHECK_OK macro. |
| Expect(Token::COMMA, CHECK_OK); |
| } |
| |
| if (fni_ != nullptr) fni_->Infer(); |
| } |
| Expect(Token::RBRACE, CHECK_OK); |
| |
| // In pattern rewriter, we rewrite rest property to call out to a |
| // runtime function passing all the other properties as arguments to |
| // this runtime function. Here, we make sure that the number of |
| // properties is less than number of arguments allowed for a runtime |
| // call. |
| if (has_rest_property && properties->length() > Code::kMaxArguments) { |
| this->classifier()->RecordPatternError(Scanner::Location(pos, position()), |
| MessageTemplate::kTooManyArguments); |
| } |
| |
| return impl()->InitializeObjectLiteral(factory()->NewObjectLiteral( |
| properties, number_of_boilerplate_properties, pos, has_rest_property)); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionListT ParserBase<Impl>::ParseArguments( |
| Scanner::Location* first_spread_arg_loc, bool maybe_arrow, |
| bool* is_simple_parameter_list, bool* ok) { |
| // Arguments :: |
| // '(' (AssignmentExpression)*[','] ')' |
| |
| Scanner::Location spread_arg = Scanner::Location::invalid(); |
| ExpressionListT result = impl()->NewExpressionList(4); |
| Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullExpressionList)); |
| bool done = (peek() == Token::RPAREN); |
| while (!done) { |
| int start_pos = peek_position(); |
| bool is_spread = Check(Token::ELLIPSIS); |
| int expr_pos = peek_position(); |
| |
| ExpressionT argument = |
| ParseAssignmentExpression(true, CHECK_OK_CUSTOM(NullExpressionList)); |
| if (!impl()->IsIdentifier(argument) && |
| is_simple_parameter_list != nullptr) { |
| *is_simple_parameter_list = false; |
| } |
| if (!maybe_arrow) { |
| ValidateExpression(CHECK_OK_CUSTOM(NullExpressionList)); |
| } |
| if (is_spread) { |
| if (is_simple_parameter_list != nullptr) { |
| *is_simple_parameter_list = false; |
| } |
| if (!spread_arg.IsValid()) { |
| spread_arg.beg_pos = start_pos; |
| spread_arg.end_pos = peek_position(); |
| } |
| if (argument->IsAssignment()) { |
| classifier()->RecordAsyncArrowFormalParametersError( |
| scanner()->location(), MessageTemplate::kRestDefaultInitializer); |
| } |
| argument = factory()->NewSpread(argument, start_pos, expr_pos); |
| } |
| result->Add(argument, zone_); |
| |
| if (result->length() > Code::kMaxArguments) { |
| ReportMessage(MessageTemplate::kTooManyArguments); |
| *ok = false; |
| return impl()->NullExpressionList(); |
| } |
| done = (peek() != Token::COMMA); |
| if (!done) { |
| Next(); |
| if (argument->IsSpread()) { |
| classifier()->RecordAsyncArrowFormalParametersError( |
| scanner()->location(), MessageTemplate::kParamAfterRest); |
| } |
| if (peek() == Token::RPAREN) { |
| // allow trailing comma |
| done = true; |
| } |
| } |
| } |
| Scanner::Location location = scanner_->location(); |
| if (Token::RPAREN != Next()) { |
| impl()->ReportMessageAt(location, MessageTemplate::kUnterminatedArgList); |
| *ok = false; |
| return impl()->NullExpressionList(); |
| } |
| *first_spread_arg_loc = spread_arg; |
| |
| if (!maybe_arrow || peek() != Token::ARROW) { |
| if (maybe_arrow) { |
| ValidateExpression(CHECK_OK_CUSTOM(NullExpressionList)); |
| } |
| } |
| |
| return result; |
| } |
| |
| // Precedence = 2 |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseAssignmentExpression(bool accept_IN, bool* ok) { |
| // AssignmentExpression :: |
| // ConditionalExpression |
| // ArrowFunction |
| // YieldExpression |
| // LeftHandSideExpression AssignmentOperator AssignmentExpression |
| int lhs_beg_pos = peek_position(); |
| |
| if (peek() == Token::YIELD && is_generator()) { |
| return ParseYieldExpression(accept_IN, ok); |
| } |
| |
| FuncNameInferrer::State fni_state(fni_); |
| ExpressionClassifier arrow_formals_classifier( |
| this, classifier()->duplicate_finder()); |
| |
| Scope::Snapshot scope_snapshot(scope()); |
| int rewritable_length = static_cast<int>( |
| function_state_->destructuring_assignments_to_rewrite().size()); |
| |
| bool is_async = peek() == Token::ASYNC && |
| !scanner()->HasLineTerminatorAfterNext() && |
| IsValidArrowFormalParametersStart(PeekAhead()); |
| |
| bool parenthesized_formals = peek() == Token::LPAREN; |
| if (!is_async && !parenthesized_formals) { |
| ArrowFormalParametersUnexpectedToken(); |
| } |
| |
| // Parse a simple, faster sub-grammar (primary expression) if it's evident |
| // that we have only a trivial expression to parse. |
| ExpressionT expression; |
| if (IsTrivialExpression()) { |
| expression = ParsePrimaryExpression(&is_async, CHECK_OK); |
| } else { |
| expression = ParseConditionalExpression(accept_IN, CHECK_OK); |
| } |
| |
| if (is_async && impl()->IsIdentifier(expression) && peek_any_identifier() && |
| PeekAhead() == Token::ARROW) { |
| // async Identifier => AsyncConciseBody |
| IdentifierT name = ParseAndClassifyIdentifier(CHECK_OK); |
| expression = |
| impl()->ExpressionFromIdentifier(name, position(), InferName::kNo); |
| if (fni_) { |
| // Remove `async` keyword from inferred name stack. |
| fni_->RemoveAsyncKeywordFromEnd(); |
| } |
| } |
| |
| if (peek() == Token::ARROW) { |
| Scanner::Location arrow_loc = scanner()->peek_location(); |
| ValidateArrowFormalParameters(expression, parenthesized_formals, is_async, |
| CHECK_OK); |
| // This reads strangely, but is correct: it checks whether any |
| // sub-expression of the parameter list failed to be a valid formal |
| // parameter initializer. Since YieldExpressions are banned anywhere |
| // in an arrow parameter list, this is correct. |
| // TODO(adamk): Rename "FormalParameterInitializerError" to refer to |
| // "YieldExpression", which is its only use. |
| ValidateFormalParameterInitializer(ok); |
| |
| Scanner::Location loc(lhs_beg_pos, scanner()->location().end_pos); |
| DeclarationScope* scope = |
| NewFunctionScope(is_async ? FunctionKind::kAsyncArrowFunction |
| : FunctionKind::kArrowFunction); |
| |
| // Because the arrow's parameters were parsed in the outer scope, |
| // we need to fix up the scope chain appropriately. |
| scope_snapshot.Reparent(scope); |
| |
| FormalParametersT parameters(scope); |
| if (!classifier()->is_simple_parameter_list()) { |
| scope->SetHasNonSimpleParameters(); |
| parameters.is_simple = false; |
| } |
| |
| scope->set_start_position(lhs_beg_pos); |
| Scanner::Location duplicate_loc = Scanner::Location::invalid(); |
| impl()->DeclareArrowFunctionFormalParameters(¶meters, expression, loc, |
| &duplicate_loc, CHECK_OK); |
| if (duplicate_loc.IsValid()) { |
| classifier()->RecordDuplicateFormalParameterError(duplicate_loc); |
| } |
| expression = ParseArrowFunctionLiteral(accept_IN, parameters, |
| rewritable_length, CHECK_OK); |
| Accumulate(ExpressionClassifier::AsyncArrowFormalParametersProduction); |
| classifier()->RecordPatternError(arrow_loc, |
| MessageTemplate::kUnexpectedToken, |
| Token::String(Token::ARROW)); |
| |
| if (fni_ != nullptr) fni_->Infer(); |
| |
| return expression; |
| } |
| |
| // "expression" was not itself an arrow function parameter list, but it might |
| // form part of one. Propagate speculative formal parameter error locations |
| // (including those for binding patterns, since formal parameters can |
| // themselves contain binding patterns). |
| unsigned productions = ExpressionClassifier::AllProductions & |
| ~ExpressionClassifier::ArrowFormalParametersProduction; |
| |
| // Parenthesized identifiers and property references are allowed as part |
| // of a larger assignment pattern, even though parenthesized patterns |
| // themselves are not allowed, e.g., "[(x)] = []". Only accumulate |
| // assignment pattern errors if the parsed expression is more complex. |
| if (IsValidReferenceExpression(expression)) { |
| productions &= ~ExpressionClassifier::AssignmentPatternProduction; |
| } |
| |
| const bool is_destructuring_assignment = |
| IsValidPattern(expression) && peek() == Token::ASSIGN; |
| if (is_destructuring_assignment) { |
| // This is definitely not an expression so don't accumulate |
| // expression-related errors. |
| productions &= ~ExpressionClassifier::ExpressionProduction; |
| } |
| |
| Accumulate(productions); |
| if (!Token::IsAssignmentOp(peek())) return expression; |
| |
| if (is_destructuring_assignment) { |
| ValidateAssignmentPattern(CHECK_OK); |
| } else { |
| expression = CheckAndRewriteReferenceExpression( |
| expression, lhs_beg_pos, scanner()->location().end_pos, |
| MessageTemplate::kInvalidLhsInAssignment, CHECK_OK); |
| } |
| |
| impl()->MarkExpressionAsAssigned(expression); |
| |
| Token::Value op = Next(); // Get assignment operator. |
| if (op != Token::ASSIGN) { |
| classifier()->RecordPatternError(scanner()->location(), |
| MessageTemplate::kUnexpectedToken, |
| Token::String(op)); |
| } |
| int pos = position(); |
| |
| ExpressionClassifier rhs_classifier(this); |
| |
| ExpressionT right = ParseAssignmentExpression(accept_IN, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| AccumulateFormalParameterContainmentErrors(); |
| |
| // We try to estimate the set of properties set by constructors. We define a |
| // new property whenever there is an assignment to a property of 'this'. We |
| // should probably only add properties if we haven't seen them |
| // before. Otherwise we'll probably overestimate the number of properties. |
| if (op == Token::ASSIGN && impl()->IsThisProperty(expression)) { |
| function_state_->AddProperty(); |
| } |
| |
| impl()->CheckAssigningFunctionLiteralToProperty(expression, right); |
| |
| if (fni_ != nullptr) { |
| // Check if the right hand side is a call to avoid inferring a |
| // name if we're dealing with "a = function(){...}();"-like |
| // expression. |
| if (op == Token::ASSIGN && !right->IsCall() && !right->IsCallNew()) { |
| fni_->Infer(); |
| } else { |
| fni_->RemoveLastFunction(); |
| } |
| } |
| |
| if (op == Token::ASSIGN) { |
| impl()->SetFunctionNameFromIdentifierRef(right, expression); |
| } |
| |
| DCHECK_NE(op, Token::INIT); |
| ExpressionT result = factory()->NewAssignment(op, expression, right, pos); |
| |
| if (is_destructuring_assignment) { |
| DCHECK_NE(op, Token::ASSIGN_EXP); |
| auto rewritable = factory()->NewRewritableExpression(result, scope()); |
| impl()->QueueDestructuringAssignmentForRewriting(rewritable); |
| result = rewritable; |
| } |
| |
| return result; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseYieldExpression( |
| bool accept_IN, bool* ok) { |
| // YieldExpression :: |
| // 'yield' ([no line terminator] '*'? AssignmentExpression)? |
| int pos = peek_position(); |
| classifier()->RecordPatternError( |
| scanner()->peek_location(), MessageTemplate::kInvalidDestructuringTarget); |
| classifier()->RecordFormalParameterInitializerError( |
| scanner()->peek_location(), MessageTemplate::kYieldInParameter); |
| Expect(Token::YIELD, CHECK_OK); |
| // The following initialization is necessary. |
| ExpressionT expression = impl()->NullExpression(); |
| bool delegating = false; // yield* |
| if (!scanner()->HasLineTerminatorBeforeNext()) { |
| if (Check(Token::MUL)) delegating = true; |
| switch (peek()) { |
| case Token::EOS: |
| case Token::SEMICOLON: |
| case Token::RBRACE: |
| case Token::RBRACK: |
| case Token::RPAREN: |
| case Token::COLON: |
| case Token::COMMA: |
| case Token::IN: |
| // The above set of tokens is the complete set of tokens that can appear |
| // after an AssignmentExpression, and none of them can start an |
| // AssignmentExpression. This allows us to avoid looking for an RHS for |
| // a regular yield, given only one look-ahead token. |
| if (!delegating) break; |
| // Delegating yields require an RHS; fall through. |
| V8_FALLTHROUGH; |
| default: |
| expression = ParseAssignmentExpression(accept_IN, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| break; |
| } |
| } |
| |
| if (delegating) { |
| ExpressionT yieldstar = factory()->NewYieldStar(expression, pos); |
| impl()->RecordSuspendSourceRange(yieldstar, PositionAfterSemicolon()); |
| function_state_->AddSuspend(); |
| if (IsAsyncGeneratorFunction(function_state_->kind())) { |
| // iterator_close and delegated_iterator_output suspend ids. |
| function_state_->AddSuspend(); |
| function_state_->AddSuspend(); |
| } |
| return yieldstar; |
| } |
| |
| // Hackily disambiguate o from o.next and o [Symbol.iterator](). |
| // TODO(verwaest): Come up with a better solution. |
| ExpressionT yield = |
| factory()->NewYield(expression, pos, Suspend::kOnExceptionThrow); |
| impl()->RecordSuspendSourceRange(yield, PositionAfterSemicolon()); |
| function_state_->AddSuspend(); |
| return yield; |
| } |
| |
| // Precedence = 3 |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseConditionalExpression(bool accept_IN, |
| bool* ok) { |
| // ConditionalExpression :: |
| // LogicalOrExpression |
| // LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression |
| |
| SourceRange then_range, else_range; |
| int pos = peek_position(); |
| // We start using the binary expression parser for prec >= 4 only! |
| ExpressionT expression = ParseBinaryExpression(4, accept_IN, CHECK_OK); |
| if (peek() != Token::CONDITIONAL) return expression; |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| ExpressionT left; |
| { |
| SourceRangeScope range_scope(scanner(), &then_range); |
| Consume(Token::CONDITIONAL); |
| ExpressionClassifier classifier(this); |
| // In parsing the first assignment expression in conditional |
| // expressions we always accept the 'in' keyword; see ECMA-262, |
| // section 11.12, page 58. |
| left = ParseAssignmentExpression(true, CHECK_OK); |
| AccumulateNonBindingPatternErrors(); |
| } |
| ValidateExpression(CHECK_OK); |
| ExpressionT right; |
| { |
| SourceRangeScope range_scope(scanner(), &else_range); |
| Expect(Token::COLON, CHECK_OK); |
| ExpressionClassifier classifier(this); |
| right = ParseAssignmentExpression(accept_IN, CHECK_OK); |
| AccumulateNonBindingPatternErrors(); |
| } |
| ValidateExpression(CHECK_OK); |
| ExpressionT expr = factory()->NewConditional(expression, left, right, pos); |
| impl()->RecordConditionalSourceRange(expr, then_range, else_range); |
| return expr; |
| } |
| |
| |
| // Precedence >= 4 |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseBinaryExpression( |
| int prec, bool accept_IN, bool* ok) { |
| DCHECK_GE(prec, 4); |
| SourceRange right_range; |
| ExpressionT x = ParseUnaryExpression(CHECK_OK); |
| for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) { |
| // prec1 >= 4 |
| while (Precedence(peek(), accept_IN) == prec1) { |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| SourceRangeScope right_range_scope(scanner(), &right_range); |
| Token::Value op = Next(); |
| int pos = position(); |
| |
| const bool is_right_associative = op == Token::EXP; |
| const int next_prec = is_right_associative ? prec1 : prec1 + 1; |
| ExpressionT y = ParseBinaryExpression(next_prec, accept_IN, CHECK_OK); |
| right_range_scope.Finalize(); |
| ValidateExpression(CHECK_OK); |
| |
| if (impl()->ShortcutNumericLiteralBinaryExpression(&x, y, op, pos)) { |
| continue; |
| } |
| |
| // For now we distinguish between comparisons and other binary |
| // operations. (We could combine the two and get rid of this |
| // code and AST node eventually.) |
| if (Token::IsCompareOp(op)) { |
| // We have a comparison. |
| Token::Value cmp = op; |
| switch (op) { |
| case Token::NE: cmp = Token::EQ; break; |
| case Token::NE_STRICT: cmp = Token::EQ_STRICT; break; |
| default: break; |
| } |
| x = factory()->NewCompareOperation(cmp, x, y, pos); |
| if (cmp != op) { |
| // The comparison was negated - add a NOT. |
| x = factory()->NewUnaryOperation(Token::NOT, x, pos); |
| } |
| } else if (impl()->CollapseNaryExpression(&x, y, op, pos, right_range)) { |
| continue; |
| } else { |
| // We have a "normal" binary operation. |
| x = factory()->NewBinaryOperation(op, x, y, pos); |
| if (op == Token::OR || op == Token::AND) { |
| impl()->RecordBinaryOperationSourceRange(x, right_range); |
| } |
| } |
| } |
| } |
| return x; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseUnaryExpression( |
| bool* ok) { |
| // UnaryExpression :: |
| // PostfixExpression |
| // 'delete' UnaryExpression |
| // 'void' UnaryExpression |
| // 'typeof' UnaryExpression |
| // '++' UnaryExpression |
| // '--' UnaryExpression |
| // '+' UnaryExpression |
| // '-' UnaryExpression |
| // '~' UnaryExpression |
| // '!' UnaryExpression |
| // [+Await] AwaitExpression[?Yield] |
| |
| Token::Value op = peek(); |
| if (Token::IsUnaryOp(op)) { |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| op = Next(); |
| int pos = position(); |
| |
| // Assume "! function ..." indicates the function is likely to be called. |
| if (op == Token::NOT && peek() == Token::FUNCTION) { |
| function_state_->set_next_function_is_likely_called(); |
| } |
| |
| ExpressionT expression = ParseUnaryExpression(CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| |
| if (op == Token::DELETE) { |
| if (impl()->IsIdentifier(expression) && is_strict(language_mode())) { |
| // "delete identifier" is a syntax error in strict mode. |
| ReportMessage(MessageTemplate::kStrictDelete); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| if (impl()->IsPropertyWithPrivateFieldKey(expression)) { |
| ReportMessage(MessageTemplate::kDeletePrivateField); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| } |
| |
| if (peek() == Token::EXP) { |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| // Allow the parser's implementation to rewrite the expression. |
| return impl()->BuildUnaryExpression(expression, op, pos); |
| } else if (Token::IsCountOp(op)) { |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| op = Next(); |
| int beg_pos = peek_position(); |
| ExpressionT expression = ParseUnaryExpression(CHECK_OK); |
| expression = CheckAndRewriteReferenceExpression( |
| expression, beg_pos, scanner()->location().end_pos, |
| MessageTemplate::kInvalidLhsInPrefixOp, CHECK_OK); |
| impl()->MarkExpressionAsAssigned(expression); |
| ValidateExpression(CHECK_OK); |
| |
| return factory()->NewCountOperation(op, |
| true /* prefix */, |
| expression, |
| position()); |
| |
| } else if (is_async_function() && peek() == Token::AWAIT) { |
| classifier()->RecordFormalParameterInitializerError( |
| scanner()->peek_location(), |
| MessageTemplate::kAwaitExpressionFormalParameter); |
| int await_pos = peek_position(); |
| Consume(Token::AWAIT); |
| |
| ExpressionT value = ParseUnaryExpression(CHECK_OK); |
| |
| classifier()->RecordBindingPatternError( |
| Scanner::Location(await_pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidDestructuringTarget); |
| |
| ExpressionT expr = factory()->NewAwait(value, await_pos); |
| function_state_->AddSuspend(); |
| impl()->RecordSuspendSourceRange(expr, PositionAfterSemicolon()); |
| return expr; |
| } else { |
| return ParsePostfixExpression(ok); |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParsePostfixExpression( |
| bool* ok) { |
| // PostfixExpression :: |
| // LeftHandSideExpression ('++' | '--')? |
| |
| int lhs_beg_pos = peek_position(); |
| ExpressionT expression = ParseLeftHandSideExpression(CHECK_OK); |
| if (!scanner()->HasLineTerminatorBeforeNext() && Token::IsCountOp(peek())) { |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| expression = CheckAndRewriteReferenceExpression( |
| expression, lhs_beg_pos, scanner()->location().end_pos, |
| MessageTemplate::kInvalidLhsInPostfixOp, CHECK_OK); |
| impl()->MarkExpressionAsAssigned(expression); |
| ValidateExpression(CHECK_OK); |
| |
| Token::Value next = Next(); |
| expression = |
| factory()->NewCountOperation(next, |
| false /* postfix */, |
| expression, |
| position()); |
| } |
| return expression; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseLeftHandSideExpression(bool* ok) { |
| // LeftHandSideExpression :: |
| // (NewExpression | MemberExpression) ... |
| |
| bool is_async = false; |
| ExpressionT result = |
| ParseMemberWithNewPrefixesExpression(&is_async, CHECK_OK); |
| |
| while (true) { |
| switch (peek()) { |
| case Token::LBRACK: { |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| Consume(Token::LBRACK); |
| int pos = position(); |
| ExpressionT index = ParseExpressionCoverGrammar(true, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| result = factory()->NewProperty(result, index, pos); |
| Expect(Token::RBRACK, CHECK_OK); |
| break; |
| } |
| |
| case Token::LPAREN: { |
| int pos; |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| if (scanner()->current_token() == Token::IDENTIFIER || |
| scanner()->current_token() == Token::SUPER || |
| scanner()->current_token() == Token::ASYNC) { |
| // For call of an identifier we want to report position of |
| // the identifier as position of the call in the stack trace. |
| pos = position(); |
| } else { |
| // For other kinds of calls we record position of the parenthesis as |
| // position of the call. Note that this is extremely important for |
| // expressions of the form function(){...}() for which call position |
| // should not point to the closing brace otherwise it will intersect |
| // with positions recorded for function literal and confuse debugger. |
| pos = peek_position(); |
| // Also the trailing parenthesis are a hint that the function will |
| // be called immediately. If we happen to have parsed a preceding |
| // function literal eagerly, we can also compile it eagerly. |
| if (result->IsFunctionLiteral()) { |
| result->AsFunctionLiteral()->SetShouldEagerCompile(); |
| result->AsFunctionLiteral()->mark_as_iife(); |
| } |
| } |
| Scanner::Location spread_pos; |
| ExpressionListT args; |
| if (V8_UNLIKELY(is_async && impl()->IsIdentifier(result))) { |
| ExpressionClassifier async_classifier(this); |
| bool is_simple_parameter_list = true; |
| args = ParseArguments(&spread_pos, true, &is_simple_parameter_list, |
| CHECK_OK); |
| if (peek() == Token::ARROW) { |
| if (fni_) { |
| fni_->RemoveAsyncKeywordFromEnd(); |
| } |
| ValidateBindingPattern(CHECK_OK); |
| ValidateFormalParameterInitializer(CHECK_OK); |
| if (!classifier()->is_valid_async_arrow_formal_parameters()) { |
| ReportClassifierError( |
| classifier()->async_arrow_formal_parameters_error()); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| if (args->length()) { |
| // async ( Arguments ) => ... |
| if (!is_simple_parameter_list) { |
| async_classifier.previous()->RecordNonSimpleParameter(); |
| } |
| return impl()->ExpressionListToExpression(args); |
| } |
| // async () => ... |
| return factory()->NewEmptyParentheses(pos); |
| } else { |
| AccumulateFormalParameterContainmentErrors(); |
| } |
| } else { |
| args = ParseArguments(&spread_pos, CHECK_OK); |
| } |
| |
| ArrowFormalParametersUnexpectedToken(); |
| |
| // Keep track of eval() calls since they disable all local variable |
| // optimizations. |
| // The calls that need special treatment are the |
| // direct eval calls. These calls are all of the form eval(...), with |
| // no explicit receiver. |
| // These calls are marked as potentially direct eval calls. Whether |
| // they are actually direct calls to eval is determined at run time. |
| Call::PossiblyEval is_possibly_eval = |
| CheckPossibleEvalCall(result, scope()); |
| |
| if (spread_pos.IsValid()) { |
| result = impl()->SpreadCall(result, args, pos, is_possibly_eval); |
| } else { |
| result = factory()->NewCall(result, args, pos, is_possibly_eval); |
| } |
| |
| if (fni_ != nullptr) fni_->RemoveLastFunction(); |
| break; |
| } |
| |
| case Token::PERIOD: { |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| Consume(Token::PERIOD); |
| int pos = position(); |
| ExpressionT key = ParseIdentifierNameOrPrivateName(CHECK_OK); |
| result = factory()->NewProperty(result, key, pos); |
| break; |
| } |
| |
| case Token::TEMPLATE_SPAN: |
| case Token::TEMPLATE_TAIL: { |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| result = ParseTemplateLiteral(result, position(), true, CHECK_OK); |
| break; |
| } |
| |
| default: |
| return result; |
| } |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseMemberWithNewPrefixesExpression(bool* is_async, |
| bool* ok) { |
| // NewExpression :: |
| // ('new')+ MemberExpression |
| // |
| // NewTarget :: |
| // 'new' '.' 'target' |
| |
| // The grammar for new expressions is pretty warped. We can have several 'new' |
| // keywords following each other, and then a MemberExpression. When we see '(' |
| // after the MemberExpression, it's associated with the rightmost unassociated |
| // 'new' to create a NewExpression with arguments. However, a NewExpression |
| // can also occur without arguments. |
| |
| // Examples of new expression: |
| // new foo.bar().baz means (new (foo.bar)()).baz |
| // new foo()() means (new foo())() |
| // new new foo()() means (new (new foo())()) |
| // new new foo means new (new foo) |
| // new new foo() means new (new foo()) |
| // new new foo().bar().baz means (new (new foo()).bar()).baz |
| |
| if (peek() == Token::NEW) { |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| Consume(Token::NEW); |
| int new_pos = position(); |
| ExpressionT result; |
| if (peek() == Token::SUPER) { |
| const bool is_new = true; |
| result = ParseSuperExpression(is_new, CHECK_OK); |
| } else if (allow_harmony_dynamic_import() && peek() == Token::IMPORT && |
| (!allow_harmony_import_meta() || PeekAhead() == Token::LPAREN)) { |
| impl()->ReportMessageAt(scanner()->peek_location(), |
| MessageTemplate::kImportCallNotNewExpression); |
| *ok = false; |
| return impl()->NullExpression(); |
| } else if (peek() == Token::PERIOD) { |
| *is_async = false; |
| result = ParseNewTargetExpression(CHECK_OK); |
| return ParseMemberExpressionContinuation(result, is_async, CHECK_OK); |
| } else { |
| result = ParseMemberWithNewPrefixesExpression(is_async, CHECK_OK); |
| } |
| ValidateExpression(CHECK_OK); |
| if (peek() == Token::LPAREN) { |
| // NewExpression with arguments. |
| Scanner::Location spread_pos; |
| ExpressionListT args = ParseArguments(&spread_pos, CHECK_OK); |
| |
| if (spread_pos.IsValid()) { |
| result = impl()->SpreadCallNew(result, args, new_pos); |
| } else { |
| result = factory()->NewCallNew(result, args, new_pos); |
| } |
| // The expression can still continue with . or [ after the arguments. |
| result = ParseMemberExpressionContinuation(result, is_async, CHECK_OK); |
| return result; |
| } |
| // NewExpression without arguments. |
| return factory()->NewCallNew(result, impl()->NewExpressionList(0), new_pos); |
| } |
| // No 'new' or 'super' keyword. |
| return ParseMemberExpression(is_async, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseMemberExpression( |
| bool* is_async, bool* ok) { |
| // MemberExpression :: |
| // (PrimaryExpression | FunctionLiteral | ClassLiteral) |
| // ('[' Expression ']' | '.' Identifier | Arguments | TemplateLiteral)* |
| // |
| // CallExpression :: |
| // (SuperCall | ImportCall) |
| // ('[' Expression ']' | '.' Identifier | Arguments | TemplateLiteral)* |
| // |
| // The '[' Expression ']' and '.' Identifier parts are parsed by |
| // ParseMemberExpressionContinuation, and the Arguments part is parsed by the |
| // caller. |
| |
| // Parse the initial primary or function expression. |
| ExpressionT result; |
| if (peek() == Token::FUNCTION) { |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| Consume(Token::FUNCTION); |
| int function_token_position = position(); |
| |
| FunctionKind function_kind = Check(Token::MUL) |
| ? FunctionKind::kGeneratorFunction |
| : FunctionKind::kNormalFunction; |
| IdentifierT name = impl()->NullIdentifier(); |
| bool is_strict_reserved_name = false; |
| Scanner::Location function_name_location = Scanner::Location::invalid(); |
| FunctionLiteral::FunctionType function_type = |
| FunctionLiteral::kAnonymousExpression; |
| if (impl()->ParsingDynamicFunctionDeclaration()) { |
| // We don't want dynamic functions to actually declare their name |
| // "anonymous". We just want that name in the toString(). |
| if (stack_overflow()) { |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| Consume(Token::IDENTIFIER); |
| DCHECK(scanner()->CurrentMatchesContextual(Token::ANONYMOUS)); |
| } else if (peek_any_identifier()) { |
| bool is_await = false; |
| name = ParseIdentifierOrStrictReservedWord( |
| function_kind, &is_strict_reserved_name, &is_await, CHECK_OK); |
| function_name_location = scanner()->location(); |
| function_type = FunctionLiteral::kNamedExpression; |
| } |
| result = impl()->ParseFunctionLiteral( |
| name, function_name_location, |
| is_strict_reserved_name ? kFunctionNameIsStrictReserved |
| : kFunctionNameValidityUnknown, |
| function_kind, function_token_position, function_type, language_mode(), |
| nullptr, CHECK_OK); |
| } else if (peek() == Token::SUPER) { |
| const bool is_new = false; |
| result = ParseSuperExpression(is_new, CHECK_OK); |
| } else if (allow_harmony_dynamic_import() && peek() == Token::IMPORT) { |
| result = ParseImportExpressions(CHECK_OK); |
| } else { |
| result = ParsePrimaryExpression(is_async, CHECK_OK); |
| } |
| |
| result = ParseMemberExpressionContinuation(result, is_async, CHECK_OK); |
| return result; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseImportExpressions( |
| bool* ok) { |
| DCHECK(allow_harmony_dynamic_import()); |
| |
| classifier()->RecordPatternError(scanner()->peek_location(), |
| MessageTemplate::kUnexpectedToken, |
| Token::String(Token::IMPORT)); |
| |
| Consume(Token::IMPORT); |
| int pos = position(); |
| if (allow_harmony_import_meta() && peek() == Token::PERIOD) { |
| ExpectMetaProperty(Token::META, "import.meta", pos, CHECK_OK); |
| if (!parsing_module_) { |
| impl()->ReportMessageAt(scanner()->location(), |
| MessageTemplate::kImportMetaOutsideModule); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| return impl()->ImportMetaExpression(pos); |
| } |
| Expect(Token::LPAREN, CHECK_OK); |
| if (peek() == Token::RPAREN) { |
| impl()->ReportMessageAt(scanner()->location(), |
| MessageTemplate::kImportMissingSpecifier); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| ExpressionT arg = ParseAssignmentExpression(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| return factory()->NewImportCallExpression(arg, pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseSuperExpression( |
| bool is_new, bool* ok) { |
| Expect(Token::SUPER, CHECK_OK); |
| int pos = position(); |
| |
| DeclarationScope* scope = GetReceiverScope(); |
| FunctionKind kind = scope->function_kind(); |
| if (IsConciseMethod(kind) || IsAccessorFunction(kind) || |
| IsClassConstructor(kind)) { |
| if (peek() == Token::PERIOD || peek() == Token::LBRACK) { |
| scope->RecordSuperPropertyUsage(); |
| return impl()->NewSuperPropertyReference(pos); |
| } |
| // new super() is never allowed. |
| // super() is only allowed in derived constructor |
| if (!is_new && peek() == Token::LPAREN && IsDerivedConstructor(kind)) { |
| // TODO(rossberg): This might not be the correct FunctionState for the |
| // method here. |
| return impl()->NewSuperCallReference(pos); |
| } |
| } |
| |
| impl()->ReportMessageAt(scanner()->location(), |
| MessageTemplate::kUnexpectedSuper); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ExpectMetaProperty(Token::Value property_name, |
| const char* full_name, int pos, |
| bool* ok) { |
| Consume(Token::PERIOD); |
| ExpectContextualKeyword(property_name, CHECK_OK_CUSTOM(Void)); |
| if (scanner()->literal_contains_escapes()) { |
| impl()->ReportMessageAt( |
| Scanner::Location(pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidEscapedMetaProperty, full_name); |
| *ok = false; |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseNewTargetExpression(bool* ok) { |
| int pos = position(); |
| ExpectMetaProperty(Token::TARGET, "new.target", pos, CHECK_OK); |
| |
| classifier()->RecordAssignmentPatternError( |
| Scanner::Location(pos, scanner()->location().end_pos), |
| MessageTemplate::kInvalidDestructuringTarget); |
| |
| if (!GetReceiverScope()->is_function_scope()) { |
| impl()->ReportMessageAt(scanner()->location(), |
| MessageTemplate::kUnexpectedNewTarget); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| return impl()->NewTargetExpression(pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseMemberExpressionContinuation(ExpressionT expression, |
| bool* is_async, bool* ok) { |
| // Parses this part of MemberExpression: |
| // ('[' Expression ']' | '.' Identifier | TemplateLiteral)* |
| while (true) { |
| switch (peek()) { |
| case Token::LBRACK: { |
| *is_async = false; |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| Consume(Token::LBRACK); |
| int pos = position(); |
| ExpressionT index = ParseExpressionCoverGrammar(true, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| expression = factory()->NewProperty(expression, index, pos); |
| impl()->PushPropertyName(index); |
| Expect(Token::RBRACK, CHECK_OK); |
| break; |
| } |
| case Token::PERIOD: { |
| *is_async = false; |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| |
| Consume(Token::PERIOD); |
| int pos = peek_position(); |
| ExpressionT key = ParseIdentifierNameOrPrivateName(CHECK_OK); |
| expression = factory()->NewProperty(expression, key, pos); |
| break; |
| } |
| case Token::TEMPLATE_SPAN: |
| case Token::TEMPLATE_TAIL: { |
| *is_async = false; |
| ValidateExpression(CHECK_OK); |
| BindingPatternUnexpectedToken(); |
| ArrowFormalParametersUnexpectedToken(); |
| int pos; |
| if (scanner()->current_token() == Token::IDENTIFIER) { |
| pos = position(); |
| } else { |
| pos = peek_position(); |
| if (expression->IsFunctionLiteral()) { |
| // If the tag function looks like an IIFE, set_parenthesized() to |
| // force eager compilation. |
| expression->AsFunctionLiteral()->SetShouldEagerCompile(); |
| } |
| } |
| expression = ParseTemplateLiteral(expression, pos, true, CHECK_OK); |
| break; |
| } |
| case Token::ILLEGAL: { |
| ReportUnexpectedTokenAt(scanner()->peek_location(), Token::ILLEGAL); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| default: |
| return expression; |
| } |
| } |
| DCHECK(false); |
| return impl()->NullExpression(); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ParseFormalParameter(FormalParametersT* parameters, |
| bool* ok) { |
| // FormalParameter[Yield,GeneratorParameter] : |
| // BindingElement[?Yield, ?GeneratorParameter] |
| bool is_rest = parameters->has_rest; |
| |
| FuncNameInferrer::State fni_state(fni_); |
| ExpressionT pattern = ParsePrimaryExpression(CHECK_OK_CUSTOM(Void)); |
| ValidateBindingPattern(CHECK_OK_CUSTOM(Void)); |
| |
| if (!impl()->IsIdentifier(pattern)) { |
| parameters->is_simple = false; |
| ValidateFormalParameterInitializer(CHECK_OK_CUSTOM(Void)); |
| classifier()->RecordNonSimpleParameter(); |
| } |
| |
| ExpressionT initializer = impl()->NullExpression(); |
| if (Check(Token::ASSIGN)) { |
| if (is_rest) { |
| ReportMessage(MessageTemplate::kRestDefaultInitializer); |
| *ok = false; |
| return; |
| } |
| ExpressionClassifier init_classifier(this); |
| initializer = ParseAssignmentExpression(true, CHECK_OK_CUSTOM(Void)); |
| ValidateExpression(CHECK_OK_CUSTOM(Void)); |
| ValidateFormalParameterInitializer(CHECK_OK_CUSTOM(Void)); |
| parameters->is_simple = false; |
| DiscardExpressionClassifier(); |
| classifier()->RecordNonSimpleParameter(); |
| |
| impl()->SetFunctionNameFromIdentifierRef(initializer, pattern); |
| } |
| |
| impl()->AddFormalParameter(parameters, pattern, initializer, |
| scanner()->location().end_pos, is_rest); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ParseFormalParameterList(FormalParametersT* parameters, |
| bool* ok) { |
| // FormalParameters[Yield] : |
| // [empty] |
| // FunctionRestParameter[?Yield] |
| // FormalParameterList[?Yield] |
| // FormalParameterList[?Yield] , |
| // FormalParameterList[?Yield] , FunctionRestParameter[?Yield] |
| // |
| // FormalParameterList[Yield] : |
| // FormalParameter[?Yield] |
| // FormalParameterList[?Yield] , FormalParameter[?Yield] |
| |
| DCHECK_EQ(0, parameters->arity); |
| |
| if (peek() != Token::RPAREN) { |
| while (true) { |
| if (parameters->arity > Code::kMaxArguments) { |
| ReportMessage(MessageTemplate::kTooManyParameters); |
| *ok = false; |
| return; |
| } |
| parameters->has_rest = Check(Token::ELLIPSIS); |
| ParseFormalParameter(parameters, CHECK_OK_CUSTOM(Void)); |
| |
| if (parameters->has_rest) { |
| parameters->is_simple = false; |
| classifier()->RecordNonSimpleParameter(); |
| if (peek() == Token::COMMA) { |
| impl()->ReportMessageAt(scanner()->peek_location(), |
| MessageTemplate::kParamAfterRest); |
| *ok = false; |
| return; |
| } |
| break; |
| } |
| if (!Check(Token::COMMA)) break; |
| if (peek() == Token::RPAREN) { |
| // allow the trailing comma |
| break; |
| } |
| } |
| } |
| |
| impl()->DeclareFormalParameters(parameters->scope, parameters->params, |
| parameters->is_simple); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::BlockT ParserBase<Impl>::ParseVariableDeclarations( |
| VariableDeclarationContext var_context, |
| DeclarationParsingResult* parsing_result, |
| ZonePtrList<const AstRawString>* names, bool* ok) { |
| // VariableDeclarations :: |
| // ('var' | 'const' | 'let') (Identifier ('=' AssignmentExpression)?)+[','] |
| // |
| // ES6: |
| // FIXME(marja, nikolaos): Add an up-to-date comment about ES6 variable |
| // declaration syntax. |
| |
| DCHECK_NOT_NULL(parsing_result); |
| parsing_result->descriptor.declaration_kind = DeclarationDescriptor::NORMAL; |
| parsing_result->descriptor.declaration_pos = peek_position(); |
| parsing_result->descriptor.initialization_pos = peek_position(); |
| |
| BlockT init_block = impl()->NullStatement(); |
| if (var_context != kForStatement) { |
| init_block = factory()->NewBlock(1, true); |
| } |
| |
| switch (peek()) { |
| case Token::VAR: |
| parsing_result->descriptor.mode = VariableMode::kVar; |
| Consume(Token::VAR); |
| break; |
| case Token::CONST: |
| Consume(Token::CONST); |
| DCHECK_NE(var_context, kStatement); |
| parsing_result->descriptor.mode = VariableMode::kConst; |
| break; |
| case Token::LET: |
| Consume(Token::LET); |
| DCHECK_NE(var_context, kStatement); |
| parsing_result->descriptor.mode = VariableMode::kLet; |
| break; |
| default: |
| UNREACHABLE(); // by current callers |
| break; |
| } |
| |
| parsing_result->descriptor.scope = scope(); |
| |
| int bindings_start = peek_position(); |
| do { |
| // Parse binding pattern. |
| FuncNameInferrer::State fni_state(fni_); |
| |
| ExpressionT pattern = impl()->NullExpression(); |
| int decl_pos = peek_position(); |
| { |
| ExpressionClassifier pattern_classifier(this); |
| pattern = ParsePrimaryExpression(CHECK_OK_CUSTOM(NullStatement)); |
| |
| ValidateBindingPattern(CHECK_OK_CUSTOM(NullStatement)); |
| if (IsLexicalVariableMode(parsing_result->descriptor.mode)) { |
| ValidateLetPattern(CHECK_OK_CUSTOM(NullStatement)); |
| } |
| } |
| |
| Scanner::Location variable_loc = scanner()->location(); |
| bool single_name = impl()->IsIdentifier(pattern); |
| |
| if (single_name) { |
| impl()->PushVariableName(impl()->AsIdentifier(pattern)); |
| } |
| |
| ExpressionT value = impl()->NullExpression(); |
| int initializer_position = kNoSourcePosition; |
| int value_beg_position = kNoSourcePosition; |
| if (Check(Token::ASSIGN)) { |
| value_beg_position = peek_position(); |
| |
| ExpressionClassifier classifier(this); |
| value = ParseAssignmentExpression(var_context != kForStatement, |
| CHECK_OK_CUSTOM(NullStatement)); |
| ValidateExpression(CHECK_OK_CUSTOM(NullStatement)); |
| variable_loc.end_pos = scanner()->location().end_pos; |
| |
| if (!parsing_result->first_initializer_loc.IsValid()) { |
| parsing_result->first_initializer_loc = variable_loc; |
| } |
| |
| // Don't infer if it is "a = function(){...}();"-like expression. |
| if (single_name && fni_ != nullptr) { |
| if (!value->IsCall() && !value->IsCallNew()) { |
| fni_->Infer(); |
| } else { |
| fni_->RemoveLastFunction(); |
| } |
| } |
| |
| impl()->SetFunctionNameFromIdentifierRef(value, pattern); |
| |
| // End position of the initializer is after the assignment expression. |
| initializer_position = scanner()->location().end_pos; |
| } else { |
| if (var_context != kForStatement || !PeekInOrOf()) { |
| // ES6 'const' and binding patterns require initializers. |
| if (parsing_result->descriptor.mode == VariableMode::kConst || |
| !impl()->IsIdentifier(pattern)) { |
| impl()->ReportMessageAt( |
| Scanner::Location(decl_pos, scanner()->location().end_pos), |
| MessageTemplate::kDeclarationMissingInitializer, |
| !impl()->IsIdentifier(pattern) ? "destructuring" : "const"); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| // 'let x' initializes 'x' to undefined. |
| if (parsing_result->descriptor.mode == VariableMode::kLet) { |
| value = factory()->NewUndefinedLiteral(position()); |
| } |
| } |
| |
| // End position of the initializer is after the variable. |
| initializer_position = position(); |
| } |
| |
| typename DeclarationParsingResult::Declaration decl( |
| pattern, initializer_position, value); |
| decl.value_beg_position = value_beg_position; |
| if (var_context == kForStatement) { |
| // Save the declaration for further handling in ParseForStatement. |
| parsing_result->declarations.push_back(decl); |
| } else { |
| // Immediately declare the variable otherwise. This avoids O(N^2) |
| // behavior (where N is the number of variables in a single |
| // declaration) in the PatternRewriter having to do with removing |
| // and adding VariableProxies to the Scope (see bug 4699). |
| impl()->DeclareAndInitializeVariables( |
| init_block, &parsing_result->descriptor, &decl, names, |
| CHECK_OK_CUSTOM(NullStatement)); |
| } |
| } while (Check(Token::COMMA)); |
| |
| parsing_result->bindings_loc = |
| Scanner::Location(bindings_start, scanner()->location().end_pos); |
| |
| DCHECK(*ok); |
| return init_block; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseFunctionDeclaration(bool* ok) { |
| Consume(Token::FUNCTION); |
| int pos = position(); |
| ParseFunctionFlags flags = ParseFunctionFlags::kIsNormal; |
| if (Check(Token::MUL)) { |
| impl()->ReportMessageAt( |
| scanner()->location(), |
| MessageTemplate::kGeneratorInSingleStatementContext); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| return ParseHoistableDeclaration(pos, flags, nullptr, false, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseHoistableDeclaration( |
| ZonePtrList<const AstRawString>* names, bool default_export, bool* ok) { |
| Expect(Token::FUNCTION, CHECK_OK_CUSTOM(NullStatement)); |
| int pos = position(); |
| ParseFunctionFlags flags = ParseFunctionFlags::kIsNormal; |
| if (Check(Token::MUL)) { |
| flags |= ParseFunctionFlags::kIsGenerator; |
| } |
| return ParseHoistableDeclaration(pos, flags, names, default_export, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseHoistableDeclaration( |
| int pos, ParseFunctionFlags flags, ZonePtrList<const AstRawString>* names, |
| bool default_export, bool* ok) { |
| // FunctionDeclaration :: |
| // 'function' Identifier '(' FormalParameters ')' '{' FunctionBody '}' |
| // 'function' '(' FormalParameters ')' '{' FunctionBody '}' |
| // GeneratorDeclaration :: |
| // 'function' '*' Identifier '(' FormalParameters ')' '{' FunctionBody '}' |
| // 'function' '*' '(' FormalParameters ')' '{' FunctionBody '}' |
| // |
| // The anonymous forms are allowed iff [default_export] is true. |
| // |
| // 'function' and '*' (if present) have been consumed by the caller. |
| |
| bool is_generator = flags & ParseFunctionFlags::kIsGenerator; |
| const bool is_async = flags & ParseFunctionFlags::kIsAsync; |
| DCHECK(!is_generator || !is_async); |
| |
| if (is_async && Check(Token::MUL)) { |
| // Async generator |
| is_generator = true; |
| } |
| |
| IdentifierT name; |
| FunctionNameValidity name_validity; |
| IdentifierT variable_name; |
| if (default_export && peek() == Token::LPAREN) { |
| impl()->GetDefaultStrings(&name, &variable_name); |
| name_validity = kSkipFunctionNameCheck; |
| } else { |
| bool is_strict_reserved; |
| bool is_await = false; |
| name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved, &is_await, |
| CHECK_OK_CUSTOM(NullStatement)); |
| name_validity = is_strict_reserved ? kFunctionNameIsStrictReserved |
| : kFunctionNameValidityUnknown; |
| variable_name = name; |
| } |
| |
| FuncNameInferrer::State fni_state(fni_); |
| impl()->PushEnclosingName(name); |
| |
| FunctionKind kind = FunctionKindFor(is_generator, is_async); |
| |
| FunctionLiteralT function = impl()->ParseFunctionLiteral( |
| name, scanner()->location(), name_validity, kind, pos, |
| FunctionLiteral::kDeclaration, language_mode(), nullptr, |
| CHECK_OK_CUSTOM(NullStatement)); |
| |
| // In ES6, a function behaves as a lexical binding, except in |
| // a script scope, or the initial scope of eval or another function. |
| VariableMode mode = |
| (!scope()->is_declaration_scope() || scope()->is_module_scope()) |
| ? VariableMode::kLet |
| : VariableMode::kVar; |
| // Async functions don't undergo sloppy mode block scoped hoisting, and don't |
| // allow duplicates in a block. Both are represented by the |
| // sloppy_block_function_map. Don't add them to the map for async functions. |
| // Generators are also supposed to be prohibited; currently doing this behind |
| // a flag and UseCounting violations to assess web compatibility. |
| bool is_sloppy_block_function = is_sloppy(language_mode()) && |
| !scope()->is_declaration_scope() && |
| !is_async && !is_generator; |
| |
| return impl()->DeclareFunction(variable_name, function, mode, pos, |
| is_sloppy_block_function, names, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseClassDeclaration( |
| ZonePtrList<const AstRawString>* names, bool default_export, bool* ok) { |
| // ClassDeclaration :: |
| // 'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}' |
| // 'class' ('extends' LeftHandExpression)? '{' ClassBody '}' |
| // |
| // The anonymous form is allowed iff [default_export] is true. |
| // |
| // 'class' is expected to be consumed by the caller. |
| // |
| // A ClassDeclaration |
| // |
| // class C { ... } |
| // |
| // has the same semantics as: |
| // |
| // let C = class C { ... }; |
| // |
| // so rewrite it as such. |
| |
| int class_token_pos = position(); |
| IdentifierT name = impl()->NullIdentifier(); |
| bool is_strict_reserved = false; |
| IdentifierT variable_name = impl()->NullIdentifier(); |
| if (default_export && (peek() == Token::EXTENDS || peek() == Token::LBRACE)) { |
| impl()->GetDefaultStrings(&name, &variable_name); |
| } else { |
| bool is_await = false; |
| name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved, &is_await, |
| CHECK_OK_CUSTOM(NullStatement)); |
| variable_name = name; |
| } |
| |
| ExpressionClassifier no_classifier(this); |
| ExpressionT value = |
| ParseClassLiteral(name, scanner()->location(), is_strict_reserved, |
| class_token_pos, CHECK_OK_CUSTOM(NullStatement)); |
| int end_pos = position(); |
| return impl()->DeclareClass(variable_name, value, names, class_token_pos, |
| end_pos, ok); |
| } |
| |
| // Language extension which is only enabled for source files loaded |
| // through the API's extension mechanism. A native function |
| // declaration is resolved by looking up the function through a |
| // callback provided by the extension. |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseNativeDeclaration( |
| bool* ok) { |
| function_state_->DisableOptimization(BailoutReason::kNativeFunctionLiteral); |
| |
| int pos = peek_position(); |
| Expect(Token::FUNCTION, CHECK_OK_CUSTOM(NullStatement)); |
| // Allow "eval" or "arguments" for backward compatibility. |
| IdentifierT name = ParseIdentifier(kAllowRestrictedIdentifiers, |
| CHECK_OK_CUSTOM(NullStatement)); |
| Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullStatement)); |
| if (peek() != Token::RPAREN) { |
| do { |
| ParseIdentifier(kAllowRestrictedIdentifiers, |
| CHECK_OK_CUSTOM(NullStatement)); |
| } while (Check(Token::COMMA)); |
| } |
| Expect(Token::RPAREN, CHECK_OK_CUSTOM(NullStatement)); |
| Expect(Token::SEMICOLON, CHECK_OK_CUSTOM(NullStatement)); |
| return impl()->DeclareNative(name, pos, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseAsyncFunctionDeclaration( |
| ZonePtrList<const AstRawString>* names, bool default_export, bool* ok) { |
| // AsyncFunctionDeclaration :: |
| // async [no LineTerminator here] function BindingIdentifier[Await] |
| // ( FormalParameters[Await] ) { AsyncFunctionBody } |
| DCHECK_EQ(scanner()->current_token(), Token::ASYNC); |
| int pos = position(); |
| if (scanner()->HasLineTerminatorBeforeNext()) { |
| *ok = false; |
| impl()->ReportUnexpectedToken(scanner()->current_token()); |
| return impl()->NullStatement(); |
| } |
| Expect(Token::FUNCTION, CHECK_OK_CUSTOM(NullStatement)); |
| ParseFunctionFlags flags = ParseFunctionFlags::kIsAsync; |
| return ParseHoistableDeclaration(pos, flags, names, default_export, ok); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ParseFunctionBody( |
| typename ParserBase<Impl>::StatementListT result, IdentifierT function_name, |
| int pos, const FormalParametersT& parameters, FunctionKind kind, |
| FunctionLiteral::FunctionType function_type, bool* ok) { |
| DeclarationScope* function_scope = scope()->AsDeclarationScope(); |
| DeclarationScope* inner_scope = function_scope; |
| BlockT inner_block = impl()->NullStatement(); |
| |
| StatementListT body = result; |
| if (!parameters.is_simple) { |
| inner_scope = NewVarblockScope(); |
| inner_scope->set_start_position(scanner()->location().beg_pos); |
| inner_block = factory()->NewBlock(8, true); |
| inner_block->set_scope(inner_scope); |
| body = inner_block->statements(); |
| } |
| |
| // If we are parsing the source as if it is wrapped in a function, the source |
| // ends without a closing brace. |
| Token::Value closing_token = |
| function_type == FunctionLiteral::kWrapped ? Token::EOS : Token::RBRACE; |
| |
| { |
| BlockState block_state(&scope_, inner_scope); |
| |
| if (IsResumableFunction(kind)) impl()->PrepareGeneratorVariables(); |
| |
| if (IsAsyncGeneratorFunction(kind)) { |
| impl()->ParseAndRewriteAsyncGeneratorFunctionBody(pos, kind, body, ok); |
| } else if (IsGeneratorFunction(kind)) { |
| impl()->ParseAndRewriteGeneratorFunctionBody(pos, kind, body, ok); |
| } else if (IsAsyncFunction(kind)) { |
| ParseAsyncFunctionBody(inner_scope, body, CHECK_OK_VOID); |
| } else { |
| ParseStatementList(body, closing_token, CHECK_OK_VOID); |
| } |
| |
| if (IsDerivedConstructor(kind)) { |
| body->Add(factory()->NewReturnStatement(impl()->ThisExpression(), |
| kNoSourcePosition), |
| zone()); |
| } |
| } |
| |
| Expect(closing_token, CHECK_OK_VOID); |
| scope()->set_end_position(scanner()->location().end_pos); |
| |
| if (!parameters.is_simple) { |
| DCHECK_NOT_NULL(inner_scope); |
| DCHECK_EQ(function_scope, scope()); |
| DCHECK_EQ(function_scope, inner_scope->outer_scope()); |
| impl()->SetLanguageMode(function_scope, inner_scope->language_mode()); |
| BlockT init_block = |
| impl()->BuildParameterInitializationBlock(parameters, CHECK_OK_VOID); |
| |
| if (is_sloppy(inner_scope->language_mode())) { |
| impl()->InsertSloppyBlockFunctionVarBindings(inner_scope); |
| } |
| |
| // TODO(littledan): Merge the two rejection blocks into one |
| if (IsAsyncFunction(kind) && !IsAsyncGeneratorFunction(kind)) { |
| init_block = impl()->BuildRejectPromiseOnException(init_block); |
| } |
| |
| inner_scope->set_end_position(scanner()->location().end_pos); |
| if (inner_scope->FinalizeBlockScope() != nullptr) { |
| impl()->CheckConflictingVarDeclarations(inner_scope, CHECK_OK_VOID); |
| impl()->InsertShadowingVarBindingInitializers(inner_block); |
| } else { |
| inner_block->set_scope(nullptr); |
| } |
| inner_scope = nullptr; |
| |
| result->Add(init_block, zone()); |
| result->Add(inner_block, zone()); |
| } else { |
| DCHECK_EQ(inner_scope, function_scope); |
| if (is_sloppy(function_scope->language_mode())) { |
| impl()->InsertSloppyBlockFunctionVarBindings(function_scope); |
| } |
| } |
| |
| if (!IsArrowFunction(kind)) { |
| // Declare arguments after parsing the function since lexical 'arguments' |
| // masks the arguments object. Declare arguments before declaring the |
| // function var since the arguments object masks 'function arguments'. |
| function_scope->DeclareArguments(ast_value_factory()); |
| } |
| |
| impl()->DeclareFunctionNameVar(function_name, function_type, function_scope); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::CheckArityRestrictions(int param_count, |
| FunctionKind function_kind, |
| bool has_rest, |
| int formals_start_pos, |
| int formals_end_pos, bool* ok) { |
| if (IsGetterFunction(function_kind)) { |
| if (param_count != 0) { |
| impl()->ReportMessageAt( |
| Scanner::Location(formals_start_pos, formals_end_pos), |
| MessageTemplate::kBadGetterArity); |
| *ok = false; |
| } |
| } else if (IsSetterFunction(function_kind)) { |
| if (param_count != 1) { |
| impl()->ReportMessageAt( |
| Scanner::Location(formals_start_pos, formals_end_pos), |
| MessageTemplate::kBadSetterArity); |
| *ok = false; |
| } |
| if (has_rest) { |
| impl()->ReportMessageAt( |
| Scanner::Location(formals_start_pos, formals_end_pos), |
| MessageTemplate::kBadSetterRestParameter); |
| *ok = false; |
| } |
| } |
| } |
| |
| template <typename Impl> |
| bool ParserBase<Impl>::IsNextLetKeyword() { |
| DCHECK(peek() == Token::LET); |
| Token::Value next_next = PeekAhead(); |
| switch (next_next) { |
| case Token::LBRACE: |
| case Token::LBRACK: |
| case Token::IDENTIFIER: |
| case Token::STATIC: |
| case Token::LET: // `let let;` is disallowed by static semantics, but the |
| // token must be first interpreted as a keyword in order |
| // for those semantics to apply. This ensures that ASI is |
| // not honored when a LineTerminator separates the |
| // tokens. |
| case Token::YIELD: |
| case Token::AWAIT: |
| case Token::ASYNC: |
| return true; |
| case Token::FUTURE_STRICT_RESERVED_WORD: |
| return is_sloppy(language_mode()); |
| default: |
| return false; |
| } |
| } |
| |
| template <typename Impl> |
| bool ParserBase<Impl>::IsTrivialExpression() { |
| Token::Value peek_token = peek(); |
| if (peek_token == Token::SMI || peek_token == Token::NUMBER || |
| peek_token == Token::BIGINT || peek_token == Token::NULL_LITERAL || |
| peek_token == Token::TRUE_LITERAL || peek_token == Token::FALSE_LITERAL || |
| peek_token == Token::STRING || peek_token == Token::IDENTIFIER || |
| peek_token == Token::THIS) { |
| // PeekAhead() is expensive & may not always be called, so we only call it |
| // after checking peek(). |
| Token::Value peek_ahead = PeekAhead(); |
| if (peek_ahead == Token::COMMA || peek_ahead == Token::RPAREN || |
| peek_ahead == Token::SEMICOLON || peek_ahead == Token::RBRACK) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseArrowFunctionLiteral( |
| bool accept_IN, const FormalParametersT& formal_parameters, |
| int rewritable_length, bool* ok) { |
| const RuntimeCallCounterId counters[2][2] = { |
| {RuntimeCallCounterId::kParseBackgroundArrowFunctionLiteral, |
| RuntimeCallCounterId::kParseArrowFunctionLiteral}, |
| {RuntimeCallCounterId::kPreParseBackgroundArrowFunctionLiteral, |
| RuntimeCallCounterId::kPreParseArrowFunctionLiteral}}; |
| RuntimeCallTimerScope runtime_timer( |
| runtime_call_stats_, |
| counters[Impl::IsPreParser()][parsing_on_main_thread_]); |
| base::ElapsedTimer timer; |
| if (V8_UNLIKELY(FLAG_log_function_events)) timer.Start(); |
| |
| if (peek() == Token::ARROW && scanner_->HasLineTerminatorBeforeNext()) { |
| // ASI inserts `;` after arrow parameters if a line terminator is found. |
| // `=> ...` is never a valid expression, so report as syntax error. |
| // If next token is not `=>`, it's a syntax error anyways. |
| ReportUnexpectedTokenAt(scanner_->peek_location(), Token::ARROW); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| StatementListT body = impl()->NullStatementList(); |
| int expected_property_count = -1; |
| int suspend_count = 0; |
| int function_literal_id = GetNextFunctionLiteralId(); |
| |
| FunctionKind kind = formal_parameters.scope->function_kind(); |
| FunctionLiteral::EagerCompileHint eager_compile_hint = |
| default_eager_compile_hint_; |
| bool can_preparse = impl()->parse_lazily() && |
| eager_compile_hint == FunctionLiteral::kShouldLazyCompile; |
| // TODO(marja): consider lazy-parsing inner arrow functions too. is_this |
| // handling in Scope::ResolveVariable needs to change. |
| bool is_lazy_top_level_function = |
| can_preparse && impl()->AllowsLazyParsingWithoutUnresolvedVariables(); |
| bool has_braces = true; |
| ProducedPreParsedScopeData* produced_preparsed_scope_data = nullptr; |
| { |
| FunctionState function_state(&function_state_, &scope_, |
| formal_parameters.scope); |
| |
| // Move any queued destructuring assignments which appeared |
| // in this function's parameter list into its own function_state. |
| function_state.AdoptDestructuringAssignmentsFromParentState( |
| rewritable_length); |
| |
| Expect(Token::ARROW, CHECK_OK); |
| |
| if (peek() == Token::LBRACE) { |
| // Multiple statement body |
| DCHECK_EQ(scope(), formal_parameters.scope); |
| if (is_lazy_top_level_function) { |
| // FIXME(marja): Arrow function parameters will be parsed even if the |
| // body is preparsed; move relevant parts of parameter handling to |
| // simulate consistent parameter handling. |
| |
| // For arrow functions, we don't need to retrieve data about function |
| // parameters. |
| int dummy_num_parameters = -1; |
| DCHECK_NE(kind & FunctionKind::kArrowFunction, 0); |
| LazyParsingResult result = impl()->SkipFunction( |
| nullptr, kind, FunctionLiteral::kAnonymousExpression, |
| formal_parameters.scope, &dummy_num_parameters, |
| &produced_preparsed_scope_data, false, false, CHECK_OK); |
| DCHECK_NE(result, kLazyParsingAborted); |
| DCHECK_NULL(produced_preparsed_scope_data); |
| USE(result); |
| formal_parameters.scope->ResetAfterPreparsing(ast_value_factory_, |
| false); |
| // Discard any queued destructuring assignments which appeared |
| // in this function's parameter list, and which were adopted |
| // into this function state, above. |
| function_state.RewindDestructuringAssignments(0); |
| } else { |
| Consume(Token::LBRACE); |
| body = impl()->NewStatementList(8); |
| ParseFunctionBody(body, impl()->NullIdentifier(), kNoSourcePosition, |
| formal_parameters, kind, |
| FunctionLiteral::kAnonymousExpression, CHECK_OK); |
| expected_property_count = function_state.expected_property_count(); |
| } |
| } else { |
| // Single-expression body |
| has_braces = false; |
| const bool is_async = IsAsyncFunction(kind); |
| body = impl()->NewStatementList(1); |
| impl()->AddParameterInitializationBlock(formal_parameters, body, is_async, |
| CHECK_OK); |
| ParseSingleExpressionFunctionBody(body, is_async, accept_IN, CHECK_OK); |
| expected_property_count = function_state.expected_property_count(); |
| } |
| |
| formal_parameters.scope->set_end_position(scanner()->location().end_pos); |
| |
| // Arrow function formal parameters are parsed as StrictFormalParameterList, |
| // which is not the same as "parameters of a strict function"; it only means |
| // that duplicates are not allowed. Of course, the arrow function may |
| // itself be strict as well. |
| const bool allow_duplicate_parameters = false; |
| ValidateFormalParameters(language_mode(), allow_duplicate_parameters, |
| CHECK_OK); |
| |
| // Validate strict mode. |
| if (is_strict(language_mode())) { |
| CheckStrictOctalLiteral(formal_parameters.scope->start_position(), |
| scanner()->location().end_pos, CHECK_OK); |
| } |
| impl()->CheckConflictingVarDeclarations(formal_parameters.scope, CHECK_OK); |
| |
| impl()->RewriteDestructuringAssignments(); |
| suspend_count = function_state.suspend_count(); |
| } |
| |
| FunctionLiteralT function_literal = factory()->NewFunctionLiteral( |
| impl()->EmptyIdentifierString(), formal_parameters.scope, body, |
| expected_property_count, formal_parameters.num_parameters(), |
| formal_parameters.function_length, |
| FunctionLiteral::kNoDuplicateParameters, |
| FunctionLiteral::kAnonymousExpression, eager_compile_hint, |
| formal_parameters.scope->start_position(), has_braces, |
| function_literal_id, produced_preparsed_scope_data); |
| |
| function_literal->set_suspend_count(suspend_count); |
| function_literal->set_function_token_position( |
| formal_parameters.scope->start_position()); |
| |
| impl()->AddFunctionForNameInference(function_literal); |
| |
| if (V8_UNLIKELY((FLAG_log_function_events))) { |
| Scope* scope = formal_parameters.scope; |
| double ms = timer.Elapsed().InMillisecondsF(); |
| const char* event_name = |
| is_lazy_top_level_function ? "preparse-no-resolution" : "parse"; |
| const char* name = "arrow function"; |
| logger_->FunctionEvent(event_name, script_id(), ms, scope->start_position(), |
| scope->end_position(), name, strlen(name)); |
| } |
| |
| return function_literal; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseClassLiteral( |
| IdentifierT name, Scanner::Location class_name_location, |
| bool name_is_strict_reserved, int class_token_pos, bool* ok) { |
| bool is_anonymous = impl()->IsNull(name); |
| |
| // All parts of a ClassDeclaration and ClassExpression are strict code. |
| if (!is_anonymous) { |
| if (name_is_strict_reserved) { |
| impl()->ReportMessageAt(class_name_location, |
| MessageTemplate::kUnexpectedStrictReserved); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| if (impl()->IsEvalOrArguments(name)) { |
| impl()->ReportMessageAt(class_name_location, |
| MessageTemplate::kStrictEvalArguments); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| } |
| |
| Scope* block_scope = NewScope(BLOCK_SCOPE); |
| BlockState block_state(&scope_, block_scope); |
| RaiseLanguageMode(LanguageMode::kStrict); |
| |
| ClassInfo class_info(this); |
| class_info.is_anonymous = is_anonymous; |
| impl()->DeclareClassVariable(name, &class_info, class_token_pos, CHECK_OK); |
| |
| scope()->set_start_position(scanner()->location().end_pos); |
| if (Check(Token::EXTENDS)) { |
| FuncNameInferrer::State fni_state(fni_); |
| ExpressionClassifier extends_classifier(this); |
| class_info.extends = ParseLeftHandSideExpression(CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| AccumulateFormalParameterContainmentErrors(); |
| } |
| |
| ClassLiteralChecker checker(this); |
| |
| Expect(Token::LBRACE, CHECK_OK); |
| |
| const bool has_extends = !impl()->IsNull(class_info.extends); |
| while (peek() != Token::RBRACE) { |
| if (Check(Token::SEMICOLON)) continue; |
| FuncNameInferrer::State fni_state(fni_); |
| bool is_computed_name = false; // Classes do not care about computed |
| // property names here. |
| bool is_static; |
| ClassLiteralProperty::Kind property_kind; |
| ExpressionClassifier property_classifier(this); |
| IdentifierT property_name; |
| // If we haven't seen the constructor yet, it potentially is the next |
| // property. |
| bool is_constructor = !class_info.has_seen_constructor; |
| ClassLiteralPropertyT property = ParseClassPropertyDefinition( |
| &checker, &class_info, &property_name, has_extends, &is_computed_name, |
| &property_kind, &is_static, CHECK_OK); |
| if (!class_info.has_static_computed_names && is_static && |
| is_computed_name) { |
| class_info.has_static_computed_names = true; |
| } |
| if (is_computed_name && |
| property_kind == ClassLiteralProperty::PUBLIC_FIELD) { |
| class_info.computed_field_count++; |
| } |
| is_constructor &= class_info.has_seen_constructor; |
| ValidateExpression(CHECK_OK); |
| AccumulateFormalParameterContainmentErrors(); |
| |
| impl()->DeclareClassProperty(name, property, property_name, property_kind, |
| is_static, is_constructor, is_computed_name, |
| &class_info, CHECK_OK); |
| impl()->InferFunctionName(); |
| } |
| |
| Expect(Token::RBRACE, CHECK_OK); |
| int end_pos = scanner()->location().end_pos; |
| block_scope->set_end_position(end_pos); |
| return impl()->RewriteClassLiteral(block_scope, name, &class_info, |
| class_token_pos, end_pos, ok); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ParseSingleExpressionFunctionBody(StatementListT body, |
| bool is_async, |
| bool accept_IN, |
| bool* ok) { |
| if (is_async) impl()->PrepareGeneratorVariables(); |
| |
| ExpressionClassifier classifier(this); |
| ExpressionT expression = ParseAssignmentExpression(accept_IN, CHECK_OK_VOID); |
| ValidateExpression(CHECK_OK_VOID); |
| |
| if (is_async) { |
| BlockT block = factory()->NewBlock(1, true); |
| impl()->RewriteAsyncFunctionBody(body, block, expression, CHECK_OK_VOID); |
| } else { |
| body->Add(BuildReturnStatement(expression, expression->position()), zone()); |
| } |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ParseAsyncFunctionBody(Scope* scope, StatementListT body, |
| bool* ok) { |
| BlockT block = factory()->NewBlock(8, true); |
| |
| ParseStatementList(block->statements(), Token::RBRACE, CHECK_OK_VOID); |
| impl()->RewriteAsyncFunctionBody( |
| body, block, factory()->NewUndefinedLiteral(kNoSourcePosition), |
| CHECK_OK_VOID); |
| scope->set_end_position(scanner()->location().end_pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::ParseAsyncFunctionLiteral(bool* ok) { |
| // AsyncFunctionLiteral :: |
| // async [no LineTerminator here] function ( FormalParameters[Await] ) |
| // { AsyncFunctionBody } |
| // |
| // async [no LineTerminator here] function BindingIdentifier[Await] |
| // ( FormalParameters[Await] ) { AsyncFunctionBody } |
| DCHECK_EQ(scanner()->current_token(), Token::ASYNC); |
| int pos = position(); |
| Expect(Token::FUNCTION, CHECK_OK); |
| bool is_strict_reserved = false; |
| IdentifierT name = impl()->NullIdentifier(); |
| FunctionLiteral::FunctionType type = FunctionLiteral::kAnonymousExpression; |
| |
| bool is_generator = Check(Token::MUL); |
| const bool kIsAsync = true; |
| const FunctionKind kind = FunctionKindFor(is_generator, kIsAsync); |
| |
| if (impl()->ParsingDynamicFunctionDeclaration()) { |
| // We don't want dynamic functions to actually declare their name |
| // "anonymous". We just want that name in the toString(). |
| if (stack_overflow()) { |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| Consume(Token::IDENTIFIER); |
| DCHECK(scanner()->CurrentMatchesContextual(Token::ANONYMOUS)); |
| } else if (peek_any_identifier()) { |
| type = FunctionLiteral::kNamedExpression; |
| bool is_await = false; |
| name = ParseIdentifierOrStrictReservedWord(kind, &is_strict_reserved, |
| &is_await, CHECK_OK); |
| // If the function name is "await", ParseIdentifierOrStrictReservedWord |
| // recognized the error. |
| DCHECK(!is_await); |
| } |
| return impl()->ParseFunctionLiteral( |
| name, scanner()->location(), |
| is_strict_reserved ? kFunctionNameIsStrictReserved |
| : kFunctionNameValidityUnknown, |
| kind, pos, type, language_mode(), nullptr, CHECK_OK); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseTemplateLiteral( |
| ExpressionT tag, int start, bool tagged, bool* ok) { |
| // A TemplateLiteral is made up of 0 or more TEMPLATE_SPAN tokens (literal |
| // text followed by a substitution expression), finalized by a single |
| // TEMPLATE_TAIL. |
| // |
| // In terms of draft language, TEMPLATE_SPAN may be either the TemplateHead or |
| // TemplateMiddle productions, while TEMPLATE_TAIL is either TemplateTail, or |
| // NoSubstitutionTemplate. |
| // |
| // When parsing a TemplateLiteral, we must have scanned either an initial |
| // TEMPLATE_SPAN, or a TEMPLATE_TAIL. |
| DCHECK(peek() == Token::TEMPLATE_SPAN || peek() == Token::TEMPLATE_TAIL); |
| |
| if (tagged) { |
| // TaggedTemplate expressions prevent the eval compilation cache from being |
| // used. This flag is only used if an eval is being parsed. |
| set_allow_eval_cache(false); |
| } |
| |
| bool forbid_illegal_escapes = !tagged; |
| |
| // If we reach a TEMPLATE_TAIL first, we are parsing a NoSubstitutionTemplate. |
| // In this case we may simply consume the token and build a template with a |
| // single TEMPLATE_SPAN and no expressions. |
| if (peek() == Token::TEMPLATE_TAIL) { |
| Consume(Token::TEMPLATE_TAIL); |
| int pos = position(); |
| typename Impl::TemplateLiteralState ts = impl()->OpenTemplateLiteral(pos); |
| bool is_valid = CheckTemplateEscapes(forbid_illegal_escapes, CHECK_OK); |
| impl()->AddTemplateSpan(&ts, is_valid, true); |
| return impl()->CloseTemplateLiteral(&ts, start, tag); |
| } |
| |
| Consume(Token::TEMPLATE_SPAN); |
| int pos = position(); |
| typename Impl::TemplateLiteralState ts = impl()->OpenTemplateLiteral(pos); |
| bool is_valid = CheckTemplateEscapes(forbid_illegal_escapes, CHECK_OK); |
| impl()->AddTemplateSpan(&ts, is_valid, false); |
| Token::Value next; |
| |
| // If we open with a TEMPLATE_SPAN, we must scan the subsequent expression, |
| // and repeat if the following token is a TEMPLATE_SPAN as well (in this |
| // case, representing a TemplateMiddle). |
| |
| do { |
| next = peek(); |
| if (next == Token::EOS) { |
| impl()->ReportMessageAt(Scanner::Location(start, peek_position()), |
| MessageTemplate::kUnterminatedTemplate); |
| *ok = false; |
| return impl()->NullExpression(); |
| } else if (next == Token::ILLEGAL) { |
| impl()->ReportMessageAt( |
| Scanner::Location(position() + 1, peek_position()), |
| MessageTemplate::kUnexpectedToken, "ILLEGAL", kSyntaxError); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| int expr_pos = peek_position(); |
| ExpressionT expression = ParseExpressionCoverGrammar(true, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| impl()->AddTemplateExpression(&ts, expression); |
| |
| if (peek() != Token::RBRACE) { |
| impl()->ReportMessageAt(Scanner::Location(expr_pos, peek_position()), |
| MessageTemplate::kUnterminatedTemplateExpr); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| // If we didn't die parsing that expression, our next token should be a |
| // TEMPLATE_SPAN or TEMPLATE_TAIL. |
| next = scanner()->ScanTemplateContinuation(); |
| Next(); |
| pos = position(); |
| |
| if (next == Token::EOS) { |
| impl()->ReportMessageAt(Scanner::Location(start, pos), |
| MessageTemplate::kUnterminatedTemplate); |
| *ok = false; |
| return impl()->NullExpression(); |
| } else if (next == Token::ILLEGAL) { |
| impl()->ReportMessageAt( |
| Scanner::Location(position() + 1, peek_position()), |
| MessageTemplate::kUnexpectedToken, "ILLEGAL", kSyntaxError); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| bool is_valid = CheckTemplateEscapes(forbid_illegal_escapes, CHECK_OK); |
| impl()->AddTemplateSpan(&ts, is_valid, next == Token::TEMPLATE_TAIL); |
| } while (next == Token::TEMPLATE_SPAN); |
| |
| DCHECK_EQ(next, Token::TEMPLATE_TAIL); |
| // Once we've reached a TEMPLATE_TAIL, we can close the TemplateLiteral. |
| return impl()->CloseTemplateLiteral(&ts, start, tag); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::CheckAndRewriteReferenceExpression( |
| ExpressionT expression, int beg_pos, int end_pos, |
| MessageTemplate::Template message, bool* ok) { |
| return CheckAndRewriteReferenceExpression(expression, beg_pos, end_pos, |
| message, kReferenceError, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT |
| ParserBase<Impl>::CheckAndRewriteReferenceExpression( |
| ExpressionT expression, int beg_pos, int end_pos, |
| MessageTemplate::Template message, ParseErrorType type, bool* ok) { |
| if (impl()->IsIdentifier(expression) && is_strict(language_mode()) && |
| impl()->IsEvalOrArguments(impl()->AsIdentifier(expression))) { |
| ReportMessageAt(Scanner::Location(beg_pos, end_pos), |
| MessageTemplate::kStrictEvalArguments, kSyntaxError); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| if (expression->IsValidReferenceExpression()) { |
| return expression; |
| } |
| if (expression->IsCall() && !expression->AsCall()->is_tagged_template()) { |
| // If it is a call, make it a runtime error for legacy web compatibility. |
| // Bug: https://bugs.chromium.org/p/v8/issues/detail?id=4480 |
| // Rewrite `expr' to `expr[throw ReferenceError]'. |
| impl()->CountUsage( |
| is_strict(language_mode()) |
| ? v8::Isolate::kAssigmentExpressionLHSIsCallInStrict |
| : v8::Isolate::kAssigmentExpressionLHSIsCallInSloppy); |
| ExpressionT error = impl()->NewThrowReferenceError(message, beg_pos); |
| return factory()->NewProperty(expression, error, beg_pos); |
| } |
| ReportMessageAt(Scanner::Location(beg_pos, end_pos), message, type); |
| *ok = false; |
| return impl()->NullExpression(); |
| } |
| |
| template <typename Impl> |
| bool ParserBase<Impl>::IsValidReferenceExpression(ExpressionT expression) { |
| return IsAssignableIdentifier(expression) || expression->IsProperty(); |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::CheckDestructuringElement(ExpressionT expression, |
| int begin, int end) { |
| if (!IsValidPattern(expression) && !expression->IsAssignment() && |
| !IsValidReferenceExpression(expression)) { |
| classifier()->RecordAssignmentPatternError( |
| Scanner::Location(begin, end), |
| MessageTemplate::kInvalidDestructuringTarget); |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseV8Intrinsic( |
| bool* ok) { |
| // CallRuntime :: |
| // '%' Identifier Arguments |
| |
| int pos = peek_position(); |
| Expect(Token::MOD, CHECK_OK); |
| // Allow "eval" or "arguments" for backward compatibility. |
| IdentifierT name = ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK); |
| Scanner::Location spread_pos; |
| ExpressionClassifier classifier(this); |
| ExpressionListT args = ParseArguments(&spread_pos, CHECK_OK); |
| |
| if (spread_pos.IsValid()) { |
| *ok = false; |
| ReportMessageAt(spread_pos, MessageTemplate::kIntrinsicWithSpread, |
| kSyntaxError); |
| return impl()->NullExpression(); |
| } |
| |
| return impl()->NewV8Intrinsic(name, args, pos, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseDoExpression( |
| bool* ok) { |
| // AssignmentExpression :: |
| // do '{' StatementList '}' |
| |
| int pos = peek_position(); |
| Expect(Token::DO, CHECK_OK); |
| BlockT block = ParseBlock(nullptr, CHECK_OK); |
| return impl()->RewriteDoExpression(block, pos, ok); |
| } |
| |
| // Redefinition of CHECK_OK for parsing statements. |
| #undef CHECK_OK |
| #define CHECK_OK CHECK_OK_CUSTOM(NullStatement) |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::LazyParsingResult |
| ParserBase<Impl>::ParseStatementList(StatementListT body, |
| Token::Value end_token, bool may_abort, |
| bool* ok) { |
| // StatementList :: |
| // (StatementListItem)* <end_token> |
| |
| // Allocate a target stack to use for this set of source |
| // elements. This way, all scripts and functions get their own |
| // target stack thus avoiding illegal breaks and continues across |
| // functions. |
| typename Types::TargetScope target_scope(this); |
| int count_statements = 0; |
| |
| DCHECK(!impl()->IsNull(body)); |
| bool directive_prologue = true; // Parsing directive prologue. |
| |
| while (peek() != end_token) { |
| if (directive_prologue && peek() != Token::STRING) { |
| directive_prologue = false; |
| } |
| |
| bool starts_with_identifier = peek() == Token::IDENTIFIER; |
| Scanner::Location token_loc = scanner()->peek_location(); |
| StatementT stat = |
| ParseStatementListItem(CHECK_OK_CUSTOM(Return, kLazyParsingComplete)); |
| |
| if (impl()->IsNull(stat) || stat->IsEmptyStatement()) { |
| directive_prologue = false; // End of directive prologue. |
| continue; |
| } |
| |
| if (directive_prologue) { |
| // The length of the token is used to distinguish between strings literals |
| // that evaluate equal to directives but contain either escape sequences |
| // (e.g., "use \x73trict") or line continuations (e.g., "use \(newline) |
| // strict"). |
| if (impl()->IsUseStrictDirective(stat) && |
| token_loc.end_pos - token_loc.beg_pos == sizeof("use strict") + 1) { |
| // Directive "use strict" (ES5 14.1). |
| RaiseLanguageMode(LanguageMode::kStrict); |
| if (!scope()->HasSimpleParameters()) { |
| // TC39 deemed "use strict" directives to be an error when occurring |
| // in the body of a function with non-simple parameter list, on |
| // 29/7/2015. https://goo.gl/ueA7Ln |
| impl()->ReportMessageAt( |
| token_loc, MessageTemplate::kIllegalLanguageModeDirective, |
| "use strict"); |
| *ok = false; |
| return kLazyParsingComplete; |
| } |
| } else if (impl()->IsUseAsmDirective(stat) && |
| token_loc.end_pos - token_loc.beg_pos == |
| sizeof("use asm") + 1) { |
| // Directive "use asm". |
| impl()->SetAsmModule(); |
| } else if (impl()->IsStringLiteral(stat)) { |
| // Possibly an unknown directive. |
| // Should not change mode, but will increment usage counters |
| // as appropriate. Ditto usages below. |
| RaiseLanguageMode(LanguageMode::kSloppy); |
| } else { |
| // End of the directive prologue. |
| directive_prologue = false; |
| RaiseLanguageMode(LanguageMode::kSloppy); |
| } |
| } else { |
| RaiseLanguageMode(LanguageMode::kSloppy); |
| } |
| |
| // If we're allowed to abort, we will do so when we see a "long and |
| // trivial" function. Our current definition of "long and trivial" is: |
| // - over kLazyParseTrialLimit statements |
| // - all starting with an identifier (i.e., no if, for, while, etc.) |
| if (may_abort) { |
| if (!starts_with_identifier) { |
| may_abort = false; |
| } else if (++count_statements > kLazyParseTrialLimit) { |
| return kLazyParsingAborted; |
| } |
| } |
| |
| body->Add(stat, zone()); |
| } |
| return kLazyParsingComplete; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseStatementListItem( |
| bool* ok) { |
| // ECMA 262 6th Edition |
| // StatementListItem[Yield, Return] : |
| // Statement[?Yield, ?Return] |
| // Declaration[?Yield] |
| // |
| // Declaration[Yield] : |
| // HoistableDeclaration[?Yield] |
| // ClassDeclaration[?Yield] |
| // LexicalDeclaration[In, ?Yield] |
| // |
| // HoistableDeclaration[Yield, Default] : |
| // FunctionDeclaration[?Yield, ?Default] |
| // GeneratorDeclaration[?Yield, ?Default] |
| // |
| // LexicalDeclaration[In, Yield] : |
| // LetOrConst BindingList[?In, ?Yield] ; |
| |
| switch (peek()) { |
| case Token::FUNCTION: |
| return ParseHoistableDeclaration(nullptr, false, ok); |
| case Token::CLASS: |
| Consume(Token::CLASS); |
| return ParseClassDeclaration(nullptr, false, ok); |
| case Token::VAR: |
| case Token::CONST: |
| return ParseVariableStatement(kStatementListItem, nullptr, ok); |
| case Token::LET: |
| if (IsNextLetKeyword()) { |
| return ParseVariableStatement(kStatementListItem, nullptr, ok); |
| } |
| break; |
| case Token::ASYNC: |
| if (PeekAhead() == Token::FUNCTION && |
| !scanner()->HasLineTerminatorAfterNext()) { |
| Consume(Token::ASYNC); |
| return ParseAsyncFunctionDeclaration(nullptr, false, ok); |
| } |
| break; |
| default: |
| break; |
| } |
| return ParseStatement(nullptr, nullptr, kAllowLabelledFunctionStatement, ok); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| AllowLabelledFunctionStatement allow_function, bool* ok) { |
| // Statement :: |
| // Block |
| // VariableStatement |
| // EmptyStatement |
| // ExpressionStatement |
| // IfStatement |
| // IterationStatement |
| // ContinueStatement |
| // BreakStatement |
| // ReturnStatement |
| // WithStatement |
| // LabelledStatement |
| // SwitchStatement |
| // ThrowStatement |
| // TryStatement |
| // DebuggerStatement |
| |
| // {own_labels} is always a subset of {labels}. |
| DCHECK_IMPLIES(labels == nullptr, own_labels == nullptr); |
| |
| // Note: Since labels can only be used by 'break' and 'continue' |
| // statements, which themselves are only valid within blocks, |
| // iterations or 'switch' statements (i.e., BreakableStatements), |
| // labels can be simply ignored in all other cases; except for |
| // trivial labeled break statements 'label: break label' which is |
| // parsed into an empty statement. |
| switch (peek()) { |
| case Token::LBRACE: |
| return ParseBlock(labels, ok); |
| case Token::SEMICOLON: |
| Next(); |
| return factory()->NewEmptyStatement(kNoSourcePosition); |
| case Token::IF: |
| return ParseIfStatement(labels, ok); |
| case Token::DO: |
| return ParseDoWhileStatement(labels, own_labels, ok); |
| case Token::WHILE: |
| return ParseWhileStatement(labels, own_labels, ok); |
| case Token::FOR: |
| if (V8_UNLIKELY(is_async_function() && PeekAhead() == Token::AWAIT)) { |
| return ParseForAwaitStatement(labels, own_labels, ok); |
| } |
| return ParseForStatement(labels, own_labels, ok); |
| case Token::CONTINUE: |
| return ParseContinueStatement(ok); |
| case Token::BREAK: |
| return ParseBreakStatement(labels, ok); |
| case Token::RETURN: |
| return ParseReturnStatement(ok); |
| case Token::THROW: |
| return ParseThrowStatement(ok); |
| case Token::TRY: { |
| // It is somewhat complicated to have labels on try-statements. |
| // When breaking out of a try-finally statement, one must take |
| // great care not to treat it as a fall-through. It is much easier |
| // just to wrap the entire try-statement in a statement block and |
| // put the labels there. |
| if (labels == nullptr) return ParseTryStatement(ok); |
| BlockT result = factory()->NewBlock(1, false, labels); |
| typename Types::Target target(this, result); |
| StatementT statement = ParseTryStatement(CHECK_OK); |
| result->statements()->Add(statement, zone()); |
| return result; |
| } |
| case Token::WITH: |
| return ParseWithStatement(labels, ok); |
| case Token::SWITCH: |
| return ParseSwitchStatement(labels, ok); |
| case Token::FUNCTION: |
| // FunctionDeclaration only allowed as a StatementListItem, not in |
| // an arbitrary Statement position. Exceptions such as |
| // ES#sec-functiondeclarations-in-ifstatement-statement-clauses |
| // are handled by calling ParseScopedStatement rather than |
| // ParseStatement directly. |
| impl()->ReportMessageAt(scanner()->peek_location(), |
| is_strict(language_mode()) |
| ? MessageTemplate::kStrictFunction |
| : MessageTemplate::kSloppyFunction); |
| *ok = false; |
| return impl()->NullStatement(); |
| case Token::DEBUGGER: |
| return ParseDebuggerStatement(ok); |
| case Token::VAR: |
| return ParseVariableStatement(kStatement, nullptr, ok); |
| case Token::ASYNC: |
| if (!scanner()->HasLineTerminatorAfterNext() && |
| PeekAhead() == Token::FUNCTION) { |
| impl()->ReportMessageAt( |
| scanner()->peek_location(), |
| MessageTemplate::kAsyncFunctionInSingleStatementContext); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| V8_FALLTHROUGH; |
| default: |
| return ParseExpressionOrLabelledStatement(labels, own_labels, |
| allow_function, ok); |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::BlockT ParserBase<Impl>::ParseBlock( |
| ZonePtrList<const AstRawString>* labels, bool* ok) { |
| // Block :: |
| // '{' StatementList '}' |
| |
| // Construct block expecting 16 statements. |
| BlockT body = factory()->NewBlock(16, false, labels); |
| |
| // Parse the statements and collect escaping labels. |
| Expect(Token::LBRACE, CHECK_OK_CUSTOM(NullStatement)); |
| { |
| BlockState block_state(zone(), &scope_); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| typename Types::Target target(this, body); |
| |
| while (peek() != Token::RBRACE) { |
| StatementT stat = ParseStatementListItem(CHECK_OK_CUSTOM(NullStatement)); |
| if (!impl()->IsNull(stat) && !stat->IsEmptyStatement()) { |
| body->statements()->Add(stat, zone()); |
| } |
| } |
| |
| Expect(Token::RBRACE, CHECK_OK_CUSTOM(NullStatement)); |
| int end_pos = scanner()->location().end_pos; |
| scope()->set_end_position(end_pos); |
| impl()->RecordBlockSourceRange(body, end_pos); |
| body->set_scope(scope()->FinalizeBlockScope()); |
| } |
| return body; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseScopedStatement( |
| ZonePtrList<const AstRawString>* labels, bool* ok) { |
| if (is_strict(language_mode()) || peek() != Token::FUNCTION) { |
| return ParseStatement(labels, nullptr, ok); |
| } else { |
| // Make a block around the statement for a lexical binding |
| // is introduced by a FunctionDeclaration. |
| BlockState block_state(zone(), &scope_); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| BlockT block = factory()->NewBlock(1, false); |
| StatementT body = ParseFunctionDeclaration(CHECK_OK); |
| block->statements()->Add(body, zone()); |
| scope()->set_end_position(scanner()->location().end_pos); |
| block->set_scope(scope()->FinalizeBlockScope()); |
| return block; |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseVariableStatement( |
| VariableDeclarationContext var_context, |
| ZonePtrList<const AstRawString>* names, bool* ok) { |
| // VariableStatement :: |
| // VariableDeclarations ';' |
| |
| // The scope of a var declared variable anywhere inside a function |
| // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). Thus we can |
| // transform a source-level var declaration into a (Function) Scope |
| // declaration, and rewrite the source-level initialization into an assignment |
| // statement. We use a block to collect multiple assignments. |
| // |
| // We mark the block as initializer block because we don't want the |
| // rewriter to add a '.result' assignment to such a block (to get compliant |
| // behavior for code such as print(eval('var x = 7')), and for cosmetic |
| // reasons when pretty-printing. Also, unless an assignment (initialization) |
| // is inside an initializer block, it is ignored. |
| |
| DeclarationParsingResult parsing_result; |
| StatementT result = |
| ParseVariableDeclarations(var_context, &parsing_result, names, CHECK_OK); |
| ExpectSemicolon(CHECK_OK); |
| return result; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseDebuggerStatement( |
| bool* ok) { |
| // In ECMA-262 'debugger' is defined as a reserved keyword. In some browser |
| // contexts this is used as a statement which invokes the debugger as i a |
| // break point is present. |
| // DebuggerStatement :: |
| // 'debugger' ';' |
| |
| int pos = peek_position(); |
| Expect(Token::DEBUGGER, CHECK_OK); |
| ExpectSemicolon(CHECK_OK); |
| return factory()->NewDebuggerStatement(pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseExpressionOrLabelledStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, |
| AllowLabelledFunctionStatement allow_function, bool* ok) { |
| // ExpressionStatement | LabelledStatement :: |
| // Expression ';' |
| // Identifier ':' Statement |
| // |
| // ExpressionStatement[Yield] : |
| // [lookahead notin {{, function, class, let [}] Expression[In, ?Yield] ; |
| |
| int pos = peek_position(); |
| |
| switch (peek()) { |
| case Token::FUNCTION: |
| case Token::LBRACE: |
| UNREACHABLE(); // Always handled by the callers. |
| case Token::CLASS: |
| ReportUnexpectedToken(Next()); |
| *ok = false; |
| return impl()->NullStatement(); |
| case Token::LET: { |
| Token::Value next_next = PeekAhead(); |
| // "let" followed by either "[", "{" or an identifier means a lexical |
| // declaration, which should not appear here. |
| // However, ASI may insert a line break before an identifier or a brace. |
| if (next_next != Token::LBRACK && |
| ((next_next != Token::LBRACE && next_next != Token::IDENTIFIER) || |
| scanner_->HasLineTerminatorAfterNext())) { |
| break; |
| } |
| impl()->ReportMessageAt(scanner()->peek_location(), |
| MessageTemplate::kUnexpectedLexicalDeclaration); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| default: |
| break; |
| } |
| |
| bool starts_with_identifier = peek_any_identifier(); |
| ExpressionT expr = ParseExpression(true, CHECK_OK); |
| if (peek() == Token::COLON && starts_with_identifier && |
| impl()->IsIdentifier(expr)) { |
| // The whole expression was a single identifier, and not, e.g., |
| // something starting with an identifier or a parenthesized identifier. |
| impl()->DeclareLabel(&labels, &own_labels, |
| impl()->AsIdentifierExpression(expr), CHECK_OK); |
| Consume(Token::COLON); |
| // ES#sec-labelled-function-declarations Labelled Function Declarations |
| if (peek() == Token::FUNCTION && is_sloppy(language_mode()) && |
| allow_function == kAllowLabelledFunctionStatement) { |
| return ParseFunctionDeclaration(ok); |
| } |
| return ParseStatement(labels, own_labels, allow_function, ok); |
| } |
| |
| // If we have an extension, we allow a native function declaration. |
| // A native function declaration starts with "native function" with |
| // no line-terminator between the two words. |
| if (extension_ != nullptr && peek() == Token::FUNCTION && |
| !scanner()->HasLineTerminatorBeforeNext() && impl()->IsNative(expr) && |
| !scanner()->literal_contains_escapes()) { |
| return ParseNativeDeclaration(ok); |
| } |
| |
| // Parsed expression statement, followed by semicolon. |
| ExpectSemicolon(CHECK_OK); |
| return factory()->NewExpressionStatement(expr, pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseIfStatement( |
| ZonePtrList<const AstRawString>* labels, bool* ok) { |
| // IfStatement :: |
| // 'if' '(' Expression ')' Statement ('else' Statement)? |
| |
| int pos = peek_position(); |
| Expect(Token::IF, CHECK_OK); |
| Expect(Token::LPAREN, CHECK_OK); |
| ExpressionT condition = ParseExpression(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| SourceRange then_range, else_range; |
| StatementT then_statement = impl()->NullStatement(); |
| { |
| SourceRangeScope range_scope(scanner(), &then_range); |
| then_statement = ParseScopedStatement(labels, CHECK_OK); |
| } |
| |
| StatementT else_statement = impl()->NullStatement(); |
| if (Check(Token::ELSE)) { |
| else_range = SourceRange::ContinuationOf(then_range); |
| else_statement = ParseScopedStatement(labels, CHECK_OK); |
| else_range.end = scanner_->location().end_pos; |
| } else { |
| else_statement = factory()->NewEmptyStatement(kNoSourcePosition); |
| } |
| StatementT stmt = |
| factory()->NewIfStatement(condition, then_statement, else_statement, pos); |
| impl()->RecordIfStatementSourceRange(stmt, then_range, else_range); |
| return stmt; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseContinueStatement( |
| bool* ok) { |
| // ContinueStatement :: |
| // 'continue' Identifier? ';' |
| |
| int pos = peek_position(); |
| Expect(Token::CONTINUE, CHECK_OK); |
| IdentifierT label = impl()->NullIdentifier(); |
| Token::Value tok = peek(); |
| if (!scanner()->HasLineTerminatorBeforeNext() && tok != Token::SEMICOLON && |
| tok != Token::RBRACE && tok != Token::EOS) { |
| // ECMA allows "eval" or "arguments" as labels even in strict mode. |
| label = ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK); |
| } |
| typename Types::IterationStatement target = |
| impl()->LookupContinueTarget(label, CHECK_OK); |
| if (impl()->IsNull(target)) { |
| // Illegal continue statement. |
| MessageTemplate::Template message = MessageTemplate::kIllegalContinue; |
| typename Types::BreakableStatement breakable_target = |
| impl()->LookupBreakTarget(label, CHECK_OK); |
| if (impl()->IsNull(label)) { |
| message = MessageTemplate::kNoIterationStatement; |
| } else if (impl()->IsNull(breakable_target)) { |
| message = MessageTemplate::kUnknownLabel; |
| } |
| ReportMessage(message, label); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| ExpectSemicolon(CHECK_OK); |
| StatementT stmt = factory()->NewContinueStatement(target, pos); |
| impl()->RecordJumpStatementSourceRange(stmt, scanner_->location().end_pos); |
| return stmt; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseBreakStatement( |
| ZonePtrList<const AstRawString>* labels, bool* ok) { |
| // BreakStatement :: |
| // 'break' Identifier? ';' |
| |
| int pos = peek_position(); |
| Expect(Token::BREAK, CHECK_OK); |
| IdentifierT label = impl()->NullIdentifier(); |
| Token::Value tok = peek(); |
| if (!scanner()->HasLineTerminatorBeforeNext() && tok != Token::SEMICOLON && |
| tok != Token::RBRACE && tok != Token::EOS) { |
| // ECMA allows "eval" or "arguments" as labels even in strict mode. |
| label = ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK); |
| } |
| // Parse labeled break statements that target themselves into |
| // empty statements, e.g. 'l1: l2: l3: break l2;' |
| if (!impl()->IsNull(label) && impl()->ContainsLabel(labels, label)) { |
| ExpectSemicolon(CHECK_OK); |
| return factory()->NewEmptyStatement(pos); |
| } |
| typename Types::BreakableStatement target = |
| impl()->LookupBreakTarget(label, CHECK_OK); |
| if (impl()->IsNull(target)) { |
| // Illegal break statement. |
| MessageTemplate::Template message = MessageTemplate::kIllegalBreak; |
| if (!impl()->IsNull(label)) { |
| message = MessageTemplate::kUnknownLabel; |
| } |
| ReportMessage(message, label); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| ExpectSemicolon(CHECK_OK); |
| StatementT stmt = factory()->NewBreakStatement(target, pos); |
| impl()->RecordJumpStatementSourceRange(stmt, scanner_->location().end_pos); |
| return stmt; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseReturnStatement( |
| bool* ok) { |
| // ReturnStatement :: |
| // 'return' [no line terminator] Expression? ';' |
| |
| // Consume the return token. It is necessary to do that before |
| // reporting any errors on it, because of the way errors are |
| // reported (underlining). |
| Expect(Token::RETURN, CHECK_OK); |
| Scanner::Location loc = scanner()->location(); |
| |
| switch (GetDeclarationScope()->scope_type()) { |
| case SCRIPT_SCOPE: |
| case EVAL_SCOPE: |
| case MODULE_SCOPE: |
| impl()->ReportMessageAt(loc, MessageTemplate::kIllegalReturn); |
| *ok = false; |
| return impl()->NullStatement(); |
| default: |
| break; |
| } |
| |
| Token::Value tok = peek(); |
| ExpressionT return_value = impl()->NullExpression(); |
| if (scanner()->HasLineTerminatorBeforeNext() || tok == Token::SEMICOLON || |
| tok == Token::RBRACE || tok == Token::EOS) { |
| if (IsDerivedConstructor(function_state_->kind())) { |
| return_value = impl()->ThisExpression(loc.beg_pos); |
| } |
| } else { |
| return_value = ParseExpression(true, CHECK_OK); |
| } |
| ExpectSemicolon(CHECK_OK); |
| return_value = impl()->RewriteReturn(return_value, loc.beg_pos); |
| int continuation_pos = scanner_->location().end_pos; |
| StatementT stmt = |
| BuildReturnStatement(return_value, loc.beg_pos, continuation_pos); |
| impl()->RecordJumpStatementSourceRange(stmt, scanner_->location().end_pos); |
| return stmt; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseWithStatement( |
| ZonePtrList<const AstRawString>* labels, bool* ok) { |
| // WithStatement :: |
| // 'with' '(' Expression ')' Statement |
| |
| Expect(Token::WITH, CHECK_OK); |
| int pos = position(); |
| |
| if (is_strict(language_mode())) { |
| ReportMessage(MessageTemplate::kStrictWith); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| |
| Expect(Token::LPAREN, CHECK_OK); |
| ExpressionT expr = ParseExpression(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| Scope* with_scope = NewScope(WITH_SCOPE); |
| StatementT body = impl()->NullStatement(); |
| { |
| BlockState block_state(&scope_, with_scope); |
| with_scope->set_start_position(scanner()->peek_location().beg_pos); |
| body = ParseStatement(labels, nullptr, CHECK_OK); |
| with_scope->set_end_position(scanner()->location().end_pos); |
| } |
| return factory()->NewWithStatement(with_scope, expr, body, pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseDoWhileStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok) { |
| // DoStatement :: |
| // 'do' Statement 'while' '(' Expression ')' ';' |
| |
| auto loop = |
| factory()->NewDoWhileStatement(labels, own_labels, peek_position()); |
| typename Types::Target target(this, loop); |
| |
| SourceRange body_range; |
| StatementT body = impl()->NullStatement(); |
| |
| Expect(Token::DO, CHECK_OK); |
| { |
| SourceRangeScope range_scope(scanner(), &body_range); |
| body = ParseStatement(nullptr, nullptr, CHECK_OK); |
| } |
| Expect(Token::WHILE, CHECK_OK); |
| Expect(Token::LPAREN, CHECK_OK); |
| |
| ExpressionT cond = ParseExpression(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| // Allow do-statements to be terminated with and without |
| // semi-colons. This allows code such as 'do;while(0)return' to |
| // parse, which would not be the case if we had used the |
| // ExpectSemicolon() functionality here. |
| Check(Token::SEMICOLON); |
| |
| loop->Initialize(cond, body); |
| impl()->RecordIterationStatementSourceRange(loop, body_range); |
| |
| return loop; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseWhileStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok) { |
| // WhileStatement :: |
| // 'while' '(' Expression ')' Statement |
| |
| auto loop = factory()->NewWhileStatement(labels, own_labels, peek_position()); |
| typename Types::Target target(this, loop); |
| |
| SourceRange body_range; |
| StatementT body = impl()->NullStatement(); |
| |
| Expect(Token::WHILE, CHECK_OK); |
| Expect(Token::LPAREN, CHECK_OK); |
| ExpressionT cond = ParseExpression(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| { |
| SourceRangeScope range_scope(scanner(), &body_range); |
| body = ParseStatement(nullptr, nullptr, CHECK_OK); |
| } |
| |
| loop->Initialize(cond, body); |
| impl()->RecordIterationStatementSourceRange(loop, body_range); |
| |
| return loop; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseThrowStatement( |
| bool* ok) { |
| // ThrowStatement :: |
| // 'throw' Expression ';' |
| |
| Expect(Token::THROW, CHECK_OK); |
| int pos = position(); |
| if (scanner()->HasLineTerminatorBeforeNext()) { |
| ReportMessage(MessageTemplate::kNewlineAfterThrow); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| ExpressionT exception = ParseExpression(true, CHECK_OK); |
| ExpectSemicolon(CHECK_OK); |
| |
| StatementT stmt = impl()->NewThrowStatement(exception, pos); |
| impl()->RecordThrowSourceRange(stmt, scanner_->location().end_pos); |
| |
| return stmt; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseSwitchStatement( |
| ZonePtrList<const AstRawString>* labels, bool* ok) { |
| // SwitchStatement :: |
| // 'switch' '(' Expression ')' '{' CaseClause* '}' |
| // CaseClause :: |
| // 'case' Expression ':' StatementList |
| // 'default' ':' StatementList |
| |
| int switch_pos = peek_position(); |
| |
| Expect(Token::SWITCH, CHECK_OK); |
| Expect(Token::LPAREN, CHECK_OK); |
| ExpressionT tag = ParseExpression(true, CHECK_OK); |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| auto switch_statement = |
| factory()->NewSwitchStatement(labels, tag, switch_pos); |
| |
| { |
| BlockState cases_block_state(zone(), &scope_); |
| scope()->set_start_position(switch_pos); |
| scope()->SetNonlinear(); |
| typename Types::Target target(this, switch_statement); |
| |
| bool default_seen = false; |
| Expect(Token::LBRACE, CHECK_OK); |
| while (peek() != Token::RBRACE) { |
| // An empty label indicates the default case. |
| ExpressionT label = impl()->NullExpression(); |
| SourceRange clause_range; |
| SourceRangeScope range_scope(scanner(), &clause_range); |
| if (Check(Token::CASE)) { |
| label = ParseExpression(true, CHECK_OK); |
| } else { |
| Expect(Token::DEFAULT, CHECK_OK); |
| if (default_seen) { |
| ReportMessage(MessageTemplate::kMultipleDefaultsInSwitch); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| default_seen = true; |
| } |
| Expect(Token::COLON, CHECK_OK); |
| StatementListT statements = impl()->NewStatementList(5); |
| while (peek() != Token::CASE && peek() != Token::DEFAULT && |
| peek() != Token::RBRACE) { |
| StatementT stat = ParseStatementListItem(CHECK_OK); |
| statements->Add(stat, zone()); |
| } |
| auto clause = factory()->NewCaseClause(label, statements); |
| impl()->RecordCaseClauseSourceRange(clause, range_scope.Finalize()); |
| switch_statement->cases()->Add(clause, zone()); |
| } |
| Expect(Token::RBRACE, CHECK_OK); |
| |
| int end_position = scanner()->location().end_pos; |
| scope()->set_end_position(end_position); |
| impl()->RecordSwitchStatementSourceRange(switch_statement, end_position); |
| Scope* switch_scope = scope()->FinalizeBlockScope(); |
| if (switch_scope != nullptr) { |
| return impl()->RewriteSwitchStatement(switch_statement, switch_scope); |
| } |
| return switch_statement; |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseTryStatement( |
| bool* ok) { |
| // TryStatement :: |
| // 'try' Block Catch |
| // 'try' Block Finally |
| // 'try' Block Catch Finally |
| // |
| // Catch :: |
| // 'catch' '(' Identifier ')' Block |
| // |
| // Finally :: |
| // 'finally' Block |
| |
| Expect(Token::TRY, CHECK_OK); |
| int pos = position(); |
| |
| BlockT try_block = ParseBlock(nullptr, CHECK_OK); |
| |
| CatchInfo catch_info(this); |
| |
| if (peek() != Token::CATCH && peek() != Token::FINALLY) { |
| ReportMessage(MessageTemplate::kNoCatchOrFinally); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| |
| SourceRange catch_range, finally_range; |
| |
| BlockT catch_block = impl()->NullStatement(); |
| { |
| SourceRangeScope catch_range_scope(scanner(), &catch_range); |
| if (Check(Token::CATCH)) { |
| bool has_binding; |
| has_binding = Check(Token::LPAREN); |
| |
| if (has_binding) { |
| catch_info.scope = NewScope(CATCH_SCOPE); |
| catch_info.scope->set_start_position(scanner()->location().beg_pos); |
| |
| { |
| BlockState catch_block_state(&scope_, catch_info.scope); |
| |
| catch_block = factory()->NewBlock(16, false); |
| |
| // Create a block scope to hold any lexical declarations created |
| // as part of destructuring the catch parameter. |
| { |
| BlockState catch_variable_block_state(zone(), &scope_); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| |
| // This does not simply call ParsePrimaryExpression to avoid |
| // ExpressionFromIdentifier from being called in the first |
| // branch, which would introduce an unresolved symbol and mess |
| // with arrow function names. |
| if (peek_any_identifier()) { |
| catch_info.name = |
| ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK); |
| } else { |
| ExpressionClassifier pattern_classifier(this); |
| catch_info.pattern = ParsePrimaryExpression(CHECK_OK); |
| ValidateBindingPattern(CHECK_OK); |
| } |
| |
| Expect(Token::RPAREN, CHECK_OK); |
| impl()->RewriteCatchPattern(&catch_info, CHECK_OK); |
| if (!impl()->IsNull(catch_info.init_block)) { |
| catch_block->statements()->Add(catch_info.init_block, zone()); |
| } |
| |
| catch_info.inner_block = ParseBlock(nullptr, CHECK_OK); |
| catch_block->statements()->Add(catch_info.inner_block, zone()); |
| impl()->ValidateCatchBlock(catch_info, CHECK_OK); |
| scope()->set_end_position(scanner()->location().end_pos); |
| catch_block->set_scope(scope()->FinalizeBlockScope()); |
| } |
| } |
| |
| catch_info.scope->set_end_position(scanner()->location().end_pos); |
| } else { |
| catch_block = ParseBlock(nullptr, CHECK_OK); |
| } |
| } |
| } |
| |
| BlockT finally_block = impl()->NullStatement(); |
| DCHECK(peek() == Token::FINALLY || !impl()->IsNull(catch_block)); |
| { |
| SourceRangeScope range_scope(scanner(), &finally_range); |
| if (Check(Token::FINALLY)) { |
| finally_block = ParseBlock(nullptr, CHECK_OK); |
| } |
| } |
| |
| return impl()->RewriteTryStatement(try_block, catch_block, catch_range, |
| finally_block, finally_range, catch_info, |
| pos); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok) { |
| // Either a standard for loop |
| // for (<init>; <cond>; <next>) { ... } |
| // or a for-each loop |
| // for (<each> of|in <iterable>) { ... } |
| // |
| // We parse a declaration/expression after the 'for (' and then read the first |
| // expression/declaration before we know if this is a for or a for-each. |
| |
| int stmt_pos = peek_position(); |
| ForInfo for_info(this); |
| |
| Expect(Token::FOR, CHECK_OK); |
| Expect(Token::LPAREN, CHECK_OK); |
| |
| if (peek() == Token::CONST || (peek() == Token::LET && IsNextLetKeyword())) { |
| // The initializer contains lexical declarations, |
| // so create an in-between scope. |
| BlockState for_state(zone(), &scope_); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| |
| // Also record whether inner functions or evals are found inside |
| // this loop, as this information is used to simplify the desugaring |
| // if none are found. |
| typename FunctionState::FunctionOrEvalRecordingScope recording_scope( |
| function_state_); |
| |
| // Create an inner block scope which will be the parent scope of scopes |
| // possibly created by ParseVariableDeclarations. |
| Scope* inner_block_scope = NewScope(BLOCK_SCOPE); |
| { |
| BlockState inner_state(&scope_, inner_block_scope); |
| ParseVariableDeclarations(kForStatement, &for_info.parsing_result, |
| nullptr, CHECK_OK); |
| } |
| DCHECK(IsLexicalVariableMode(for_info.parsing_result.descriptor.mode)); |
| for_info.position = scanner()->location().beg_pos; |
| |
| if (CheckInOrOf(&for_info.mode)) { |
| scope()->set_is_hidden(); |
| return ParseForEachStatementWithDeclarations( |
| stmt_pos, &for_info, labels, own_labels, inner_block_scope, ok); |
| } |
| |
| Expect(Token::SEMICOLON, CHECK_OK); |
| |
| StatementT init = impl()->BuildInitializationBlock( |
| &for_info.parsing_result, &for_info.bound_names, CHECK_OK); |
| |
| Scope* finalized = inner_block_scope->FinalizeBlockScope(); |
| // No variable declarations will have been created in inner_block_scope. |
| DCHECK_NULL(finalized); |
| USE(finalized); |
| return ParseStandardForLoopWithLexicalDeclarations( |
| stmt_pos, init, &for_info, labels, own_labels, ok); |
| } |
| |
| StatementT init = impl()->NullStatement(); |
| if (peek() == Token::VAR) { |
| ParseVariableDeclarations(kForStatement, &for_info.parsing_result, nullptr, |
| CHECK_OK); |
| DCHECK_EQ(for_info.parsing_result.descriptor.mode, VariableMode::kVar); |
| for_info.position = scanner()->location().beg_pos; |
| |
| if (CheckInOrOf(&for_info.mode)) { |
| return ParseForEachStatementWithDeclarations(stmt_pos, &for_info, labels, |
| own_labels, nullptr, ok); |
| } |
| |
| init = impl()->BuildInitializationBlock(&for_info.parsing_result, nullptr, |
| CHECK_OK); |
| } else if (peek() != Token::SEMICOLON) { |
| // The initializer does not contain declarations. |
| int lhs_beg_pos = peek_position(); |
| ExpressionClassifier classifier(this); |
| ExpressionT expression = ParseExpressionCoverGrammar(false, CHECK_OK); |
| int lhs_end_pos = scanner()->location().end_pos; |
| |
| bool is_for_each = CheckInOrOf(&for_info.mode); |
| bool is_destructuring = is_for_each && (expression->IsArrayLiteral() || |
| expression->IsObjectLiteral()); |
| |
| if (is_destructuring) { |
| ValidateAssignmentPattern(CHECK_OK); |
| } else { |
| ValidateExpression(CHECK_OK); |
| } |
| |
| if (is_for_each) { |
| return ParseForEachStatementWithoutDeclarations( |
| stmt_pos, expression, lhs_beg_pos, lhs_end_pos, &for_info, labels, |
| own_labels, ok); |
| } |
| // Initializer is just an expression. |
| init = factory()->NewExpressionStatement(expression, lhs_beg_pos); |
| } |
| |
| Expect(Token::SEMICOLON, CHECK_OK); |
| |
| // Standard 'for' loop, we have parsed the initializer at this point. |
| ExpressionT cond = impl()->NullExpression(); |
| StatementT next = impl()->NullStatement(); |
| StatementT body = impl()->NullStatement(); |
| ForStatementT loop = ParseStandardForLoop(stmt_pos, labels, own_labels, &cond, |
| &next, &body, CHECK_OK); |
| loop->Initialize(init, cond, next, body); |
| return loop; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseForEachStatementWithDeclarations( |
| int stmt_pos, ForInfo* for_info, ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, Scope* inner_block_scope, |
| bool* ok) { |
| // Just one declaration followed by in/of. |
| if (for_info->parsing_result.declarations.size() != 1) { |
| impl()->ReportMessageAt(for_info->parsing_result.bindings_loc, |
| MessageTemplate::kForInOfLoopMultiBindings, |
| ForEachStatement::VisitModeString(for_info->mode)); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| if (for_info->parsing_result.first_initializer_loc.IsValid() && |
| (is_strict(language_mode()) || |
| for_info->mode == ForEachStatement::ITERATE || |
| IsLexicalVariableMode(for_info->parsing_result.descriptor.mode) || |
| !impl()->IsIdentifier( |
| for_info->parsing_result.declarations[0].pattern))) { |
| impl()->ReportMessageAt(for_info->parsing_result.first_initializer_loc, |
| MessageTemplate::kForInOfLoopInitializer, |
| ForEachStatement::VisitModeString(for_info->mode)); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| |
| // Reset the declaration_kind to ensure proper processing during declaration. |
| for_info->parsing_result.descriptor.declaration_kind = |
| DeclarationDescriptor::FOR_EACH; |
| |
| BlockT init_block = impl()->RewriteForVarInLegacy(*for_info); |
| |
| auto loop = factory()->NewForEachStatement(for_info->mode, labels, own_labels, |
| stmt_pos); |
| typename Types::Target target(this, loop); |
| |
| ExpressionT enumerable = impl()->NullExpression(); |
| if (for_info->mode == ForEachStatement::ITERATE) { |
| ExpressionClassifier classifier(this); |
| enumerable = ParseAssignmentExpression(true, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| } else { |
| enumerable = ParseExpression(true, CHECK_OK); |
| } |
| |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| Scope* for_scope = nullptr; |
| if (inner_block_scope != nullptr) { |
| for_scope = inner_block_scope->outer_scope(); |
| DCHECK(for_scope == scope()); |
| inner_block_scope->set_start_position(scanner()->location().beg_pos); |
| } |
| |
| ExpressionT each_variable = impl()->NullExpression(); |
| BlockT body_block = impl()->NullStatement(); |
| { |
| BlockState block_state( |
| &scope_, inner_block_scope != nullptr ? inner_block_scope : scope_); |
| |
| SourceRange body_range; |
| SourceRangeScope range_scope(scanner(), &body_range); |
| |
| StatementT body = ParseStatement(nullptr, nullptr, CHECK_OK); |
| impl()->RecordIterationStatementSourceRange(loop, range_scope.Finalize()); |
| |
| impl()->DesugarBindingInForEachStatement(for_info, &body_block, |
| &each_variable, CHECK_OK); |
| body_block->statements()->Add(body, zone()); |
| |
| if (inner_block_scope != nullptr) { |
| inner_block_scope->set_end_position(scanner()->location().end_pos); |
| body_block->set_scope(inner_block_scope->FinalizeBlockScope()); |
| } |
| } |
| |
| StatementT final_loop = impl()->InitializeForEachStatement( |
| loop, each_variable, enumerable, body_block); |
| |
| init_block = impl()->CreateForEachStatementTDZ(init_block, *for_info, ok); |
| |
| if (for_scope != nullptr) { |
| for_scope->set_end_position(scanner()->location().end_pos); |
| for_scope = for_scope->FinalizeBlockScope(); |
| } |
| |
| // Parsed for-in loop w/ variable declarations. |
| if (!impl()->IsNull(init_block)) { |
| init_block->statements()->Add(final_loop, zone()); |
| init_block->set_scope(for_scope); |
| return init_block; |
| } |
| |
| DCHECK_NULL(for_scope); |
| return final_loop; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseForEachStatementWithoutDeclarations( |
| int stmt_pos, ExpressionT expression, int lhs_beg_pos, int lhs_end_pos, |
| ForInfo* for_info, ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok) { |
| // Initializer is reference followed by in/of. |
| if (!expression->IsArrayLiteral() && !expression->IsObjectLiteral()) { |
| expression = CheckAndRewriteReferenceExpression( |
| expression, lhs_beg_pos, lhs_end_pos, MessageTemplate::kInvalidLhsInFor, |
| kSyntaxError, CHECK_OK); |
| } |
| |
| auto loop = factory()->NewForEachStatement(for_info->mode, labels, own_labels, |
| stmt_pos); |
| typename Types::Target target(this, loop); |
| |
| ExpressionT enumerable = impl()->NullExpression(); |
| if (for_info->mode == ForEachStatement::ITERATE) { |
| ExpressionClassifier classifier(this); |
| enumerable = ParseAssignmentExpression(true, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| } else { |
| enumerable = ParseExpression(true, CHECK_OK); |
| } |
| |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| StatementT body = impl()->NullStatement(); |
| { |
| SourceRange body_range; |
| SourceRangeScope range_scope(scanner(), &body_range); |
| |
| body = ParseStatement(nullptr, nullptr, CHECK_OK); |
| impl()->RecordIterationStatementSourceRange(loop, range_scope.Finalize()); |
| } |
| return impl()->InitializeForEachStatement(loop, expression, enumerable, body); |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT |
| ParserBase<Impl>::ParseStandardForLoopWithLexicalDeclarations( |
| int stmt_pos, StatementT init, ForInfo* for_info, |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok) { |
| // The condition and the next statement of the for loop must be parsed |
| // in a new scope. |
| Scope* inner_scope = NewScope(BLOCK_SCOPE); |
| ForStatementT loop = impl()->NullStatement(); |
| ExpressionT cond = impl()->NullExpression(); |
| StatementT next = impl()->NullStatement(); |
| StatementT body = impl()->NullStatement(); |
| { |
| BlockState block_state(&scope_, inner_scope); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| loop = ParseStandardForLoop(stmt_pos, labels, own_labels, &cond, &next, |
| &body, CHECK_OK); |
| scope()->set_end_position(scanner()->location().end_pos); |
| } |
| |
| scope()->set_end_position(scanner()->location().end_pos); |
| if (for_info->bound_names.length() > 0 && |
| function_state_->contains_function_or_eval()) { |
| scope()->set_is_hidden(); |
| return impl()->DesugarLexicalBindingsInForStatement( |
| loop, init, cond, next, body, inner_scope, *for_info, ok); |
| } else { |
| inner_scope = inner_scope->FinalizeBlockScope(); |
| DCHECK_NULL(inner_scope); |
| USE(inner_scope); |
| } |
| |
| Scope* for_scope = scope()->FinalizeBlockScope(); |
| if (for_scope != nullptr) { |
| // Rewrite a for statement of the form |
| // for (const x = i; c; n) b |
| // |
| // into |
| // |
| // { |
| // const x = i; |
| // for (; c; n) b |
| // } |
| // |
| DCHECK(!impl()->IsNull(init)); |
| BlockT block = factory()->NewBlock(2, false); |
| block->statements()->Add(init, zone()); |
| block->statements()->Add(loop, zone()); |
| block->set_scope(for_scope); |
| loop->Initialize(impl()->NullStatement(), cond, next, body); |
| return block; |
| } |
| |
| loop->Initialize(init, cond, next, body); |
| return loop; |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::ForStatementT ParserBase<Impl>::ParseStandardForLoop( |
| int stmt_pos, ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, ExpressionT* cond, |
| StatementT* next, StatementT* body, bool* ok) { |
| ForStatementT loop = factory()->NewForStatement(labels, own_labels, stmt_pos); |
| typename Types::Target target(this, loop); |
| |
| if (peek() != Token::SEMICOLON) { |
| *cond = ParseExpression(true, CHECK_OK); |
| } |
| Expect(Token::SEMICOLON, CHECK_OK); |
| |
| if (peek() != Token::RPAREN) { |
| ExpressionT exp = ParseExpression(true, CHECK_OK); |
| *next = factory()->NewExpressionStatement(exp, exp->position()); |
| } |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| SourceRange body_range; |
| { |
| SourceRangeScope range_scope(scanner(), &body_range); |
| *body = ParseStatement(nullptr, nullptr, CHECK_OK); |
| } |
| impl()->RecordIterationStatementSourceRange(loop, body_range); |
| |
| return loop; |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::MarkLoopVariableAsAssigned( |
| Scope* scope, Variable* var, |
| typename DeclarationDescriptor::Kind declaration_kind) { |
| if (!IsLexicalVariableMode(var->mode()) && |
| (!scope->is_function_scope() || |
| declaration_kind == DeclarationDescriptor::FOR_EACH)) { |
| var->set_maybe_assigned(); |
| } |
| } |
| |
| template <typename Impl> |
| typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseForAwaitStatement( |
| ZonePtrList<const AstRawString>* labels, |
| ZonePtrList<const AstRawString>* own_labels, bool* ok) { |
| // for await '(' ForDeclaration of AssignmentExpression ')' |
| DCHECK(is_async_function()); |
| |
| int stmt_pos = peek_position(); |
| |
| ForInfo for_info(this); |
| for_info.mode = ForEachStatement::ITERATE; |
| |
| // Create an in-between scope for let-bound iteration variables. |
| BlockState for_state(zone(), &scope_); |
| Expect(Token::FOR, CHECK_OK); |
| Expect(Token::AWAIT, CHECK_OK); |
| Expect(Token::LPAREN, CHECK_OK); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| scope()->set_is_hidden(); |
| |
| auto loop = factory()->NewForOfStatement(labels, own_labels, stmt_pos); |
| typename Types::Target target(this, loop); |
| |
| ExpressionT each_variable = impl()->NullExpression(); |
| |
| bool has_declarations = false; |
| Scope* inner_block_scope = NewScope(BLOCK_SCOPE); |
| |
| if (peek() == Token::VAR || peek() == Token::CONST || |
| (peek() == Token::LET && IsNextLetKeyword())) { |
| // The initializer contains declarations |
| // 'for' 'await' '(' ForDeclaration 'of' AssignmentExpression ')' |
| // Statement |
| // 'for' 'await' '(' 'var' ForBinding 'of' AssignmentExpression ')' |
| // Statement |
| has_declarations = true; |
| |
| { |
| BlockState inner_state(&scope_, inner_block_scope); |
| ParseVariableDeclarations(kForStatement, &for_info.parsing_result, |
| nullptr, CHECK_OK); |
| } |
| for_info.position = scanner()->location().beg_pos; |
| |
| // Only a single declaration is allowed in for-await-of loops |
| if (for_info.parsing_result.declarations.size() != 1) { |
| impl()->ReportMessageAt(for_info.parsing_result.bindings_loc, |
| MessageTemplate::kForInOfLoopMultiBindings, |
| "for-await-of"); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| |
| // for-await-of's declarations do not permit initializers. |
| if (for_info.parsing_result.first_initializer_loc.IsValid()) { |
| impl()->ReportMessageAt(for_info.parsing_result.first_initializer_loc, |
| MessageTemplate::kForInOfLoopInitializer, |
| "for-await-of"); |
| *ok = false; |
| return impl()->NullStatement(); |
| } |
| } else { |
| // The initializer does not contain declarations. |
| // 'for' 'await' '(' LeftHandSideExpression 'of' AssignmentExpression ')' |
| // Statement |
| int lhs_beg_pos = peek_position(); |
| BlockState inner_state(&scope_, inner_block_scope); |
| ExpressionClassifier classifier(this); |
| ExpressionT lhs = each_variable = ParseLeftHandSideExpression(CHECK_OK); |
| int lhs_end_pos = scanner()->location().end_pos; |
| |
| if (lhs->IsArrayLiteral() || lhs->IsObjectLiteral()) { |
| ValidateAssignmentPattern(CHECK_OK); |
| } else { |
| ValidateExpression(CHECK_OK); |
| each_variable = CheckAndRewriteReferenceExpression( |
| lhs, lhs_beg_pos, lhs_end_pos, MessageTemplate::kInvalidLhsInFor, |
| kSyntaxError, CHECK_OK); |
| } |
| } |
| |
| ExpectContextualKeyword(Token::OF, CHECK_OK); |
| int each_keyword_pos = scanner()->location().beg_pos; |
| |
| const bool kAllowIn = true; |
| ExpressionT iterable = impl()->NullExpression(); |
| |
| { |
| ExpressionClassifier classifier(this); |
| iterable = ParseAssignmentExpression(kAllowIn, CHECK_OK); |
| ValidateExpression(CHECK_OK); |
| } |
| |
| Expect(Token::RPAREN, CHECK_OK); |
| |
| StatementT body = impl()->NullStatement(); |
| { |
| BlockState block_state(&scope_, inner_block_scope); |
| scope()->set_start_position(scanner()->location().beg_pos); |
| |
| SourceRange body_range; |
| SourceRangeScope range_scope(scanner(), &body_range); |
| |
| body = ParseStatement(nullptr, nullptr, CHECK_OK); |
| scope()->set_end_position(scanner()->location().end_pos); |
| impl()->RecordIterationStatementSourceRange(loop, range_scope.Finalize()); |
| |
| if (has_declarations) { |
| BlockT body_block = impl()->NullStatement(); |
| impl()->DesugarBindingInForEachStatement(&for_info, &body_block, |
| &each_variable, CHECK_OK); |
| body_block->statements()->Add(body, zone()); |
| body_block->set_scope(scope()->FinalizeBlockScope()); |
| body = body_block; |
| } else { |
| Scope* block_scope = scope()->FinalizeBlockScope(); |
| DCHECK_NULL(block_scope); |
| USE(block_scope); |
| } |
| } |
| const bool finalize = true; |
| StatementT final_loop = impl()->InitializeForOfStatement( |
| loop, each_variable, iterable, body, finalize, IteratorType::kAsync, |
| each_keyword_pos); |
| |
| if (!has_declarations) { |
| Scope* for_scope = scope()->FinalizeBlockScope(); |
| DCHECK_NULL(for_scope); |
| USE(for_scope); |
| return final_loop; |
| } |
| |
| BlockT init_block = |
| impl()->CreateForEachStatementTDZ(impl()->NullStatement(), for_info, ok); |
| |
| scope()->set_end_position(scanner()->location().end_pos); |
| Scope* for_scope = scope()->FinalizeBlockScope(); |
| // Parsed for-in loop w/ variable declarations. |
| if (!impl()->IsNull(init_block)) { |
| init_block->statements()->Add(final_loop, zone()); |
| init_block->set_scope(for_scope); |
| return init_block; |
| } |
| DCHECK_NULL(for_scope); |
| return final_loop; |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ObjectLiteralChecker::CheckDuplicateProto( |
| Token::Value property) { |
| if (property == Token::SMI || property == Token::NUMBER) return; |
| |
| if (IsProto()) { |
| if (has_seen_proto_) { |
| this->parser()->classifier()->RecordExpressionError( |
| this->scanner()->location(), MessageTemplate::kDuplicateProto); |
| return; |
| } |
| has_seen_proto_ = true; |
| } |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ClassLiteralChecker::CheckClassMethodName( |
| Token::Value property, PropertyKind type, bool is_generator, bool is_async, |
| bool is_static, bool* ok) { |
| DCHECK(type == PropertyKind::kMethodProperty || |
| type == PropertyKind::kAccessorProperty); |
| |
| if (property == Token::SMI || property == Token::NUMBER) return; |
| |
| if (is_static) { |
| if (IsPrototype()) { |
| this->parser()->ReportMessage(MessageTemplate::kStaticPrototype); |
| *ok = false; |
| return; |
| } |
| } else if (IsConstructor()) { |
| if (is_generator || is_async || type == PropertyKind::kAccessorProperty) { |
| MessageTemplate::Template msg = |
| is_generator ? MessageTemplate::kConstructorIsGenerator |
| : is_async ? MessageTemplate::kConstructorIsAsync |
| : MessageTemplate::kConstructorIsAccessor; |
| this->parser()->ReportMessage(msg); |
| *ok = false; |
| return; |
| } |
| if (has_seen_constructor_) { |
| this->parser()->ReportMessage(MessageTemplate::kDuplicateConstructor); |
| *ok = false; |
| return; |
| } |
| has_seen_constructor_ = true; |
| return; |
| } |
| } |
| |
| template <typename Impl> |
| void ParserBase<Impl>::ClassLiteralChecker::CheckClassFieldName(bool is_static, |
| bool* ok) { |
| if (is_static && IsPrototype()) { |
| this->parser()->ReportMessage(MessageTemplate::kStaticPrototype); |
| *ok = false; |
| return; |
| } |
| |
| if (IsConstructor() || IsPrivateConstructor()) { |
| this->parser()->ReportMessage(MessageTemplate::kConstructorClassField); |
| *ok = false; |
| return; |
| } |
| } |
| |
| #undef CHECK_OK |
| #undef CHECK_OK_CUSTOM |
| #undef CHECK_OK_VOID |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_PARSING_PARSER_BASE_H_ |