From 48593a4350353e8f09ec6e2876b73e87c7148272 Mon Sep 17 00:00:00 2001 From: CHatingPython Date: Tue, 26 May 2026 14:11:28 +0200 Subject: [PATCH] Add ast::node and handle comparison And parser test for literals fingerscrossed This commit is good, innit? But there will also be second one, and dessert Signed-off-by: CHatingPython --- .clang-tidy | 3 +- furc/include/furc/ast/declaration.hpp | 12 +++++++ furc/include/furc/ast/expression.hpp | 2 ++ furc/include/furc/ast/literal.hpp | 11 ++++--- furc/include/furc/ast/node.hpp | 7 +++- furc/include/furc/ast/program.hpp | 2 ++ furc/include/furc/ast/statement.hpp | 6 ++++ furc/include/furc/diag.hpp | 6 ++++ furc/include/furc/handle.hpp | 41 ++++++++++++++++++------ furc/src/ast.cpp | 46 +++++++++++++++++++++++++++ furc/src/front/parser.cpp | 2 +- furc/test/parser.cpp | 27 ++++++++++++++++ 12 files changed, 148 insertions(+), 17 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index 0dec191..b8580c9 100755 --- a/.clang-tidy +++ b/.clang-tidy @@ -27,7 +27,8 @@ Checks: > -cppcoreguidelines-pro-bounds-constant-array-index, -cppcoreguidelines-macro-usage, -cppcoreguidelines-owning-memory, - -cppcoreguidelines-non-private-member-variables-in-classes + -cppcoreguidelines-non-private-member-variables-in-classes, + -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access WarningsAsErrors: "*" diff --git a/furc/include/furc/ast/declaration.hpp b/furc/include/furc/ast/declaration.hpp index 56ef412..2e758ce 100644 --- a/furc/include/furc/ast/declaration.hpp +++ b/furc/include/furc/ast/declaration.hpp @@ -23,11 +23,19 @@ public: statement_node_t statement_type() const override { return statement_node_t::Declaration; } virtual declaration_node_t declaration_type() const = 0; +protected: + bool equal(const node& rhs) const override; }; struct function_body { location begin, end; std::vector> statements; + + bool operator==(const function_body& rhs) const { + return begin == rhs.begin && end == rhs.end && statements == rhs.statements; + } + + bool operator!=(const function_body& rhs) const { return !this->operator==(rhs); } }; using function_body_handle = handle; @@ -42,6 +50,8 @@ public: front::token name() const { return m_name; } public: std::ostream& print(std::ostream& os) const override; +protected: + bool equal(const node& rhs) const override; protected: front::token m_name; }; @@ -56,6 +66,8 @@ public: const function_body_handle& body() const { return m_body; } public: std::ostream& print(std::ostream& os) const override; +protected: + bool equal(const node& rhs) const override; private: function_body_handle m_body; }; diff --git a/furc/include/furc/ast/expression.hpp b/furc/include/furc/ast/expression.hpp index 48ef95a..059a1d6 100644 --- a/furc/include/furc/ast/expression.hpp +++ b/furc/include/furc/ast/expression.hpp @@ -18,6 +18,8 @@ public: statement_node_t statement_type() const override { return statement_node_t::Expression; } virtual expression_node_t expression_type() const = 0; +protected: + bool equal(const node& rhs) const override; }; } // namespace ast diff --git a/furc/include/furc/ast/literal.hpp b/furc/include/furc/ast/literal.hpp index 47f7b1b..557ba95 100644 --- a/furc/include/furc/ast/literal.hpp +++ b/furc/include/furc/ast/literal.hpp @@ -20,6 +20,8 @@ public: expression_node_t expression_type() const override { return expression_node_t::Literal; } virtual literal_node_t literal_type() const = 0; +protected: + bool equal(const node& rhs) const override; }; class string_literal_node : public literal_node { @@ -31,10 +33,9 @@ public: const handle& value() const { return m_value; } public: - std::ostream& print(std::ostream& os) const override { - if (m_value.has_error()) return os << m_value.error(); - return os << "string literal (" << *m_value << ")"; - } + std::ostream& print(std::ostream& os) const override; +protected: + bool equal(const node& rhs) const override; private: handle m_value; }; @@ -49,6 +50,8 @@ public: const handle& value() const { return m_value; } public: std::ostream& print(std::ostream& os) const override; +protected: + bool equal(const node& rhs) const override; private: handle m_value; }; diff --git a/furc/include/furc/ast/node.hpp b/furc/include/furc/ast/node.hpp index fa06801..c6b307e 100644 --- a/furc/include/furc/ast/node.hpp +++ b/furc/include/furc/ast/node.hpp @@ -37,10 +37,15 @@ public: node& operator=(const node&) = delete; public: virtual node_t category() const = 0; - +public: + bool operator==(const node& rhs) const { return category() == rhs.category() && equal(rhs); } + bool operator!=(const node& rhs) const { return !this->operator==(rhs); } +public: virtual std::ostream& print(std::ostream& os) const = 0; friend std::ostream& operator<<(std::ostream& os, const node& node) { return node.print(os); } +protected: + virtual bool equal(const node& rhs) const = 0; }; template diff --git a/furc/include/furc/ast/program.hpp b/furc/include/furc/ast/program.hpp index b1e151b..1f5b137 100644 --- a/furc/include/furc/ast/program.hpp +++ b/furc/include/furc/ast/program.hpp @@ -20,6 +20,8 @@ public: const std::vector>& declarations() const { return m_declarations; } public: std::ostream& print(std::ostream& os) const override; +protected: + bool equal(const node& rhs) const override; private: std::vector> m_declarations; }; diff --git a/furc/include/furc/ast/statement.hpp b/furc/include/furc/ast/statement.hpp index 34994fe..160b385 100644 --- a/furc/include/furc/ast/statement.hpp +++ b/furc/include/furc/ast/statement.hpp @@ -17,6 +17,8 @@ public: node_t category() const override { return node_t::Statement; } virtual statement_node_t statement_type() const = 0; +protected: + bool equal(const node& rhs) const override; }; class expression_node; @@ -26,10 +28,14 @@ public: return_statement_node(node_handle&& value) : m_value(std::move(value)) {} +public: + node_handle value() const { return m_value; } public: statement_node_t statement_type() const override { return statement_node_t::Return; } std::ostream& print(std::ostream& os) const override; +protected: + bool equal(const node& rhs) const override; private: node_handle m_value; }; diff --git a/furc/include/furc/diag.hpp b/furc/include/furc/diag.hpp index 2e99fb5..59e15de 100644 --- a/furc/include/furc/diag.hpp +++ b/furc/include/furc/diag.hpp @@ -10,6 +10,12 @@ struct location { std::string_view filename; std::size_t line = 0; std::size_t column = 0; + + bool operator==(const location& rhs) const { + return filename == rhs.filename && line == rhs.line && column == rhs.column; + } + + bool operator!=(const location& rhs) const { return !this->operator==(rhs); } }; static inline std::ostream& operator<<(std::ostream& os, const location& location) { diff --git a/furc/include/furc/handle.hpp b/furc/include/furc/handle.hpp index 8bc52ac..04ae96f 100644 --- a/furc/include/furc/handle.hpp +++ b/furc/include/furc/handle.hpp @@ -80,7 +80,16 @@ public: pointer operator->() { return &m_value.value(); } // NOLINT(bugprone-unchecked-optional-access) const_pointer operator->() const { return &m_value.value(); } // NOLINT(bugprone-unchecked-optional-access) public: - bool operator==(const T& rhs) const { return m_value.has_value() && *m_value == rhs; } + bool operator==(const handle& rhs) const { + if (present() != rhs.present() || error() != rhs.error()) return false; + if (m_value.has_value() && m_value.value() != rhs.m_value.value()) // NOLINT(bugprone-unchecked-optional-access) + return false; + return true; + } + + bool operator==(const T& rhs) const { + return m_value.has_value() && *m_value == rhs; // NOLINT(bugprone-unchecked-optional-access) + } public: friend std::ostream& operator<<(std::ostream& os, const handle& result) { os << result.m_location << ": "; @@ -167,13 +176,23 @@ public: bool present() const { return m_data.has_value() && m_data->value != nullptr; } bool has_error() const { return m_data.has_value() && m_data->value == nullptr; } - std::shared_ptr shared() const { return m_data->value; } - Error error() const { return m_data->error; } + std::shared_ptr shared() const { return m_data->value; } // NOLINT(bugprone-unchecked-optional-access) + Error error() const { return m_data->error; } // NOLINT(bugprone-unchecked-optional-access) - reference operator*() { return *m_data->value; } - const_reference operator*() const { return *m_data->value; } - pointer operator->() { return m_data->value.get(); } - const_pointer operator->() const { return m_data->value.get(); } + reference operator*() { return *m_data->value; } // NOLINT(bugprone-unchecked-optional-access) + const_reference operator*() const { return *m_data->value; } // NOLINT(bugprone-unchecked-optional-access) + pointer operator->() { return m_data->value.get(); } // NOLINT(bugprone-unchecked-optional-access) + const_pointer operator->() const { return m_data->value.get(); } // NOLINT(bugprone-unchecked-optional-access) +public: + bool operator==(const handle& rhs) const { + if (present() != rhs.present() || error() != rhs.error()) return false; + if (present() && m_data->value != rhs.m_data->value) return false; // NOLINT(bugprone-unchecked-optional-access) + return true; + } + + bool operator==(const value_type& rhs) const { + return present() && *m_data->value == rhs; // NOLINT(bugprone-unchecked-optional-access) + } public: friend std::ostream& operator<<(std::ostream& os, const handle& result) { if (!result.m_data.has_value()) return os << "handle empty"; @@ -211,11 +230,13 @@ private: template || std::is_base_of_v>> data(const handle& other) - : location(other.m_data->location) { + : location(other.m_data->location) { // NOLINT(bugprone-unchecked-optional-access) if constexpr (std::is_base_of_v) { - value = std::static_pointer_cast(std::move(other.m_data->value)); + value = std::static_pointer_cast( + std::move(other.m_data->value)); // NOLINT(bugprone-unchecked-optional-access) } else { - value = std::dynamic_pointer_cast(std::move(other.m_data->value)); + value = std::dynamic_pointer_cast( + std::move(other.m_data->value)); // NOLINT(bugprone-unchecked-optional-access) } } diff --git a/furc/src/ast.cpp b/furc/src/ast.cpp index 4ccbbd9..e4e0720 100644 --- a/furc/src/ast.cpp +++ b/furc/src/ast.cpp @@ -8,15 +8,44 @@ namespace furc::ast { +bool literal_node::equal(const node& rhs) const { + return literal_type() == reinterpret_cast(rhs).literal_type(); +} + std::ostream& integer_literal_node::print(std::ostream& os) const { if (m_value.has_error()) return os << m_value.error(); return os << "integer literal (" << *m_value << ")"; } +bool integer_literal_node::equal(const node& rhs) const { + return literal_node::equal(rhs) && m_value == reinterpret_cast(rhs).m_value; +} + +std::ostream& string_literal_node::print(std::ostream& os) const { + if (m_value.has_error()) return os << m_value.error(); + return os << "string literal (" << *m_value << ")"; +} + +bool string_literal_node::equal(const node& rhs) const { + return literal_node::equal(rhs) && m_value == reinterpret_cast(rhs).m_value; +} + +bool expression_node::equal(const node& rhs) const { + return expression_type() == reinterpret_cast(rhs).expression_type(); +} + +bool declaration_node::equal(const node& rhs) const { + return declaration_type() == reinterpret_cast(rhs).declaration_type(); +} + std::ostream& function_declarartion_node::print(std::ostream& os) const { return os << "function " << m_name->string << " declaration"; } +bool function_declarartion_node::equal(const node& rhs) const { + return declaration_node::equal(rhs) && m_name == reinterpret_cast(rhs).m_name; +} + std::ostream& function_definition_node::print(std::ostream& os) const { function_declarartion_node::print(os); os << ':'; @@ -28,12 +57,29 @@ std::ostream& function_definition_node::print(std::ostream& os) const { return os << m_body.error(); // error } +bool function_definition_node::equal(const node& rhs) const { + return function_declarartion_node::equal(rhs) && + m_body == reinterpret_cast(rhs).m_body; +} + +bool statement_node::equal(const node& rhs) const { + return statement_type() == reinterpret_cast(rhs).statement_type(); +} + std::ostream& return_statement_node::print(std::ostream& os) const { os << "return statement"; if (m_value.present()) return os << " (" << *m_value << ')'; return os; } +bool return_statement_node::equal(const node& rhs) const { + return statement_node::equal(rhs) && m_value == reinterpret_cast(rhs).m_value; +} + +bool program_node::equal(const node& rhs) const { + return m_declarations == reinterpret_cast(rhs).m_declarations; +} + std::ostream& program_node::print(std::ostream& os) const { os << "program:"; for (const auto& handle : m_declarations) { diff --git a/furc/src/front/parser.cpp b/furc/src/front/parser.cpp index 2a30283..9b1ce03 100644 --- a/furc/src/front/parser.cpp +++ b/furc/src/front/parser.cpp @@ -28,7 +28,7 @@ parser::parser(std::string_view filename) ast::node_handle parser::parse() & { auto program = m_arena.allocate_shared(); - while (!m_lexer.empty()) { + while (peek_token()->type != token_t::None && !m_lexer.empty()) { program->push(std::move(parse_declaration())); } diff --git a/furc/test/parser.cpp b/furc/test/parser.cpp index ab03ec3..f61b43f 100644 --- a/furc/test/parser.cpp +++ b/furc/test/parser.cpp @@ -30,4 +30,31 @@ TEST(Parser, EmptyFunctions) { } } +TEST(Parser, Literals) { + parser parser("", R"( + func test1() { return 67; } + func test2() { return "uwu"; } + )"); + auto program = parser.parse(); + EXPECT_TRUE(program.present()); + EXPECT_EQ(program->declarations().size(), 2); + { + auto test1 = program->declarations()[0]; + EXPECT_TRUE(test1.present()); + EXPECT_EQ(test1->declaration_type(), declaration_node_t::FunctionDefinition); + node_handle funcDef = test1; + EXPECT_EQ(funcDef->name()->string, "test1"); + EXPECT_EQ(funcDef->body()->statements.size(), 1); + node_handle ret = funcDef->body()->statements[0]; + EXPECT_EQ(ret->value(), integer_literal_node({ furc::location{ "", 1, 26 }, 67 })); + } + { + auto test2 = program->declarations()[1]; + EXPECT_TRUE(test2.present()); + EXPECT_EQ(test2->declaration_type(), declaration_node_t::FunctionDefinition); + node_handle funcDecl = test2; + EXPECT_EQ(funcDecl->name()->string, "test2"); + } +} + } // namespace \ No newline at end of file