Add err to analyzer context

1 files changed, 33 insertions, 2 deletions

diff --git a/src/main.c b/src/main.c
index 7e95e2e..5c99a10 100644
--- a/src/main.c
+++ b/src/main.c
@@ -10,7 +10,6 @@
 // TODO: unions
 // TODO: match deconstruct enums
 // TODO: arrays and pointers
-// TODO: if we have errors make sure we mark the analyzer as such
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -98,6 +97,7 @@ typedef struct Analyzer {
     Scope **scopes;
     StrSet *numeric_types;
     StrSet *integer_types;
+    bool err;
 } Analyzer;
 
 Scope *
@@ -274,6 +274,7 @@ graph_types(Scope **scopes, Arena a) {
 void
 emit_semantic_error(Analyzer *a, Node *n, Str msg) {
     eprintln("%s:%d:%d: error: %s", a->file_name, n->line, n->col, msg);
+    a->err = true;
 }
 
 Str type_inference(Analyzer *a, Node *node, Scope *scope);
@@ -286,6 +287,7 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
         if (structmap_lookup(&scope->structs, field_name)) {
             eprintln("%s:%d:%d: error: struct field '%s' already exists",
                      a->file_name, node->line, node->col, field_name);
+            a->err = true;
         }
         Str type = cstr("\\{ ");
         for (sz i = 0; i < array_size(node->field_type->elements); i++) {
@@ -303,10 +305,12 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
         if (!find_type(scope, field_type)) {
             eprintln("%s:%d:%d: error: unknown type '%s'", a->file_name,
                      node->field_type->line, node->field_type->col, field_type);
+            a->err = true;
         }
         if (structmap_lookup(&scope->structs, field_name)) {
             eprintln("%s:%d:%d: error: struct field '%s' already exists",
                      a->file_name, node->line, node->col, field_name);
+            a->err = true;
         }
         if (node->field_val) {
             Str type = type_inference(a, node->field_val, scope);
@@ -317,6 +321,7 @@ typecheck_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
                     "for '%s': %s expected %s",
                     a->file_name, node->line, node->col, field_name, type,
                     field_type);
+                a->err = true;
             }
         }
         structmap_insert(&scope->structs, field_name,
@@ -352,6 +357,7 @@ typecheck_lit_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
         if (!s) {
             eprintln("%s:%d:%d: error: unknown struct field '%s'", a->file_name,
                      node->line, node->col, symbol);
+            a->err = true;
             return;
         }
         Str field_type = s->val.type;
@@ -362,6 +368,7 @@ typecheck_lit_field(Analyzer *a, Node *node, Scope *scope, Str symbol) {
                 "value "
                 "for '%s': %s expected %s",
                 a->file_name, node->line, node->col, symbol, type, field_type);
+            a->err = true;
         }
         node->type = field_type;
     }
@@ -387,6 +394,7 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
                 eprintln(
                     "%s:%d:%d: error: mismatched return type %s, expected %s",
                     a->file_name, node->line, node->col, node->type, expected);
+                a->err = true;
             }
         } break;
         case NODE_BLOCK: {
@@ -457,6 +465,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "scope ",
                     a->file_name, node->var_name->line, node->var_name->col,
                     symbol);
+                a->err = true;
                 return cstr("");
             }
             if (node->var_type) {
@@ -466,6 +475,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     eprintln("%s:%d:%d: error: unknown type '%s'", a->file_name,
                              node->var_type->line, node->var_type->col,
                              type_name);
+                    a->err = true;
                     return cstr("");
                 }
                 if (node->var_val) {
@@ -476,6 +486,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                             "'%s'",
                             a->file_name, node->var_type->line,
                             node->var_type->col, symbol);
+                        a->err = true;
                         return cstr("");
                     }
                     // TODO: Consider compatible types.
@@ -490,6 +501,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                                 " to a variable of type %s",
                                 a->file_name, node->var_type->line,
                                 node->var_type->col, type, type_name);
+                            a->err = true;
                             return cstr("");
                         }
                     }
@@ -517,6 +529,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "%s"
                     " to a variable of type %s",
                     a->file_name, node->line, node->col, val, name);
+                a->err = true;
                 return cstr("");
             }
             node->type = cstr("nil");
@@ -530,6 +543,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: struct '%s' already exists in current "
                     "scope",
                     a->file_name, node->line, node->col, symbol);
+                a->err = true;
                 return cstr("");
             }
             structmap_insert(&scope->structs, symbol, (Struct){.name = symbol},
@@ -551,6 +565,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: enum '%s' already exists in current "
                     "scope",
                     a->file_name, node->line, node->col, symbol);
