Initial lowering pass 2 implementation, create shells for source expressions and statements

Signed-off-by: Mel <mel@rnrd.eu>

2 files changed, 116 insertions, 100 deletions

diff --git a/boot/visit/ir.c b/boot/visit/ir.c
index 20296e3..1920f3b 100644
--- a/boot/visit/ir.c
+++ b/boot/visit/ir.c
@@ -78,14 +78,12 @@ walk(struct Visit* visit, struct Unit* unit)
 void
 walk_unit(struct Visit* visit, struct Unit* unit)
 {
-    FOR_EACH_ARRAY(struct Type*, type, &unit->types.entries, { VISIT(visit_type, type); })
-    FOR_EACH_ARRAY(struct Function*, function, &unit->functions.entries, {
-        VISIT(visit_function, function);
-    })
-    FOR_EACH_ARRAY(struct Import, import, &unit->imports, { VISIT(visit_import, &import); })
-    FOR_EACH_ARRAY(struct Diagnostic, diagnostic, &unit->diagnostics, {
-        VISIT(visit_diagnostic, &diagnostic);
-    })
+    FOR_EACH_ARRAY (struct Type*, type, &unit->types.entries) VISIT(visit_type, *type);
+    FOR_EACH_ARRAY (struct Function*, function, &unit->functions.entries)
+        VISIT(visit_function, *function);
+    FOR_EACH_ARRAY (struct Import, import, &unit->imports) VISIT(visit_import, import);
+    FOR_EACH_ARRAY (struct Diagnostic, diagnostic, &unit->diagnostics)
+        VISIT(visit_diagnostic, diagnostic);
 }
 
 void
@@ -120,33 +118,31 @@ WALK_LEAF_FUNCTION(walk_type_alias, struct Type*);
 void
 walk_type_structure(struct Visit* visit, struct Type* type)
 {
-    FOR_EACH_ARRAY(struct Field, field, &type->value.structure.fields, {
-        VISIT(visit_type_ref, &field.type);
-    })
+    FOR_EACH_ARRAY (struct Field, field, &type->value.structure.fields)
+        VISIT(visit_type_ref, &field->type);
 }
 
 void
 walk_type_variant(struct Visit* visit, struct Type* type)
 {
-    FOR_EACH_ARRAY(struct Variant_Case, one_case, &type->value.variant.cases, {
-        if (one_case.has_payload) VISIT(visit_type_ref, &one_case.payload);
-    })
+    FOR_EACH_ARRAY (struct Variant_Case, one_case, &type->value.variant.cases) {
+        if (one_case->has_payload) VISIT(visit_type_ref, &one_case->payload);
+    }
 }
 
 void
 walk_type_function(struct Visit* visit, struct Type* type)
 {
     VISIT(visit_type_ref, &type->value.function.return_type);
-    FOR_EACH_ARRAY(struct Type_Ref, param, &type->value.function.params, {
-        VISIT(visit_type_ref, &param);
-    })
+    FOR_EACH_ARRAY (struct Type_Ref, param, &type->value.function.params)
+        VISIT(visit_type_ref, param);
 }
 
 void
 walk_function(struct Visit* visit, struct Function* function)
 {
     VISIT(visit_type_ref, &function->return_type);
-    FOR_EACH_ARRAY(struct Param, param, &function->params, { VISIT(visit_type_ref, &param.type); })
+    FOR_EACH_ARRAY (struct Param, param, &function->params) VISIT(visit_type_ref, &param->type);
     VISIT_MAYBE(visit_block, function->body);
 }
 
@@ -217,10 +213,10 @@ walk_statement_expression(struct Visit* visit, struct Statement* stmt)
 void
 walk_statement_conditional(struct Visit* visit, struct Statement* stmt)
 {
-    FOR_EACH_ARRAY(struct If_Branch, branch, &stmt->value.conditional.branches, {
-        VISIT_MAYBE(visit_expression, branch.condition);
-        VISIT(visit_block, branch.body);
-    })
+    FOR_EACH_ARRAY (struct If_Branch, branch, &stmt->value.conditional.branches) {
+        VISIT_MAYBE(visit_expression, branch->condition);
+        VISIT(visit_block, branch->body);
+    }
 }
 
 void
