From 34fc6c7e1cccec365149514206d2008ea4b76ae6 Mon Sep 17 00:00:00 2001 From: Itamar Date: Tue, 6 Jul 2021 22:44:20 +0300 Subject: [PATCH] LibCpp: Make the fields of AST node types private Previously almost all fields were public and were directly accessed by the Parser and CppComprehensionEngine. This commit makes all fields of AST node types private. They are now accessed via getters & setters. --- .../Cpp/CppComprehensionEngine.cpp | 75 +++++---- Userland/Libraries/LibCpp/AST.cpp | 22 +-- Userland/Libraries/LibCpp/AST.h | 156 +++++++++++++++++- Userland/Libraries/LibCpp/Parser.cpp | 131 ++++++++------- 4 files changed, 265 insertions(+), 119 deletions(-) diff --git a/Userland/DevTools/HackStudio/LanguageServers/Cpp/CppComprehensionEngine.cpp b/Userland/DevTools/HackStudio/LanguageServers/Cpp/CppComprehensionEngine.cpp index ec29ee1ae5..e391e42919 100644 --- a/Userland/DevTools/HackStudio/LanguageServers/Cpp/CppComprehensionEngine.cpp +++ b/Userland/DevTools/HackStudio/LanguageServers/Cpp/CppComprehensionEngine.cpp @@ -117,7 +117,7 @@ Optional> CppComprehensionEngine::try_a auto partial_text = String::empty(); if (containing_token.value().type() != Token::Type::Dot) { - if (&node != parent.m_property) + if (&node != parent.property()) return {}; partial_text = containing_token.value().text(); } @@ -191,15 +191,16 @@ Vector CppComprehensionEngine::scope_of_reference_to_symbol(const AS VERIFY(name->is_name()); Vector scope_parts; - for (auto& scope_part : name->m_scope) { - scope_parts.append(scope_part.m_name); + for (auto& scope_part : name->scope()) { + scope_parts.append(scope_part.name()); } return scope_parts; } Vector CppComprehensionEngine::autocomplete_property(const DocumentData& document, const MemberExpression& parent, const String partial_text) const { - auto type = type_of(document, *parent.m_object); + VERIFY(parent.object()); + auto type = type_of(document, *parent.object()); if (type.is_null()) { dbgln_if(CPP_LANGUAGE_SERVER_DEBUG, "Could not infer type of object"); return {}; @@ -220,26 +221,28 @@ bool CppComprehensionEngine::is_property(const ASTNode& node) const return false; auto& parent = (MemberExpression&)(*node.parent()); - return parent.m_property.ptr() == &node; + return parent.property() == &node; } String CppComprehensionEngine::type_of_property(const DocumentData& document, const Identifier& identifier) const { auto& parent = (const MemberExpression&)(*identifier.parent()); - auto properties = properties_of_type(document, type_of(document, *parent.m_object)); + VERIFY(parent.object()); + auto properties = properties_of_type(document, type_of(document, *parent.object())); for (auto& prop : properties) { - if (prop.name.name != identifier.m_name) + if (prop.name.name != identifier.name()) continue; - Type* type { nullptr }; + const Type* type { nullptr }; if (prop.declaration->is_variable_declaration()) { - type = ((VariableDeclaration&)*prop.declaration).m_type.ptr(); + type = ((VariableDeclaration&)*prop.declaration).type(); } if (!type) continue; if (!type->is_named_type()) continue; - return ((NamedType&)*type).m_name->full_name(); + VERIFY(((NamedType const&)*type).name()); + return ((NamedType const&)*type).name()->full_name(); } return {}; } @@ -251,8 +254,9 @@ String CppComprehensionEngine::type_of_variable(const Identifier& identifier) co for (auto& decl : current->declarations()) { if (decl.is_variable_or_parameter_declaration()) { auto& var_or_param = (VariableOrParameterDeclaration&)decl; - if (var_or_param.m_name == identifier.m_name && var_or_param.m_type->is_named_type()) { - return ((NamedType&)(*var_or_param.m_type)).m_name->full_name(); + if (var_or_param.name() == identifier.name() && var_or_param.type()->is_named_type()) { + VERIFY(((NamedType const&)(*var_or_param.type())).name()); + return ((NamedType const&)(*var_or_param.type())).name()->full_name(); } } } @@ -265,14 +269,15 @@ String CppComprehensionEngine::type_of(const DocumentData& document, const Expre { if (expression.is_member_expression()) { auto& member_expression = (const MemberExpression&)expression; - if (member_expression.m_property->is_identifier()) - return type_of_property(document, static_cast(*member_expression.m_property)); + VERIFY(member_expression.property()); + if (member_expression.property()->is_identifier()) + return type_of_property(document, static_cast(*member_expression.property())); return {}; } const Identifier* identifier { nullptr }; if (expression.is_name()) { - identifier = static_cast(expression).m_name.ptr(); + identifier = static_cast(expression).name(); } else if (expression.is_identifier()) { identifier = &static_cast(expression); } else { @@ -304,11 +309,11 @@ Vector CppComprehensionEngine::properties_of_typ VERIFY(struct_or_class.name() == type_symbol.name); Vector properties; - for (auto& member : struct_or_class.m_members) { + for (auto& member : struct_or_class.members()) { Vector scope(type_symbol.scope); scope.append(type_symbol.name); // FIXME: We don't have to create the Symbol here, it should already exist in the 'm_symbol' table of some DocumentData we already parsed. - properties.append(Symbol::create(member.m_name, scope, member, Symbol::IsLocal::No)); + properties.append(Symbol::create(member.name(), scope, member, Symbol::IsLocal::No)); } return properties; } @@ -435,7 +440,7 @@ static Optional get_target_declaration(const ASTNode& node) return {}; } - String name = static_cast(node).m_name; + String name = static_cast(node).name(); if ((node.parent() && node.parent()->is_function_call()) || (node.parent()->is_name() && node.parent()->parent() && node.parent()->parent()->is_function_call())) { return TargetDeclaration { TargetDeclaration::Type::Function, name }; @@ -614,7 +619,7 @@ Vector CppComprehensionEngine::scope_of_node(const ASTNode& node) co StringView containing_scope; if (parent_decl.is_namespace()) - containing_scope = static_cast(parent_decl).m_name; + containing_scope = static_cast(parent_decl).name(); if (parent_decl.is_struct_or_class()) containing_scope = static_cast(parent_decl).name(); if (parent_decl.is_function()) @@ -753,7 +758,7 @@ Optional CppComprehensionEngine::ge // If we're in a function call with 0 arguments if (token.has_value() && (token->type() == Token::Type::LeftParen || token->type() == Token::Type::RightParen)) { - return get_function_params_hint(document, *call_node, call_node->m_arguments.is_empty() ? 0 : call_node->m_arguments.size() - 1); + return get_function_params_hint(document, *call_node, call_node->arguments().is_empty() ? 0 : call_node->arguments().size() - 1); } } @@ -773,15 +778,15 @@ Optional CppComprehensionEngine::ge } Optional invoked_arg_index; - for (size_t arg_index = 0; arg_index < call_node->m_arguments.size(); ++arg_index) { - if (&call_node->m_arguments[arg_index] == node.ptr()) { + for (size_t arg_index = 0; arg_index < call_node->arguments().size(); ++arg_index) { + if (&call_node->arguments()[arg_index] == node.ptr()) { invoked_arg_index = arg_index; break; } } if (!invoked_arg_index.has_value()) { dbgln_if(CPP_LANGUAGE_SERVER_DEBUG, "could not find argument index, defaulting to the last argument"); - invoked_arg_index = call_node->m_arguments.is_empty() ? 0 : call_node->m_arguments.size() - 1; + invoked_arg_index = call_node->arguments().is_empty() ? 0 : call_node->arguments().size() - 1; } dbgln_if(CPP_LANGUAGE_SERVER_DEBUG, "arg index: {}", invoked_arg_index.value()); @@ -793,20 +798,22 @@ Optional CppComprehensionEngine::get FunctionCall& call_node, size_t argument_index) { - Identifier* callee = nullptr; - if (call_node.m_callee->is_identifier()) { - callee = (Identifier*)call_node.m_callee.ptr(); - } else if (call_node.m_callee->is_name()) { - callee = ((Name&)*call_node.m_callee).m_name.ptr(); - } else if (call_node.m_callee->is_member_expression()) { - auto& member_exp = ((MemberExpression&)*call_node.m_callee); - if (member_exp.m_property->is_identifier()) { - callee = (Identifier*)member_exp.m_property.ptr(); + const Identifier* callee = nullptr; + VERIFY(call_node.callee()); + if (call_node.callee()->is_identifier()) { + callee = (const Identifier*)call_node.callee(); + } else if (call_node.callee()->is_name()) { + callee = ((Name const&)*call_node.callee()).name(); + } else if (call_node.callee()->is_member_expression()) { + auto& member_exp = ((MemberExpression const&)*call_node.callee()); + VERIFY(member_exp.property()); + if (member_exp.property()->is_identifier()) { + callee = (const Identifier*)member_exp.property(); } } if (!callee) { - dbgln("unexpected node type for function call: {}", call_node.m_callee->class_name()); + dbgln("unexpected node type for function call: {}", call_node.callee()->class_name()); return {}; } VERIFY(callee); @@ -826,7 +833,7 @@ Optional CppComprehensionEngine::get FunctionParamsHint hint {}; hint.current_index = argument_index; - for (auto& arg : func_decl.m_parameters) { + for (auto& arg : func_decl.parameters()) { Vector tokens_text; for (auto token : document_of_declaration->parser().tokens_in_range(arg.start(), arg.end())) { tokens_text.append(token.text()); diff --git a/Userland/Libraries/LibCpp/AST.cpp b/Userland/Libraries/LibCpp/AST.cpp index 07ede080e8..237f550dfa 100644 --- a/Userland/Libraries/LibCpp/AST.cpp +++ b/Userland/Libraries/LibCpp/AST.cpp @@ -78,11 +78,11 @@ void Type::dump(FILE* output, size_t indent) const String NamedType::to_string() const { String qualifiers_string; - if (!m_qualifiers.is_empty()) - qualifiers_string = String::formatted("[{}] ", String::join(" ", m_qualifiers)); + if (!qualifiers().is_empty()) + qualifiers_string = String::formatted("[{}] ", String::join(" ", qualifiers())); String name; - if (m_is_auto) + if (is_auto()) name = "auto"; else name = m_name.is_null() ? "" : m_name->full_name(); @@ -473,10 +473,10 @@ String Name::full_name() const StringBuilder builder; if (!m_scope.is_empty()) { for (auto& scope : m_scope) { - builder.appendff("{}::", scope.m_name); + builder.appendff("{}::", scope.name()); } } - return String::formatted("{}{}", builder.to_string(), m_name.is_null() ? "" : m_name->m_name); + return String::formatted("{}{}", builder.to_string(), m_name.is_null() ? "" : m_name->name()); } String TemplatizedName::full_name() const @@ -539,13 +539,13 @@ void Constructor::dump(FILE* output, size_t indent) const outln(output, "C'tor"); print_indent(output, indent + 1); outln(output, "("); - for (const auto& arg : m_parameters) { + for (const auto& arg : parameters()) { arg.dump(output, indent + 1); } print_indent(output, indent + 1); outln(output, ")"); - if (!m_definition.is_null()) { - m_definition->dump(output, indent + 1); + if (definition()) { + definition()->dump(output, indent + 1); } } @@ -555,13 +555,13 @@ void Destructor::dump(FILE* output, size_t indent) const outln(output, "D'tor"); print_indent(output, indent + 1); outln(output, "("); - for (const auto& arg : m_parameters) { + for (const auto& arg : parameters()) { arg.dump(output, indent + 1); } print_indent(output, indent + 1); outln(output, ")"); - if (!m_definition.is_null()) { - m_definition->dump(output, indent + 1); + if (definition()) { + definition()->dump(output, indent + 1); } } diff --git a/Userland/Libraries/LibCpp/AST.h b/Userland/Libraries/LibCpp/AST.h index eec5c38224..8b1edda722 100644 --- a/Userland/Libraries/LibCpp/AST.h +++ b/Userland/Libraries/LibCpp/AST.h @@ -89,6 +89,9 @@ public: { } + void set_declarations(NonnullRefPtrVector&& declarations) { m_declarations = move(declarations); } + +private: NonnullRefPtrVector m_declarations; }; @@ -119,14 +122,15 @@ public: virtual bool is_namespace() const { return false; } virtual bool is_member() const { return false; } const StringView& name() const { return m_name; } - - StringView m_name; + void set_name(const StringView& name) { m_name = move(name); } protected: Declaration(ASTNode* parent, Optional start, Optional end, const String& filename) : Statement(parent, start, end, filename) { } + + StringView m_name; }; class InvalidDeclaration : public Declaration { @@ -156,7 +160,16 @@ public: } virtual NonnullRefPtrVector declarations() const override; + const Vector& qualifiers() const { return m_qualifiers; } + void set_qualifiers(const Vector& qualifiers) { m_qualifiers = qualifiers; } + const Type* return_type() const { return m_return_type.ptr(); } + void set_return_type(const RefPtr& return_type) { m_return_type = return_type; } + const NonnullRefPtrVector& parameters() const { return m_parameters; } + void set_parameters(const NonnullRefPtrVector& parameters) { m_parameters = parameters; } + const FunctionDefinition* definition() const { return m_definition.ptr(); } + void set_definition(RefPtr&& definition) { m_definition = move(definition); } +private: Vector m_qualifiers; RefPtr m_return_type; NonnullRefPtrVector m_parameters; @@ -168,13 +181,16 @@ public: virtual ~VariableOrParameterDeclaration() override = default; virtual bool is_variable_or_parameter_declaration() const override { return true; } - RefPtr m_type; + void set_type(RefPtr&& type) { m_type = move(type); } + const Type* type() const { return m_type.ptr(); } protected: VariableOrParameterDeclaration(ASTNode* parent, Optional start, Optional end, const String& filename) : Declaration(parent, start, end, filename) { } + + RefPtr m_type; }; class Parameter : public VariableOrParameterDeclaration { @@ -190,6 +206,10 @@ public: m_name = name; } + bool is_ellipsis() const { return m_is_ellipsis; } + void set_ellipsis(bool is_ellipsis) { m_is_ellipsis = is_ellipsis; } + +private: bool m_is_ellipsis { false }; }; @@ -203,14 +223,20 @@ public: virtual String to_string() const = 0; virtual void dump(FILE* = stdout, size_t indent = 0) const override; - bool m_is_auto { false }; - Vector m_qualifiers; + bool is_auto() const { return m_is_auto; } + void set_auto(bool is_auto) { m_is_auto = is_auto; } + Vector const& qualifiers() const { return m_qualifiers; } + void set_qualifiers(Vector&& qualifiers) { m_qualifiers = move(qualifiers); } protected: Type(ASTNode* parent, Optional start, Optional end, const String& filename) : ASTNode(parent, start, end, filename) { } + +private: + bool m_is_auto { false }; + Vector m_qualifiers; }; class NamedType : public Type { @@ -225,6 +251,10 @@ public: { } + const Name* name() const { return m_name.ptr(); } + void set_name(RefPtr&& name) { m_name = move(name); } + +private: RefPtr m_name; }; @@ -240,6 +270,10 @@ public: { } + const Type* pointee() const { return m_pointee.ptr(); } + void set_pointee(RefPtr&& pointee) { m_pointee = move(pointee); } + +private: RefPtr m_pointee; }; @@ -247,7 +281,6 @@ class FunctionDefinition : public ASTNode { public: virtual ~FunctionDefinition() override = default; virtual const char* class_name() const override { return "FunctionDefinition"; } - NonnullRefPtrVector& statements() { return m_statements; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; FunctionDefinition(ASTNode* parent, Optional start, Optional end, const String& filename) @@ -256,7 +289,10 @@ public: } virtual NonnullRefPtrVector declarations() const override; + NonnullRefPtrVector const& statements() { return m_statements; } + void add_statement(NonnullRefPtr&& statement) { m_statements.append(move(statement)); } +private: NonnullRefPtrVector m_statements; }; @@ -305,6 +341,10 @@ public: virtual bool is_variable_declaration() const override { return true; } + const Expression* initial_value() const { return m_initial_value; } + void set_initial_value(RefPtr&& initial_value) { m_initial_value = move(initial_value); } + +private: RefPtr m_initial_value; }; @@ -326,6 +366,10 @@ public: virtual bool is_identifier() const override { return true; } + StringView const& name() const { return m_name; } + void set_name(StringView&& name) { m_name = move(name); } + +private: StringView m_name; }; @@ -343,6 +387,13 @@ public: } virtual String full_name() const; + const Identifier* name() const { return m_name.ptr(); } + void set_name(RefPtr&& name) { m_name = move(name); } + NonnullRefPtrVector const& scope() const { return m_scope; } + void set_scope(NonnullRefPtrVector scope) { m_scope = move(scope); } + void add_to_scope(NonnullRefPtr&& part) { m_scope.append(move(part)); } + +private: RefPtr m_name; NonnullRefPtrVector m_scope; }; @@ -359,6 +410,9 @@ public: { } + void add_template_argument(NonnullRefPtr&& type) { m_template_arguments.append(move(type)); } + +private: NonnullRefPtrVector m_template_arguments; }; @@ -374,6 +428,7 @@ public: { } +private: StringView m_value; }; @@ -401,6 +456,7 @@ public: { } +private: bool m_value; }; @@ -437,6 +493,14 @@ public: virtual const char* class_name() const override { return "BinaryExpression"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + BinaryOp op() const { return m_op; } + void set_op(BinaryOp op) { m_op = op; } + Expression const* lhs() const { return m_lhs.ptr(); } + void set_lhs(RefPtr&& e) { m_lhs = move(e); } + Expression const* rhs() const { return m_rhs.ptr(); } + void set_rhs(RefPtr&& e) { m_rhs = move(e); } + +private: BinaryOp m_op; RefPtr m_lhs; RefPtr m_rhs; @@ -459,7 +523,15 @@ public: virtual const char* class_name() const override { return "AssignmentExpression"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; - AssignmentOp m_op; + AssignmentOp op() const { return m_op; } + void set_op(AssignmentOp op) { m_op = op; } + const Expression* lhs() const { return m_lhs; } + void set_lhs(RefPtr&& e) { m_lhs = move(e); } + const Expression* rhs() const { return m_rhs; } + void set_rhs(RefPtr&& e) { m_rhs = move(e); } + +private: + AssignmentOp m_op {}; RefPtr m_lhs; RefPtr m_rhs; }; @@ -477,6 +549,13 @@ public: virtual bool is_function_call() const override { return true; } virtual bool is_templatized() const { return false; } + const Expression* callee() const { return m_callee.ptr(); } + void set_callee(RefPtr&& callee) { m_callee = move(callee); } + + void add_argument(NonnullRefPtr&& arg) { m_arguments.append(move(arg)); } + NonnullRefPtrVector const& arguments() const { return m_arguments; } + +private: RefPtr m_callee; NonnullRefPtrVector m_arguments; }; @@ -492,6 +571,10 @@ public: virtual const char* class_name() const override { return "StringLiteral"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + String const& value() const { return m_value; } + void set_value(String value) { m_value = move(value); } + +private: String m_value; }; @@ -506,6 +589,10 @@ public: } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + const Expression* value() const { return m_value.ptr(); } + void set_value(RefPtr&& value) { m_value = move(value); } + +private: RefPtr m_value; }; @@ -525,7 +612,11 @@ public: EnumClass }; - Type type { Type::RegularEnum }; + void set_type(Type type) { m_type = type; } + void add_entry(StringView entry) { m_entries.append(move(entry)); } + +private: + Type m_type { Type::RegularEnum }; Vector m_entries; }; @@ -550,6 +641,10 @@ public: { } + NonnullRefPtrVector const& members() const { return m_members; } + void set_members(NonnullRefPtrVector&& members) { m_members = move(members); } + +private: StructOrClassDeclaration::Type m_type; NonnullRefPtrVector m_members; }; @@ -575,6 +670,10 @@ public: virtual const char* class_name() const override { return "UnaryExpression"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + void set_op(UnaryOp op) { m_op = op; } + void set_lhs(RefPtr&& e) { m_lhs = move(e); } + +private: UnaryOp m_op; RefPtr m_lhs; }; @@ -591,6 +690,12 @@ public: virtual void dump(FILE* = stdout, size_t indent = 0) const override; virtual bool is_member_expression() const override { return true; } + const Expression* object() const { return m_object.ptr(); } + void set_object(RefPtr&& object) { m_object = move(object); } + const Expression* property() const { return m_property.ptr(); } + void set_property(RefPtr&& property) { m_property = move(property); } + +private: RefPtr m_object; RefPtr m_property; }; @@ -608,6 +713,13 @@ public: virtual NonnullRefPtrVector declarations() const override; + void set_init(RefPtr&& init) { m_init = move(init); } + void set_test(RefPtr&& test) { m_test = move(test); } + void set_update(RefPtr&& update) { m_update = move(update); } + void set_body(RefPtr&& body) { m_body = move(body); } + const Statement* body() const { return m_body.ptr(); } + +private: RefPtr m_init; RefPtr m_test; RefPtr m_update; @@ -627,6 +739,9 @@ public: virtual NonnullRefPtrVector declarations() const override; + void add_statement(NonnullRefPtr&& statement) { m_statements.append(move(statement)); } + +private: NonnullRefPtrVector m_statements; }; @@ -653,6 +768,14 @@ public: virtual void dump(FILE* = stdout, size_t indent = 0) const override; virtual NonnullRefPtrVector declarations() const override; + void set_predicate(RefPtr&& predicate) { m_predicate = move(predicate); } + void set_then_statement(RefPtr&& then) { m_then = move(then); } + void set_else_statement(RefPtr&& _else) { m_else = move(_else); } + + const Statement* then_statement() const { return m_then.ptr(); } + const Statement* else_statement() const { return m_else.ptr(); } + +private: RefPtr m_predicate; RefPtr m_then; RefPtr m_else; @@ -671,7 +794,9 @@ public: } virtual NonnullRefPtrVector declarations() const override { return m_declarations; } + void add_declaration(NonnullRefPtr&& declaration) { m_declarations.append(move(declaration)); } +private: NonnullRefPtrVector m_declarations; }; @@ -686,6 +811,11 @@ public: virtual const char* class_name() const override { return "CppCastExpression"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + void set_cast_type(StringView cast_type) { m_cast_type = move(cast_type); } + void set_type(NonnullRefPtr&& type) { m_type = move(type); } + void set_expression(NonnullRefPtr&& e) { m_expression = move(e); } + +private: StringView m_cast_type; RefPtr m_type; RefPtr m_expression; @@ -702,6 +832,10 @@ public: virtual const char* class_name() const override { return "CStyleCastExpression"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + void set_type(NonnullRefPtr&& type) { m_type = move(type); } + void set_expression(NonnullRefPtr&& e) { m_expression = move(e); } + +private: RefPtr m_type; RefPtr m_expression; }; @@ -717,6 +851,9 @@ public: virtual const char* class_name() const override { return "SizeofExpression"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + void set_type(RefPtr&& type) { m_type = move(type); } + +private: RefPtr m_type; }; @@ -731,6 +868,9 @@ public: virtual const char* class_name() const override { return "BracedInitList"; } virtual void dump(FILE* = stdout, size_t indent = 0) const override; + void add_expression(NonnullRefPtr&& exp) { m_expressions.append(move(exp)); } + +private: NonnullRefPtrVector m_expressions; }; diff --git a/Userland/Libraries/LibCpp/Parser.cpp b/Userland/Libraries/LibCpp/Parser.cpp index 136175599a..22f4ce4fed 100644 --- a/Userland/Libraries/LibCpp/Parser.cpp +++ b/Userland/Libraries/LibCpp/Parser.cpp @@ -51,7 +51,7 @@ NonnullRefPtr Parser::parse() if (m_tokens.is_empty()) return create_root_ast_node({}, {}); auto unit = create_root_ast_node(m_tokens.first().start(), m_tokens.last().end()); - unit->m_declarations = parse_declarations_in_translation_unit(*unit); + unit->set_declarations(parse_declarations_in_translation_unit(*unit)); return unit; } @@ -119,16 +119,16 @@ NonnullRefPtr Parser::parse_function_declaration(ASTNode& p { auto func = create_ast_node(parent, position(), {}); - func->m_qualifiers = parse_function_qualifiers(); - func->m_return_type = parse_type(*func); + func->set_qualifiers(parse_function_qualifiers()); + func->set_return_type(parse_type(*func)); auto function_name = consume(Token::Type::Identifier); - func->m_name = text_of_token(function_name); + func->set_name(text_of_token(function_name)); consume(Token::Type::LeftParen); auto parameters = parse_parameter_list(*func); if (parameters.has_value()) - func->m_parameters = move(parameters.value()); + func->set_parameters(parameters.value()); consume(Token::Type::RightParen); @@ -144,7 +144,7 @@ NonnullRefPtr Parser::parse_function_declaration(ASTNode& p consume(Token::Type::Semicolon); } - func->m_definition = move(body); + func->set_definition(move(body)); func->set_end(func_end); return func; } @@ -155,7 +155,7 @@ NonnullRefPtr Parser::parse_function_definition(ASTNode& par auto func = create_ast_node(parent, position(), {}); consume(Token::Type::LeftCurly); while (!eof() && peek().type() != Token::Type::RightCurly) { - func->statements().append(parse_statement(func)); + func->add_statement(parse_statement(func)); } func->set_end(position()); if (!eof()) @@ -221,7 +221,7 @@ NonnullRefPtr Parser::parse_block_statement(ASTNode& parent) auto block_statement = create_ast_node(parent, position(), {}); consume(Token::Type::LeftCurly); while (!eof() && peek().type() != Token::Type::RightCurly) { - block_statement->m_statements.append(parse_statement(*block_statement)); + block_statement->add_statement(parse_statement(*block_statement)); } consume(Token::Type::RightCurly); block_statement->set_end(position()); @@ -330,7 +330,7 @@ NonnullRefPtr Parser::parse_variable_declaration(ASTNode& p var->set_end(position()); return var; } - var->m_type = parse_type(var); + var->set_type(parse_type(var)); auto identifier_token = consume(Token::Type::Identifier); RefPtr initial_value; @@ -347,8 +347,8 @@ NonnullRefPtr Parser::parse_variable_declaration(ASTNode& p consume(Token::Type::Semicolon); var->set_end(position()); - var->m_name = text_of_token(identifier_token); - var->m_initial_value = move(initial_value); + var->set_name(text_of_token(identifier_token)); + var->set_initial_value(move(initial_value)); return var; } @@ -510,9 +510,9 @@ NonnullRefPtr Parser::parse_unary_expression(ASTNode& parent) default: break; } - unary_exp->m_op = op; + unary_exp->set_op(op); auto lhs = parse_expression(*unary_exp); - unary_exp->m_lhs = lhs; + unary_exp->set_lhs(lhs); unary_exp->set_end(lhs->end()); return unary_exp; } @@ -573,9 +573,9 @@ NonnullRefPtr Parser::parse_secondary_expression(ASTNode& parent, No consume(); auto exp = create_ast_node(parent, lhs->start(), {}); lhs->set_parent(*exp); - exp->m_object = move(lhs); + exp->set_object(move(lhs)); auto identifier_token = consume(Token::Type::Identifier); - exp->m_property = create_ast_node(*exp, identifier_token.start(), identifier_token.end(), identifier_token.text()); + exp->set_property(create_ast_node(*exp, identifier_token.start(), identifier_token.end(), identifier_token.text())); exp->set_end(position()); return exp; } @@ -583,9 +583,9 @@ NonnullRefPtr Parser::parse_secondary_expression(ASTNode& parent, No consume(); auto func = create_ast_node(parent, lhs->start(), {}); lhs->set_parent(*func); - func->m_callee = lhs; + func->set_callee(move(lhs)); while (peek().type() != Token::Type::RightParen && !eof()) { - func->m_arguments.append(parse_expression(*func)); + func->add_argument(parse_expression(*func)); if (peek().type() == Token::Type::Comma) consume(Token::Type::Comma); } @@ -606,11 +606,11 @@ NonnullRefPtr Parser::parse_binary_expression(ASTNode& parent, consume(); // Operator auto exp = create_ast_node(parent, lhs->start(), {}); lhs->set_parent(*exp); - exp->m_op = op; - exp->m_lhs = move(lhs); + exp->set_op(op); + exp->set_lhs(move(lhs)); auto rhs = parse_expression(exp); exp->set_end(rhs->end()); - exp->m_rhs = move(rhs); + exp->set_rhs(move(rhs)); return exp; } @@ -619,11 +619,11 @@ NonnullRefPtr Parser::parse_assignment_expression(ASTNode& consume(); // Operator auto exp = create_ast_node(parent, lhs->start(), {}); lhs->set_parent(*exp); - exp->m_op = op; - exp->m_lhs = move(lhs); + exp->set_op(op); + exp->set_lhs(move(lhs)); auto rhs = parse_expression(exp); exp->set_end(rhs->end()); - exp->m_rhs = move(rhs); + exp->set_rhs(move(rhs)); return exp; } @@ -747,7 +747,7 @@ Optional> Parser::parse_parameter_list(ASTNode& p consume(Token::Type::Dot); consume(Token::Type::Dot); auto last_dot = consume(Token::Type::Dot); - param->m_is_ellipsis = true; + param->set_ellipsis(true); param->set_end(last_dot.end()); parameters.append(move(param)); } else { @@ -763,7 +763,7 @@ Optional> Parser::parse_parameter_list(ASTNode& p auto param = create_ast_node(parent, type->start(), name_identifier.has_value() ? name_identifier.value().end() : type->end(), name); - param->m_type = move(type); + param->set_type(move(type)); parameters.append(move(param)); } @@ -1042,7 +1042,7 @@ NonnullRefPtr Parser::parse_string_literal(ASTNode& parent) auto text = text_in_range(start_token.start(), end_token.end()); auto string_literal = create_ast_node(parent, start_token.start(), end_token.end()); - string_literal->m_value = text; + string_literal->set_value(move(text)); return string_literal; } @@ -1052,8 +1052,7 @@ NonnullRefPtr Parser::parse_return_statement(ASTNode& parent) auto return_statement = create_ast_node(parent, position(), {}); consume(Token::Type::Keyword); if (!peek(Token::Type::Semicolon).has_value()) { - auto expression = parse_expression(*return_statement); - return_statement->m_value = expression; + return_statement->set_value(parse_expression(*return_statement)); } return_statement->set_end(position()); return return_statement; @@ -1067,16 +1066,16 @@ NonnullRefPtr Parser::parse_enum_declaration(ASTNode& parent) if (match_keyword("class")) { consume(Token::Type::Keyword); - enum_decl->type = EnumDeclaration::Type::EnumClass; + enum_decl->set_type(EnumDeclaration::Type::EnumClass); } else { - enum_decl->type = EnumDeclaration::Type::RegularEnum; + enum_decl->set_type(EnumDeclaration::Type::RegularEnum); } auto name_token = consume(Token::Type::Identifier); - enum_decl->m_name = text_of_token(name_token); + enum_decl->set_name(text_of_token(name_token)); consume(Token::Type::LeftCurly); while (!eof() && peek().type() != Token::Type::RightCurly) { - enum_decl->m_entries.append(text_of_token(consume(Token::Type::Identifier))); + enum_decl->add_entry(text_of_token(consume(Token::Type::Identifier))); if (peek().type() != Token::Type::Comma) { break; } @@ -1129,12 +1128,12 @@ NonnullRefPtr Parser::parse_class_declaration(ASTNode& auto decl = create_ast_node(parent, position(), {}, type); auto name_token = consume(Token::Type::Identifier); - decl->m_name = text_of_token(name_token); + decl->set_name(text_of_token(name_token)); consume(Token::Type::LeftCurly); while (!eof() && peek().type() != Token::Type::RightCurly) { - decl->m_members = parse_class_members(*decl); + decl->set_members(parse_class_members(*decl)); } consume(Token::Type::RightCurly); @@ -1175,11 +1174,11 @@ NonnullRefPtr Parser::parse_type(ASTNode& parent) auto named_type = create_ast_node(parent, position(), {}); auto qualifiers = parse_type_qualifiers(); - named_type->m_qualifiers = move(qualifiers); + named_type->set_qualifiers(move(qualifiers)); if (match_keyword("auto")) { consume(Token::Type::Keyword); - named_type->m_is_auto = true; + named_type->set_auto(true); named_type->set_end(position()); return named_type; } @@ -1193,7 +1192,7 @@ NonnullRefPtr Parser::parse_type(ASTNode& parent) error(String::formatted("expected name instead of: {}", peek().text())); return named_type; } - named_type->m_name = parse_name(*named_type); + named_type->set_name(parse_name(*named_type)); NonnullRefPtr type = named_type; while (!eof() && peek().type() == Token::Type::Asterisk) { @@ -1201,7 +1200,7 @@ NonnullRefPtr Parser::parse_type(ASTNode& parent) auto asterisk = consume(); auto ptr = create_ast_node(parent, type->start(), asterisk.end()); type->set_parent(*ptr); - ptr->m_pointee = type; + ptr->set_pointee(type); ptr->set_end(position()); type = ptr; } @@ -1217,20 +1216,20 @@ NonnullRefPtr Parser::parse_for_statement(ASTNode& parent) consume(Token::Type::Keyword); consume(Token::Type::LeftParen); if (peek().type() != Token::Type::Semicolon) - for_statement->m_init = parse_variable_declaration(*for_statement, false); + for_statement->set_init(parse_variable_declaration(*for_statement, false)); consume(Token::Type::Semicolon); if (peek().type() != Token::Type::Semicolon) - for_statement->m_test = parse_expression(*for_statement); + for_statement->set_test(parse_expression(*for_statement)); consume(Token::Type::Semicolon); if (peek().type() != Token::Type::RightParen) - for_statement->m_update = parse_expression(*for_statement); + for_statement->set_update(parse_expression(*for_statement)); consume(Token::Type::RightParen); - for_statement->m_body = parse_statement(*for_statement); + for_statement->set_body(parse_statement(*for_statement)); - for_statement->set_end(for_statement->m_body->end()); + for_statement->set_end(for_statement->body()->end()); return for_statement; } @@ -1240,15 +1239,15 @@ NonnullRefPtr Parser::parse_if_statement(ASTNode& parent) auto if_statement = create_ast_node(parent, position(), {}); consume(Token::Type::Keyword); consume(Token::Type::LeftParen); - if_statement->m_predicate = parse_expression(*if_statement); + if_statement->set_predicate(parse_expression(*if_statement)); consume(Token::Type::RightParen); - if_statement->m_then = parse_statement(*if_statement); + if_statement->set_then_statement(parse_statement(*if_statement)); if (match_keyword("else")) { consume(Token::Type::Keyword); - if_statement->m_else = parse_statement(*if_statement); - if_statement->set_end(if_statement->m_else->end()); + if_statement->set_else_statement(parse_statement(*if_statement)); + if_statement->set_end(if_statement->else_statement()->end()); } else { - if_statement->set_end(if_statement->m_then->end()); + if_statement->set_end(if_statement->then_statement()->end()); } return if_statement; } @@ -1340,11 +1339,11 @@ NonnullRefPtr Parser::parse_namespace_declaration(ASTNode& consume(Token::Type::Keyword); auto name_token = consume(Token::Type::Identifier); - namespace_decl->m_name = name_token.text(); + namespace_decl->set_name(name_token.text()); if (peek().type() == Token::Type::ColonColon) { consume(Token::Type::ColonColon); - namespace_decl->m_declarations.append(parse_namespace_declaration(*namespace_decl, true)); + namespace_decl->add_declaration(parse_namespace_declaration(*namespace_decl, true)); namespace_decl->set_end(position()); return namespace_decl; } @@ -1353,7 +1352,7 @@ NonnullRefPtr Parser::parse_namespace_declaration(ASTNode& while (!eof() && peek().type() != Token::Type::RightCurly) { auto declaration = parse_single_declaration_in_translation_unit(*namespace_decl); if (declaration) { - namespace_decl->m_declarations.append(declaration.release_nonnull()); + namespace_decl->add_declaration(declaration.release_nonnull()); } else { error("unexpected token"); consume(); @@ -1376,13 +1375,13 @@ NonnullRefPtr Parser::parse_name(ASTNode& parent) NonnullRefPtr name_node = create_ast_node(parent, position(), {}); while (!eof() && (peek().type() == Token::Type::Identifier || peek().type() == Token::Type::KnownType) && peek(1).type() == Token::Type::ColonColon) { auto token = consume(); - name_node->m_scope.append(create_ast_node(*name_node, token.start(), token.end(), token.text())); + name_node->add_to_scope(create_ast_node(*name_node, token.start(), token.end(), token.text())); consume(Token::Type::ColonColon); } if (peek().type() == Token::Type::Identifier || peek().type() == Token::Type::KnownType) { auto token = consume(); - name_node->m_name = create_ast_node(*name_node, token.start(), token.end(), token.text()); + name_node->set_name(create_ast_node(*name_node, token.start(), token.end(), token.text())); } else { name_node->set_end(position()); return name_node; @@ -1391,12 +1390,12 @@ NonnullRefPtr Parser::parse_name(ASTNode& parent) if (match_template_arguments()) { consume(Token::Type::Less); NonnullRefPtr templatized_name = create_ast_node(parent, name_node->start(), {}); - templatized_name->m_name = move(name_node->m_name); - templatized_name->m_scope = move(name_node->m_scope); + templatized_name->set_name(name_node->name()); + templatized_name->set_scope(name_node->scope()); name_node->set_end(position()); name_node = templatized_name; while (peek().type() != Token::Type::Greater && !eof()) { - templatized_name->m_template_arguments.append(parse_type(*templatized_name)); + templatized_name->add_template_argument(parse_type(*templatized_name)); if (peek().type() == Token::Type::Comma) consume(Token::Type::Comma); } @@ -1448,9 +1447,9 @@ NonnullRefPtr Parser::parse_c_style_cast_expression(ASTNod auto parse_exp = create_ast_node(parent, position(), {}); consume(Token::Type::LeftParen); - parse_exp->m_type = parse_type(*parse_exp); + parse_exp->set_type(parse_type(*parse_exp)); consume(Token::Type::RightParen); - parse_exp->m_expression = parse_expression(*parse_exp); + parse_exp->set_expression(parse_expression(*parse_exp)); parse_exp->set_end(position()); return parse_exp; @@ -1460,14 +1459,14 @@ NonnullRefPtr Parser::parse_cpp_cast_expression(ASTNode& pare { auto cast_expression = create_ast_node(parent, position(), {}); - cast_expression->m_cast_type = consume(Token::Type::Keyword).text(); + cast_expression->set_cast_type(consume(Token::Type::Keyword).text()); consume(Token::Type::Less); - cast_expression->m_type = parse_type(*cast_expression); + cast_expression->set_type(parse_type(*cast_expression)); consume(Token::Type::Greater); consume(Token::Type::LeftParen); - cast_expression->m_expression = parse_expression(*cast_expression); + cast_expression->set_expression(parse_expression(*cast_expression)); consume(Token::Type::RightParen); cast_expression->set_end(position()); @@ -1485,7 +1484,7 @@ NonnullRefPtr Parser::parse_sizeof_expression(ASTNode& parent) auto exp = create_ast_node(parent, position(), {}); consume(Token::Type::Keyword); consume(Token::Type::LeftParen); - exp->m_type = parse_type(parent); + exp->set_type(parse_type(parent)); consume(Token::Type::RightParen); exp->set_end(position()); return exp; @@ -1502,7 +1501,7 @@ NonnullRefPtr Parser::parse_braced_init_list(ASTNode& parent) consume(Token::Type::LeftCurly); while (!eof() && peek().type() != Token::Type::RightCurly) { - init_list->m_expressions.append(parse_expression(*init_list)); + init_list->add_expression(parse_expression(*init_list)); } consume(Token::Type::RightCurly); init_list->set_end(position()); @@ -1592,7 +1591,7 @@ void Parser::parse_constructor_or_destructor_impl(FunctionDeclaration& func, Cto if (name_token.type() != Token::Type::Identifier && name_token.type() != Token::Type::KnownType) { error("Unexpected constructor name"); } - func.m_name = name_token.text(); + func.set_name(name_token.text()); consume(Token::Type::LeftParen); auto parameters = parse_parameter_list(func); @@ -1600,7 +1599,7 @@ void Parser::parse_constructor_or_destructor_impl(FunctionDeclaration& func, Cto if (type == CtorOrDtor::Dtor && !parameters->is_empty()) error("Destructor declaration that takes parameters"); else - func.m_parameters = move(parameters.value()); + func.set_parameters(parameters.value()); } consume(Token::Type::RightParen); @@ -1619,7 +1618,7 @@ void Parser::parse_constructor_or_destructor_impl(FunctionDeclaration& func, Cto consume(Token::Type::Semicolon); } - func.m_definition = move(body); + func.set_definition(move(body)); func.set_end(ctor_end); }