Add resolution of PreUnaryCalcul

Fil-Language · Aug 25, 2023 · 5414ba3 · 5414ba3
1 parent b0f9f88
commit 5414ba3
Show file tree

Hide file tree

Showing 10 changed files with 136 additions and 6 deletions.
diff --git a/src/lib/ast/AST.h b/src/lib/ast/AST.h
@@ -81,7 +81,8 @@ namespace filc::ast {
 
         [[nodiscard]] auto getExpressionType() const -> AbstractType *;
 
-        virtual auto resolveType(filc::environment::Environment *environment, filc::message::MessageCollector *collector) -> void;
+        virtual auto
+        resolveType(filc::environment::Environment *environment, filc::message::MessageCollector *collector) -> void;
 
     private:
         bool _exported{false};
@@ -102,7 +103,8 @@ namespace filc::ast {
 
         [[nodiscard]] auto getName() const -> const std::string &;
 
-        auto resolveType(filc::environment::Environment *environment, filc::message::MessageCollector *collector) -> void override;
+        auto resolveType(filc::environment::Environment *environment,
+                         filc::message::MessageCollector *collector) -> void override;
 
     private:
         std::string _name;
@@ -288,6 +290,9 @@ namespace filc::ast {
     class PreUnaryCalcul : public UnaryCalcul {
     public:
         PreUnaryCalcul(Identifier *variable, Operator *p_operator);
+
+        auto resolveType(filc::environment::Environment *environment,
+                         filc::message::MessageCollector *collector) -> void override;
     };
 
     class PostUnaryCalcul : public UnaryCalcul {
@@ -325,6 +330,8 @@ namespace filc::ast {
 
         auto operator=(Operator &&other) -> Operator & = default;
 
+        virtual auto dump() -> std::string = 0;
+
     protected:
         Operator() = default;
     };
@@ -357,6 +364,8 @@ namespace filc::ast {
 
         [[nodiscard]] auto getOperator() const -> OPERATOR;
 
+        auto dump() -> std::string override;
+
     private:
         OPERATOR _operator;
     };
@@ -369,6 +378,8 @@ namespace filc::ast {
 
         [[nodiscard]] auto getExpression() const -> AbstractExpression *;
 
+        auto dump() -> std::string override;
+
     private:
         AbstractExpression *_expression;
     };
@@ -381,6 +392,8 @@ namespace filc::ast {
 
         [[nodiscard]] auto getExpressions() const -> const std::vector<AbstractExpression *> &;
 
+        auto dump() -> std::string override;
+
     private:
         std::vector<AbstractExpression *> _expressions;
     };
@@ -393,6 +406,8 @@ namespace filc::ast {
 
         [[nodiscard]] auto getInnerOperator() const -> Operator *;
 
+        auto dump() -> std::string override;
+
     private:
         Operator *_inner_operator;
     };
@@ -461,7 +476,7 @@ namespace filc::ast {
     private:
         AbstractExpression *_condition;
         std::vector<AbstractExpression *> _body;
-        If* _else;
+        If *_else;
     };
 
     class Switch : public AbstractExpression {

diff --git a/src/lib/ast/ArrayOperator.cpp b/src/lib/ast/ArrayOperator.cpp
@@ -34,4 +34,8 @@ namespace filc::ast {
     ArrayOperator::~ArrayOperator() {
         delete _expression;
     }
+
+    std::string ArrayOperator::dump() {
+        return "[]";
+    }
 }
diff --git a/src/lib/ast/AssignationOperator.cpp b/src/lib/ast/AssignationOperator.cpp
@@ -34,4 +34,8 @@ namespace filc::ast {
     auto AssignationOperator::getInnerOperator() const -> Operator * {
         return _inner_operator;
     }
+
+    std::string AssignationOperator::dump() {
+        throw std::logic_error("Should not be called");
+    }
 }
diff --git a/src/lib/ast/ClassicOperator.cpp b/src/lib/ast/ClassicOperator.cpp
@@ -30,4 +30,47 @@ namespace filc::ast {
     auto ClassicOperator::getOperator() const -> OPERATOR {
         return _operator;
     }
+
+    std::string ClassicOperator::dump() {
+        switch (_operator) {
+            case PLUSPLUS:
+                return "++";
+            case MINUSMINUS:
+                return "--";
+            case PLUS:
+                return "+";
+            case MINUS:
+                return "-";
+            case REF:
+                return "&";
+            case STAR:
+                return "*";
+            case NOT:
+                return "!";
+            case DIV:
+                return "/";
+            case MOD:
+                return "%";
+            case FLEFT:
+                return "<<";
+            case FRIGHT:
+                return ">>";
+            case LESS:
+                return "<";
+            case GREATER:
+                return ">";
+            case EQEQ:
+                return "==";
+            case LEQ:
+                return "<=";
+            case GEQ:
+                return ">=";
+            case NEQ:
+                return "!=";
+            case AND:
+                return "&&";
+            case OR:
+                return "||";
+        }
+    }
 }
diff --git a/src/lib/ast/FunctionOperator.cpp b/src/lib/ast/FunctionOperator.cpp
@@ -36,4 +36,8 @@ namespace filc::ast {
             delete expression;
         }
     }
+
+    std::string FunctionOperator::dump() {
+        return "()";
+    }
 }
diff --git a/src/lib/ast/PreUnaryCalcul.cpp b/src/lib/ast/PreUnaryCalcul.cpp
@@ -22,8 +22,31 @@
  * SOFTWARE.
  */
 #include "AST.h"
+#include "Error.h"
 
 namespace filc::ast {
     PreUnaryCalcul::PreUnaryCalcul(filc::ast::Identifier *variable, filc::ast::Operator *p_operator)
             : UnaryCalcul(variable, p_operator) {}
+
+    auto PreUnaryCalcul::resolveType(filc::environment::Environment *environment,
+                                     filc::message::MessageCollector *collector) -> void {
+        _variable->resolveType(environment, collector);
+        auto *variable_type = _variable->getExpressionType();
+        if (variable_type == nullptr) {
+            return;
+        }
+
+        auto operator_name = "operator" + _operator->dump();
+        if (environment->getName(operator_name, new LambdaType({}, variable_type)) == nullptr) {
+            collector->addError(
+                    new filc::message::Error(filc::message::ERROR,
+                                             "There is no operator " + _operator->dump() +
+                                             " for type " + variable_type->dump(),
+                                             getPosition())
+            );
+            return;
+        }
+
+        setExpressionType(variable_type);
+    }
 }
diff --git a/src/lib/ast/VariableDeclaration.cpp b/src/lib/ast/VariableDeclaration.cpp
@@ -38,7 +38,7 @@ namespace filc::ast {
         return _constant;
     }
 
-    auto VariableDeclaration::getIdentifier() const -> Identifier* {
+    auto VariableDeclaration::getIdentifier() const -> Identifier * {
         return _identifier;
     }
 
@@ -80,6 +80,7 @@ namespace filc::ast {
             return;
         }
 
+        environment->addName(_identifier->getName(), _type);
         setExpressionType(_type);
     }
 }
diff --git a/src/lib/environment/Environment.cpp b/src/lib/environment/Environment.cpp
@@ -118,11 +118,13 @@ namespace filc::environment {
         auto *float_type = new filc::ast::Type(new filc::ast::Identifier("float"));
         auto *char_type = new filc::ast::Type(new filc::ast::Identifier("char"));
         auto *bool_type = new filc::ast::Type(new filc::ast::Identifier("bool"));
+        auto *void_type = new filc::ast::Type(new filc::ast::Identifier("void"));
         auto is_ok = global->addType(int_type)
                      && global->addType(double_type)
                      && global->addType(float_type)
                      && global->addType(char_type)
-                     && global->addType(bool_type);
+                     && global->addType(bool_type)
+                     && global->addType(void_type);
         if (!is_ok) {
             throw std::logic_error("Fail to add base types to global environment");
         }
@@ -157,6 +159,23 @@ namespace filc::environment {
         if (!is_ok) {
             throw std::logic_error("Fail to add base assignations to global environment");
         }
+        // - Prefix unary
+        is_ok = global->addName("operator++", new filc::ast::LambdaType({}, int_type))
+                && global->addName("operator--", new filc::ast::LambdaType({}, int_type))
+                && global->addName("operator+", new filc::ast::LambdaType({}, int_type))
+                && global->addName("operator-", new filc::ast::LambdaType({}, int_type))
+                && global->addName("operator++", new filc::ast::LambdaType({}, double_type))
+                && global->addName("operator--", new filc::ast::LambdaType({}, double_type))
+                && global->addName("operator+", new filc::ast::LambdaType({}, double_type))
+                && global->addName("operator-", new filc::ast::LambdaType({}, double_type))
+                && global->addName("operator++", new filc::ast::LambdaType({}, float_type))
+                && global->addName("operator--", new filc::ast::LambdaType({}, float_type))
+                && global->addName("operator+", new filc::ast::LambdaType({}, float_type))
+                && global->addName("operator-", new filc::ast::LambdaType({}, float_type))
+                && global->addName("operator!", new filc::ast::LambdaType({}, bool_type));
+        if (!is_ok) {
+            throw std::logic_error("Fail to add base prefix unary calcul to global environment");
+        }
 
         return global;
     }

diff --git a/tests/unit/Fixtures/ast/unary_calcul1.fil b/tests/unit/Fixtures/ast/unary_calcul1.fil
@@ -0,0 +1,4 @@
+module test
+
+var a: int = 12
+--a
diff --git a/tests/unit/ast/PreUnaryCalculTest.cpp b/tests/unit/ast/PreUnaryCalculTest.cpp
@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 #include "AST.h"
-#include <gtest/gtest.h>
+#include "Parser.h"
 #include "test_tools.h"
 
 TEST(PreUnaryCalcul, constructor) {
@@ -32,4 +32,17 @@ TEST(PreUnaryCalcul, constructor) {
     );
     ASSERT_IDENTIFIER("val1", puc1.getVariable());
     ASSERT_CLASSIC_OPERATOR(DIV, puc1.getOperator());
+}
+
+#define FIXTURES_PATH "../../tests/unit/Fixtures"
+
+#define COLLECTOR filc::message::MessageCollector::getCollector()
+
+TEST(PreUnaryCalcul, resolveType) {
+    filc::grammar::Parser parser1(FIXTURES_PATH "/ast/unary_calcul1.fil", COLLECTOR);
+    auto *program1 = parser1.getProgram();
+    ASSERT_NO_THROW(program1->resolveEnvironment(COLLECTOR));
+    ASSERT_THAT(program1->getExpressions(), SizeIs(2));
+    ASSERT_TYPE("int", program1->getExpressions()[0]->getExpressionType());
+    ASSERT_TYPE("int", program1->getExpressions()[1]->getExpressionType());
 }