@@ -326,9 +322,8 @@ void
 walk_expression_call(struct Visit* visit, struct Expression* expr)
 {
     VISIT(visit_expression, expr->value.call.subject);
-    FOR_EACH_ARRAY(struct Expression*, argument, &expr->value.call.arguments, {
-        VISIT(visit_expression, argument);
-    })
+    FOR_EACH_ARRAY (struct Expression*, argument, &expr->value.call.arguments)
+        VISIT(visit_expression, *argument);
 }
 
 void
@@ -354,13 +349,16 @@ walk_expression_cast(struct Visit* visit, struct Expression* expr)
 void
 walk_expression_construct(struct Visit* visit, struct Expression* expr)
 {
-    FOR_EACH_ARRAY(struct Construct_Field, field, &expr->value.construct.fields, {
-        VISIT(visit_expression, field.value);
-    })
+    FOR_EACH_ARRAY (struct Construct_Field, field, &expr->value.construct.fields)
+        VISIT(visit_expression, field->value);
 }
 
-void walk_block(struct Visit* visit, struct Block* block){ FOR_EACH_ARRAY(
-    struct Statement*, statement, &block -> statements, { VISIT(visit_statement, statement); }) }
+void
+walk_block(struct Visit* visit, struct Block* block)
+{
+    FOR_EACH_ARRAY (struct Statement*, statement, &block->statements)
+        VISIT(visit_statement, *statement);
+}
 
 WALK_LEAF_FUNCTION(walk_type_ref, struct Type_Ref*);
 WALK_LEAF_FUNCTION(walk_import, struct Import*);
@@ -475,11 +473,11 @@ printer_visit_unit(struct Visit* visit, struct Unit* unit)
         printer_indent(p);
         PRINT("(types");
         p->indentation_level++;
-        FOR_EACH_ARRAY(struct Type*, type, &unit->types.entries, {
+        FOR_EACH_ARRAY (struct Type*, type, &unit->types.entries) {
             PRINT("\n");
             printer_indent(p);
-            VISIT(visit_type, type);
-        })
+            VISIT(visit_type, *type);
+        }
         p->indentation_level--;
         PRINT(")");
     }
@@ -489,11 +487,11 @@ printer_visit_unit(struct Visit* visit, struct Unit* unit)
         printer_indent(p);
         PRINT("(functions");
         p->indentation_level++;
-        FOR_EACH_ARRAY(struct Function*, function, &unit->functions.entries, {
+        FOR_EACH_ARRAY (struct Function*, function, &unit->functions.entries) {
             PRINT("\n");
             printer_indent(p);
-            VISIT(visit_function, function);
-        })
+            VISIT(visit_function, *function);
+        }
         p->indentation_level--;
         PRINT(")");
     }
@@ -502,10 +500,10 @@ printer_visit_unit(struct Visit* visit, struct Unit* unit)
         PRINT("\n");
         printer_indent(p);
         PRINT("(imports");
-        FOR_EACH_ARRAY(struct Import, import, &unit->imports, {
+        FOR_EACH_ARRAY (struct Import, import, &unit->imports) {
             PRINT(" ");
-            VISIT(visit_import, &import);
-        })
+            VISIT(visit_import, import);
+        }
         PRINT(")");
     }
 
@@ -513,7 +511,7 @@ printer_visit_unit(struct Visit* visit, struct Unit* unit)
         PRINT("\n");
         printer_indent(p);
         PRINT("(emission_order");
-        FOR_EACH_ARRAY(Type_Id, id, &unit->type_emission_order, { PRINT(" %lu", id); })
+        FOR_EACH_ARRAY (Type_Id, id, &unit->type_emission_order) PRINT(" %lu", *id);
         PRINT(")");
     }
 
@@ -522,11 +520,11 @@ printer_visit_unit(struct Visit* visit, struct Unit* unit)
         printer_indent(p);
         PRINT("(diagnostics");
         p->indentation_level++;
-        FOR_EACH_ARRAY(struct Diagnostic, diagnostic, &unit->diagnostics, {
+        FOR_EACH_ARRAY (struct Diagnostic, diagnostic, &unit->diagnostics) {
             PRINT("\n");
             printer_indent(p);
-            VISIT(visit_diagnostic, &diagnostic);
-        })
+            VISIT(visit_diagnostic, diagnostic);
+        }
         p->indentation_level--;
         PRINT(")");
     }
