From 8d7218ae648550b67d0a68525ec616ef4efa1694 Mon Sep 17 00:00:00 2001 From: Kevin Traini Date: Sat, 26 Aug 2023 17:31:13 +0200 Subject: [PATCH] Replace some throw by MessageCollector --- README.md | 7 +-- src/lib/ast/AST.h | 54 +++++++++++---------- src/lib/ast/AbstractExpression.cpp | 8 ++- src/lib/ast/ArrayOperator.cpp | 15 ++++-- src/lib/ast/AssignationOperator.cpp | 23 +++++++-- src/lib/ast/ClassicOperator.cpp | 6 ++- src/lib/ast/FunctionOperator.cpp | 15 ++++-- src/lib/ast/PostUnaryCalcul.cpp | 3 +- src/lib/ast/PreUnaryCalcul.cpp | 3 +- src/lib/message/MessageCollector.cpp | 5 ++ src/lib/message/MessageCollector.h | 2 + tests/unit/ast/AbstractExpressionTest.cpp | 16 ++++-- tests/unit/ast/IdentifierTest.cpp | 2 +- tests/unit/ast/ProgramTest.cpp | 7 ++- tests/unit/message/MessageCollectorTest.cpp | 30 +++++++++--- 15 files changed, 138 insertions(+), 58 deletions(-) diff --git a/README.md b/README.md index 0ce5a954..9199de4a 100644 --- a/README.md +++ b/README.md @@ -92,8 +92,9 @@ DEV WARNING | ^ ``` -| Dev code | Meaning | File | -|:------------:|:--------------------------------------------|:-----------------------------------| -| 2 | Lexer found a character that is not regular | `src/lib/ast/CharacterLiteral.cpp` | +| Dev code | Meaning | File | +|:------------:|:-----------------------------------------------------|:---------------------------------------| +| 2 | Lexer found a character that is not regular | `src/lib/ast/CharacterLiteral.cpp` | +| 3 | A function that should not be called has been called | Several files (refer to error message) | These codes are for events that should not happen, but if they do, it's better to fix them. diff --git a/src/lib/ast/AST.h b/src/lib/ast/AST.h index 8232d93e..7c3123a5 100644 --- a/src/lib/ast/AST.h +++ b/src/lib/ast/AST.h @@ -363,12 +363,14 @@ namespace filc::ast { [[nodiscard]] virtual auto dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * = 0; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * = 0; [[nodiscard]] virtual auto dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * = 0; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * = 0; protected: Operator() = default; @@ -404,15 +406,15 @@ namespace filc::ast { [[nodiscard]] auto dump() const -> std::string override; - [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; - [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; private: OPERATOR _operator; @@ -428,15 +430,15 @@ namespace filc::ast { [[nodiscard]] auto dump() const -> std::string override; - [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; - [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; private: AbstractExpression *_expression; @@ -452,15 +454,15 @@ namespace filc::ast { [[nodiscard]] auto dump() const -> std::string override; - [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; - [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; private: std::vector _expressions; @@ -476,15 +478,15 @@ namespace filc::ast { [[nodiscard]] auto dump() const -> std::string override; - [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; - [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, - AbstractType *called_on, + [[nodiscard]] auto dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * override; + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * override; private: Operator *_inner_operator; diff --git a/src/lib/ast/AbstractExpression.cpp b/src/lib/ast/AbstractExpression.cpp index e655b8de..42e73d3f 100644 --- a/src/lib/ast/AbstractExpression.cpp +++ b/src/lib/ast/AbstractExpression.cpp @@ -22,7 +22,7 @@ * SOFTWARE. */ #include "AST.h" -#include +#include "Error.h" namespace filc::ast { AbstractExpression::~AbstractExpression() { @@ -56,6 +56,10 @@ namespace filc::ast { auto AbstractExpression::resolveType(filc::environment::Environment *environment, filc::message::MessageCollector *collector, AbstractType *preferred_type) -> void { - throw std::logic_error("Not implemented"); + collector->addError( + new filc::message::Error(filc::message::FATAL_ERROR, + "resolveType not implemented", + getPosition()) + ); } } diff --git a/src/lib/ast/ArrayOperator.cpp b/src/lib/ast/ArrayOperator.cpp index 48e1fb1e..bf967243 100644 --- a/src/lib/ast/ArrayOperator.cpp +++ b/src/lib/ast/ArrayOperator.cpp @@ -22,6 +22,7 @@ * SOFTWARE. */ #include "AST.h" +#include "DevWarning.h" namespace filc::ast { ArrayOperator::ArrayOperator(filc::ast::AbstractExpression *expression) @@ -42,14 +43,22 @@ namespace filc::ast { auto ArrayOperator::dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { - throw std::logic_error("Should not be called"); + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { + collector->addError(new filc::message::DevWarning( + 3, + position, + "ArrayOperator::dumpPreLambdaType should not be called but has been called" + )); + + return nullptr; } auto ArrayOperator::dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { _expression->resolveType(environment, collector); auto *expression_type = _expression->getExpressionType(); if (expression_type == nullptr) { diff --git a/src/lib/ast/AssignationOperator.cpp b/src/lib/ast/AssignationOperator.cpp index fcb117f1..586054f2 100644 --- a/src/lib/ast/AssignationOperator.cpp +++ b/src/lib/ast/AssignationOperator.cpp @@ -22,6 +22,7 @@ * SOFTWARE. */ #include "AST.h" +#include "DevWarning.h" namespace filc::ast { AssignationOperator::AssignationOperator(filc::ast::Operator *inner_operator) @@ -42,14 +43,28 @@ namespace filc::ast { auto AssignationOperator::dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { - throw std::logic_error("Should not be called"); + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { + collector->addError(new filc::message::DevWarning( + 3, + position, + "AssignationOperator::dumpPreLambdaType should not be called but has been called" + )); + + return nullptr; } auto AssignationOperator::dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { - throw std::logic_error("Should not be called"); + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { + collector->addError(new filc::message::DevWarning( + 3, + position, + "AssignationOperator::dumpPostLambdaType should not be called but has been called" + )); + + return nullptr; } } diff --git a/src/lib/ast/ClassicOperator.cpp b/src/lib/ast/ClassicOperator.cpp index d0deb063..7506ac61 100644 --- a/src/lib/ast/ClassicOperator.cpp +++ b/src/lib/ast/ClassicOperator.cpp @@ -79,14 +79,16 @@ namespace filc::ast { auto ClassicOperator::dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { return new LambdaType({}, return_type, called_on); } auto ClassicOperator::dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { if (!environment->hasType("void")) { environment->addType(new filc::ast::Type(new filc::ast::Identifier("void"))); } diff --git a/src/lib/ast/FunctionOperator.cpp b/src/lib/ast/FunctionOperator.cpp index 560555a4..015af003 100644 --- a/src/lib/ast/FunctionOperator.cpp +++ b/src/lib/ast/FunctionOperator.cpp @@ -22,6 +22,7 @@ * SOFTWARE. */ #include "AST.h" +#include "DevWarning.h" namespace filc::ast { FunctionOperator::FunctionOperator(const std::vector &expressions) @@ -44,14 +45,22 @@ namespace filc::ast { auto FunctionOperator::dumpPreLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { - throw std::logic_error("Should not be called"); + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { + collector->addError(new filc::message::DevWarning( + 3, + position, + "FunctionOperator::dumpPreLambdaType should not be called but has been called" + )); + + return nullptr; } auto FunctionOperator::dumpPostLambdaType(AbstractType *return_type, AbstractType *called_on, filc::environment::Environment *environment, - filc::message::MessageCollector *collector) const -> LambdaType * { + filc::message::MessageCollector *collector, + filc::utils::Position *position) const -> LambdaType * { std::vector args_types; for (const auto &expression: _expressions) { expression->resolveType(environment, collector, nullptr); diff --git a/src/lib/ast/PostUnaryCalcul.cpp b/src/lib/ast/PostUnaryCalcul.cpp index e61097e4..5102cc72 100644 --- a/src/lib/ast/PostUnaryCalcul.cpp +++ b/src/lib/ast/PostUnaryCalcul.cpp @@ -38,7 +38,8 @@ namespace filc::ast { } auto operator_name = "operator" + getOperator()->dump(); - auto *operator_type = getOperator()->dumpPostLambdaType(variable_type, variable_type, environment, collector); + auto *operator_type = getOperator()->dumpPostLambdaType(variable_type, variable_type, environment, collector, + getPosition()); if (environment->getName(operator_name, operator_type) == nullptr) { collector->addError( new filc::message::Error(filc::message::ERROR, diff --git a/src/lib/ast/PreUnaryCalcul.cpp b/src/lib/ast/PreUnaryCalcul.cpp index 666c0c7c..586919ff 100644 --- a/src/lib/ast/PreUnaryCalcul.cpp +++ b/src/lib/ast/PreUnaryCalcul.cpp @@ -38,7 +38,8 @@ namespace filc::ast { } auto operator_name = "operator" + getOperator()->dump(); - auto *operator_type = getOperator()->dumpPreLambdaType(variable_type, variable_type, environment, collector); + auto *operator_type = getOperator()->dumpPreLambdaType(variable_type, variable_type, environment, collector, + getPosition()); if (environment->getName(operator_name, operator_type) == nullptr) { collector->addError( new filc::message::Error(filc::message::ERROR, diff --git a/src/lib/message/MessageCollector.cpp b/src/lib/message/MessageCollector.cpp index a6b25ff9..e670df01 100644 --- a/src/lib/message/MessageCollector.cpp +++ b/src/lib/message/MessageCollector.cpp @@ -90,4 +90,9 @@ namespace filc::message { return collector; } + + auto MessageCollector::flush() -> void { + _errors.clear(); + _messages.clear(); + } } diff --git a/src/lib/message/MessageCollector.h b/src/lib/message/MessageCollector.h index a3d91d78..4e3c1ae0 100644 --- a/src/lib/message/MessageCollector.h +++ b/src/lib/message/MessageCollector.h @@ -50,6 +50,8 @@ namespace filc::message { static auto getCollector(LEVEL level = FATAL_ERROR) -> MessageCollector *; + auto flush() -> void; + private: LEVEL _level; std::vector _messages; diff --git a/tests/unit/ast/AbstractExpressionTest.cpp b/tests/unit/ast/AbstractExpressionTest.cpp index 923ea7d0..3d90e50a 100644 --- a/tests/unit/ast/AbstractExpressionTest.cpp +++ b/tests/unit/ast/AbstractExpressionTest.cpp @@ -61,13 +61,19 @@ TEST(AbstractExpression, expression_type) { ASSERT_TYPE("int", obj1.getExpressionType()); } +#define COLLECTOR filc::message::MessageCollector::getCollector() + // NOLINTBEGIN(readability-function-cognitive-complexity) TEST(AbstractExpression, resolveType) { class : public filc::ast::AbstractExpression { } obj1; - ASSERT_THROW(obj1.resolveType(nullptr, nullptr, nullptr), std::logic_error); - ASSERT_THROW(obj1.resolveType(new filc::environment::Environment, nullptr, nullptr), std::logic_error); + obj1.resolveType(nullptr, COLLECTOR, nullptr); + ASSERT_TRUE(COLLECTOR->hasErrors()); + COLLECTOR->flush(); + obj1.resolveType(new filc::environment::Environment, COLLECTOR, nullptr); + ASSERT_TRUE(COLLECTOR->hasErrors()); + COLLECTOR->flush(); class : public filc::ast::AbstractExpression { public: @@ -78,7 +84,9 @@ TEST(AbstractExpression, resolveType) { } } obj2; - ASSERT_NO_THROW(obj2.resolveType(nullptr, nullptr, nullptr)); - ASSERT_NO_THROW(obj2.resolveType(new filc::environment::Environment, nullptr, nullptr)); + obj2.resolveType(nullptr, COLLECTOR, nullptr); + ASSERT_FALSE(COLLECTOR->hasErrors()); + obj2.resolveType(new filc::environment::Environment, COLLECTOR, nullptr); + ASSERT_FALSE(COLLECTOR->hasErrors()); } // NOLINTEND(readability-function-cognitive-complexity) \ No newline at end of file diff --git a/tests/unit/ast/IdentifierTest.cpp b/tests/unit/ast/IdentifierTest.cpp index ae49b934..5ba4f2db 100644 --- a/tests/unit/ast/IdentifierTest.cpp +++ b/tests/unit/ast/IdentifierTest.cpp @@ -37,7 +37,7 @@ TEST(Identifier, resolveType) { filc::ast::Identifier id1("hello"); id1.resolveType(environment, collector, nullptr); ASSERT_TRUE(collector->hasErrors()); - collector->printAll(); + collector->flush(); environment->addName("hello", new filc::ast::Type(new filc::ast::Identifier("int"))); id1.resolveType(environment, collector, nullptr); diff --git a/tests/unit/ast/ProgramTest.cpp b/tests/unit/ast/ProgramTest.cpp index 2b7f04bc..defb4045 100644 --- a/tests/unit/ast/ProgramTest.cpp +++ b/tests/unit/ast/ProgramTest.cpp @@ -51,9 +51,12 @@ TEST(Program, filename) { TEST(Program, resolveEnvironment) { filc::grammar::Parser parser1(FIXTURES_PATH "/grammar/module1.fil", COLLECTOR); auto *program1 = parser1.getProgram(); - ASSERT_NO_THROW(program1->resolveEnvironment(COLLECTOR)); + program1->resolveEnvironment(COLLECTOR); + ASSERT_FALSE(COLLECTOR->hasErrors()); + COLLECTOR->flush(); filc::grammar::Parser parser2(FIXTURES_PATH "/grammar/while1.fil", COLLECTOR); auto *program2 = parser2.getProgram(); - ASSERT_THROW(program2->resolveEnvironment(COLLECTOR), std::logic_error); + program2->resolveEnvironment(COLLECTOR); + ASSERT_TRUE(COLLECTOR->hasErrors()); } \ No newline at end of file diff --git a/tests/unit/message/MessageCollectorTest.cpp b/tests/unit/message/MessageCollectorTest.cpp index a802535d..13490719 100644 --- a/tests/unit/message/MessageCollectorTest.cpp +++ b/tests/unit/message/MessageCollectorTest.cpp @@ -24,7 +24,14 @@ #include "MessageCollector.h" #include -TEST(MessageCollector, getCollector) { +class MessageCollector : public testing::Test { +protected: + auto SetUp() -> void override { + filc::message::MessageCollector::getCollector()->flush(); + } +}; + +TEST_F(MessageCollector, getCollector) { auto *collector1 = filc::message::MessageCollector::getCollector(); auto *collector2 = filc::message::MessageCollector::getCollector(); ASSERT_EQ(collector1, collector2); @@ -35,7 +42,7 @@ TEST(MessageCollector, getCollector) { ASSERT_TRUE(collector2->hasMessages()); } -TEST(MessageCollector, hasMessages) { +TEST_F(MessageCollector, hasMessages) { auto *collector = filc::message::MessageCollector::getCollector(); ASSERT_FALSE(collector->hasMessages()); @@ -45,7 +52,7 @@ TEST(MessageCollector, hasMessages) { ASSERT_FALSE(collector->hasErrors()); } -TEST(MessageCollector, hasErrors) { +TEST_F(MessageCollector, hasErrors) { auto *collector = filc::message::MessageCollector::getCollector(); ASSERT_FALSE(collector->hasMessages()); @@ -55,7 +62,7 @@ TEST(MessageCollector, hasErrors) { ASSERT_TRUE(collector->hasErrors()); } -TEST(MessageCollector, printMessages) { +TEST_F(MessageCollector, printMessages) { auto *collector = filc::message::MessageCollector::getCollector(); collector->addMessage(new filc::message::Message(filc::message::INFO, "Hello")); collector->printMessages(); @@ -63,7 +70,7 @@ TEST(MessageCollector, printMessages) { ASSERT_FALSE(collector->hasMessages()); } -TEST(MessageCollector, printErrors) { +TEST_F(MessageCollector, printErrors) { auto *collector = filc::message::MessageCollector::getCollector(); collector->addError(new filc::message::Message(filc::message::INFO, "Hello")); collector->printErrors(); @@ -71,12 +78,23 @@ TEST(MessageCollector, printErrors) { ASSERT_FALSE(collector->hasErrors()); } -TEST(MessageCollector, printAll) { +TEST_F(MessageCollector, printAll) { auto *collector = filc::message::MessageCollector::getCollector(); collector->addMessage(new filc::message::Message(filc::message::INFO, "Hello")); collector->addError(new filc::message::Message(filc::message::INFO, "Hello")); collector->printAll(); + ASSERT_FALSE(collector->hasMessages()); + ASSERT_FALSE(collector->hasErrors()); +} + +TEST_F(MessageCollector, flush) { + auto *collector = filc::message::MessageCollector::getCollector(); + collector->addMessage(new filc::message::Message(filc::message::INFO, "Hello")); + collector->addError(new filc::message::Message(filc::message::INFO, "Hello")); + ASSERT_TRUE(collector->hasMessages()); + ASSERT_TRUE(collector->hasErrors()); + collector->flush(); ASSERT_FALSE(collector->hasMessages()); ASSERT_FALSE(collector->hasErrors()); } \ No newline at end of file