Add parsing for function definitions

This commits also changes the structure of some existing functions.
Namely, parse_* functions other than parse_next check that the type of
the token to parse is correct. This allow us to use them directly in the
rest of the code to consume tokens and properly produce an error if the
token type is not the expected one.

In the same fashion, two new functions consume_lparen and consume_rparen
are implemented. They only report true/false and report errors if
something went wrong.

5 files changed, 180 insertions, 27 deletions

diff --git a/src/errors.c b/src/errors.c
index e69e4f9..b93b462 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -8,6 +8,13 @@ static const char* error_msgs[] = {
     [ERR_MALFORMED_NUMBER] = "error: malformed number token",
     [ERR_MALFORMED_EXPR]   = "error: malformed expression",
     [ERR_UNIMPLEMENTED]    = "error: not implemented",
+    [ERR_NOT_A_NUMBER]     = "error: expected a number",
+    [ERR_NOT_A_SYMBOL]     = "error: expected a symbol",
+    [ERR_NOT_A_STRING]     = "error: expected a string",
+    [ERR_NOT_A_TYPE]       = "error: expected a type",
+    [ERR_NOT_A_BOOL]       = "error: expected a bool",
+    [ERR_NOT_A_LPAREN]     = "error: expected opening parentheses (lparen)",
+    [ERR_NOT_A_RPAREN]     = "error: expected closing parentheses (rparen)",
 };
 
 static Error current_error = {.value = ERR_OK};
diff --git a/src/errors.h b/src/errors.h
index 25f9945..871711b 100644
--- a/src/errors.h
+++ b/src/errors.h
@@ -16,6 +16,13 @@ typedef enum ErrorValue {
     ERR_MALFORMED_NUMBER,
     ERR_MALFORMED_EXPR,
     ERR_UNIMPLEMENTED,
+    ERR_NOT_A_NUMBER,
+    ERR_NOT_A_SYMBOL,
+    ERR_NOT_A_STRING,
+    ERR_NOT_A_TYPE,
+    ERR_NOT_A_BOOL,
+    ERR_NOT_A_LPAREN,
+    ERR_NOT_A_RPAREN,
     ERR_OK,
 } ErrorValue;
 
diff --git a/src/nodes.c b/src/nodes.c
index 855d186..fc39d8e 100644
--- a/src/nodes.c
+++ b/src/nodes.c
@@ -23,6 +23,7 @@ print_node(Node *node) {
             }
         } break;
         case NODE_SYMBOL:
+        case NODE_TYPE:
         case NODE_STRING: {
             sv_write(&node->string);
         } break;
@@ -51,7 +52,7 @@ print_node(Node *node) {
             printf("(def ");
             print_node(node->def.symbol);
             printf(":");
-            sv_write(&node->def.type);
+            print_node(node->def.type);
             printf(" ");
             print_node(node->def.value);
             printf(")");
@@ -63,6 +64,31 @@ print_node(Node *node) {
             print_node(node->def.value);
             printf(")");
         } break;
+        case NODE_FUN: {
+            printf("(fun ");
+            print_node(node->fun.name);
+            printf(" (");
+            size_t n_params = array_size(node->fun.param_names);
+            for (size_t i = 0; i < n_params; ++i) {
+                print_node(node->fun.param_names[i]);
+                printf(":");
+                print_node(node->fun.param_types[i]);
+                if (i < n_params - 1) {
+                    printf(" ");
+                }
+            }
+            printf(")");
+            printf(": ");
+            print_node(node->fun.return_type);
+
+            size_t n_expr = array_size(node->fun.body);
+            for (size_t i = 0; i < n_expr; ++i) {
+                printf(" ");
+                print_node(node->fun.body[i]);
+            }
+
+            printf(")");
+        } break;
         default: { printf("{#unknown#}"); } break;
     }
 }
diff --git a/src/nodes.h b/src/nodes.h
index 566d6d3..2e24ea5 100644
--- a/src/nodes.h
+++ b/src/nodes.h
@@ -7,8 +7,10 @@ typedef enum NodeType {
     NODE_BOOL,
     NODE_STRING,
     NODE_SYMBOL,
+    NODE_TYPE,
     NODE_DEF,
     NODE_SET,
+    NODE_FUN,
 } NodeType;
 
 typedef struct Node {
@@ -38,13 +40,23 @@ typedef struct Node {
         struct {
             struct Node *symbol;
             struct Node *value;
-            StringView type;
+            struct Node *type;
         } def;
 
+        // Variable assignment.
         struct {
             struct Node *symbol;
             struct Node *value;
         } set;
+
+        // Function definition.
+        struct {
+            struct Node *name;
+            struct Node **param_names;
+            struct Node **param_types;
+            struct Node *return_type;
+            struct Node **body;
+        } fun;
     };
 } Node;
 
diff --git a/src/parser.c b/src/parser.c
index b36ddc9..cfbefaf 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -16,9 +16,33 @@ has_next(Parser *parser) {
     return parser->current < array_size(parser->tokens);
 }
 
+bool
+consume_rparen(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_RPAREN) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_RPAREN, tok.line, tok.col);
+        return false;
+    }
+    return true;
+}
+
+bool
+consume_lparen(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_LPAREN) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_LPAREN, tok.line, tok.col);
+        return false;
+    }
+    return true;
+}
+
 Node *
 parse_number(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_NUMBER) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_NUMBER, tok.line, tok.col);
+        return NULL;
+    }
 
     bool negative = false;
     int base = 10;
