added parsing for function literals

src/ast/expressions/function.cpp

@@ -0,0 +1,35 @@
+#include "function.hpp"
+
+#include <sstream>
+
+namespace ast {
+    function_literal::function_literal(token::token token)
+        : token(std::move(token)),
+          block(nullptr) {};
+
+    std::string function_literal::token_literal() const {
+        return token.literal;
+    };
+
+    std::string function_literal::str() const {
+        std::stringstream ss;
+        ss << "fn (";
+        bool first = true;
+        for (auto& param : parameters) {
+            if (!first)
+                ss << ", ";
+            ss << param->str();
+            first = false;
+        }
+        ss << ")";
+        ss << block->str();
+        return ss.str();
+    };
+
+    function_literal::~function_literal() {
+        for (auto& param : parameters)
+            delete param;
+        if (block != nullptr)
+            delete block;
+    }
+} // namespace ast

src/ast/expressions/function.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "ast/ast.hpp"
+#include "ast/expressions/identifier.hpp"
+#include "ast/statements/block.hpp"
+#include "token/token.hpp"
+
+#include <string>
+
+namespace ast {
+    struct function_literal : expression {
+        function_literal(token::token);
+        token::token token;
+        std::vector<identifier*> parameters;
+        ast::block_stmt* block;
+
+        std::string token_literal() const override;
+        std::string str() const override;
+        ~function_literal();
+    };
+} // namespace ast

src/parser/parser.cpp

@@ -59,6 +59,11 @@ namespace parser {
             std::bind(&parser::parse_if_then_else, this)
         );
 
+        register_prefix(
+            token::type::FUNCTION,
+            std::bind(&parser::parse_function, this)
+        );
+
         using namespace std::placeholders;
         register_infix(
             {token::type::PLUS,
@@ -243,6 +248,39 @@ namespace parser {
         );
     };
 
+    ast::function_literal* parser::parse_function() {
+        TRACE_FUNCTION;
+        ast::function_literal* ret = new ast::function_literal(current);
+        if (!expect_next(token::type::LPAREN)) {
+            delete ret;
+            return nullptr;
+        }
+
+        while (next.type != token::type::RPAREN
+               && expect_next(token::type::IDENTIFIER)) {
+            ret->parameters.push_back(parse_identifier());
+            if (next.type == token::type::RPAREN)
+                break;
+            if (!expect_next(token::type::COMMA)) {
+                // delete ret;
+                return nullptr;
+            }
+        }
+
+        if (!expect_next(token::type::RPAREN)) {
+            // delete ret;
+            return nullptr;
+        }
+
+        if (!expect_next(token::type::LBRACE)) {
+            // delete ret;
+            return nullptr;
+        }
+        ret->block = parse_block();
+
+        return ret;
+    };
+
     ast::prefix_expr* parser::parse_prefix_expr() {
         TRACE_FUNCTION;
         ast::prefix_expr* ret = new ast::prefix_expr(current, current.literal);

test/parser/function.cpp

@@ -0,0 +1,134 @@
+#include "ast/expressions/function.hpp"
+
+#include "ast/statements/return.hpp"
+#include "utils.hpp"
+
+#include <doctest.h>
+
+TEST_SUITE("Parser: function") {
+    TEST_CASE("Malformed if then else (checking for memory leaks)") {}
+
+    TEST_CASE_FIXTURE(ParserFixture, "Parse well formed function literal") {
+        SUBCASE("no param function") {
+            setup("\
+fn () {\
+    return true;\
+}\
+");
+            REQUIRE(program->statements.size() == 1);
+            CHECK(program->statements[0]->token_literal() == "fn");
+
+            ast::expression_stmt* expr_stmt =
+                cast<ast::expression_stmt>(program->statements[0]);
+
+            ast::function_literal* fun =
+                cast<ast::function_literal>(expr_stmt->expression);
+
+            // parameters
+            CHECK(fun->parameters.size() == 0);
+
+            // block
+            REQUIRE(fun->block->statements.size() == 1);
+            ast::return_stmt* ret =
+                cast<ast::return_stmt>(fun->block->statements[0]);
+            test_boolean_literal(ret->value, true);
+
+            // full string
+            CHECK(fun->str() == "fn (){return true;}");
+        }
+
+        SUBCASE("one param function") {
+            setup("\
+fn (x) {\
+    return x + 1;\
+}\
+");
+            REQUIRE(program->statements.size() == 1);
+            CHECK(program->statements[0]->token_literal() == "fn");
+
+            ast::expression_stmt* expr_stmt =
+                cast<ast::expression_stmt>(program->statements[0]);
+
+            ast::function_literal* fun =
+                cast<ast::function_literal>(expr_stmt->expression);
+
+            // parameters
+            REQUIRE(fun->parameters.size() == 1);
+            test_identifier(fun->parameters[0], "x");
+
+            // block
+            REQUIRE(fun->block->statements.size() == 1);
+            ast::return_stmt* ret =
+                cast<ast::return_stmt>(fun->block->statements[0]);
+            test_infix_expression(ret->value, "x", "+", 1);
+
+            // full string
+            CHECK(fun->str() == "fn (x){return (x + 1);}");
+        }
+
+        SUBCASE("two param function") {
+            setup("\
+fn (x, y) {\
+    return x + y;\
+}\
+");
+            REQUIRE(program->statements.size() == 1);
+            CHECK(program->statements[0]->token_literal() == "fn");
+
+            ast::expression_stmt* expr_stmt =
+                cast<ast::expression_stmt>(program->statements[0]);
+
+            ast::function_literal* fun =
+                cast<ast::function_literal>(expr_stmt->expression);
+
+            // parameters
+            REQUIRE(fun->parameters.size() == 2);
+            test_identifier(fun->parameters[0], "x");
+            test_identifier(fun->parameters[1], "y");
+
+            // block
+            REQUIRE(fun->block->statements.size() == 1);
+            ast::return_stmt* ret =
+                cast<ast::return_stmt>(fun->block->statements[0]);
+            test_infix_expression(ret->value, "x", "+", "y");
+
+            // full string
+            CHECK(fun->str() == "fn (x, y){return (x + y);}");
+        }
+
+        SUBCASE("two param function assigned to variable") {
+            setup("\
+let fun = fn (x, y) {\
+    return x + y;\
+}\
+");
+            REQUIRE(program->statements.size() == 1);
+            CHECK(program->statements[0]->token_literal() == "let");
+
+            ast::let_stmt* let_stmt =
+                cast<ast::let_stmt>(program->statements[0]);
+
+            // let lhs
+            test_identifier(let_stmt->name, "fun");
+
+            // let rhs
+            CHECK(let_stmt->value->token_literal() == "fn");
+            ast::function_literal* fun =
+                cast<ast::function_literal>(let_stmt->value);
+
+            // parameters
+            REQUIRE(fun->parameters.size() == 2);
+            test_identifier(fun->parameters[0], "x");
+            test_identifier(fun->parameters[1], "y");
+
+            // block
+            REQUIRE(fun->block->statements.size() == 1);
+            ast::return_stmt* ret =
+                cast<ast::return_stmt>(fun->block->statements[0]);
+            test_infix_expression(ret->value, "x", "+", "y");
+
+            // full string
+            CHECK(fun->str() == "fn (x, y){return (x + y);}");
+        }
+    }
+}