1 files changed, 16 insertions, 14 deletions

diff --git a/src/semantic.c b/src/semantic.c
index 22d290e..fe88249 100644
--- a/src/semantic.c
+++ b/src/semantic.c
@@ -130,7 +130,7 @@ find_type(Scope *scope, Node *type) {
         }
         scope = scope->parent;
     }
-    push_error(ERR_TYPE_PARSER, ERR_UNKNOWN_TYPE, type->line, type->col);
+    push_error(ERR_TYPE_SEMANTIC, ERR_UNKNOWN_TYPE, type->line, type->col);
     return NULL;
 }
 
@@ -139,7 +139,7 @@ insert_symbol(Scope *scope, Node *symbol, Symbol *val) {
     // Check if symbol already exists.
     HashTable *symbols = scope->symbols;
     if (ht_lookup(symbols, symbol) != NULL) {
-        push_error(ERR_TYPE_PARSER, ERR_SYMBOL_REDEF, symbol->line, symbol->col);
+        push_error(ERR_TYPE_SEMANTIC, ERR_SYMBOL_REDEF, symbol->line, symbol->col);
         return false;
     }
     ht_insert(symbols, symbol, val);
@@ -214,7 +214,7 @@ find_symbol(Scope *scope, Node *node) {
         }
         scope = scope->parent;
     }
-    push_error(ERR_TYPE_PARSER, ERR_UNKNOWN_SYMBOL, node->line, node->col);
+    push_error(ERR_TYPE_SEMANTIC, ERR_UNKNOWN_SYMBOL, node->line, node->col);
     return NULL;
 }
 
@@ -244,7 +244,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
 
                         // Check that all arguments are numbers.
                         if (!type_is_numeric(arg->expr_type)) {
-                            push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_NUM,
+                            push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_TYPE_NUM,
                                 arg->line, arg->col);
                             return false;
                         }
@@ -259,13 +259,15 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
                 } break;
                 // Bools.
                 case TOKEN_NOT:
+                    // TODO: not should only take one argument and
+                    // return the inverse.
                 case TOKEN_AND:
                 case TOKEN_OR: {
                     // Check that all arguments are boolean.
                     for (size_t i = 0; i < array_size(node->builtin.args); ++i) {
                         Node *arg = node->builtin.args[i];
                         if (arg->expr_type != &default_types[TYPE_BOOL]) {
-                            push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_BOOL,
+                            push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_TYPE_BOOL,
                                 arg->line, arg->col);
                             return false;
                         }
@@ -283,7 +285,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
                         // TODO: Make sure all arguments have the same type,
                         // like with numeric expressions.
                         if (!type_is_numeric(arg->expr_type)) {
-                            push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_NUM,
+                            push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_TYPE_NUM,
                                 arg->line, arg->col);
                             return false;
                         }
@@ -354,7 +356,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
             StringView *type_body = &node->fun.body->expr_type->name;
             StringView *return_type = &node->fun.return_type->string;
             if (!sv_equal(type_body, return_type)) {
-                push_error(ERR_TYPE_PARSER, ERR_WRONG_RET_TYPE, node->line, node->col);
+                push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_RET_TYPE, node->line, node->col);
                 return false;
             }
         } break;
@@ -390,7 +392,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
             // Check ifexpr.cond is a bool.
             Type *type_cond = node->ifexpr.cond->expr_type;
             if (!sv_equal(&type_cond->name, &default_types[TYPE_BOOL].name)) {
-                push_error(ERR_TYPE_PARSER, ERR_WRONG_COND_TYPE,
+                push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_COND_TYPE,
                     node->line, node->col);
                 return false;
             }
@@ -401,7 +403,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
                 if (type_is_numeric(type_true) && type_is_numeric(type_false)) {
                     node->expr_type = coerce_numeric_types(type_true, type_false);
                 } else if (!sv_equal(&type_true->name, &type_false->name)) {
-                    push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_T_F,
+                    push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_TYPE_T_F,
                         node->line, node->col);
                     return false;
                 }
@@ -418,7 +420,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
             Node *symbol = node->set.symbol;
             Node *value = node->set.value;
             if (!sv_equal(&symbol->expr_type->name, &value->expr_type->name)) {
-                push_error(ERR_TYPE_PARSER, ERR_TYPE_MISMATCH,
+                push_error(ERR_TYPE_SEMANTIC, ERR_TYPE_MISMATCH,
                     node->line, node->col);
                 return false;
             }
@@ -446,7 +448,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
             Node *symbol = node->def.symbol;
             Node *value = node->def.value;
             if (!sv_equal(&symbol->expr_type->name, &value->expr_type->name)) {
-                push_error(ERR_TYPE_PARSER, ERR_TYPE_MISMATCH,
+                push_error(ERR_TYPE_SEMANTIC, ERR_TYPE_MISMATCH,
                     node->line, node->col);
                 return false;
             }
@@ -474,12 +476,12 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
                 return false;
             }
             if (val->type != SYMBOL_FUN) {
-                push_error(ERR_TYPE_PARSER, ERR_WRONG_TYPE_FUN,
+                push_error(ERR_TYPE_SEMANTIC, ERR_WRONG_TYPE_FUN,
                     node->funcall.name->line, node->funcall.name->col);
                 return false;
             }
             if (array_size(node->funcall.args) != array_size(val->fun.param_types)) {
-                push_error(ERR_TYPE_PARSER, ERR_BAD_ARGS, node->line, node->col);
+                push_error(ERR_TYPE_SEMANTIC, ERR_BAD_ARGS, node->line, node->col);
                 return false;
             }
             node->expr_type = node->funcall.name->expr_type;
@@ -490,7 +492,7 @@ resolve_type(ParseTree *ast, Scope *scope, Node *node) {
                 }
                 Node *expected = val->fun.param_types[i];
                 if (!sv_equal(&arg->expr_type->name, &expected->string)) {
-                    push_error(ERR_TYPE_PARSER, ERR_TYPE_MISMATCH,
+                    push_error(ERR_TYPE_SEMANTIC, ERR_TYPE_MISMATCH,
                             arg->line, arg->col);
                     return false;
                 }