@@ -93,6 +117,10 @@ parse_number(Parser *parser) {
 Node *
 parse_string(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_STRING) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_STRING, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_STRING);
     node->string = tok.value;
     return node;
@@ -101,14 +129,39 @@ parse_string(Parser *parser) {
 Node *
 parse_symbol(Parser *parser) {
     Token tok = next_token(parser);
+    if (tok.type != TOKEN_SYMBOL) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_SYMBOL, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_SYMBOL);
     node->string = tok.value;
     return node;
 }
 
 Node *
+parse_type(Parser *parser) {
+    Token tok = next_token(parser);
+    if (tok.type != TOKEN_COLON) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_TYPE, tok.line, tok.col);
+        return NULL;
+    }
+    tok = next_token(parser);
+    if (tok.type != TOKEN_SYMBOL) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_TYPE, tok.line, tok.col);
+        return NULL;
+    }
+    Node *node = alloc_node(NODE_TYPE);
+    node->string = tok.value;
+    return node;
+}
+
+Node *
 parse_bool(Parser *parser) {
     Token tok = next_token(parser);
+    if (!(tok.type == TOKEN_TRUE || tok.type == TOKEN_FALSE)) {
+        push_error(ERR_TYPE_PARSER, ERR_NOT_A_BOOL, tok.line, tok.col);
+        return NULL;
+    }
     Node *node = alloc_node(NODE_BOOL);
     node->boolean = tok.type == TOKEN_TRUE;
     return node;
@@ -138,63 +191,51 @@ parse_builtin(Parser *parser) {
 
 Node *
 parse_def(Parser *parser) {
-    Token op = next_token(parser);
-    Node *symbol = parse_next(parser);
-    if (symbol == NULL || symbol->type != NODE_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    next_token(parser); // Skip keyword.
+
+    Node *symbol = parse_symbol(parser);
+    if (symbol == NULL) {
         return NULL;
     }
 
     // TODO: Making type checking mandatory for now until we introduce
     // type inference.
-    Token next = next_token(parser);
-    if (next.type != TOKEN_COLON) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
-        return NULL;
-    }
-    Token type_name = next_token(parser);
-    if (type_name.type != TOKEN_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    Node *type = parse_type(parser);
+    if (type == NULL) {
         return NULL;
     }
 
     Node *value = parse_next(parser);
     if (value == NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
         return NULL;
     }
 
-    Token end = next_token(parser);
-    if (end.type != TOKEN_RPAREN) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    if (!consume_rparen(parser)) {
         return NULL;
     }
 
     Node *node = alloc_node(NODE_DEF);
     node->def.symbol = symbol;
     node->def.value = value;
-    node->def.type = type_name.value;
+    node->def.type = type;
     return node;
 }
 
 Node *
 parse_set(Parser *parser) {
-    Token op = next_token(parser);
-    Node *symbol = parse_next(parser);
-    if (symbol == NULL || symbol->type != NODE_SYMBOL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    next_token(parser); // Skip keyword.
+
+    Node *symbol = parse_symbol(parser);
+    if (symbol == NULL) {
         return NULL;
     }
 
     Node *value = parse_next(parser);
     if (value == NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
         return NULL;
     }
 
-    Token end = next_token(parser);
-    if (end.type != TOKEN_RPAREN) {
-        push_error(ERR_TYPE_PARSER, ERR_MALFORMED_EXPR, op.line, op.col);
+    if (!consume_rparen(parser)) {
         return NULL;
     }
 
@@ -205,6 +246,65 @@ parse_set(Parser *parser) {
 }
 
 Node *
+parse_fun(Parser *parser) {
+    next_token(parser); // Skip keyword.
+
+    Node *name = parse_symbol(parser);
+    if (name == NULL) {
+        return NULL;
+    }
+
+    Node *node = alloc_node(NODE_FUN);
+    node->fun.name = name;
+    array_init(node->fun.param_names, 0);
+    array_init(node->fun.param_types, 0);
+    array_init(node->fun.body, 0);
+
+    // Parse parameter list and return type.
+    if (!consume_lparen(parser)) {
+        return NULL;
+    }
+    while (true) {
+        Token next = peek_token(parser);
+        if (next.type == TOKEN_RPAREN) {
+            next_token(parser);
+            break;
+        }
+        Node *name = parse_symbol(parser);
+        if (name == NULL) {
+            return NULL;
+        }
+        Node *type = parse_type(parser);
+        if (type == NULL) {
+            return NULL;
+        }
+        array_push(node->fun.param_names, name);
+        array_push(node->fun.param_types, type);
+    }
+    Node *ret_type = parse_type(parser);
+    if (ret_type == NULL) {
+        return NULL;
+    }
+    node->fun.return_type = ret_type;
+
+    // Parse body.
+    while (true) {
+        Token next = peek_token(parser);
+        if (next.type == TOKEN_RPAREN) {
+            next_token(parser);
+            break;
+        }
+        Node *expr = parse_next(parser);
+        if (expr == NULL) {
+            return NULL;
+        }
+        array_push(node->fun.body, expr);
+    }
+
+    return node;
+}
+
+Node *
 parse_paren(Parser *parser) {
     next_token(parser); // Skip paren.
     Token tok = peek_token(parser);
@@ -222,6 +322,7 @@ parse_paren(Parser *parser) {
         // Special functions.
         case TOKEN_DEF: { return parse_def(parser); } break;
         case TOKEN_SET: { return parse_set(parser); } break;
+        case TOKEN_FUN: { return parse_fun(parser); } break;
         default: break;
     }