+                a->err = true;
                 return cstr("");
             }
             enummap_insert(&scope->enums, symbol,
@@ -567,6 +582,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                 if (enummap_lookup(&scope->enums, field_name)) {
                     eprintln("%s:%d:%d: error: enum field '%s' already exists",
                              a->file_name, field->line, field->col, field_name);
+                    a->err = true;
                 }
                 if (field->field_val) {
                     Str type = type_inference(a, field->field_val, scope);
@@ -575,6 +591,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                             "%s:%d:%d: error: non int enum value for '%s.%s'",
                             a->file_name, field->line, field->col, symbol,
                             field_name);
+                        a->err = true;
                     }
                 }
                 enummap_insert(&scope->enums, field_name,
@@ -803,6 +820,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             if (!type) {
                 eprintln("%s:%d:%d: error: couldn't resolve symbol '%s'",
                          a->file_name, node->line, node->col, symbol);
+                a->err = true;
                 return cstr("");
             }
 
@@ -813,6 +831,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         "%s:%d:%d: error: unspecified enum field for symbol "
                         "'%s'",
                         a->file_name, node->line, node->col, symbol);
+                    a->err = true;
                     return cstr("");
                 }
                 // Check if there is a next and it matches the enum field.
@@ -824,6 +843,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         "'%s': %s",
                         a->file_name, node->line, node->col, symbol,
                         node->next->value.str);
+                    a->err = true;
                     return cstr("");
                 }
                 node->next->type = cstr("int");
@@ -839,6 +859,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         "'%s', did you mean to use %s:{}?",
                         a->file_name, node->line, node->col, type->val,
                         type->val);
+                    a->err = true;
                     return cstr("");
                 } else {
                     if (node->next) {
@@ -856,6 +877,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                             eprintln(
                                 "%s:%d:%d: error: unknown struct field '%s'",
                                 a->file_name, node->line, node->col, chain);
+                            a->err = true;
                             return cstr("");
                         }
                         node->type = field->val.type;
@@ -872,6 +894,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
             if (!s.map) {
                 eprintln("%s:%d:%d: error: unknown struct type '%s'",
                          a->file_name, node->line, node->col, name);
+                a->err = true;
                 return cstr("");
             }
 
@@ -887,6 +910,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         "%s:%d:%d: error: field '%s' already present in struct "
                         "literal",
                         a->file_name, next->line, next->col, field_name);
+                    a->err = true;
                 } else {
                     strset_insert(&set, field_name, a->storage);
                 }
@@ -903,6 +927,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: function '%s' doesn't exist in current "
                     "scope ",
                     a->file_name, node->line, node->col, symbol);
+                a->err = true;
                 return cstr("");
             }
             // Check that actual parameters typecheck
@@ -924,6 +949,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: mismatched parameter types: %s expected "
                     "%s",
                     a->file_name, node->line, node->col, args, expected);
+                a->err = true;
             }
             node->type = fun->val.return_type;
             return node->type;
@@ -1002,6 +1028,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                         "scope ",
                         a->file_name, node->var_name->line, node->var_name->col,
                         symbol);
+                    a->err = true;
                     return cstr("");
                 }
                 symmap_insert(&scope->symbols, symbol,
@@ -1035,6 +1062,7 @@ type_inference(Analyzer *a, Node *node, Scope *scope) {
                     "%s:%d:%d: error: mismatched return type %s, expected %s",
                     a->file_name, node->line, node->col, node->func_body->type,
                     ret_type);
+                a->err = true;
             }
 
             // Ensure ALL return statements match the function prototype.
@@ -1115,6 +1143,7 @@ symbolic_analysis(Analyzer *a, Parser *parser) {
                     "scope ",
                     a->file_name, root->var_name->line, root->var_name->col,
                     symbol);
+                a->err = true;
             }
             symmap_insert(&scope->symbols, symbol,
                           (Symbol){.name = symbol, .kind = SYM_FUN},
@@ -1198,10 +1227,12 @@ process_file(Str path) {
         .file_name = path,
     };
     symbolic_analysis(&analyzer, &parser);
+    if (analyzer.err) {
+        exit(EXIT_FAILURE);
+    }
 
     // Printing symbol tables.
     if (mode == PRINT_SYMTABLES) {
-        // graph_symbols(analyzer.scopes, lexer_arena);
         graph_types(analyzer.scopes, lexer_arena);
     }
     if (mode == PRINT_SEMANTIC) {