Add resolution of UnaryCalcul

It does for Pre and Post
Fil-Language · Aug 25, 2023 · 698193c · 698193c
1 parent 5414ba3
commit 698193c
Show file tree

Hide file tree

Showing 11 changed files with 109 additions and 32 deletions.
diff --git a/src/lib/ast/AST.h b/src/lib/ast/AST.h
@@ -282,6 +282,9 @@ namespace filc::ast {
 
         [[nodiscard]] auto getOperator() const -> Operator *;
 
+        auto resolveType(filc::environment::Environment *environment,
+                         filc::message::MessageCollector *collector) -> void override;
+
     protected:
         Identifier *_variable;
         Operator *_operator;
@@ -290,9 +293,6 @@ 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 {
@@ -332,6 +332,9 @@ namespace filc::ast {
 
         virtual auto dump() -> std::string = 0;
 
+        virtual auto dumpLambdaType(filc::ast::AbstractType *return_type, filc::environment::Environment *environment,
+                                    filc::message::MessageCollector *collector) -> LambdaType * = 0;
+
     protected:
         Operator() = default;
     };
@@ -366,6 +369,9 @@ namespace filc::ast {
 
         auto dump() -> std::string override;
 
+        auto dumpLambdaType(filc::ast::AbstractType *return_type, filc::environment::Environment *environment,
+                            filc::message::MessageCollector *collector) -> LambdaType * override;
+
     private:
         OPERATOR _operator;
     };
@@ -380,6 +386,9 @@ namespace filc::ast {
 
         auto dump() -> std::string override;
 
+        auto dumpLambdaType(filc::ast::AbstractType *return_type, filc::environment::Environment *environment,
+                            filc::message::MessageCollector *collector) -> LambdaType * override;
+
     private:
         AbstractExpression *_expression;
     };
@@ -394,6 +403,9 @@ namespace filc::ast {
 
         auto dump() -> std::string override;
 
+        auto dumpLambdaType(filc::ast::AbstractType *return_type, filc::environment::Environment *environment,
+                            filc::message::MessageCollector *collector) -> LambdaType * override;
+
     private:
         std::vector<AbstractExpression *> _expressions;
     };
@@ -408,6 +420,9 @@ namespace filc::ast {
 
         auto dump() -> std::string override;
 
+        auto dumpLambdaType(filc::ast::AbstractType *return_type, filc::environment::Environment *environment,
+                            filc::message::MessageCollector *collector) -> LambdaType * override;
+
     private:
         Operator *_inner_operator;
     };

diff --git a/src/lib/ast/ArrayOperator.cpp b/src/lib/ast/ArrayOperator.cpp
@@ -35,7 +35,19 @@ namespace filc::ast {
         delete _expression;
     }
 
-    std::string ArrayOperator::dump() {
+    auto ArrayOperator::dump() -> std::string {
         return "[]";
     }
+
+    auto ArrayOperator::dumpLambdaType(filc::ast::AbstractType *return_type,
+                                       filc::environment::Environment *environment,
+                                       filc::message::MessageCollector *collector) -> LambdaType * {
+        _expression->resolveType(environment, collector);
+        auto *expression_type = _expression->getExpressionType();
+        if (expression_type == nullptr) {
+            return nullptr;
+        }
+
+        return new LambdaType({expression_type}, return_type);
+    }
 }
diff --git a/src/lib/ast/AssignationOperator.cpp b/src/lib/ast/AssignationOperator.cpp
@@ -35,7 +35,13 @@ namespace filc::ast {
         return _inner_operator;
     }
 
-    std::string AssignationOperator::dump() {
+    auto AssignationOperator::dump() -> std::string {
+        return _inner_operator->dump() + "=";
+    }
+
+    auto AssignationOperator::dumpLambdaType(filc::ast::AbstractType *return_type,
+                                             filc::environment::Environment *environment,
+                                             filc::message::MessageCollector *collector) -> LambdaType * {
         throw std::logic_error("Should not be called");
     }
 }
diff --git a/src/lib/ast/ClassicOperator.cpp b/src/lib/ast/ClassicOperator.cpp
@@ -31,7 +31,7 @@ namespace filc::ast {
         return _operator;
     }
 
-    std::string ClassicOperator::dump() {
+    auto ClassicOperator::dump() -> std::string {
         switch (_operator) {
             case PLUSPLUS:
                 return "++";
@@ -72,5 +72,13 @@ namespace filc::ast {
             case OR:
                 return "||";
         }
+
+        throw std::logic_error("Should not come here");
+    }
+
+    auto ClassicOperator::dumpLambdaType(filc::ast::AbstractType *return_type,
+                                         filc::environment::Environment *environment,
+                                         filc::message::MessageCollector *collector) -> LambdaType * {
+        return new LambdaType({}, return_type);
     }
 }
diff --git a/src/lib/ast/FunctionOperator.cpp b/src/lib/ast/FunctionOperator.cpp
@@ -37,7 +37,25 @@ namespace filc::ast {
         }
     }
 
-    std::string FunctionOperator::dump() {
+    auto FunctionOperator::dump() -> std::string {
         return "()";
     }
+
+    auto FunctionOperator::dumpLambdaType(filc::ast::AbstractType *return_type,
+                                          filc::environment::Environment *environment,
+                                          filc::message::MessageCollector *collector) -> LambdaType * {
+        std::vector<AbstractType *> args_types;
+        for (const auto &expression: _expressions) {
+            expression->resolveType(environment, collector);
+            auto *expression_type = expression->getExpressionType();
+            if (expression_type != nullptr) {
+                args_types.push_back(expression_type);
+            }
+        }
+        if (args_types.size() != _expressions.size()) {
+            return nullptr;
+        }
+
+        return new LambdaType(args_types, return_type);
+    }
 }
diff --git a/src/lib/ast/PreUnaryCalcul.cpp b/src/lib/ast/PreUnaryCalcul.cpp
@@ -22,31 +22,8 @@
  * 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/UnaryCalcul.cpp b/src/lib/ast/UnaryCalcul.cpp
@@ -22,6 +22,7 @@
  * SOFTWARE.
  */
 #include "AST.h"
+#include "Error.h"
 
 namespace filc::ast {
     UnaryCalcul::UnaryCalcul(filc::ast::Identifier *variable, Operator *p_operator)
@@ -39,4 +40,27 @@ namespace filc::ast {
         delete _variable;
         delete _operator;
     }
+
+    auto UnaryCalcul::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,
+                                 _operator->dumpLambdaType(variable_type, environment, collector)) == 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/tests/unit/Fixtures/ast/post_unary_calcul1.fil b/tests/unit/Fixtures/ast/post_unary_calcul1.fil
@@ -0,0 +1,4 @@
+module test
+
+var a: int = 3
+a++
diff --git a/tests/unit/Fixtures/ast/unary_calcul1.fil → ...s/unit/Fixtures/ast/pre_unary_calcul1.fil b/tests/unit/Fixtures/ast/unary_calcul1.fil → ...s/unit/Fixtures/ast/pre_unary_calcul1.fil
diff --git a/tests/unit/ast/PostUnaryCalculTest.cpp b/tests/unit/ast/PostUnaryCalculTest.cpp
@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 #include "AST.h"
-#include <gtest/gtest.h>
+#include "Parser.h"
 #include "test_tools.h"
 
 TEST(PostUnaryCalcul, constructor) {
@@ -32,4 +32,17 @@ TEST(PostUnaryCalcul, constructor) {
     );
     ASSERT_IDENTIFIER("abcd", puc1.getVariable());
     ASSERT_CLASSIC_OPERATOR(MOD, puc1.getOperator());
+}
+
+#define FIXTURES_PATH "../../tests/unit/Fixtures"
+
+#define COLLECTOR filc::message::MessageCollector::getCollector()
+
+TEST(PostUnaryCalcul, resolveType) {
+    filc::grammar::Parser parser1(FIXTURES_PATH "/ast/post_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());
 }
diff --git a/tests/unit/ast/PreUnaryCalculTest.cpp b/tests/unit/ast/PreUnaryCalculTest.cpp
@@ -39,7 +39,7 @@ TEST(PreUnaryCalcul, constructor) {
 #define COLLECTOR filc::message::MessageCollector::getCollector()
 
 TEST(PreUnaryCalcul, resolveType) {
-    filc::grammar::Parser parser1(FIXTURES_PATH "/ast/unary_calcul1.fil", COLLECTOR);
+    filc::grammar::Parser parser1(FIXTURES_PATH "/ast/pre_unary_calcul1.fil", COLLECTOR);
     auto *program1 = parser1.getProgram();
     ASSERT_NO_THROW(program1->resolveEnvironment(COLLECTOR));
     ASSERT_THAT(program1->getExpressions(), SizeIs(2));