mirror of
https://github.com/RGBCube/serenity
synced 2025-07-26 05:47:34 +00:00
LibJS: Make RefPtr and NonnullRefPtr usage const-correct
This mainly affected the AST, which is now const throughout.
This commit is contained in:
Andreas Kling
parent
b2b942b4ec
commit
bd5d8e9d35
15 changed files with 505 additions and 494 deletions
|
|
@ -1,6 +1,7 @@
|
|||
/*
|
||||
* Copyright (c) 2020, Stephan Unverwerth <s.unverwerth@serenityos.org>
|
||||
* Copyright (c) 2021-2022, David Tuin <davidot@serenityos.org>
|
||||
* Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
|
@ -70,34 +71,34 @@ public:
|
|||
No
|
||||
};
|
||||
|
||||
RefPtr<BindingPattern> parse_binding_pattern(AllowDuplicates is_var_declaration = AllowDuplicates::No, AllowMemberExpressions allow_member_expressions = AllowMemberExpressions::No);
|
||||
RefPtr<BindingPattern const> parse_binding_pattern(AllowDuplicates is_var_declaration = AllowDuplicates::No, AllowMemberExpressions allow_member_expressions = AllowMemberExpressions::No);
|
||||
|
||||
struct PrimaryExpressionParseResult {
|
||||
NonnullRefPtr<Expression> result;
|
||||
NonnullRefPtr<Expression const> result;
|
||||
bool should_continue_parsing_as_expression { true };
|
||||
};
|
||||
|
||||
NonnullRefPtr<Declaration> parse_declaration();
|
||||
NonnullRefPtr<Declaration const> parse_declaration();
|
||||
|
||||
enum class AllowLabelledFunction {
|
||||
No,
|
||||
Yes
|
||||
};
|
||||
|
||||
NonnullRefPtr<Statement> parse_statement(AllowLabelledFunction allow_labelled_function = AllowLabelledFunction::No);
|
||||
NonnullRefPtr<BlockStatement> parse_block_statement();
|
||||
NonnullRefPtr<FunctionBody> parse_function_body(Vector<FunctionParameter> const& parameters, FunctionKind function_kind, bool& contains_direct_call_to_eval);
|
||||
NonnullRefPtr<ReturnStatement> parse_return_statement();
|
||||
NonnullRefPtr<Statement const> parse_statement(AllowLabelledFunction allow_labelled_function = AllowLabelledFunction::No);
|
||||
NonnullRefPtr<BlockStatement const> parse_block_statement();
|
||||
NonnullRefPtr<FunctionBody const> parse_function_body(Vector<FunctionParameter> const& parameters, FunctionKind function_kind, bool& contains_direct_call_to_eval);
|
||||
NonnullRefPtr<ReturnStatement const> parse_return_statement();
|
||||
|
||||
enum class IsForLoopVariableDeclaration {
|
||||
No,
|
||||
Yes
|
||||
};
|
||||
|
||||
NonnullRefPtr<VariableDeclaration> parse_variable_declaration(IsForLoopVariableDeclaration is_for_loop_variable_declaration = IsForLoopVariableDeclaration::No);
|
||||
RefPtr<Identifier> parse_lexical_binding();
|
||||
NonnullRefPtr<UsingDeclaration> parse_using_declaration(IsForLoopVariableDeclaration is_for_loop_variable_declaration = IsForLoopVariableDeclaration::No);
|
||||
NonnullRefPtr<Statement> parse_for_statement();
|
||||
NonnullRefPtr<VariableDeclaration const> parse_variable_declaration(IsForLoopVariableDeclaration is_for_loop_variable_declaration = IsForLoopVariableDeclaration::No);
|
||||
RefPtr<Identifier const> parse_lexical_binding();
|
||||
NonnullRefPtr<UsingDeclaration const> parse_using_declaration(IsForLoopVariableDeclaration is_for_loop_variable_declaration = IsForLoopVariableDeclaration::No);
|
||||
NonnullRefPtr<Statement const> parse_for_statement();
|
||||
|
||||
enum class IsForAwaitLoop {
|
||||
No,
|
||||
|
|
@ -122,36 +123,43 @@ public:
|
|||
|
||||
struct ExpressionResult {
|
||||
template<typename T>
|
||||
ExpressionResult(NonnullRefPtr<T> expression, ForbiddenTokens forbidden = {})
|
||||
: expression(expression)
|
||||
ExpressionResult(NonnullRefPtr<T const> expression, ForbiddenTokens forbidden = {})
|
||||
: expression(move(expression))
|
||||
, forbidden(forbidden)
|
||||
{
|
||||
}
|
||||
NonnullRefPtr<Expression> expression;
|
||||
|
||||
template<typename T>
|
||||
ExpressionResult(NonnullRefPtr<T> expression, ForbiddenTokens forbidden = {})
|
||||
: expression(move(expression))
|
||||
, forbidden(forbidden)
|
||||
{
|
||||
}
|
||||
NonnullRefPtr<Expression const> expression;
|
||||
ForbiddenTokens forbidden;
|
||||
};
|
||||
|
||||
NonnullRefPtr<Statement> parse_for_in_of_statement(NonnullRefPtr<ASTNode> lhs, IsForAwaitLoop is_await);
|
||||
NonnullRefPtr<IfStatement> parse_if_statement();
|
||||
NonnullRefPtr<ThrowStatement> parse_throw_statement();
|
||||
NonnullRefPtr<TryStatement> parse_try_statement();
|
||||
NonnullRefPtr<CatchClause> parse_catch_clause();
|
||||
NonnullRefPtr<SwitchStatement> parse_switch_statement();
|
||||
NonnullRefPtr<SwitchCase> parse_switch_case();
|
||||
NonnullRefPtr<BreakStatement> parse_break_statement();
|
||||
NonnullRefPtr<ContinueStatement> parse_continue_statement();
|
||||
NonnullRefPtr<DoWhileStatement> parse_do_while_statement();
|
||||
NonnullRefPtr<WhileStatement> parse_while_statement();
|
||||
NonnullRefPtr<WithStatement> parse_with_statement();
|
||||
NonnullRefPtr<DebuggerStatement> parse_debugger_statement();
|
||||
NonnullRefPtr<ConditionalExpression> parse_conditional_expression(NonnullRefPtr<Expression> test, ForbiddenTokens);
|
||||
NonnullRefPtr<OptionalChain> parse_optional_chain(NonnullRefPtr<Expression> base);
|
||||
NonnullRefPtr<Expression> parse_expression(int min_precedence, Associativity associate = Associativity::Right, ForbiddenTokens forbidden = {});
|
||||
NonnullRefPtr<Statement const> parse_for_in_of_statement(NonnullRefPtr<ASTNode const> lhs, IsForAwaitLoop is_await);
|
||||
NonnullRefPtr<IfStatement const> parse_if_statement();
|
||||
NonnullRefPtr<ThrowStatement const> parse_throw_statement();
|
||||
NonnullRefPtr<TryStatement const> parse_try_statement();
|
||||
NonnullRefPtr<CatchClause const> parse_catch_clause();
|
||||
NonnullRefPtr<SwitchStatement const> parse_switch_statement();
|
||||
NonnullRefPtr<SwitchCase const> parse_switch_case();
|
||||
NonnullRefPtr<BreakStatement const> parse_break_statement();
|
||||
NonnullRefPtr<ContinueStatement const> parse_continue_statement();
|
||||
NonnullRefPtr<DoWhileStatement const> parse_do_while_statement();
|
||||
NonnullRefPtr<WhileStatement const> parse_while_statement();
|
||||
NonnullRefPtr<WithStatement const> parse_with_statement();
|
||||
NonnullRefPtr<DebuggerStatement const> parse_debugger_statement();
|
||||
NonnullRefPtr<ConditionalExpression const> parse_conditional_expression(NonnullRefPtr<Expression const> test, ForbiddenTokens);
|
||||
NonnullRefPtr<OptionalChain const> parse_optional_chain(NonnullRefPtr<Expression const> base);
|
||||
NonnullRefPtr<Expression const> parse_expression(int min_precedence, Associativity associate = Associativity::Right, ForbiddenTokens forbidden = {});
|
||||
PrimaryExpressionParseResult parse_primary_expression();
|
||||
NonnullRefPtr<Expression> parse_unary_prefixed_expression();
|
||||
NonnullRefPtr<RegExpLiteral> parse_regexp_literal();
|
||||
NonnullRefPtr<ObjectExpression> parse_object_expression();
|
||||
NonnullRefPtr<ArrayExpression> parse_array_expression();
|
||||
NonnullRefPtr<Expression const> parse_unary_prefixed_expression();
|
||||
NonnullRefPtr<RegExpLiteral const> parse_regexp_literal();
|
||||
NonnullRefPtr<ObjectExpression const> parse_object_expression();
|
||||
NonnullRefPtr<ArrayExpression const> parse_array_expression();
|
||||
|
||||
enum class StringLiteralType {
|
||||
Normal,
|
||||
|
|
@ -159,26 +167,26 @@ public:
|
|||
TaggedTemplate
|
||||
};
|
||||
|
||||
NonnullRefPtr<StringLiteral> parse_string_literal(Token const& token, StringLiteralType string_literal_type = StringLiteralType::Normal, bool* contains_invalid_escape = nullptr);
|
||||
NonnullRefPtr<TemplateLiteral> parse_template_literal(bool is_tagged);
|
||||
ExpressionResult parse_secondary_expression(NonnullRefPtr<Expression>, int min_precedence, Associativity associate = Associativity::Right, ForbiddenTokens forbidden = {});
|
||||
NonnullRefPtr<Expression> parse_call_expression(NonnullRefPtr<Expression>);
|
||||
NonnullRefPtr<NewExpression> parse_new_expression();
|
||||
NonnullRefPtr<ClassDeclaration> parse_class_declaration();
|
||||
NonnullRefPtr<ClassExpression> parse_class_expression(bool expect_class_name);
|
||||
NonnullRefPtr<YieldExpression> parse_yield_expression();
|
||||
NonnullRefPtr<AwaitExpression> parse_await_expression();
|
||||
NonnullRefPtr<Expression> parse_property_key();
|
||||
NonnullRefPtr<AssignmentExpression> parse_assignment_expression(AssignmentOp, NonnullRefPtr<Expression> lhs, int min_precedence, Associativity, ForbiddenTokens forbidden = {});
|
||||
NonnullRefPtr<Identifier> parse_identifier();
|
||||
NonnullRefPtr<ImportStatement> parse_import_statement(Program& program);
|
||||
NonnullRefPtr<ExportStatement> parse_export_statement(Program& program);
|
||||
NonnullRefPtr<StringLiteral const> parse_string_literal(Token const& token, StringLiteralType string_literal_type = StringLiteralType::Normal, bool* contains_invalid_escape = nullptr);
|
||||
NonnullRefPtr<TemplateLiteral const> parse_template_literal(bool is_tagged);
|
||||
ExpressionResult parse_secondary_expression(NonnullRefPtr<Expression const>, int min_precedence, Associativity associate = Associativity::Right, ForbiddenTokens forbidden = {});
|
||||
NonnullRefPtr<Expression const> parse_call_expression(NonnullRefPtr<Expression const>);
|
||||
NonnullRefPtr<NewExpression const> parse_new_expression();
|
||||
NonnullRefPtr<ClassDeclaration const> parse_class_declaration();
|
||||
NonnullRefPtr<ClassExpression const> parse_class_expression(bool expect_class_name);
|
||||
NonnullRefPtr<YieldExpression const> parse_yield_expression();
|
||||
NonnullRefPtr<AwaitExpression const> parse_await_expression();
|
||||
NonnullRefPtr<Expression const> parse_property_key();
|
||||
NonnullRefPtr<AssignmentExpression const> parse_assignment_expression(AssignmentOp, NonnullRefPtr<Expression const> lhs, int min_precedence, Associativity, ForbiddenTokens forbidden = {});
|
||||
NonnullRefPtr<Identifier const> parse_identifier();
|
||||
NonnullRefPtr<ImportStatement const> parse_import_statement(Program& program);
|
||||
NonnullRefPtr<ExportStatement const> parse_export_statement(Program& program);
|
||||
|
||||
RefPtr<FunctionExpression> try_parse_arrow_function_expression(bool expect_parens, bool is_async = false);
|
||||
RefPtr<LabelledStatement> try_parse_labelled_statement(AllowLabelledFunction allow_function);
|
||||
RefPtr<MetaProperty> try_parse_new_target_expression();
|
||||
RefPtr<MetaProperty> try_parse_import_meta_expression();
|
||||
NonnullRefPtr<ImportCall> parse_import_call();
|
||||
RefPtr<FunctionExpression const> try_parse_arrow_function_expression(bool expect_parens, bool is_async = false);
|
||||
RefPtr<LabelledStatement const> try_parse_labelled_statement(AllowLabelledFunction allow_function);
|
||||
RefPtr<MetaProperty const> try_parse_new_target_expression();
|
||||
RefPtr<MetaProperty const> try_parse_import_meta_expression();
|
||||
NonnullRefPtr<ImportCall const> parse_import_call();
|
||||
|
||||
Vector<CallExpression::Argument> parse_arguments();
|
||||
|
||||
|
|
@ -246,7 +254,7 @@ private:
|
|||
void discard_saved_state();
|
||||
Position position() const;
|
||||
|
||||
RefPtr<BindingPattern> synthesize_binding_pattern(Expression const& expression);
|
||||
RefPtr<BindingPattern const> synthesize_binding_pattern(Expression const& expression);
|
||||
|
||||
Token next_token(size_t steps = 1) const;
|
||||
|
||||
|
|
@ -333,7 +341,7 @@ private:
|
|||
}
|
||||
};
|
||||
|
||||
NonnullRefPtr<SourceCode> m_source_code;
|
||||
NonnullRefPtr<SourceCode const> m_source_code;
|
||||
Vector<Position> m_rule_starts;
|
||||
ParserState m_state;
|
||||
DeprecatedFlyString m_filename;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue