Add more graph viz for function maps and types

2 files changed, 205 insertions, 44 deletions

diff --git a/src/main.c b/src/main.c
index 33ab4ed..4bfd104 100644
--- a/src/main.c
+++ b/src/main.c
@@ -63,8 +63,15 @@ typedef struct Symbol {
     struct SymbolMap *fields;
 } Symbol;
 
+typedef struct Fun {
+    Str name;
+    Str param_type;
+    Str return_type;
+} Fun;
+
 MAPDEF(SymbolMap, symmap, Str, Symbol, str_hash, str_eq)
 MAPDEF(TypeMap, typemap, Str, Type, str_hash, str_eq)
+MAPDEF(FunMap, funmap, Str, Fun, str_hash, str_eq)
 
 typedef struct Scope {
     sz id;
@@ -74,13 +81,17 @@ typedef struct Scope {
 } Scope;
 
 typedef struct TypeScope {
+    sz id;
+    Str name;
     TypeMap *types;
+    FunMap *funcs;
     struct TypeScope *parent;
 } TypeScope;
 
 typedef struct Analyzer {
     Arena *storage;
     Str file_name;
+    sz typescope_gen;
     sz scope_gen;
     Scope **scopes;
     TypeScope **types;
@@ -103,6 +114,7 @@ TypeScope *
 typescope_alloc(Analyzer *a, TypeScope *parent) {
     TypeScope *scope = arena_calloc(sizeof(TypeScope), a->storage);
     scope->parent = parent;
+    scope->id = a->typescope_gen++;
     array_push(a->types, scope, a->storage);
     return scope;
 }
@@ -139,25 +151,35 @@ graph_scope(Scope *scope, Arena a) {
     SymbolMapIter iter = symmap_iterator(scope->symbols, &a);
     SymbolMap *sym = symmap_next(&iter, &a);
     print(
-        "%d[shape=\"none\" label=<\
-<TABLE ALIGN=\"left\" STYLE=\"rounded\"  BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" COLUMNS=\"*\">\
-  <TR style=\"rounded\" ><TD COLSPAN=\"3\">ID: %d</TD></TR>",
+        "%d[shape=\"none\" label=<<TABLE ALIGN=\"left\" STYLE=\"rounded\" "
+        "BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" "
+        "COLUMNS=\"*\">"
+        "<TR style=\"rounded\"><TD COLSPAN=\"3\">ID: %d</TD></TR>",
         scope->id, scope->id);
     print(
-        "<TR ><TD ALIGN=\"left\" > NAME </TD><TD ALIGN=\"left\" > KIND "
-        "</TD><TD ALIGN=\"left\" > TYPE </TD></TR>");
+        "<TR >"
+        "<TD ALIGN=\"left\" > NAME </TD>"
+        "<TD ALIGN=\"left\" > KIND </TD>"
+        "<TD ALIGN=\"left\" > TYPE </TD>"
+        "</TR>");
     while (sym) {
         Str type_name = cstr("nil");
         print(
-            "<TR><TD ALIGN=\"left\"> %s </TD><TD ALIGN=\"left\"> %s </TD><TD "
-            "ALIGN=\"left\"> %s </TD></TR>",
+            "<TR>"
+            "<TD ALIGN=\"left\"> %s </TD>"
+            "<TD ALIGN=\"left\"> %s </TD>"
+            "<TD ALIGN=\"left\"> %s </TD>"
+            "</TR>",
             sym->val.name, sym_kind_str[sym->val.kind], type_name);
         SymbolMapIter field_iter = symmap_iterator(sym->val.fields, &a);
         SymbolMap *field = symmap_next(&field_iter, &a);
         while (field) {
             print(
-                "<TR><TD ALIGN=\"left\"> %s.%s </TD><TD ALIGN=\"left\"> %s "
-                "</TD></TR>",
+                "<TR>"
+                "<TD ALIGN=\"left\"> %s.%s </TD>"
+                "<TD ALIGN=\"left\"> %s "
+                "</TD>"
+                "</TR>",
                 sym->val.name, field->val.name, sym_kind_str[field->val.kind]);
             field = symmap_next(&field_iter, &a);
         }
@@ -176,6 +198,85 @@ graph_scope(Scope *scope, Arena a) {
 }
 
 void
+graph_typescope(TypeScope *scope, Arena a) {
+    if (!scope->types) {
+        return;
+    }
+    TypeMapIter iter = typemap_iterator(scope->types, &a);
+    TypeMap *type = typemap_next(&iter, &a);
+    print(
+        "%d[shape=\"none\" label=<<TABLE ALIGN=\"left\" STYLE=\"rounded\" "
+        "BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" "
+        "COLUMNS=\"*\">",
+        scope->id);
+    print(
+        "<TR >"
+        "<TD ALIGN=\"left\" > NAME </TD>"
+        "<TD ALIGN=\"left\" > TYPE </TD>"
+        "</TR>");
+    while (type) {
+        print(
+            "<TR>"
+            "<TD ALIGN=\"left\"> %s </TD>"
+            "<TD ALIGN=\"left\"> %s</TD>"
+            "</TR>",
+            type->key, type->val);
+        type = typemap_next(&iter, &a);
+    }
+    println("</TABLE>>];");
+
+    sz this_id = scope->id;
+    while (scope->parent) {
+        if (scope->parent->types) {
+            println("%d:e->%d:w;", this_id, scope->parent->id);
+            break;
+        } else {
+            scope = scope->parent;
+        }
+    }
+}
+
+void
+graph_functions(TypeScope *scope, Arena a) {
+    if (!scope->funcs) {
+        return;
+    }
+    FunMapIter iter = funmap_iterator(scope->funcs, &a);
+    FunMap *func = funmap_next(&iter, &a);
+    print(
+        "fun_%d[shape=\"none\" label=<<TABLE ALIGN=\"left\" STYLE=\"rounded\"  "
+        "BORDER=\"1\" CELLBORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"6\" "
+        "COLUMNS=\"*\">",
+        scope->id);
+    print(
+        "<TR >"
+        "<TD ALIGN=\"left\" > NAME </TD>"
+        "<TD ALIGN=\"left\" > PARAMS </TD>"
+        "<TD ALIGN=\"left\" > RETURN </TD>"
+        "</TR>");
+    while (func) {
+        print(
+            "<TR>"
+            "<TD PORT=\"%s\" ALIGN=\"left\" > %s </TD>"
+            "<TD ALIGN=\"left\" > %s </TD>"
+            "<TD ALIGN=\"left\" > %s </TD>"
+            "</TR>",
+            func->val.name, func->val.name, func->val.param_type, func->val.return_type);
+        func = funmap_next(&iter, &a);
+    }
+    println("</TABLE>>];");
+    sz this_id = scope->id;
+    while (scope->parent) {
+        if (scope->parent->types) {
+            println("fun_%d:e->fun_%d:%s:w;", this_id, scope->parent->id, scope->name);
+            break;
+        } else {
+            scope = scope->parent;
+        }
+    }
+}
+
+void
 graph_symbols(Scope **scopes, Arena a) {
     if (scopes == NULL) return;
     println("digraph symbols {");
@@ -197,6 +298,28 @@ graph_symbols(Scope **scopes, Arena a) {
 }
 
 void
+graph_types(TypeScope **scopes, Arena a) {
+    if (scopes == NULL) return;
+    println("digraph symbols {");
+    println("rankdir=LR;");
+    println("ranksep=\"0.95 equally\";");
+    println("nodesep=\"0.5 equally\";");
+    println("overlap=scale;");
+    println("bgcolor=\"transparent\";");
+    for (sz i = 0; i < array_size(scopes); i++) {
+        TypeScope *scope = scopes[i];
+        if (!scope) {
+            continue;
+        }
+        println("subgraph %d {", i);
+        graph_typescope(scope, a);
+        graph_functions(scope, a);
+        println("}");
+    }
+    println("}");
+}
+
+void
 emit_semantic_error(Analyzer *a, Node *n, Str msg) {
     eprintln("%s:%d:%d: error: %s", a->file_name, n->line, n->col, msg);
 }
@@ -219,7 +342,9 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
         case NODE_RETURN: {
             bool err = !str_eq(node->type, expected);
             if (err) {
-                emit_semantic_error(a, node, cstr("mismatched return types"));
+                eprintln(
+                    "%s:%d:%d: error: mismatched return type %s, expected %s",
+                    a->file_name, node->line, node->col, node->type, expected);
             }
         } break;
         case NODE_BLOCK: {
@@ -242,7 +367,25 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
                 typecheck_returns(a, node->var_val, expected);
             }
         } break;
-        default: {
+        case NODE_ADD:
+        case NODE_SUB:
+        case NODE_DIV:
+        case NODE_MUL:
+        case NODE_MOD:
+        case NODE_NOT:
+        case NODE_AND:
+        case NODE_OR:
+        case NODE_EQ:
+        case NODE_NEQ:
+        case NODE_LT:
+        case NODE_GT:
+        case NODE_LE:
+        case NODE_GE:
+        case NODE_BITNOT:
+        case NODE_BITAND:
+        case NODE_BITOR:
+        case NODE_BITLSHIFT:
+        case NODE_BITRSHIFT: {
             if (node->left) {
                 typecheck_returns(a, node->left, expected);
             }
@@ -250,6 +393,7 @@ typecheck_returns(Analyzer *a, Node *node, Str expected) {
                 typecheck_returns(a, node->right, expected);
             }
         } break;
+        default: break;
     }
 }
 
@@ -543,7 +687,7 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             return node->type;
         } break;
         case NODE_RETURN: {
-            Type ret_type = cstr("(");
+            Type ret_type = cstr("");
             for (sz i = 0; i < array_size(node->elements); i++) {
                 Node *expr = node->elements[i];
                 Type type = type_inference(a, expr, scope);
@@ -552,7 +696,6 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     ret_type = str_concat(ret_type, cstr(","), a->storage);
                 }
             }
-            ret_type = str_concat(ret_type, cstr(")"), a->storage);
             node->type = ret_type;
             return node->type;
         } break;