@@ -541,9 +539,9 @@ printer_visit_type_ref(struct Visit* visit, struct Type_Ref* ref)
     PRINTER_PREAMBLE
 
     PRINT("(ref");
-    FOR_EACH_ARRAY(enum Type_Modifier, mod, &ref->mods, {
-        if (mod == TYPE_MOD_REFERENCE) PRINT(" &");
-    })
+    FOR_EACH_ARRAY (enum Type_Modifier, mod, &ref->mods) {
+        if (*mod == TYPE_MOD_REFERENCE) PRINT(" &");
+    }
     struct Type* target = printer_type_at(p, ref->type_id);
     if (target)
         PRINT(" %s", string_c_str(target->name));
@@ -562,7 +560,7 @@ printer_visit_type(struct Visit* visit, struct Type* type)
     walk_type(visit, type);
     if (array_length(&type->depends_on) > 0) {
         PRINT(" (depends_on");
-        FOR_EACH_ARRAY(Type_Id, dep, &type->depends_on, { PRINT(" %lu", dep); })
+        FOR_EACH_ARRAY (Type_Id, dep, &type->depends_on) PRINT(" %lu", *dep);
         PRINT(")");
     }
     PRINT(")");
@@ -594,11 +592,11 @@ printer_visit_type_structure(struct Visit* visit, struct Type* type)
     PRINTER_PREAMBLE
 
     PRINT(" structure");
-    FOR_EACH_ARRAY(struct Field, field, &type->value.structure.fields, {
-        PRINT(" (field %s ", string_c_str(field.name));
-        VISIT(visit_type_ref, &field.type);
+    FOR_EACH_ARRAY (struct Field, field, &type->value.structure.fields) {
+        PRINT(" (field %s ", string_c_str(field->name));
+        VISIT(visit_type_ref, &field->type);
         PRINT(")");
-    })
+    }
 }
 
 void
@@ -607,14 +605,14 @@ printer_visit_type_variant(struct Visit* visit, struct Type* type)
     PRINTER_PREAMBLE
 
     PRINT(" variant");
-    FOR_EACH_ARRAY(struct Variant_Case, one_case, &type->value.variant.cases, {
-        PRINT(" (case %s tag=%u", string_c_str(one_case.name), one_case.tag);
-        if (one_case.has_payload) {
+    FOR_EACH_ARRAY (struct Variant_Case, one_case, &type->value.variant.cases) {
+        PRINT(" (case %s tag=%u", string_c_str(one_case->name), one_case->tag);
+        if (one_case->has_payload) {
             PRINT(" ");
-            VISIT(visit_type_ref, &one_case.payload);
+            VISIT(visit_type_ref, &one_case->payload);
         }
         PRINT(")");
-    })
+    }
 }
 
 void
@@ -625,11 +623,11 @@ printer_visit_type_function(struct Visit* visit, struct Type* type)
     PRINT(" function (returns ");
     VISIT(visit_type_ref, &type->value.function.return_type);
     PRINT(")");
-    FOR_EACH_ARRAY(struct Type_Ref, param, &type->value.function.params, {
+    FOR_EACH_ARRAY (struct Type_Ref, param, &type->value.function.params) {
         PRINT(" (param ");
-        VISIT(visit_type_ref, &param);
+        VISIT(visit_type_ref, param);
         PRINT(")");
-    })
+    }
     if (type->value.function.variadic) PRINT(" variadic");
 }
 
@@ -644,11 +642,11 @@ printer_visit_function(struct Visit* visit, struct Function* function)
     PRINT(" (returns ");
     VISIT(visit_type_ref, &function->return_type);
     PRINT(")");
