From 4c8df58e088570cf97a7ad807cf4f1190a380453 Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Sat, 19 Jun 2021 14:43:09 +0200 Subject: [PATCH] LibJS: Rename Parser::m_parser_state => m_state Also remove the "m_" prefix from all the public data members. --- Userland/Libraries/LibJS/Parser.cpp | 487 ++++++++++++++-------------- Userland/Libraries/LibJS/Parser.h | 42 +-- 2 files changed, 265 insertions(+), 264 deletions(-) diff --git a/Userland/Libraries/LibJS/Parser.cpp b/Userland/Libraries/LibJS/Parser.cpp index 36a23e12d6..651efb53d7 100644 --- a/Userland/Libraries/LibJS/Parser.cpp +++ b/Userland/Libraries/LibJS/Parser.cpp @@ -39,21 +39,21 @@ public: , m_mask(mask) { if (m_mask & Var) - m_parser.m_parser_state.m_var_scopes.append(NonnullRefPtrVector()); + m_parser.m_state.var_scopes.append(NonnullRefPtrVector()); if (m_mask & Let) - m_parser.m_parser_state.m_let_scopes.append(NonnullRefPtrVector()); + m_parser.m_state.let_scopes.append(NonnullRefPtrVector()); if (m_mask & Function) - m_parser.m_parser_state.m_function_scopes.append(NonnullRefPtrVector()); + m_parser.m_state.function_scopes.append(NonnullRefPtrVector()); } ~ScopePusher() { if (m_mask & Var) - m_parser.m_parser_state.m_var_scopes.take_last(); + m_parser.m_state.var_scopes.take_last(); if (m_mask & Let) - m_parser.m_parser_state.m_let_scopes.take_last(); + m_parser.m_state.let_scopes.take_last(); if (m_mask & Function) - m_parser.m_parser_state.m_function_scopes.take_last(); + m_parser.m_state.function_scopes.take_last(); } Parser& m_parser; @@ -174,14 +174,14 @@ private: constexpr OperatorPrecedenceTable g_operator_precedence; -Parser::ParserState::ParserState(Lexer lexer) - : m_lexer(move(lexer)) - , m_current_token(m_lexer.next()) +Parser::ParserState::ParserState(Lexer l) + : lexer(move(l)) + , current_token(lexer.next()) { } Parser::Parser(Lexer lexer) - : m_parser_state(move(lexer)) + : m_state(move(lexer)) { } @@ -242,9 +242,9 @@ NonnullRefPtr Parser::parse_program() if (statement_is_use_strict_directive(statement)) { if (first) { program->set_strict_mode(); - m_parser_state.m_strict_mode = true; + m_state.strict_mode = true; } - if (m_parser_state.m_string_legacy_octal_escape_sequence_in_scope) + if (m_state.string_legacy_octal_escape_sequence_in_scope) syntax_error("Octal escape sequence in string literal not allowed in strict mode"); } } else { @@ -253,10 +253,10 @@ NonnullRefPtr Parser::parse_program() } first = false; } - if (m_parser_state.m_var_scopes.size() == 1) { - program->add_variables(m_parser_state.m_var_scopes.last()); - program->add_variables(m_parser_state.m_let_scopes.last()); - program->add_functions(m_parser_state.m_function_scopes.last()); + if (m_state.var_scopes.size() == 1) { + program->add_variables(m_state.var_scopes.last()); + program->add_variables(m_state.let_scopes.last()); + program->add_functions(m_state.function_scopes.last()); } else { syntax_error("Unclosed scope"); } @@ -267,12 +267,12 @@ NonnullRefPtr Parser::parse_program() NonnullRefPtr Parser::parse_declaration() { auto rule_start = push_start(); - switch (m_parser_state.m_current_token.type()) { + switch (m_state.current_token.type()) { case TokenType::Class: return parse_class_declaration(); case TokenType::Function: { auto declaration = parse_function_node(); - m_parser_state.m_function_scopes.last().append(declaration); + m_state.function_scopes.last().append(declaration); return declaration; } case TokenType::Let: @@ -281,14 +281,14 @@ NonnullRefPtr Parser::parse_declaration() default: expected("declaration"); consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); } } NonnullRefPtr Parser::parse_statement() { auto rule_start = push_start(); - switch (m_parser_state.m_current_token.type()) { + switch (m_state.current_token.type()) { case TokenType::CurlyOpen: return parse_block_statement(); case TokenType::Return: @@ -314,14 +314,14 @@ NonnullRefPtr Parser::parse_statement() case TokenType::While: return parse_while_statement(); case TokenType::With: - if (m_parser_state.m_strict_mode) + if (m_state.strict_mode) syntax_error("'with' statement not allowed in strict mode"); return parse_with_statement(); case TokenType::Debugger: return parse_debugger_statement(); case TokenType::Semicolon: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); default: if (match(TokenType::Identifier)) { auto result = try_parse_labelled_statement(); @@ -333,18 +333,18 @@ NonnullRefPtr Parser::parse_statement() syntax_error("Function declaration not allowed in single-statement context"); auto expr = parse_expression(0); consume_or_insert_semicolon(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(expr)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(expr)); } expected("statement"); consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); } } RefPtr Parser::try_parse_arrow_function_expression(bool expect_parens) { save_state(); - m_parser_state.m_var_scopes.append(NonnullRefPtrVector()); + m_state.var_scopes.append(NonnullRefPtrVector()); auto rule_start = push_start(); ArmedScopeGuard state_rollback_guard = [&] { @@ -359,9 +359,9 @@ RefPtr Parser::try_parse_arrow_function_expression(bool expe // parameter, maybe a trailing comma. If we have a new syntax error afterwards we // check if it's about a wrong token (something like duplicate parameter name must // not abort), know parsing failed and rollback the parser state. - auto previous_syntax_errors = m_parser_state.m_errors.size(); + auto previous_syntax_errors = m_state.errors.size(); parameters = parse_formal_parameters(function_length, FunctionNodeParseOptions::IsArrowFunction); - if (m_parser_state.m_errors.size() > previous_syntax_errors && m_parser_state.m_errors[previous_syntax_errors].message.starts_with("Unexpected token")) + if (m_state.errors.size() > previous_syntax_errors && m_state.errors[previous_syntax_errors].message.starts_with("Unexpected token")) return nullptr; if (!match(TokenType::ParenClose)) return nullptr; @@ -374,7 +374,7 @@ RefPtr Parser::try_parse_arrow_function_expression(bool expe } // If there's a newline between the closing paren and arrow it's not a valid arrow function, // ASI should kick in instead (it'll then fail with "Unexpected token Arrow") - if (m_parser_state.m_current_token.trivia_contains_line_terminator()) + if (m_state.current_token.trivia_contains_line_terminator()) return nullptr; if (!match(TokenType::Arrow)) return nullptr; @@ -383,17 +383,17 @@ RefPtr Parser::try_parse_arrow_function_expression(bool expe if (function_length == -1) function_length = parameters.size(); - m_parser_state.function_parameters.append(parameters); + m_state.function_parameters.append(parameters); - auto old_labels_in_scope = move(m_parser_state.m_labels_in_scope); + auto old_labels_in_scope = move(m_state.labels_in_scope); ScopeGuard guard([&]() { - m_parser_state.m_labels_in_scope = move(old_labels_in_scope); + m_state.labels_in_scope = move(old_labels_in_scope); }); bool is_strict = false; auto function_body_result = [&]() -> RefPtr { - TemporaryChange change(m_parser_state.m_in_arrow_function_context, true); + TemporaryChange change(m_state.in_arrow_function_context, true); if (match(TokenType::CurlyOpen)) { // Parse a function body with statements return parse_block_statement(is_strict); @@ -406,7 +406,7 @@ RefPtr Parser::try_parse_arrow_function_expression(bool expe // Esprima generates a single "ArrowFunctionExpression" // with a "body" property. auto return_expression = parse_expression(2); - auto return_block = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + auto return_block = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); return_block->append({ m_filename, rule_start.position(), position() }, move(return_expression)); return return_block; } @@ -414,15 +414,15 @@ RefPtr Parser::try_parse_arrow_function_expression(bool expe return nullptr; }(); - m_parser_state.function_parameters.take_last(); + m_state.function_parameters.take_last(); if (!function_body_result.is_null()) { state_rollback_guard.disarm(); discard_saved_state(); auto body = function_body_result.release_nonnull(); return create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, "", move(body), - move(parameters), function_length, m_parser_state.m_var_scopes.take_last(), FunctionKind::Regular, is_strict, true); + { m_state.current_token.filename(), rule_start.position(), position() }, "", move(body), + move(parameters), function_length, m_state.var_scopes.take_last(), FunctionKind::Regular, is_strict, true); } return nullptr; @@ -443,9 +443,9 @@ RefPtr Parser::try_parse_labelled_statement() if (!match_statement()) return {}; - m_parser_state.m_labels_in_scope.set(identifier); + m_state.labels_in_scope.set(identifier); auto statement = parse_statement(); - m_parser_state.m_labels_in_scope.remove(identifier); + m_state.labels_in_scope.remove(identifier); statement->set_label(identifier); state_rollback_guard.disarm(); @@ -472,20 +472,20 @@ RefPtr Parser::try_parse_new_target_expression() state_rollback_guard.disarm(); discard_saved_state(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, MetaProperty::Type::NewTarget); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, MetaProperty::Type::NewTarget); } NonnullRefPtr Parser::parse_class_declaration() { auto rule_start = push_start(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, parse_class_expression(true)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, parse_class_expression(true)); } NonnullRefPtr Parser::parse_class_expression(bool expect_class_name) { auto rule_start = push_start(); // Classes are always in strict mode. - TemporaryChange strict_mode_rollback(m_parser_state.m_strict_mode, true); + TemporaryChange strict_mode_rollback(m_state.strict_mode, true); consume(TokenType::Class); @@ -517,13 +517,13 @@ NonnullRefPtr Parser::parse_class_expression(bool expect_class_ if (match_property_key()) { StringView name; - if (match(TokenType::Identifier) && m_parser_state.m_current_token.value() == "static") { + if (match(TokenType::Identifier) && m_state.current_token.value() == "static") { consume(); is_static = true; } if (match(TokenType::Identifier)) { - auto identifier_name = m_parser_state.m_current_token.value(); + auto identifier_name = m_state.current_token.value(); if (identifier_name == "get") { method_kind = ClassMethod::Kind::Getter; @@ -535,10 +535,10 @@ NonnullRefPtr Parser::parse_class_expression(bool expect_class_ } if (match_property_key()) { - switch (m_parser_state.m_current_token.type()) { + switch (m_state.current_token.type()) { case TokenType::Identifier: name = consume().value(); - property_key = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, name); + property_key = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, name); break; case TokenType::StringLiteral: { auto string_literal = parse_string_literal(consume()); @@ -578,7 +578,7 @@ NonnullRefPtr Parser::parse_class_expression(bool expect_class_ if (is_constructor) { constructor = move(function); } else if (!property_key.is_null()) { - methods.append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, property_key.release_nonnull(), move(function), method_kind, is_static)); + methods.append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, property_key.release_nonnull(), move(function), method_kind, is_static)); } else { syntax_error("No key for class method"); } @@ -591,28 +591,28 @@ NonnullRefPtr Parser::parse_class_expression(bool expect_class_ consume(TokenType::CurlyClose); if (constructor.is_null()) { - auto constructor_body = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + auto constructor_body = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); if (!super_class.is_null()) { // Set constructor to the result of parsing the source text // constructor(... args){ super (...args);} auto super_call = create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, - create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }), - Vector { CallExpression::Argument { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, "args"), true } }); - constructor_body->append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(super_call))); - constructor_body->add_variables(m_parser_state.m_var_scopes.last()); + { m_state.current_token.filename(), rule_start.position(), position() }, + create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }), + Vector { CallExpression::Argument { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, "args"), true } }); + constructor_body->append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(super_call))); + constructor_body->add_variables(m_state.var_scopes.last()); constructor = create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), + { m_state.current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), Vector { FunctionNode::Parameter { FlyString { "args" }, nullptr, true } }, 0, NonnullRefPtrVector(), FunctionKind::Regular, true); } else { constructor = create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), + { m_state.current_token.filename(), rule_start.position(), position() }, class_name, move(constructor_body), Vector {}, 0, NonnullRefPtrVector(), FunctionKind::Regular, true); } } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(class_name), move(constructor), move(super_class), move(methods)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(class_name), move(constructor), move(super_class), move(methods)); } Parser::PrimaryExpressionParseResult Parser::parse_primary_expression() @@ -621,7 +621,7 @@ Parser::PrimaryExpressionParseResult Parser::parse_primary_expression() if (match_unary_prefixed_expression()) return { parse_unary_prefixed_expression() }; - switch (m_parser_state.m_current_token.type()) { + switch (m_state.current_token.type()) { case TokenType::ParenOpen: { auto paren_position = position(); consume(TokenType::ParenOpen); @@ -641,14 +641,14 @@ Parser::PrimaryExpressionParseResult Parser::parse_primary_expression() } case TokenType::This: consume(); - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }) }; case TokenType::Class: return { parse_class_expression(false) }; case TokenType::Super: consume(); - if (!m_parser_state.m_allow_super_property_lookup) + if (!m_state.allow_super_property_lookup) syntax_error("'super' keyword unexpected here"); - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }) }; case TokenType::Identifier: { read_as_identifier:; if (!try_parse_arrow_function_expression_failed_at_position(position())) { @@ -660,9 +660,9 @@ Parser::PrimaryExpressionParseResult Parser::parse_primary_expression() } auto string = consume().value(); Optional argument_index; - if (!m_parser_state.function_parameters.is_empty()) { + if (!m_state.function_parameters.is_empty()) { size_t i = 0; - for (auto& parameter : m_parser_state.function_parameters.last()) { + for (auto& parameter : m_state.function_parameters.last()) { parameter.binding.visit( [&](FlyString const& name) { if (name == string) { @@ -674,19 +674,20 @@ Parser::PrimaryExpressionParseResult Parser::parse_primary_expression() ++i; } } - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, string, argument_index) }; + argument_index = {}; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, string, argument_index) }; } case TokenType::NumericLiteral: - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume_and_validate_numeric_literal().double_value()) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume_and_validate_numeric_literal().double_value()) }; case TokenType::BigIntLiteral: - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume().value()) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume().value()) }; case TokenType::BoolLiteral: - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume().bool_value()) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume().bool_value()) }; case TokenType::StringLiteral: return { parse_string_literal(consume()) }; case TokenType::NullLiteral: consume(); - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }) }; case TokenType::CurlyOpen: return { parse_object_expression() }; case TokenType::Function: @@ -701,20 +702,20 @@ Parser::PrimaryExpressionParseResult Parser::parse_primary_expression() auto new_start = position(); auto new_target_result = try_parse_new_target_expression(); if (!new_target_result.is_null()) { - if (!m_parser_state.m_in_function_context) + if (!m_state.in_function_context) syntax_error("'new.target' not allowed outside of a function", new_start); return { new_target_result.release_nonnull() }; } return { parse_new_expression() }; } case TokenType::Yield: - if (!m_parser_state.m_in_generator_function_context) + if (!m_state.in_generator_function_context) goto read_as_identifier; return { parse_yield_expression(), false }; default: expected("primary expression"); consume(); - return { create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }) }; + return { create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }) }; } } @@ -738,15 +739,15 @@ NonnullRefPtr Parser::parse_regexp_literal() seen_flags.set(*flag.characters_without_null_termination()); } } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, pattern, flags); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, pattern, flags); } NonnullRefPtr Parser::parse_unary_prefixed_expression() { auto rule_start = push_start(); - auto precedence = g_operator_precedence.get(m_parser_state.m_current_token.type()); - auto associativity = operator_associativity(m_parser_state.m_current_token.type()); - switch (m_parser_state.m_current_token.type()) { + auto precedence = g_operator_precedence.get(m_state.current_token.type()); + auto associativity = operator_associativity(m_state.current_token.type()); + switch (m_state.current_token.type()) { case TokenType::PlusPlus: { consume(); auto rhs_start = position(); @@ -755,7 +756,7 @@ NonnullRefPtr Parser::parse_unary_prefixed_expression() // other engines throw ReferenceError for ++foo() if (!is(*rhs) && !is(*rhs)) syntax_error(String::formatted("Right-hand side of prefix increment operator must be identifier or member expression, got {}", rhs->class_name()), rhs_start); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UpdateOp::Increment, move(rhs), true); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UpdateOp::Increment, move(rhs), true); } case TokenType::MinusMinus: { consume(); @@ -765,33 +766,33 @@ NonnullRefPtr Parser::parse_unary_prefixed_expression() // other engines throw ReferenceError for --foo() if (!is(*rhs) && !is(*rhs)) syntax_error(String::formatted("Right-hand side of prefix decrement operator must be identifier or member expression, got {}", rhs->class_name()), rhs_start); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UpdateOp::Decrement, move(rhs), true); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UpdateOp::Decrement, move(rhs), true); } case TokenType::ExclamationMark: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::Not, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::Not, parse_expression(precedence, associativity)); case TokenType::Tilde: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::BitwiseNot, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::BitwiseNot, parse_expression(precedence, associativity)); case TokenType::Plus: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::Plus, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::Plus, parse_expression(precedence, associativity)); case TokenType::Minus: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::Minus, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::Minus, parse_expression(precedence, associativity)); case TokenType::Typeof: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::Typeof, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::Typeof, parse_expression(precedence, associativity)); case TokenType::Void: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::Void, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::Void, parse_expression(precedence, associativity)); case TokenType::Delete: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UnaryOp::Delete, parse_expression(precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UnaryOp::Delete, parse_expression(precedence, associativity)); default: expected("primary expression"); consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); } } @@ -801,9 +802,9 @@ NonnullRefPtr Parser::parse_property_key() if (match(TokenType::StringLiteral)) { return parse_string_literal(consume()); } else if (match(TokenType::NumericLiteral)) { - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume().double_value()); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume().double_value()); } else if (match(TokenType::BigIntLiteral)) { - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume().value()); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume().value()); } else if (match(TokenType::BracketOpen)) { consume(TokenType::BracketOpen); auto result = parse_expression(2); @@ -812,7 +813,7 @@ NonnullRefPtr Parser::parse_property_key() } else { if (!match_identifier_name()) expected("IdentifierName"); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume().value()); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume().value()); } } @@ -838,7 +839,7 @@ NonnullRefPtr Parser::parse_object_expression() if (match(TokenType::TripleDot)) { consume(); property_name = parse_expression(4); - properties.append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, *property_name, nullptr, ObjectProperty::Type::Spread, false)); + properties.append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, *property_name, nullptr, ObjectProperty::Type::Spread, false)); if (!match(TokenType::Comma)) break; consume(TokenType::Comma); @@ -859,8 +860,8 @@ NonnullRefPtr Parser::parse_object_expression() property_type = ObjectProperty::Type::Setter; property_name = parse_property_key(); } else { - property_name = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, identifier); - property_value = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, identifier); + property_name = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, identifier); + property_value = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, identifier); } } else { property_name = parse_property_key(); @@ -884,7 +885,7 @@ NonnullRefPtr Parser::parse_object_expression() if (function_kind == FunctionKind::Generator) parse_options |= FunctionNodeParseOptions::IsGeneratorFunction; auto function = parse_function_node(parse_options); - properties.append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, *property_name, function, property_type, true)); + properties.append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, *property_name, function, property_type, true)); } else if (match(TokenType::Colon)) { if (!property_name) { syntax_error("Expected a property name"); @@ -892,9 +893,9 @@ NonnullRefPtr Parser::parse_object_expression() continue; } consume(); - properties.append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, *property_name, parse_expression(2), property_type, false)); + properties.append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, *property_name, parse_expression(2), property_type, false)); } else if (property_name && property_value) { - properties.append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, *property_name, *property_value, property_type, false)); + properties.append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, *property_name, *property_value, property_type, false)); } else { syntax_error("Expected a property"); skip_to_next_property(); @@ -907,7 +908,7 @@ NonnullRefPtr Parser::parse_object_expression() } consume(TokenType::CurlyClose); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, properties); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, properties); } NonnullRefPtr Parser::parse_array_expression() @@ -921,7 +922,7 @@ NonnullRefPtr Parser::parse_array_expression() if (match(TokenType::TripleDot)) { consume(TokenType::TripleDot); - expression = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, parse_expression(2)); + expression = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, parse_expression(2)); } else if (match_expression()) { expression = parse_expression(2); } @@ -933,7 +934,7 @@ NonnullRefPtr Parser::parse_array_expression() } consume(TokenType::BracketClose); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(elements)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(elements)); } NonnullRefPtr Parser::parse_string_literal(const Token& token, bool in_template_literal) @@ -944,10 +945,10 @@ NonnullRefPtr Parser::parse_string_literal(const Token& token, bo if (status != Token::StringValueStatus::Ok) { String message; if (status == Token::StringValueStatus::LegacyOctalEscapeSequence) { - m_parser_state.m_string_legacy_octal_escape_sequence_in_scope = true; + m_state.string_legacy_octal_escape_sequence_in_scope = true; if (in_template_literal) message = "Octal escape sequence not allowed in template literal"; - else if (m_parser_state.m_strict_mode) + else if (m_state.strict_mode) message = "Octal escape sequence in string literal not allowed in strict mode"; } else if (status == Token::StringValueStatus::MalformedHexEscape || status == Token::StringValueStatus::MalformedUnicodeEscape) { auto type = status == Token::StringValueStatus::MalformedUnicodeEscape ? "unicode" : "hexadecimal"; @@ -964,7 +965,7 @@ NonnullRefPtr Parser::parse_string_literal(const Token& token, bo auto is_use_strict_directive = !in_template_literal && (token.value() == "'use strict'" || token.value() == "\"use strict\""); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, string, is_use_strict_directive); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, string, is_use_strict_directive); } NonnullRefPtr Parser::parse_template_literal(bool is_tagged) @@ -976,7 +977,7 @@ NonnullRefPtr Parser::parse_template_literal(bool is_tagged) NonnullRefPtrVector raw_strings; auto append_empty_string = [this, &rule_start, &expressions, &raw_strings, is_tagged]() { - auto string_literal = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, ""); + auto string_literal = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, ""); expressions.append(string_literal); if (is_tagged) raw_strings.append(string_literal); @@ -990,18 +991,18 @@ NonnullRefPtr Parser::parse_template_literal(bool is_tagged) auto token = consume(); expressions.append(parse_string_literal(token, true)); if (is_tagged) - raw_strings.append(create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, token.value())); + raw_strings.append(create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, token.value())); } else if (match(TokenType::TemplateLiteralExprStart)) { consume(TokenType::TemplateLiteralExprStart); if (match(TokenType::TemplateLiteralExprEnd)) { syntax_error("Empty template literal expression block"); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, expressions); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, expressions); } expressions.append(parse_expression(0)); if (match(TokenType::UnterminatedTemplateLiteral)) { syntax_error("Unterminated template literal"); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, expressions); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, expressions); } consume(TokenType::TemplateLiteralExprEnd); @@ -1020,8 +1021,8 @@ NonnullRefPtr Parser::parse_template_literal(bool is_tagged) } if (is_tagged) - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, expressions, raw_strings); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, expressions); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, expressions, raw_strings); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, expressions); } NonnullRefPtr Parser::parse_expression(int min_precedence, Associativity associativity, const Vector& forbidden) @@ -1030,21 +1031,21 @@ NonnullRefPtr Parser::parse_expression(int min_precedence, Associati auto [expression, should_continue_parsing] = parse_primary_expression(); while (match(TokenType::TemplateLiteralStart)) { auto template_literal = parse_template_literal(true); - expression = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(expression), move(template_literal)); + expression = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(expression), move(template_literal)); } if (should_continue_parsing) { while (match_secondary_expression(forbidden)) { - int new_precedence = g_operator_precedence.get(m_parser_state.m_current_token.type()); + int new_precedence = g_operator_precedence.get(m_state.current_token.type()); if (new_precedence < min_precedence) break; if (new_precedence == min_precedence && associativity == Associativity::Left) break; - Associativity new_associativity = operator_associativity(m_parser_state.m_current_token.type()); + Associativity new_associativity = operator_associativity(m_state.current_token.type()); expression = parse_secondary_expression(move(expression), new_precedence, new_associativity); while (match(TokenType::TemplateLiteralStart)) { auto template_literal = parse_template_literal(true); - expression = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(expression), move(template_literal)); + expression = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(expression), move(template_literal)); } } } @@ -1055,7 +1056,7 @@ NonnullRefPtr Parser::parse_expression(int min_precedence, Associati consume(); expressions.append(parse_expression(2)); } - expression = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(expressions)); + expression = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(expressions)); } return expression; } @@ -1063,95 +1064,95 @@ NonnullRefPtr Parser::parse_expression(int min_precedence, Associati NonnullRefPtr Parser::parse_secondary_expression(NonnullRefPtr lhs, int min_precedence, Associativity associativity) { auto rule_start = push_start(); - switch (m_parser_state.m_current_token.type()) { + switch (m_state.current_token.type()) { case TokenType::Plus: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::Addition, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::Addition, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::PlusEquals: return parse_assignment_expression(AssignmentOp::AdditionAssignment, move(lhs), min_precedence, associativity); case TokenType::Minus: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::Subtraction, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::Subtraction, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::MinusEquals: return parse_assignment_expression(AssignmentOp::SubtractionAssignment, move(lhs), min_precedence, associativity); case TokenType::Asterisk: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::Multiplication, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::Multiplication, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::AsteriskEquals: return parse_assignment_expression(AssignmentOp::MultiplicationAssignment, move(lhs), min_precedence, associativity); case TokenType::Slash: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::Division, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::Division, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::SlashEquals: return parse_assignment_expression(AssignmentOp::DivisionAssignment, move(lhs), min_precedence, associativity); case TokenType::Percent: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::Modulo, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::Modulo, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::PercentEquals: return parse_assignment_expression(AssignmentOp::ModuloAssignment, move(lhs), min_precedence, associativity); case TokenType::DoubleAsterisk: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::Exponentiation, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::Exponentiation, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::DoubleAsteriskEquals: return parse_assignment_expression(AssignmentOp::ExponentiationAssignment, move(lhs), min_precedence, associativity); case TokenType::GreaterThan: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::GreaterThan, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::GreaterThan, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::GreaterThanEquals: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::GreaterThanEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::GreaterThanEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::LessThan: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::LessThan, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::LessThan, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::LessThanEquals: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::LessThanEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::LessThanEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::EqualsEqualsEquals: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::TypedEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::TypedEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ExclamationMarkEqualsEquals: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::TypedInequals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::TypedInequals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::EqualsEquals: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::AbstractEquals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::AbstractEquals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ExclamationMarkEquals: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::AbstractInequals, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::AbstractInequals, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::In: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::In, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::In, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::Instanceof: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::InstanceOf, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::InstanceOf, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::Ampersand: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::BitwiseAnd, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::BitwiseAnd, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::AmpersandEquals: return parse_assignment_expression(AssignmentOp::BitwiseAndAssignment, move(lhs), min_precedence, associativity); case TokenType::Pipe: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::BitwiseOr, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::BitwiseOr, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::PipeEquals: return parse_assignment_expression(AssignmentOp::BitwiseOrAssignment, move(lhs), min_precedence, associativity); case TokenType::Caret: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::BitwiseXor, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::BitwiseXor, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::CaretEquals: return parse_assignment_expression(AssignmentOp::BitwiseXorAssignment, move(lhs), min_precedence, associativity); case TokenType::ShiftLeft: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::LeftShift, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::LeftShift, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ShiftLeftEquals: return parse_assignment_expression(AssignmentOp::LeftShiftAssignment, move(lhs), min_precedence, associativity); case TokenType::ShiftRight: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::RightShift, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::RightShift, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::ShiftRightEquals: return parse_assignment_expression(AssignmentOp::RightShiftAssignment, move(lhs), min_precedence, associativity); case TokenType::UnsignedShiftRight: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, BinaryOp::UnsignedRightShift, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::UnsignedRightShift, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::UnsignedShiftRightEquals: return parse_assignment_expression(AssignmentOp::UnsignedRightShiftAssignment, move(lhs), min_precedence, associativity); case TokenType::ParenOpen: @@ -1162,10 +1163,10 @@ NonnullRefPtr Parser::parse_secondary_expression(NonnullRefPtr({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(lhs), create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, consume().value())); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(lhs), create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, consume().value())); case TokenType::BracketOpen: { consume(TokenType::BracketOpen); - auto expression = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(lhs), parse_expression(0), true); + auto expression = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(lhs), parse_expression(0), true); consume(TokenType::BracketClose); return expression; } @@ -1175,27 +1176,27 @@ NonnullRefPtr Parser::parse_secondary_expression(NonnullRefPtr(*lhs) && !is(*lhs)) syntax_error(String::formatted("Left-hand side of postfix increment operator must be identifier or member expression, got {}", lhs->class_name())); consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UpdateOp::Increment, move(lhs)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UpdateOp::Increment, move(lhs)); case TokenType::MinusMinus: // FIXME: Apparently for functions this should also not be enforced on a parser level, // other engines throw ReferenceError for foo()-- if (!is(*lhs) && !is(*lhs)) syntax_error(String::formatted("Left-hand side of postfix increment operator must be identifier or member expression, got {}", lhs->class_name())); consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, UpdateOp::Decrement, move(lhs)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, UpdateOp::Decrement, move(lhs)); case TokenType::DoubleAmpersand: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, LogicalOp::And, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, LogicalOp::And, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::DoubleAmpersandEquals: return parse_assignment_expression(AssignmentOp::AndAssignment, move(lhs), min_precedence, associativity); case TokenType::DoublePipe: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, LogicalOp::Or, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, LogicalOp::Or, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::DoublePipeEquals: return parse_assignment_expression(AssignmentOp::OrAssignment, move(lhs), min_precedence, associativity); case TokenType::DoubleQuestionMark: consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, LogicalOp::NullishCoalescing, move(lhs), parse_expression(min_precedence, associativity)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, LogicalOp::NullishCoalescing, move(lhs), parse_expression(min_precedence, associativity)); case TokenType::DoubleQuestionMarkEquals: return parse_assignment_expression(AssignmentOp::NullishAssignment, move(lhs), min_precedence, associativity); case TokenType::QuestionMark: @@ -1203,7 +1204,7 @@ NonnullRefPtr Parser::parse_secondary_expression(NonnullRefPtr({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); } } @@ -1229,11 +1230,11 @@ NonnullRefPtr Parser::parse_assignment_expression(Assignme consume(); if (!is(*lhs) && !is(*lhs) && !is(*lhs)) { syntax_error("Invalid left-hand side in assignment"); - } else if (m_parser_state.m_strict_mode && is(*lhs)) { + } else if (m_state.strict_mode && is(*lhs)) { auto name = static_cast(*lhs).string(); if (name == "eval" || name == "arguments") syntax_error(String::formatted("'{}' cannot be assigned to in strict mode code", name)); - } else if (m_parser_state.m_strict_mode && is(*lhs)) { + } else if (m_state.strict_mode && is(*lhs)) { syntax_error("Cannot assign to function call"); } auto rhs = parse_expression(min_precedence, associativity); @@ -1245,7 +1246,7 @@ NonnullRefPtr Parser::parse_assignment_expression(Assignme if (is(*ident)) static_cast(*rhs).set_name_if_possible(static_cast(*ident).string()); } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, assignment_op, move(lhs), move(rhs)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, assignment_op, move(lhs), move(rhs)); } NonnullRefPtr Parser::parse_identifier() @@ -1253,14 +1254,14 @@ NonnullRefPtr Parser::parse_identifier() auto identifier_start = position(); auto token = consume(TokenType::Identifier); return create_ast_node( - { m_parser_state.m_current_token.filename(), identifier_start, position() }, + { m_state.current_token.filename(), identifier_start, position() }, token.value()); } NonnullRefPtr Parser::parse_call_expression(NonnullRefPtr lhs) { auto rule_start = push_start(); - if (!m_parser_state.m_allow_super_constructor_call && is(*lhs)) + if (!m_state.allow_super_constructor_call && is(*lhs)) syntax_error("'super' keyword unexpected here"); consume(TokenType::ParenOpen); @@ -1281,7 +1282,7 @@ NonnullRefPtr Parser::parse_call_expression(NonnullRefPtr({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(lhs), move(arguments)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(lhs), move(arguments)); } NonnullRefPtr Parser::parse_new_expression() @@ -1309,7 +1310,7 @@ NonnullRefPtr Parser::parse_new_expression() consume(TokenType::ParenClose); } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(callee), move(arguments)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(callee), move(arguments)); } NonnullRefPtr Parser::parse_yield_expression() @@ -1319,7 +1320,7 @@ NonnullRefPtr Parser::parse_yield_expression() RefPtr argument; bool yield_from = false; - if (!m_parser_state.m_current_token.trivia_contains_line_terminator()) { + if (!m_state.current_token.trivia_contains_line_terminator()) { if (match(TokenType::Asterisk)) { consume(); yield_from = true; @@ -1329,29 +1330,29 @@ NonnullRefPtr Parser::parse_yield_expression() argument = parse_expression(0); } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(argument), yield_from); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(argument), yield_from); } NonnullRefPtr Parser::parse_return_statement() { auto rule_start = push_start(); - if (!m_parser_state.m_in_function_context && !m_parser_state.m_in_arrow_function_context) + if (!m_state.in_function_context && !m_state.in_arrow_function_context) syntax_error("'return' not allowed outside of a function"); consume(TokenType::Return); // Automatic semicolon insertion: terminate statement when return is followed by newline - if (m_parser_state.m_current_token.trivia_contains_line_terminator()) - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, nullptr); + if (m_state.current_token.trivia_contains_line_terminator()) + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, nullptr); if (match_expression()) { auto expression = parse_expression(0); consume_or_insert_semicolon(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(expression)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(expression)); } consume_or_insert_semicolon(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, nullptr); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, nullptr); } NonnullRefPtr Parser::parse_block_statement() @@ -1365,11 +1366,11 @@ NonnullRefPtr Parser::parse_block_statement(bool& is_strict) { auto rule_start = push_start(); ScopePusher scope(*this, ScopePusher::Let); - auto block = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + auto block = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); consume(TokenType::CurlyOpen); bool first = true; - bool initial_strict_mode_state = m_parser_state.m_strict_mode; + bool initial_strict_mode_state = m_state.strict_mode; if (initial_strict_mode_state) is_strict = true; @@ -1382,9 +1383,9 @@ NonnullRefPtr Parser::parse_block_statement(bool& is_strict) if (statement_is_use_strict_directive(statement)) { if (first && !initial_strict_mode_state) { is_strict = true; - m_parser_state.m_strict_mode = true; + m_state.strict_mode = true; } - if (m_parser_state.m_string_legacy_octal_escape_sequence_in_scope) + if (m_state.string_legacy_octal_escape_sequence_in_scope) syntax_error("Octal escape sequence in string literal not allowed in strict mode"); } } else { @@ -1393,11 +1394,11 @@ NonnullRefPtr Parser::parse_block_statement(bool& is_strict) } first = false; } - m_parser_state.m_strict_mode = initial_strict_mode_state; - m_parser_state.m_string_legacy_octal_escape_sequence_in_scope = false; + m_state.strict_mode = initial_strict_mode_state; + m_state.string_legacy_octal_escape_sequence_in_scope = false; consume(TokenType::CurlyClose); - block->add_variables(m_parser_state.m_let_scopes.last()); - block->add_functions(m_parser_state.m_function_scopes.last()); + block->add_variables(m_state.let_scopes.last()); + block->add_functions(m_state.function_scopes.last()); return block; } @@ -1407,8 +1408,8 @@ NonnullRefPtr Parser::parse_function_node(u8 parse_options) auto rule_start = push_start(); VERIFY(!(parse_options & FunctionNodeParseOptions::IsGetterFunction && parse_options & FunctionNodeParseOptions::IsSetterFunction)); - TemporaryChange super_property_access_rollback(m_parser_state.m_allow_super_property_lookup, !!(parse_options & FunctionNodeParseOptions::AllowSuperPropertyLookup)); - TemporaryChange super_constructor_call_rollback(m_parser_state.m_allow_super_constructor_call, !!(parse_options & FunctionNodeParseOptions::AllowSuperConstructorCall)); + TemporaryChange super_property_access_rollback(m_state.allow_super_property_lookup, !!(parse_options & FunctionNodeParseOptions::AllowSuperPropertyLookup)); + TemporaryChange super_constructor_call_rollback(m_state.allow_super_constructor_call, !!(parse_options & FunctionNodeParseOptions::AllowSuperConstructorCall)); ScopePusher scope(*this, ScopePusher::Var | ScopePusher::Function); @@ -1435,24 +1436,24 @@ NonnullRefPtr Parser::parse_function_node(u8 parse_options) if (function_length == -1) function_length = parameters.size(); - TemporaryChange change(m_parser_state.m_in_function_context, true); - TemporaryChange generator_change(m_parser_state.m_in_generator_function_context, m_parser_state.m_in_generator_function_context || is_generator); - auto old_labels_in_scope = move(m_parser_state.m_labels_in_scope); + TemporaryChange change(m_state.in_function_context, true); + TemporaryChange generator_change(m_state.in_generator_function_context, m_state.in_generator_function_context || is_generator); + auto old_labels_in_scope = move(m_state.labels_in_scope); ScopeGuard guard([&]() { - m_parser_state.m_labels_in_scope = move(old_labels_in_scope); + m_state.labels_in_scope = move(old_labels_in_scope); }); - m_parser_state.function_parameters.append(parameters); + m_state.function_parameters.append(parameters); bool is_strict = false; auto body = parse_block_statement(is_strict); - m_parser_state.function_parameters.take_last(); + m_state.function_parameters.take_last(); - body->add_variables(m_parser_state.m_var_scopes.last()); - body->add_functions(m_parser_state.m_function_scopes.last()); + body->add_variables(m_state.var_scopes.last()); + body->add_functions(m_state.function_scopes.last()); return create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, + { m_state.current_token.filename(), rule_start.position(), position() }, name, move(body), move(parameters), function_length, NonnullRefPtrVector(), is_generator ? FunctionKind::Generator : FunctionKind::Regular, is_strict); } @@ -1478,7 +1479,7 @@ Vector Parser::parse_formal_parameters(int& function_le String message; if (parse_options & FunctionNodeParseOptions::IsArrowFunction) message = String::formatted("Duplicate parameter '{}' not allowed in arrow function", parameter_name); - else if (m_parser_state.m_strict_mode) + else if (m_state.strict_mode) message = String::formatted("Duplicate parameter '{}' not allowed in strict mode", parameter_name); else if (has_default_parameter || match(TokenType::Equals)) message = String::formatted("Duplicate parameter '{}' not allowed in function with default parameter", parameter_name); @@ -1651,7 +1652,7 @@ NonnullRefPtr Parser::parse_variable_declaration(bool for_l auto rule_start = push_start(); DeclarationKind declaration_kind; - switch (m_parser_state.m_current_token.type()) { + switch (m_state.current_token.type()) { case TokenType::Var: declaration_kind = DeclarationKind::Var; break; @@ -1671,7 +1672,7 @@ NonnullRefPtr Parser::parse_variable_declaration(bool for_l Variant, NonnullRefPtr, Empty> target { Empty() }; if (match(TokenType::Identifier)) { target = create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, + { m_state.current_token.filename(), rule_start.position(), position() }, consume(TokenType::Identifier).value()); } else if (auto pattern = parse_binding_pattern()) { target = pattern.release_nonnull(); @@ -1701,7 +1702,7 @@ NonnullRefPtr Parser::parse_variable_declaration(bool for_l } declarations.append(create_ast_node( - { m_parser_state.m_current_token.filename(), rule_start.position(), position() }, + { m_state.current_token.filename(), rule_start.position(), position() }, move(target).downcast, NonnullRefPtr>(), move(init))); @@ -1714,11 +1715,11 @@ NonnullRefPtr Parser::parse_variable_declaration(bool for_l if (!for_loop_variable_declaration) consume_or_insert_semicolon(); - auto declaration = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, declaration_kind, move(declarations)); + auto declaration = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, declaration_kind, move(declarations)); if (declaration_kind == DeclarationKind::Var) - m_parser_state.m_var_scopes.last().append(declaration); + m_state.var_scopes.last().append(declaration); else - m_parser_state.m_let_scopes.last().append(declaration); + m_state.let_scopes.last().append(declaration); return declaration; } @@ -1728,14 +1729,14 @@ NonnullRefPtr Parser::parse_throw_statement() consume(TokenType::Throw); // Automatic semicolon insertion: terminate statement when throw is followed by newline - if (m_parser_state.m_current_token.trivia_contains_line_terminator()) { + if (m_state.current_token.trivia_contains_line_terminator()) { syntax_error("No line break is allowed between 'throw' and its expression"); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() })); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() })); } auto expression = parse_expression(0); consume_or_insert_semicolon(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(expression)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(expression)); } NonnullRefPtr Parser::parse_break_statement() @@ -1746,39 +1747,39 @@ NonnullRefPtr Parser::parse_break_statement() if (match(TokenType::Semicolon)) { consume(); } else { - if (match(TokenType::Identifier) && !m_parser_state.m_current_token.trivia_contains_line_terminator()) { + if (match(TokenType::Identifier) && !m_state.current_token.trivia_contains_line_terminator()) { target_label = consume().value(); - if (!m_parser_state.m_labels_in_scope.contains(target_label)) + if (!m_state.labels_in_scope.contains(target_label)) syntax_error(String::formatted("Label '{}' not found", target_label)); } consume_or_insert_semicolon(); } - if (target_label.is_null() && !m_parser_state.m_in_break_context) + if (target_label.is_null() && !m_state.in_break_context) syntax_error("Unlabeled 'break' not allowed outside of a loop or switch statement"); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, target_label); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, target_label); } NonnullRefPtr Parser::parse_continue_statement() { auto rule_start = push_start(); - if (!m_parser_state.m_in_continue_context) + if (!m_state.in_continue_context) syntax_error("'continue' not allow outside of a loop"); consume(TokenType::Continue); FlyString target_label; if (match(TokenType::Semicolon)) { consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, target_label); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, target_label); } - if (match(TokenType::Identifier) && !m_parser_state.m_current_token.trivia_contains_line_terminator()) { + if (match(TokenType::Identifier) && !m_state.current_token.trivia_contains_line_terminator()) { target_label = consume().value(); - if (!m_parser_state.m_labels_in_scope.contains(target_label)) + if (!m_state.labels_in_scope.contains(target_label)) syntax_error(String::formatted("Label '{}' not found", target_label)); } consume_or_insert_semicolon(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, target_label); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, target_label); } NonnullRefPtr Parser::parse_conditional_expression(NonnullRefPtr test) @@ -1788,7 +1789,7 @@ NonnullRefPtr Parser::parse_conditional_expression(Nonnul auto consequent = parse_expression(2); consume(TokenType::Colon); auto alternate = parse_expression(2); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(test), move(consequent), move(alternate)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(test), move(consequent), move(alternate)); } NonnullRefPtr Parser::parse_try_statement() @@ -1811,7 +1812,7 @@ NonnullRefPtr Parser::parse_try_statement() if (!handler && !finalizer) syntax_error("try statement must have a 'catch' or 'finally' clause"); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(block), move(handler), move(finalizer)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(block), move(handler), move(finalizer)); } NonnullRefPtr Parser::parse_do_while_statement() @@ -1820,8 +1821,8 @@ NonnullRefPtr Parser::parse_do_while_statement() consume(TokenType::Do); auto body = [&]() -> NonnullRefPtr { - TemporaryChange break_change(m_parser_state.m_in_break_context, true); - TemporaryChange continue_change(m_parser_state.m_in_continue_context, true); + TemporaryChange break_change(m_state.in_break_context, true); + TemporaryChange continue_change(m_state.in_continue_context, true); return parse_statement(); }(); @@ -1836,7 +1837,7 @@ NonnullRefPtr Parser::parse_do_while_statement() if (match(TokenType::Semicolon)) consume(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(test), move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(test), move(body)); } NonnullRefPtr Parser::parse_while_statement() @@ -1849,11 +1850,11 @@ NonnullRefPtr Parser::parse_while_statement() consume(TokenType::ParenClose); - TemporaryChange break_change(m_parser_state.m_in_break_context, true); - TemporaryChange continue_change(m_parser_state.m_in_continue_context, true); + TemporaryChange break_change(m_state.in_break_context, true); + TemporaryChange continue_change(m_state.in_continue_context, true); auto body = parse_statement(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(test), move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(test), move(body)); } NonnullRefPtr Parser::parse_switch_statement() @@ -1881,7 +1882,7 @@ NonnullRefPtr Parser::parse_switch_statement() consume(TokenType::CurlyClose); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(determinant), move(cases)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(determinant), move(cases)); } NonnullRefPtr Parser::parse_with_statement() @@ -1895,7 +1896,7 @@ NonnullRefPtr Parser::parse_with_statement() consume(TokenType::ParenClose); auto body = parse_statement(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(object), move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(object), move(body)); } NonnullRefPtr Parser::parse_switch_case() @@ -1910,7 +1911,7 @@ NonnullRefPtr Parser::parse_switch_case() consume(TokenType::Colon); NonnullRefPtrVector consequent; - TemporaryChange break_change(m_parser_state.m_in_break_context, true); + TemporaryChange break_change(m_state.in_break_context, true); for (;;) { if (match_declaration()) consequent.append(parse_declaration()); @@ -1920,7 +1921,7 @@ NonnullRefPtr Parser::parse_switch_case() break; } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(test), move(consequent)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(test), move(consequent)); } NonnullRefPtr Parser::parse_catch_clause() @@ -1936,7 +1937,7 @@ NonnullRefPtr Parser::parse_catch_clause() } auto body = parse_block_statement(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, parameter, move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, parameter, move(body)); } NonnullRefPtr Parser::parse_if_statement() @@ -1948,9 +1949,9 @@ NonnullRefPtr Parser::parse_if_statement() // FunctionDeclaration[?Yield, ?Await, ~Default] was the sole StatementListItem // of a BlockStatement occupying that position in the source code. ScopePusher scope(*this, ScopePusher::Let); - auto block = create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + auto block = create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); block->append(parse_declaration()); - block->add_functions(m_parser_state.m_function_scopes.last()); + block->add_functions(m_state.function_scopes.last()); return block; }; @@ -1960,7 +1961,7 @@ NonnullRefPtr Parser::parse_if_statement() consume(TokenType::ParenClose); RefPtr consequent; - if (!m_parser_state.m_strict_mode && match(TokenType::Function)) + if (!m_state.strict_mode && match(TokenType::Function)) consequent = parse_function_declaration_as_block_statement(); else consequent = parse_statement(); @@ -1968,19 +1969,19 @@ NonnullRefPtr Parser::parse_if_statement() RefPtr alternate; if (match(TokenType::Else)) { consume(); - if (!m_parser_state.m_strict_mode && match(TokenType::Function)) + if (!m_state.strict_mode && match(TokenType::Function)) alternate = parse_function_declaration_as_block_statement(); else alternate = parse_statement(); } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(predicate), move(*consequent), move(alternate)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(predicate), move(*consequent), move(alternate)); } NonnullRefPtr Parser::parse_for_statement() { auto rule_start = push_start(); auto match_for_in_of = [&]() { - return match(TokenType::In) || (match(TokenType::Identifier) && m_parser_state.m_current_token.value() == "of"); + return match(TokenType::In) || (match(TokenType::Identifier) && m_state.current_token.value() == "of"); }; consume(TokenType::For); @@ -1996,7 +1997,7 @@ NonnullRefPtr Parser::parse_for_statement() return parse_for_in_of_statement(*init); } else if (match_variable_declaration()) { if (!match(TokenType::Var)) { - m_parser_state.m_let_scopes.append(NonnullRefPtrVector()); + m_state.let_scopes.append(NonnullRefPtrVector()); in_scope = true; } init = parse_variable_declaration(true); @@ -2026,15 +2027,15 @@ NonnullRefPtr Parser::parse_for_statement() consume(TokenType::ParenClose); - TemporaryChange break_change(m_parser_state.m_in_break_context, true); - TemporaryChange continue_change(m_parser_state.m_in_continue_context, true); + TemporaryChange break_change(m_state.in_break_context, true); + TemporaryChange continue_change(m_state.in_continue_context, true); auto body = parse_statement(); if (in_scope) { - m_parser_state.m_let_scopes.take_last(); + m_state.let_scopes.take_last(); } - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(init), move(test), move(update), move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(init), move(test), move(update), move(body)); } NonnullRefPtr Parser::parse_for_in_of_statement(NonnullRefPtr lhs) @@ -2053,12 +2054,12 @@ NonnullRefPtr Parser::parse_for_in_of_statement(NonnullRefPtr({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(lhs), move(rhs), move(body)); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }, move(lhs), move(rhs), move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(lhs), move(rhs), move(body)); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }, move(lhs), move(rhs), move(body)); } NonnullRefPtr Parser::parse_debugger_statement() @@ -2066,17 +2067,17 @@ NonnullRefPtr Parser::parse_debugger_statement() auto rule_start = push_start(); consume(TokenType::Debugger); consume_or_insert_semicolon(); - return create_ast_node({ m_parser_state.m_current_token.filename(), rule_start.position(), position() }); + return create_ast_node({ m_state.current_token.filename(), rule_start.position(), position() }); } bool Parser::match(TokenType type) const { - return m_parser_state.m_current_token.type() == type; + return m_state.current_token.type() == type; } bool Parser::match_expression() const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); return type == TokenType::BoolLiteral || type == TokenType::NumericLiteral || type == TokenType::BigIntLiteral @@ -2098,7 +2099,7 @@ bool Parser::match_expression() const bool Parser::match_unary_prefixed_expression() const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); return type == TokenType::PlusPlus || type == TokenType::MinusMinus || type == TokenType::ExclamationMark @@ -2112,7 +2113,7 @@ bool Parser::match_unary_prefixed_expression() const bool Parser::match_secondary_expression(const Vector& forbidden) const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); if (forbidden.contains_slow(type)) return false; return type == TokenType::Plus @@ -2166,7 +2167,7 @@ bool Parser::match_secondary_expression(const Vector& forbidden) cons bool Parser::match_statement() const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); return match_expression() || type == TokenType::Return || type == TokenType::Yield @@ -2188,7 +2189,7 @@ bool Parser::match_statement() const bool Parser::match_declaration() const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); return type == TokenType::Function || type == TokenType::Class || type == TokenType::Const @@ -2197,7 +2198,7 @@ bool Parser::match_declaration() const bool Parser::match_variable_declaration() const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); return type == TokenType::Var || type == TokenType::Let || type == TokenType::Const; @@ -2205,12 +2206,12 @@ bool Parser::match_variable_declaration() const bool Parser::match_identifier_name() const { - return m_parser_state.m_current_token.is_identifier_name(); + return m_state.current_token.is_identifier_name(); } bool Parser::match_property_key() const { - auto type = m_parser_state.m_current_token.type(); + auto type = m_state.current_token.type(); return match_identifier_name() || type == TokenType::BracketOpen || type == TokenType::StringLiteral @@ -2225,8 +2226,8 @@ bool Parser::done() const Token Parser::consume() { - auto old_token = m_parser_state.m_current_token; - m_parser_state.m_current_token = m_parser_state.m_lexer.next(); + auto old_token = m_state.current_token; + m_state.current_token = m_state.lexer.next(); return old_token; } @@ -2239,7 +2240,7 @@ void Parser::consume_or_insert_semicolon() } // Insert semicolon if... // ...token is preceded by one or more newlines - if (m_parser_state.m_current_token.trivia_contains_line_terminator()) + if (m_state.current_token.trivia_contains_line_terminator()) return; // ...token is a closing curly brace if (match(TokenType::CurlyClose)) @@ -2264,7 +2265,7 @@ Token Parser::consume(TokenType expected_type) if (expected_type == TokenType::Identifier) { if (any_of(reserved_words.begin(), reserved_words.end(), [&](auto const& word) { return word == token.value(); })) syntax_error("Identifier must not be a reserved word"); - if (m_parser_state.m_strict_mode && any_of(strict_reserved_words.begin(), strict_reserved_words.end(), [&](auto const& word) { return word == token.value(); })) + if (m_state.strict_mode && any_of(strict_reserved_words.begin(), strict_reserved_words.end(), [&](auto const& word) { return word == token.value(); })) syntax_error("Identifier must not be a class-related reserved word in strict mode"); } return token; @@ -2277,26 +2278,26 @@ Token Parser::consume_and_validate_numeric_literal() }; auto literal_start = position(); auto token = consume(TokenType::NumericLiteral); - if (m_parser_state.m_strict_mode && is_unprefixed_octal_number(token.value())) + if (m_state.strict_mode && is_unprefixed_octal_number(token.value())) syntax_error("Unprefixed octal number not allowed in strict mode", literal_start); - if (match_identifier_name() && m_parser_state.m_current_token.trivia().is_empty()) + if (match_identifier_name() && m_state.current_token.trivia().is_empty()) syntax_error("Numeric literal must not be immediately followed by identifier"); return token; } void Parser::expected(const char* what) { - auto message = m_parser_state.m_current_token.message(); + auto message = m_state.current_token.message(); if (message.is_empty()) - message = String::formatted("Unexpected token {}. Expected {}", m_parser_state.m_current_token.name(), what); + message = String::formatted("Unexpected token {}. Expected {}", m_state.current_token.name(), what); syntax_error(message); } Position Parser::position() const { return { - m_parser_state.m_current_token.line_number(), - m_parser_state.m_current_token.line_column() + m_state.current_token.line_number(), + m_state.current_token.line_column() }; } @@ -2318,18 +2319,18 @@ void Parser::syntax_error(const String& message, Optional position) { if (!position.has_value()) position = this->position(); - m_parser_state.m_errors.append({ message, position }); + m_state.errors.append({ message, position }); } void Parser::save_state() { - m_saved_state.append(m_parser_state); + m_saved_state.append(m_state); } void Parser::load_state() { VERIFY(!m_saved_state.is_empty()); - m_parser_state = m_saved_state.take_last(); + m_state = m_saved_state.take_last(); } void Parser::discard_saved_state() diff --git a/Userland/Libraries/LibJS/Parser.h b/Userland/Libraries/LibJS/Parser.h index 490dcff09a..245bf59ba1 100644 --- a/Userland/Libraries/LibJS/Parser.h +++ b/Userland/Libraries/LibJS/Parser.h @@ -124,12 +124,12 @@ public: } }; - bool has_errors() const { return m_parser_state.m_errors.size(); } - const Vector& errors() const { return m_parser_state.m_errors; } + bool has_errors() const { return m_state.errors.size(); } + const Vector& errors() const { return m_state.errors; } void print_errors() const { - for (auto& error : m_parser_state.m_errors) { - auto hint = error.source_location_hint(m_parser_state.m_lexer.source()); + for (auto& error : m_state.errors) { + auto hint = error.source_location_hint(m_state.lexer.source()); if (!hint.is_empty()) warnln("{}", hint); warnln("SyntaxError: {}", error.to_string()); @@ -197,25 +197,25 @@ private: [[nodiscard]] RulePosition push_start() { return { *this, position() }; } struct ParserState { - Lexer m_lexer; - Token m_current_token; - Vector m_errors; - Vector> m_var_scopes; - Vector> m_let_scopes; - Vector> m_function_scopes; + Lexer lexer; + Token current_token; + Vector errors; + Vector> var_scopes; + Vector> let_scopes; + Vector> function_scopes; Vector&> function_parameters; - HashTable m_labels_in_scope; - bool m_strict_mode { false }; - bool m_allow_super_property_lookup { false }; - bool m_allow_super_constructor_call { false }; - bool m_in_function_context { false }; - bool m_in_generator_function_context { false }; - bool m_in_arrow_function_context { false }; - bool m_in_break_context { false }; - bool m_in_continue_context { false }; - bool m_string_legacy_octal_escape_sequence_in_scope { false }; + HashTable labels_in_scope; + bool strict_mode { false }; + bool allow_super_property_lookup { false }; + bool allow_super_constructor_call { false }; + bool in_function_context { false }; + bool in_generator_function_context { false }; + bool in_arrow_function_context { false }; + bool in_break_context { false }; + bool in_continue_context { false }; + bool string_legacy_octal_escape_sequence_in_scope { false }; explicit ParserState(Lexer); }; @@ -234,7 +234,7 @@ private: }; Vector m_rule_starts; - ParserState m_parser_state; + ParserState m_state; FlyString m_filename; Vector m_saved_state; HashMap m_token_memoizations;