Add function body

Fil-Language · Aug 6, 2023 · 3878de6 · 3878de6
1 parent c580b3c
commit 3878de6
Show file tree

Hide file tree

Showing 5 changed files with 46 additions and 12 deletions.
diff --git a/src/lib/ast/AST.h b/src/lib/ast/AST.h
@@ -334,18 +334,22 @@ namespace filc::ast {
 
     class Function : public AbstractExpression {
     public:
-        Function(Identifier *name, const std::vector<FunctionParameter *> &parameters, AbstractType *return_type);
+        Function(Identifier *name, const std::vector<FunctionParameter *> &parameters, AbstractType *return_type,
+                 const std::vector<AbstractExpression *> &body);
 
         [[nodiscard]] auto getName() const -> Identifier *;
 
         [[nodiscard]] auto getParameters() const -> const std::vector<FunctionParameter *> &;
 
         [[nodiscard]] auto getReturnType() const -> AbstractType *;
 
+        [[nodiscard]] auto getBody() const -> const std::vector<AbstractExpression *> &;
+
     private:
         Identifier *_name;
         std::vector<FunctionParameter *> _parameters;
         AbstractType *_return_type;
+        std::vector<AbstractExpression *> _body;
     };
 
     class FunctionParameter {

diff --git a/src/lib/ast/Function.cpp b/src/lib/ast/Function.cpp
@@ -24,8 +24,9 @@
 #include "AST.h"
 
 namespace filc::ast {
-    Function::Function(Identifier *name, const std::vector<FunctionParameter *> &parameters, AbstractType *return_type)
-            : AbstractExpression(), _name(name), _parameters(parameters), _return_type(return_type) {}
+    Function::Function(Identifier *name, const std::vector<FunctionParameter *> &parameters, AbstractType *return_type,
+                       const std::vector<AbstractExpression *> &body)
+            : AbstractExpression(), _name(name), _parameters(parameters), _return_type(return_type), _body(body) {}
 
     auto Function::getName() const -> Identifier * {
         return _name;
@@ -38,4 +39,8 @@ namespace filc::ast {
     auto Function::getReturnType() const -> AbstractType * {
         return _return_type;
     }
+
+    auto Function::getBody() const -> const std::vector<AbstractExpression *> & {
+        return _body;
+    }
 }
diff --git a/src/lib/grammar/FilParser.g4 b/src/lib/grammar/FilParser.g4
@@ -289,8 +289,8 @@ binary_operator returns[filc::ast::Operator *tree]
     };
 
 function returns[filc::ast::Function *tree]
-    : fd=function_declaration function_body {
-        $tree = new filc::ast::Function($fd.identifier, $fd.parameters, $fd.return_type);
+    : fd=function_declaration fb=function_body {
+        $tree = new filc::ast::Function($fd.identifier, $fd.parameters, $fd.return_type, $fb.tree);
     };
 
 function_declaration returns[filc::ast::Identifier *identifier, std::vector<filc::ast::FunctionParameter *> parameters, filc::ast::AbstractType *return_type]
@@ -355,14 +355,27 @@ function_type returns[filc::ast::AbstractType *tree]
         $tree = $t.tree;
     };
 
-function_body
-    : assignation | parenthesis_body | block_body;
+function_body returns[std::vector<filc::ast::AbstractExpression *> tree]
+    : a=assignation {
+        $tree = std::vector<filc::ast::AbstractExpression *>({$a.tree});
+    } | pb=parenthesis_body {
+        $tree = $pb.tree;
+    } | bb=block_body {
+        $tree = $bb.tree;
+    };
 
-parenthesis_body
-    : LPAREN expression RPAREN;
+parenthesis_body returns[std::vector<filc::ast::AbstractExpression *> tree]
+    : LPAREN e=expression {
+        $tree = std::vector<filc::ast::AbstractExpression *>({$e.tree});
+    } RPAREN;
 
-block_body
-    : LBRACE expression* RBRACE;
+block_body returns[std::vector<filc::ast::AbstractExpression *> tree]
+@init {
+    $tree = std::vector<filc::ast::AbstractExpression *>();
+}
+    : LBRACE (e=expression {
+        $tree.push_back($e.tree);
+    })* RBRACE;
 
 lambda
     : LPAREN function_parameters? RPAREN function_type ARROW (expression | parenthesis_body | block_body);

diff --git a/tests/unit/ast/FunctionTest.cpp b/tests/unit/ast/FunctionTest.cpp
@@ -32,9 +32,11 @@ TEST(Function, constructor) {
     filc::ast::Function fun1(
             new filc::ast::Identifier("fact"),
             {},
-            new filc::ast::Type(new filc::ast::Identifier("int"))
+            new filc::ast::Type(new filc::ast::Identifier("int")),
+            {}
     );
     ASSERT_IDENTIFIER("fact", fun1.getName());
     ASSERT_THAT(fun1.getParameters(), IsEmpty());
     ASSERT_TYPE("int", fun1.getReturnType());
+    ASSERT_THAT(fun1.getBody(), IsEmpty());
 }
diff --git a/tests/unit/grammar/ParserTest.cpp b/tests/unit/grammar/ParserTest.cpp
@@ -318,6 +318,11 @@ TEST(Parser, Function) {
     ASSERT_IDENTIFIER("b", parameter1_2->getName());
     ASSERT_TYPE("int", parameter1_1->getType());
     ASSERT_TYPE("int", parameter1_2->getType());
+    ASSERT_THAT(expression1->getBody(), SizeIs(1));
+    auto *body1 = static_cast<filc::ast::BinaryCalcul *>(expression1->getBody()[0]);
+    ASSERT_IDENTIFIER("a", body1->getLeftExpression());
+    ASSERT_IDENTIFIER("b", body1->getRightExpression());
+    ASSERT_CLASSIC_OPERATOR(filc::ast::ClassicOperator::MINUS, body1->getOperator());
 
     filc::grammar::Parser parser2(FIXTURES_PATH "/function2.fil");
     auto *program2 = parser2.getProgram();
@@ -333,4 +338,9 @@ TEST(Parser, Function) {
     ASSERT_IDENTIFIER("b", parameter2_2->getName());
     ASSERT_TYPE("float", parameter2_1->getType());
     ASSERT_TYPE("float", parameter2_2->getType());
+    ASSERT_THAT(expression2->getBody(), SizeIs(1));
+    auto *body2 = static_cast<filc::ast::BinaryCalcul *>(expression2->getBody()[0]);
+    ASSERT_IDENTIFIER("a", body2->getLeftExpression());
+    ASSERT_IDENTIFIER("b", body2->getRightExpression());
+    ASSERT_CLASSIC_OPERATOR(filc::ast::ClassicOperator::EQEQ, body2->getOperator());
 }