-    FOR_EACH_ARRAY(struct Param, param, &function->params, {
-        PRINT(" (param %s ", string_c_str(param.name));
-        VISIT(visit_type_ref, &param.type);
+    FOR_EACH_ARRAY (struct Param, param, &function->params) {
+        PRINT(" (param %s ", string_c_str(param->name));
+        VISIT(visit_type_ref, &param->type);
         PRINT(")");
-    })
+    }
     if (function->variadic) PRINT(" variadic");
 
     if (function->body) {
@@ -709,17 +707,17 @@ printer_visit_statement_conditional(struct Visit* visit, struct Statement* stmt)
     PRINTER_PREAMBLE
 
     PRINT("(conditional");
-    FOR_EACH_ARRAY(struct If_Branch, branch, &stmt->value.conditional.branches, {
+    FOR_EACH_ARRAY (struct If_Branch, branch, &stmt->value.conditional.branches) {
         PRINT(" ");
-        if (branch.condition) {
+        if (branch->condition) {
             PRINT("(when ");
-            VISIT(visit_expression, branch.condition);
+            VISIT(visit_expression, branch->condition);
             PRINT(") ");
         } else {
             PRINT("(else) ");
         }
-        VISIT(visit_block, branch.body);
-    })
+        VISIT(visit_block, branch->body);
+    }
     PRINT(")");
 }
 
@@ -862,10 +860,10 @@ printer_visit_expression_call(struct Visit* visit, struct Expression* expr)
     PRINTER_PREAMBLE
     PRINT("(call ");
     VISIT(visit_expression, expr->value.call.subject);
-    FOR_EACH_ARRAY(struct Expression*, argument, &expr->value.call.arguments, {
+    FOR_EACH_ARRAY (struct Expression*, argument, &expr->value.call.arguments) {
         PRINT(" ");
-        VISIT(visit_expression, argument);
-    })
+        VISIT(visit_expression, *argument);
+    }
     PRINT(")");
 }
 
@@ -911,14 +909,14 @@ printer_visit_expression_construct(struct Visit* visit, struct Expression* expr)
         PRINT(" %s", string_c_str(type->name));
     else
         PRINT(" #%lu", expr->value.construct.type_id);
-    FOR_EACH_ARRAY(struct Construct_Field, field, &expr->value.construct.fields, {
-        if (field.name.length > 0)
-            PRINT(" (field %s ", string_c_str(field.name));
+    FOR_EACH_ARRAY (struct Construct_Field, field, &expr->value.construct.fields) {
+        if (field->name.length > 0)
+            PRINT(" (field %s ", string_c_str(field->name));
         else
             PRINT(" (positional ");
-        VISIT(visit_expression, field.value);
+        VISIT(visit_expression, field->value);
         PRINT(")");
-    })
+    }
     PRINT(")");
 }
 
@@ -931,10 +929,10 @@ printer_visit_block(struct Visit* visit, struct Block* block)
     if (array_length(&block->statements) > 0) {
         PRINT("\n");
         p->indentation_level++;
-        FOR_EACH_ARRAY(struct Statement*, statement, &block->statements, {
-            VISIT(visit_statement, statement);
+        FOR_EACH_ARRAY (struct Statement*, statement, &block->statements) {
+            VISIT(visit_statement, *statement);
             PRINT("\n");
-        })
+        }
         p->indentation_level--;
         printer_indent(p);
     }
diff --git a/boot/visit/tree.c b/boot/visit/tree.c
index 48db391..efeffe9 100644
--- a/boot/visit/tree.c
+++ b/boot/visit/tree.c
@@ -33,19 +33,26 @@ struct Tree_Visit_Table
     void (*visit_statement_defer)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
 
     void (*visit_expression)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_integer_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_float_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_string_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_boolean_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_integer_literal)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_float_literal)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_string_literal)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_boolean_literal)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_name)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_unary_operation)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_binary_operation)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_unary_operation)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_binary_operation)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_group)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_call)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_construct)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_subscript)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_member)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
-    void (*visit_expression_increment_decrement)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
+    void (*visit_expression_increment_decrement)(
+        struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_try)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_must)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
     void (*visit_expression_function)(struct Tree_Visit* visitor, struct Tree_Expression* expr);
@@ -63,8 +70,10 @@ struct Tree_Visit_Table
     void (*visit_type_node_class)(struct Tree_Visit* visitor, struct Tree_Type* node);
 
     void (*visit_block_node)(struct Tree_Visit* visitor, struct Tree_Block* node);