@@ -576,8 +719,9 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
             // }
 
             node->type = cstr("nil");
+            TypeScope *prev_scope = scope;
             scope = typescope_alloc(a, scope);
-            Type param_type = cstr("(");
+            Type param_type = cstr("");
             for (sz i = 0; i < array_size(node->func_params); i++) {
                 Node *param = node->func_params[i];
                 Str symbol = param->param_name->value.str;
@@ -591,10 +735,9 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     param_type = str_concat(param_type, cstr(","), a->storage);
                 }
             }
-            param_type = str_concat(param_type, cstr(")"), a->storage);
             node->fun_params = param_type;
 
-            Type ret_type = cstr("(");
+            Type ret_type = cstr("");
             for (sz i = 0; i < array_size(node->func_ret); i++) {
                 Node *expr = node->func_ret[i];
                 Type type = type_inference(a, expr, scope);
@@ -603,9 +746,17 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
                     ret_type = str_concat(ret_type, cstr(","), a->storage);
                 }
             }
-            ret_type = str_concat(ret_type, cstr(")"), a->storage);
             node->fun_return = ret_type;
 
+            Str symbol = node->func_name->value.str;
+            // TODO: check it was not defined before.
+            scope->name = symbol;
+            funmap_insert(&prev_scope->funcs, symbol,
+                          (Fun){.name = symbol,
+                                .param_type = param_type,
+                                .return_type = ret_type},
+                          a->storage);
+
             if (node->func_body->kind == NODE_BLOCK) {
                 Type type;
                 for (sz i = 0; i < array_size(node->func_body->elements); i++) {
@@ -619,7 +770,10 @@ type_inference(Analyzer *a, Node *node, TypeScope *scope) {
 
             // Ensure main body return matches the prototype.
             if (!str_eq(node->func_body->type, ret_type)) {
-                emit_semantic_error(a, node, cstr("mismatched return types"));
+                eprintln(
+                    "%s:%d:%d: error: mismatched return type %s, expected %s",
+                    a->file_name, node->line, node->col, node->func_body->type,
+                    ret_type);
             }
 
             // Ensure ALL return statements match the function prototype.
@@ -1017,7 +1171,8 @@ process_file(Str path) {
 
     // Printing symbol tables.
     if (mode == PRINT_SYMTABLES) {
-        graph_symbols(analyzer.scopes, lexer_arena);
+        // graph_symbols(analyzer.scopes, lexer_arena);
+        graph_types(analyzer.types, lexer_arena);
     }
     if (mode == PRINT_SEMANTIC) {
         graph_ast(parser.nodes);
diff --git a/tests/semantics.bad b/tests/semantics.bad
index 518ef40..3305222 100644
--- a/tests/semantics.bad
+++ b/tests/semantics.bad
@@ -1,22 +1,22 @@
 ; let a:f32 = (1.0 + 2.0 * 2.0) / 2.0
 
-; let annotated:int = (1 + 2 * 2) / 2
-; let numbers = 1
-; let symbols = numbers
-; let arith = 1 + 2 * 4
-; let cmp = 1 <= 2
-; let logic = !true && false || (1 <= 2)
-; let bits = 0xff & 0b00001111
-; let block = {
-;     let a = 1 + 2
-;     a + 3
-; }
+let annotated:int = (1 + 2 * 2) / 2
+let numbers = 1
+let symbols = numbers
+let arith = 1 + 2 * 4
+let cmp = 1 <= 2
+let logic = !true && false || (1 <= 2)
+let bits = 0xff & 0b00001111
+let block = {
+    let a = 1 + 2
+    a + 3
+}
 
-; let maybe = if (1 == 2) {
-;     32
-; } else {
-;     44
-; }
+let maybe = if (1 == 2) {
+    32
+} else {
+    44
+}
 
 ; let single = if (true) {
 ;     123
@@ -46,15 +46,18 @@
 ; let a:my_struct
 ; set a.field_a = 1
 
-; fun nested(): u32 {
-;     fun adder(a: u32, b: u32): u32 a + b
-;     if (1 + 1 == 2) {
-;         {
-;             let b = 32
-;         }
-;     }
-;     adder(1,2)
-; }
+fun nested(): int {
+    fun adder(a: u32, b: u32): u32 {
+        a + b
+    }
+    if (1 + 1 == 2) {
+        let b = 15
+        5 + b
+    ;     {
+    ;         let b = 32
+    ;     }
+    }
+}
 
 ; enum field {
 ;     a
@@ -110,6 +113,9 @@
 ;     1 + 1 + c
 ; }
 fun foo(a: int b: str): (f64, f64) {
+    fun bar(): nil {
+        println("ding")
+    }
     if (a == 1) {
         ; return("test", b)
         return(3.0, 4.0)