-    void (*visit_bare_declaration_node)(struct Tree_Visit* visitor, struct Tree_Bare_Declaration* node);
-    void (*visit_function_header_node)(struct Tree_Visit* visitor, struct Tree_Function_Header* header);
+    void (*visit_bare_declaration_node)(
+        struct Tree_Visit* visitor, struct Tree_Bare_Declaration* node);
+    void (*visit_function_header_node)(
+        struct Tree_Visit* visitor, struct Tree_Function_Header* header);
     void (*visit_argument_group_node)(struct Tree_Visit* visitor, struct Tree_Argument_Group* node);
     void (*visit_pragma_node)(struct Tree_Visit* visitor, struct Tree_Pragma* node);
 };
@@ -291,7 +300,8 @@ tree_walk_expression_member(struct Tree_Visit* visit, struct Tree_Expression* ex
 }
 
 void
-tree_walk_expression_increment_decrement(struct Tree_Visit* visit, struct Tree_Expression* expression)
+tree_walk_expression_increment_decrement(
+    struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.increment_decrement.subject);
 }
@@ -416,7 +426,9 @@ tree_walk_type_class(struct Tree_Visit* visit, struct Tree_Type* node)
 void
 tree_walk_block(struct Tree_Visit* visit, struct Tree_Block* node)
 {
-    FOR_EACH (struct Tree_Statement*, statement, node->statements) { VISIT(visit_statement, statement); }
+    FOR_EACH (struct Tree_Statement*, statement, node->statements) {
+        VISIT(visit_statement, statement);
+    }
 }
 
 void
@@ -438,7 +450,9 @@ tree_walk_function_header(struct Tree_Visit* visit, struct Tree_Function_Header*
 void
 tree_walk_argument_group(struct Tree_Visit* visit, struct Tree_Argument_Group* node)
 {
-    FOR_EACH (struct Tree_Expression*, argument, node->arguments) { VISIT(visit_expression, argument); }
+    FOR_EACH (struct Tree_Expression*, argument, node->arguments) {
+        VISIT(visit_expression, argument);
+    }
 }
 
 void
@@ -601,7 +615,8 @@ tree_printer_visit_statement_conditional(struct Tree_Visit* visit, struct Tree_S
 
     PRINT("(conditional");
     for (uint i = 0; i < stmt->value.conditional.condition_count; ++i) {
-        const struct Tree_Statement_Conditional_Branch* branch = &stmt->value.conditional.conditions[i];
+        const struct Tree_Statement_Conditional_Branch* branch =
+            &stmt->value.conditional.conditions[i];
         PRINT(" ");
         if (branch->when) {
             PRINT("(when ");
@@ -707,7 +722,8 @@ tree_printer_visit_expression(struct Tree_Visit* visit, struct Tree_Expression*
 }
 
 void
-tree_printer_visit_expression_integer_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
+tree_printer_visit_expression_integer_literal(
+    struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -731,7 +747,8 @@ tree_printer_visit_expression_string_literal(struct Tree_Visit* visit, struct Tr
 }
 
 void
-tree_printer_visit_expression_boolean_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
+tree_printer_visit_expression_boolean_literal(
+    struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -747,7 +764,8 @@ tree_printer_visit_expression_name(struct Tree_Visit* visit, struct Tree_Express
 }
 
 void
-tree_printer_visit_expression_unary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr)
+tree_printer_visit_expression_unary_operation(
+    struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -757,7 +775,8 @@ tree_printer_visit_expression_unary_operation(struct Tree_Visit* visit, struct T
 }
 
 void
-tree_printer_visit_expression_binary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr)
+tree_printer_visit_expression_binary_operation(
+    struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -827,7 +846,8 @@ tree_printer_visit_expression_member(struct Tree_Visit* visit, struct Tree_Expre
 }
 
 void
-tree_printer_visit_expression_increment_decrement(struct Tree_Visit* visit, struct Tree_Expression* expr)
+tree_printer_visit_expression_increment_decrement(
+    struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -1016,9 +1036,7 @@ tree_printer_visit_bare_declaration(struct Tree_Visit* visit, struct Tree_Bare_D
     TREE_PRINTER_PREAMBLE
 
     PRINT("(declaration ");
-    FOR_EACH_ARRAY(struct String, name, &node->names, {
-        PRINT("%s ", name.data);
-    })
+    FOR_EACH_ARRAY (struct String, name, &node->names) PRINT("%s ", name->data);
 
     if (node->type && node->type->type != TREE_TYPE_NONE) {
         VISIT(visit_type_node, node->type);