Rename tree nodes to add consistent prefix, de-node, clean-up names

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

1 files changed, 326 insertions, 326 deletions

diff --git a/boot/visit.c b/boot/visit.c
index f9ad51c..83de09a 100644
--- a/boot/visit.c
+++ b/boot/visit.c
@@ -13,60 +13,60 @@
 
 #include "catboot.h"
 
-struct Visit
+struct Tree_Visit
 {
-    struct Visit_Table* table;
+    struct Tree_Visit_Table* table;
     void* user_data;
 };
 
-struct Visit_Table
-{
-    void (*visit_tree)(struct Visit* visitor, struct Tree* tree);
-
-    void (*visit_statement)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_declaration)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_conditional)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_loop)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_return)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_break)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_continue)(struct Visit* visitor, struct Statement* stmt);
-    void (*visit_statement_defer)(struct Visit* visitor, struct Statement* stmt);
-
-    void (*visit_expression)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_integer_literal)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_float_literal)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_string_literal)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_boolean_literal)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_name)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_unary_operation)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_binary_operation)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_group)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_call)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_construct)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_subscript)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_member)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_increment_decrement)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_try)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_must)(struct Visit* visitor, struct Expression* expr);
-    void (*visit_expression_function)(struct Visit* visitor, struct Expression* expr);
-
-    void (*visit_type_node)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_name)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_array)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_reference)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_maybe)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_tuple)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_map)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_function)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_structure)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_variant)(struct Visit* visitor, struct Type_Node* node);
-    void (*visit_type_node_class)(struct Visit* visitor, struct Type_Node* node);
-
-    void (*visit_block_node)(struct Visit* visitor, struct Block_Node* node);
-    void (*visit_bare_declaration_node)(struct Visit* visitor, struct Bare_Declaration_Node* node);
-    void (*visit_function_header_node)(struct Visit* visitor, struct Function_Header_Node* header);
-    void (*visit_argument_group_node)(struct Visit* visitor, struct Argument_Group_Node* node);
-    void (*visit_pragma_node)(struct Visit* visitor, struct Pragma_Node* node);
+struct Tree_Visit_Table
+{
+    void (*visit_tree)(struct Tree_Visit* visitor, struct Tree* tree);
+
+    void (*visit_statement)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    void (*visit_statement_declaration)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    void (*visit_statement_conditional)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    void (*visit_statement_loop)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    void (*visit_statement_return)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    void (*visit_statement_break)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    void (*visit_statement_continue)(struct Tree_Visit* visitor, struct Tree_Statement* stmt);
+    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_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_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_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);
+
+    void (*visit_type_node)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_name)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_array)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_reference)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_maybe)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_tuple)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_map)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_function)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_structure)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    void (*visit_type_node_variant)(struct Tree_Visit* visitor, struct Tree_Type* node);
+    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_argument_group_node)(struct Tree_Visit* visitor, struct Tree_Argument_Group* node);
+    void (*visit_pragma_node)(struct Tree_Visit* visitor, struct Tree_Pragma* node);
 };
 
 #define VISIT(visit_function, node) visit->table->visit_function(visit, node);
@@ -78,76 +78,76 @@ struct Visit_Table
     type* name = (type*)visit->user_data; \
     if (!name) { failure("visit user data is NULL for " #name); }
 
-// walk functions are the default traversal mechanism
+// tree_walk functions are the default traversal mechanism
 
-// define a walk function which goes nowhere.
-#define WALK_LEAF_FUNCTION(name, type) \
-    void name(struct Visit* visit, type node) {}
+// define a tree_walk function which goes nowhere.
+#define TREE_WALK_LEAF_FUNCTION(name, type) \
+    void name(struct Tree_Visit* visit, type node) {}
 
-// top-level walk function for beginning the visit flow.
+// top-level tree_walk function for beginning the visit flow.
 void
-walk(struct Visit* visit, struct Tree* tree)
+tree_walk(struct Tree_Visit* visit, struct Tree* tree)
 {
     VISIT(visit_tree, tree);
 }
 
 void
-walk_tree(struct Visit* visit, struct Tree* tree)
+tree_walk_tree(struct Tree_Visit* visit, struct Tree* tree)
 {
-    FOR_EACH (struct Statement*, statement, tree->top_level_statements) {
+    FOR_EACH (struct Tree_Statement*, statement, tree->top_level_statements) {
         VISIT(visit_statement, statement);
     }
 }
 
 void
-walk_statement(struct Visit* visit, struct Statement* statement)
+tree_walk_statement(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
     switch (statement->kind) {
-    case STATEMENT_EXPRESSION:
+    case TREE_STATEMENT_EXPRESSION:
         VISIT(visit_expression, statement->value.expression.inner);
         break;
-    case STATEMENT_DECLARATION:
+    case TREE_STATEMENT_DECLARATION:
         VISIT(visit_statement_declaration, statement);
         break;
-    case STATEMENT_BLOCK:
+    case TREE_STATEMENT_BLOCK:
         VISIT(visit_block_node, &statement->value.block.inner);
         break;
-    case STATEMENT_CONDITIONAL:
+    case TREE_STATEMENT_CONDITIONAL:
         VISIT(visit_statement_conditional, statement);
         break;
-    case STATEMENT_LOOP:
+    case TREE_STATEMENT_LOOP:
         VISIT(visit_statement_loop, statement);
         break;
-    case STATEMENT_RETURN:
+    case TREE_STATEMENT_RETURN:
         VISIT(visit_statement_return, statement);
         break;
-    case STATEMENT_BREAK:
+    case TREE_STATEMENT_BREAK:
         VISIT(visit_statement_break, statement);
         break;
-    case STATEMENT_CONTINUE:
+    case TREE_STATEMENT_CONTINUE:
         VISIT(visit_statement_continue, statement);
         break;
-    case STATEMENT_DEFER:
+    case TREE_STATEMENT_DEFER:
         VISIT(visit_statement_defer, statement);
         break;
-    case STATEMENT_PRAGMA:
+    case TREE_STATEMENT_PRAGMA:
         VISIT(visit_pragma_node, statement->value.pragma.inner);
         break;
     default:
-        failure("unexpected statement kind in `walk_statement`");
+        failure("unexpected statement kind in `tree_walk_statement`");
     }
 }
 
 void
-walk_statement_declaration(struct Visit* visit, struct Statement* statement)
+tree_walk_statement_declaration(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
     VISIT(visit_bare_declaration_node, &statement->value.declaration.inner);
 }
 
 void
-walk_statement_conditional(struct Visit* visit, struct Statement* statement)
+tree_walk_statement_conditional(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
-    struct Statement_Value_Conditional* conditional = &statement->value.conditional;
+    struct Tree_Statement_Value_Conditional* conditional = &statement->value.conditional;
     for (uint i = 0; i < conditional->condition_count; ++i) {
         VISIT_MAYBE(visit_expression, conditional->conditions[i].when);
         VISIT(visit_block_node, &conditional->conditions[i].then);
@@ -155,16 +155,16 @@ walk_statement_conditional(struct Visit* visit, struct Statement* statement)
 }
 
 void
-walk_statement_loop(struct Visit* visit, struct Statement* statement)
+tree_walk_statement_loop(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
-    struct Statement_Value_Loop* loop = &statement->value.loop;
+    struct Tree_Statement_Value_Loop* loop = &statement->value.loop;
     VISIT_MAYBE(visit_expression, loop->condition);
     VISIT_MAYBE(visit_expression, loop->iteration);
     VISIT(visit_block_node, &loop->body);
 }
 
 void
-walk_statement_return(struct Visit* visit, struct Statement* statement)
+tree_walk_statement_return(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
     VISIT_MAYBE(visit_expression, statement->value.return_value.value);
 }
@@ -172,358 +172,358 @@ walk_statement_return(struct Visit* visit, struct Statement* statement)
 // although.. maybe with `break` we could make a loop become an expression,
 // this returning the break value as the value of the loop?
 // something to think about.
-WALK_LEAF_FUNCTION(walk_statement_break, struct Statement*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_statement_break, struct Tree_Statement*);
 
-WALK_LEAF_FUNCTION(walk_statement_continue, struct Statement*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_statement_continue, struct Tree_Statement*);
 
 void
-walk_statement_defer(struct Visit* visit, struct Statement* statement)
+tree_walk_statement_defer(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
     VISIT_MAYBE(visit_expression, statement->value.defer.expression);
     VISIT(visit_block_node, &statement->value.defer.block);
 }
 
 void
-walk_expression(struct Visit* visit, struct Expression* expression)
+tree_walk_expression(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     switch (expression->kind) {
-    case EXPRESSION_INTEGER_LITERAL:
+    case TREE_EXPRESSION_INTEGER_LITERAL:
         VISIT(visit_expression_integer_literal, expression);
         break;
-    case EXPRESSION_FLOAT_LITERAL:
+    case TREE_EXPRESSION_FLOAT_LITERAL:
         VISIT(visit_expression_float_literal, expression);
         break;
-    case EXPRESSION_STRING_LITERAL:
+    case TREE_EXPRESSION_STRING_LITERAL:
         VISIT(visit_expression_string_literal, expression);
         break;
-    case EXPRESSION_BOOLEAN_LITERAL:
+    case TREE_EXPRESSION_BOOLEAN_LITERAL:
         VISIT(visit_expression_boolean_literal, expression);
         break;
-    case EXPRESSION_NAME:
+    case TREE_EXPRESSION_NAME:
         VISIT(visit_expression_name, expression);
         break;
-    case EXPRESSION_UNARY_OPERATION:
+    case TREE_EXPRESSION_UNARY_OPERATION:
         VISIT(visit_expression_unary_operation, expression);
         break;
-    case EXPRESSION_BINARY_OPERATION:
+    case TREE_EXPRESSION_BINARY_OPERATION:
         VISIT(visit_expression_binary_operation, expression);
         break;
-    case EXPRESSION_GROUP:
+    case TREE_EXPRESSION_GROUP:
         VISIT(visit_expression_group, expression);
         break;
-    case EXPRESSION_CALL:
+    case TREE_EXPRESSION_CALL:
         VISIT(visit_expression_call, expression);
         break;
-    case EXPRESSION_CONSTRUCT:
+    case TREE_EXPRESSION_CONSTRUCT:
         VISIT(visit_expression_construct, expression);
         break;
-    case EXPRESSION_SUBSCRIPT:
+    case TREE_EXPRESSION_SUBSCRIPT:
         VISIT(visit_expression_subscript, expression);
         break;
-    case EXPRESSION_MEMBER:
+    case TREE_EXPRESSION_MEMBER:
         VISIT(visit_expression_member, expression);
         break;
-    case EXPRESSION_INCREMENT_DECREMENT:
+    case TREE_EXPRESSION_INCREMENT_DECREMENT:
         VISIT(visit_expression_increment_decrement, expression);
         break;
-    case EXPRESSION_TRY:
+    case TREE_EXPRESSION_TRY:
         VISIT(visit_expression_try, expression);
         break;
-    case EXPRESSION_MUST:
+    case TREE_EXPRESSION_MUST:
         VISIT(visit_expression_must, expression);
         break;
-    case EXPRESSION_FUNCTION:
+    case TREE_EXPRESSION_FUNCTION:
         VISIT(visit_expression_function, expression);
         break;
-    case EXPRESSION_TYPE:
+    case TREE_EXPRESSION_TYPE:
         VISIT(visit_type_node, expression->value.type.type);
         break;
     default:
-        failure("unexpected expression kind in `walk_expression`");
+        failure("unexpected expression kind in `tree_walk_expression`");
     }
 }
 
-WALK_LEAF_FUNCTION(walk_expression_integer_literal, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_integer_literal, struct Tree_Expression*);
 
-WALK_LEAF_FUNCTION(walk_expression_float_literal, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_float_literal, struct Tree_Expression*);
 
-WALK_LEAF_FUNCTION(walk_expression_string_literal, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_string_literal, struct Tree_Expression*);
 
-WALK_LEAF_FUNCTION(walk_expression_boolean_literal, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_boolean_literal, struct Tree_Expression*);
 
-WALK_LEAF_FUNCTION(walk_expression_name, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_name, struct Tree_Expression*);
 
 void
-walk_expression_unary_operation(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_unary_operation(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.unary_operator.operand);
 }
 
 void
-walk_expression_binary_operation(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_binary_operation(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.binary_operator.left_operand);
     VISIT(visit_expression, expression->value.binary_operator.right_operand);
 }
 
 void
-walk_expression_group(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_group(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.group.inner_expression);
 }
 
 void
-walk_expression_call(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_call(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
-    struct Expression_Call* call = &expression->value.call;
+    struct Tree_Expression_Call* call = &expression->value.call;
     VISIT(visit_expression, call->subject);
     VISIT(visit_argument_group_node, &call->argument_group);
 }
 
 void
-walk_expression_construct(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_construct(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
-    struct Expression_Construct* construct = &expression->value.construct;
+    struct Tree_Expression_Construct* construct = &expression->value.construct;
     VISIT(visit_expression, construct->subject);
     VISIT(visit_argument_group_node, &construct->argument_group);
 }
 
 void
-walk_expression_subscript(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_subscript(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.subscript.subject);
     VISIT(visit_expression, expression->value.subscript.index);
 }
 
 void
-walk_expression_member(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_member(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.member.subject);
 }
 
 void
-walk_expression_increment_decrement(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_increment_decrement(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_expression, expression->value.increment_decrement.subject);
 }
 
-WALK_LEAF_FUNCTION(walk_expression_try, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_try, struct Tree_Expression*);
 
-WALK_LEAF_FUNCTION(walk_expression_must, struct Expression*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_expression_must, struct Tree_Expression*);
 
 void
-walk_expression_function(struct Visit* visit, struct Expression* expression)
+tree_walk_expression_function(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     VISIT(visit_function_header_node, &expression->value.function.header);
     VISIT(visit_block_node, &expression->value.function.body);
 }
 
 void
-walk_type_node(struct Visit* visit, struct Type_Node* node)
+tree_walk_type(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     switch (node->type) {
-    case TYPE_NODE_NONE:
+    case TREE_TYPE_NONE:
         break;
-    case TYPE_NODE_NAME:
+    case TREE_TYPE_NAME:
         VISIT(visit_type_node_name, node);
         break;
-    case TYPE_NODE_ARRAY:
+    case TREE_TYPE_ARRAY:
         VISIT(visit_type_node_array, node);
         break;
-    case TYPE_NODE_REFERENCE:
+    case TREE_TYPE_REFERENCE:
         VISIT(visit_type_node_reference, node);
         break;
-    case TYPE_NODE_MAYBE:
+    case TREE_TYPE_MAYBE:
         VISIT(visit_type_node_maybe, node);
         break;
-    case TYPE_NODE_TUPLE:
+    case TREE_TYPE_TUPLE:
         VISIT(visit_type_node_tuple, node);
         break;
-    case TYPE_NODE_MAP:
+    case TREE_TYPE_MAP:
         VISIT(visit_type_node_map, node);
         break;
-    case TYPE_NODE_FUNCTION:
+    case TREE_TYPE_FUNCTION:
         VISIT(visit_type_node_function, node);
         break;
-    case TYPE_NODE_STRUCTURE:
+    case TREE_TYPE_STRUCTURE:
         VISIT(visit_type_node_structure, node);
         break;
-    case TYPE_NODE_VARIANT:
+    case TREE_TYPE_VARIANT:
         VISIT(visit_type_node_variant, node);
         break;
-    case TYPE_NODE_CLASS:
+    case TREE_TYPE_CLASS:
         VISIT(visit_type_node_class, node);
         break;
     default:
-        failure("unexpected type node kind in `walk_type_node`");
+        failure("unexpected type node kind in `tree_walk_type`");
     }
 }
 
-WALK_LEAF_FUNCTION(walk_type_node_name, struct Type_Node*);
+TREE_WALK_LEAF_FUNCTION(tree_walk_type_name, struct Tree_Type*);
 
 void
-walk_type_node_array(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_array(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     VISIT(visit_type_node, node->value.array.element_type);
 }
 
 void
-walk_type_node_reference(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_reference(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     VISIT(visit_type_node, node->value.reference.referenced_type);
 }
 
 void
-walk_type_node_maybe(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_maybe(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     VISIT(visit_type_node, node->value.maybe.inner_type);
 }
 
 void
-walk_type_node_tuple(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_tuple(struct Tree_Visit* visit, struct Tree_Type* node)
 {
-    FOR_EACH (struct Type_Node*, current, node->value.tuple.head) {
+    FOR_EACH (struct Tree_Type*, current, node->value.tuple.head) {
         VISIT(visit_type_node, current);
     }
 }
 
 void
-walk_type_node_map(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_map(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     VISIT(visit_type_node, node->value.map.key_type);
     VISIT(visit_type_node, node->value.map.value_type);
 }
 
 void
-walk_type_node_function(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_function(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     VISIT(visit_function_header_node, &node->value.function.header);
 }
 
 void
-walk_type_node_structure(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_structure(struct Tree_Visit* visit, struct Tree_Type* node)
 {
-    FOR_EACH (struct Type_Node*, field, node->value.structure.fields) {
+    FOR_EACH (struct Tree_Type*, field, node->value.structure.fields) {
         VISIT(visit_type_node, field);
     }
 }
 
 void
-walk_type_node_variant(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_variant(struct Tree_Visit* visit, struct Tree_Type* node)
 {
-    FOR_EACH (struct Type_Node*, method, node->value.variant.variants) {
+    FOR_EACH (struct Tree_Type*, method, node->value.variant.variants) {
         VISIT(visit_type_node, method);
     }
 }
 
 void
-walk_type_node_class(struct Visit* visit, struct Type_Node* node)
+tree_walk_type_class(struct Tree_Visit* visit, struct Tree_Type* node)
 {
-    FOR_EACH (struct Type_Node*, method, node->value.class.methods) {
+    FOR_EACH (struct Tree_Type*, method, node->value.class.methods) {
         VISIT(visit_type_node, method);
     }
 }
 
 void
-walk_block_node(struct Visit* visit, struct Block_Node* node)
+tree_walk_block(struct Tree_Visit* visit, struct Tree_Block* node)
 {
-    FOR_EACH (struct Statement*, statement, node->statements) { VISIT(visit_statement, statement); }
+    FOR_EACH (struct Tree_Statement*, statement, node->statements) { VISIT(visit_statement, statement); }
 }
 
 void
-walk_bare_declaration_node(struct Visit* visit, struct Bare_Declaration_Node* node)
+tree_walk_bare_declaration(struct Tree_Visit* visit, struct Tree_Bare_Declaration* node)
 {
     VISIT_MAYBE(visit_type_node, node->type);
     VISIT(visit_expression, node->initializer);
 }
 
 void
-walk_function_header_node(struct Visit* visit, struct Function_Header_Node* header)
+tree_walk_function_header(struct Tree_Visit* visit, struct Tree_Function_Header* header)
 {
-    FOR_EACH (struct Type_Node*, param_type, header->parameters_type_and_name) {
+    FOR_EACH (struct Tree_Type*, param_type, header->parameters_type_and_name) {
         VISIT(visit_type_node, param_type);
     }
     VISIT_MAYBE(visit_type_node, header->return_type);
 }
 
 void
-walk_argument_group_node(struct Visit* visit, struct Argument_Group_Node* node)
+tree_walk_argument_group(struct Tree_Visit* visit, struct Tree_Argument_Group* node)
 {
-    FOR_EACH (struct Expression*, argument, node->arguments) { VISIT(visit_expression, argument); }
+    FOR_EACH (struct Tree_Expression*, argument, node->arguments) { VISIT(visit_expression, argument); }
 }
 
 void
-walk_pragma_node(struct Visit* visit, struct Pragma_Node* node)
+tree_walk_pragma(struct Tree_Visit* visit, struct Tree_Pragma* node)
 {
     // visit each pragma node in the linked list.
     VISIT_MAYBE(visit_pragma_node, node->next);
 }
 
-struct Visit_Table walk_functions = {
-    .visit_tree = walk_tree,
-
-    .visit_statement = walk_statement,
-    .visit_statement_declaration = walk_statement_declaration,
-    .visit_statement_conditional = walk_statement_conditional,
-    .visit_statement_loop = walk_statement_loop,
-    .visit_statement_return = walk_statement_return,
-    .visit_statement_break = walk_statement_break,
-    .visit_statement_continue = walk_statement_continue,
-    .visit_statement_defer = walk_statement_defer,
-
-    .visit_expression = walk_expression,
-    .visit_expression_integer_literal = walk_expression_integer_literal,
-    .visit_expression_float_literal = walk_expression_float_literal,
-    .visit_expression_string_literal = walk_expression_string_literal,
-    .visit_expression_boolean_literal = walk_expression_boolean_literal,
-    .visit_expression_name = walk_expression_name,
-    .visit_expression_unary_operation = walk_expression_unary_operation,
-    .visit_expression_binary_operation = walk_expression_binary_operation,
-    .visit_expression_group = walk_expression_group,
-    .visit_expression_call = walk_expression_call,
-    .visit_expression_construct = walk_expression_construct,
-    .visit_expression_subscript = walk_expression_subscript,
-    .visit_expression_member = walk_expression_member,
-    .visit_expression_increment_decrement = walk_expression_increment_decrement,
-    .visit_expression_function = walk_expression_function,
-
-    .visit_type_node = walk_type_node,
-    .visit_type_node_name = walk_type_node_name,
-    .visit_type_node_array = walk_type_node_array,
-    .visit_type_node_reference = walk_type_node_reference,
-    .visit_type_node_maybe = walk_type_node_maybe,
-    .visit_type_node_tuple = walk_type_node_tuple,
-    .visit_type_node_map = walk_type_node_map,
-    .visit_type_node_function = walk_type_node_function,
-    .visit_type_node_structure = walk_type_node_structure,
-    .visit_type_node_variant = walk_type_node_variant,
-    .visit_type_node_class = walk_type_node_class,
-
-    .visit_block_node = walk_block_node,
-    .visit_bare_declaration_node = walk_bare_declaration_node,
-    .visit_function_header_node = walk_function_header_node,
-    .visit_argument_group_node = walk_argument_group_node,
-    .visit_pragma_node = walk_pragma_node,
+struct Tree_Visit_Table tree_walk_functions = {
+    .visit_tree = tree_walk_tree,
+
+    .visit_statement = tree_walk_statement,
+    .visit_statement_declaration = tree_walk_statement_declaration,
+    .visit_statement_conditional = tree_walk_statement_conditional,
+    .visit_statement_loop = tree_walk_statement_loop,
+    .visit_statement_return = tree_walk_statement_return,
+    .visit_statement_break = tree_walk_statement_break,
+    .visit_statement_continue = tree_walk_statement_continue,
+    .visit_statement_defer = tree_walk_statement_defer,
+
+    .visit_expression = tree_walk_expression,
+    .visit_expression_integer_literal = tree_walk_expression_integer_literal,
+    .visit_expression_float_literal = tree_walk_expression_float_literal,
+    .visit_expression_string_literal = tree_walk_expression_string_literal,
+    .visit_expression_boolean_literal = tree_walk_expression_boolean_literal,
+    .visit_expression_name = tree_walk_expression_name,
+    .visit_expression_unary_operation = tree_walk_expression_unary_operation,
+    .visit_expression_binary_operation = tree_walk_expression_binary_operation,
+    .visit_expression_group = tree_walk_expression_group,
+    .visit_expression_call = tree_walk_expression_call,
+    .visit_expression_construct = tree_walk_expression_construct,
+    .visit_expression_subscript = tree_walk_expression_subscript,
+    .visit_expression_member = tree_walk_expression_member,
+    .visit_expression_increment_decrement = tree_walk_expression_increment_decrement,
+    .visit_expression_function = tree_walk_expression_function,
+
+    .visit_type_node = tree_walk_type,
+    .visit_type_node_name = tree_walk_type_name,
+    .visit_type_node_array = tree_walk_type_array,
+    .visit_type_node_reference = tree_walk_type_reference,
+    .visit_type_node_maybe = tree_walk_type_maybe,
+    .visit_type_node_tuple = tree_walk_type_tuple,
+    .visit_type_node_map = tree_walk_type_map,
+    .visit_type_node_function = tree_walk_type_function,
+    .visit_type_node_structure = tree_walk_type_structure,
+    .visit_type_node_variant = tree_walk_type_variant,
+    .visit_type_node_class = tree_walk_type_class,
+
+    .visit_block_node = tree_walk_block,
+    .visit_bare_declaration_node = tree_walk_bare_declaration,
+    .visit_function_header_node = tree_walk_function_header,
+    .visit_argument_group_node = tree_walk_argument_group,
+    .visit_pragma_node = tree_walk_pragma,
 };
 
-// fills in the visit table with default walk functions
+// fills in the visit table with default tree_walk functions
 void
-visit_table_fill_defaults(struct Visit_Table* table)
+tree_visit_table_fill_defaults(struct Tree_Visit_Table* table)
 {
     // not portable, nor safe, but sometimes you need to have a bit of fun! :3
 
     // assumptions:
-    // - sizeof(struct Visit_Table) is a multiple of the size of a function pointer,
+    // - sizeof(struct Tree_Visit_Table) is a multiple of the size of a function pointer,
     //   with no padding between function pointers.
     // - the size of a function pointer is the same across all platforms we care about.
-    // - casting struct Visit_Table to a function pointer array is undefined, but safe.
-    const uint function_count = sizeof(struct Visit_Table) / sizeof(void (*)());
+    // - casting struct Tree_Visit_Table to a function pointer array is undefined, but safe.
+    const uint function_count = sizeof(struct Tree_Visit_Table) / sizeof(void (*)());
     typedef void (*Function_Ptr)();
 
     for (uint fi = 0; fi < function_count; ++fi) {
         Function_Ptr* function_slot = &((Function_Ptr*)table)[fi];
-        Function_Ptr* walk = &((Function_Ptr*)&walk_functions)[fi];
-        if (!*function_slot) *function_slot = *walk;
+        Function_Ptr* tree_walk = &((Function_Ptr*)&tree_walk_functions)[fi];
+        if (!*function_slot) *function_slot = *tree_walk;
     }
 }
 
@@ -572,33 +572,33 @@ tree_printer_indent(struct Tree_Printer* printer)
 }
 
 void
-printer_visit_tree(struct Visit* visit, struct Tree* tree)
+tree_printer_visit_tree(struct Tree_Visit* visit, struct Tree* tree)
 {
     TREE_PRINTER_PREAMBLE
 
-    FOR_EACH (struct Statement*, statement, tree->top_level_statements) {
+    FOR_EACH (struct Tree_Statement*, statement, tree->top_level_statements) {
         VISIT(visit_statement, statement);
         PRINT("\n");
     }
 }
 
 void
-printer_visit_statement(struct Visit* visit, struct Statement* statement)
+tree_printer_visit_statement(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
     TREE_PRINTER_PREAMBLE
 
     tree_printer_indent(printer);
-    walk_statement(visit, statement);
+    tree_walk_statement(visit, statement);
 }
 
 void
-printer_visit_statement_declaration(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_declaration(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
-    if (stmt->value.declaration.kind == STATEMENT_DECLARATION_VARIABLE)
+    if (stmt->value.declaration.kind == TREE_STATEMENT_DECLARATION_VARIABLE)
         PRINT("(variable ");
-    else if (stmt->value.declaration.kind == STATEMENT_DECLARATION_CONSTANT)
+    else if (stmt->value.declaration.kind == TREE_STATEMENT_DECLARATION_CONSTANT)
         PRINT("(constant ");
 
     VISIT(visit_bare_declaration_node, &stmt->value.declaration.inner);
@@ -606,13 +606,13 @@ printer_visit_statement_declaration(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-printer_visit_statement_conditional(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_conditional(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
     PRINT("(conditional");
     for (uint i = 0; i < stmt->value.conditional.condition_count; ++i) {
-        const struct 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 ");
@@ -621,20 +621,20 @@ printer_visit_statement_conditional(struct Visit* visit, struct Statement* stmt)
         } else {
             PRINT("(always) ");
         }
-        VISIT(visit_block_node, (struct Block_Node*)&branch->then);
+        VISIT(visit_block_node, (struct Tree_Block*)&branch->then);
     }
     PRINT(")");
 }
 
 void
-printer_visit_statement_loop(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_loop(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
     PRINT("(loop ");
 
     switch (stmt->value.loop.style) {
-    case STATEMENT_LOOP_STYLE_C:
+    case TREE_STATEMENT_LOOP_STYLE_C:
         PRINT("c-style ");
         VISIT(visit_bare_declaration_node, &stmt->value.loop.declaration);
         PRINT(" (condition ");
@@ -643,21 +643,21 @@ printer_visit_statement_loop(struct Visit* visit, struct Statement* stmt)
         VISIT(visit_expression, stmt->value.loop.iteration);
         PRINT(") ");
         break;
-    case STATEMENT_LOOP_STYLE_FOR_EACH:
+    case TREE_STATEMENT_LOOP_STYLE_FOR_EACH:
         PRINT("for-each ");
         VISIT(visit_bare_declaration_node, &stmt->value.loop.declaration);
         PRINT(" ");
         break;
-    case STATEMENT_LOOP_STYLE_WHILE:
+    case TREE_STATEMENT_LOOP_STYLE_WHILE:
         PRINT("while (condition ");
         VISIT(visit_expression, stmt->value.loop.condition);
         PRINT(") ");
         break;
-    case STATEMENT_LOOP_STYLE_ENDLESS:
+    case TREE_STATEMENT_LOOP_STYLE_ENDLESS:
         PRINT("endless ");
         break;
     default:
-        fprintf(stderr, "unexpected loop style in `printer_visit_statement_loop`");
+        fprintf(stderr, "unexpected loop style in `tree_printer_visit_statement_loop`");
         break;
     }
 
@@ -666,7 +666,7 @@ printer_visit_statement_loop(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-printer_visit_statement_return(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_return(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -679,7 +679,7 @@ printer_visit_statement_return(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-printer_visit_statement_break(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_break(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -687,7 +687,7 @@ printer_visit_statement_break(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-printer_visit_statement_continue(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_continue(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -695,7 +695,7 @@ printer_visit_statement_continue(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-printer_visit_statement_defer(struct Visit* visit, struct Statement* stmt)
+tree_printer_visit_statement_defer(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -709,16 +709,16 @@ printer_visit_statement_defer(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-printer_visit_expression(struct Visit* visit, struct Expression* expression)
+tree_printer_visit_expression(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     TREE_PRINTER_PREAMBLE
     PRINT("(expr ");
-    walk_expression(visit, expression);
+    tree_walk_expression(visit, expression);
     PRINT(")");
 }
 
 void
-printer_visit_expression_integer_literal(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_integer_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -726,7 +726,7 @@ printer_visit_expression_integer_literal(struct Visit* visit, struct Expression*
 }
 
 void
-printer_visit_expression_float_literal(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_float_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -734,7 +734,7 @@ printer_visit_expression_float_literal(struct Visit* visit, struct Expression* e
 }
 
 void
-printer_visit_expression_string_literal(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_string_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -742,7 +742,7 @@ printer_visit_expression_string_literal(struct Visit* visit, struct Expression*
 }
 
 void
-printer_visit_expression_boolean_literal(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_boolean_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -750,7 +750,7 @@ printer_visit_expression_boolean_literal(struct Visit* visit, struct Expression*
 }
 
 void
-printer_visit_expression_name(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_name(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -758,7 +758,7 @@ printer_visit_expression_name(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_unary_operation(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_unary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -768,7 +768,7 @@ printer_visit_expression_unary_operation(struct Visit* visit, struct Expression*
 }
 
 void
-printer_visit_expression_binary_operation(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_binary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -780,7 +780,7 @@ printer_visit_expression_binary_operation(struct Visit* visit, struct Expression
 }
 
 void
-printer_visit_expression_group(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_group(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -790,11 +790,11 @@ printer_visit_expression_group(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_call(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_call(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
-    struct Expression_Call* call = &expr->value.call;
+    struct Tree_Expression_Call* call = &expr->value.call;
     PRINT("(call ");
     VISIT(visit_expression, call->subject);
     VISIT(visit_argument_group_node, &call->argument_group);
@@ -803,11 +803,11 @@ printer_visit_expression_call(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_construct(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_construct(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
-    struct Expression_Construct* construct = &expr->value.construct;
+    struct Tree_Expression_Construct* construct = &expr->value.construct;
     PRINT("(construct ");
     VISIT(visit_expression, construct->subject);
     VISIT(visit_argument_group_node, &construct->argument_group);
@@ -816,7 +816,7 @@ printer_visit_expression_construct(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_subscript(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_subscript(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -828,7 +828,7 @@ printer_visit_expression_subscript(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_member(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_member(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -838,11 +838,11 @@ printer_visit_expression_member(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_increment_decrement(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_increment_decrement(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
-    const struct Expression_Increment_Decrement* inc_dec = &expr->value.increment_decrement;
+    const struct Tree_Expression_Increment_Decrement* inc_dec = &expr->value.increment_decrement;
     const ascii* prefix_or_postfix = inc_dec->prefix ? "prefix" : "postfix";
     PRINT("(increment/decrement %s %s ",
           increment_decrement_operation_to_string(inc_dec->operation), prefix_or_postfix);
@@ -851,7 +851,7 @@ printer_visit_expression_increment_decrement(struct Visit* visit, struct Express
 }
 
 void
-printer_visit_expression_try(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_try(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -861,7 +861,7 @@ printer_visit_expression_try(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_must(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_must(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -871,30 +871,30 @@ printer_visit_expression_must(struct Visit* visit, struct Expression* expr)
 }
 
 void
-printer_visit_expression_function(struct Visit* visit, struct Expression* expr)
+tree_printer_visit_expression_function(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TREE_PRINTER_PREAMBLE
 
-    struct Expression_Function* fun = &expr->value.function;
+    struct Tree_Expression_Function* fun = &expr->value.function;
     PRINT("(function ");
     VISIT(visit_function_header_node, &fun->header);
     PRINT_WHITESPACE_IF_NEEDED(" ");
-    VISIT(visit_block_node, (struct Block_Node*)&fun->body);
+    VISIT(visit_block_node, (struct Tree_Block*)&fun->body);
     PRINT(")");
 }
 
 void
-printer_visit_type_node(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
     PRINT("(type ");
     if (node->variadic) PRINT("variadic ");
-    walk_type_node(visit, node);
+    tree_walk_type(visit, node);
     PRINT(")");
 }
 
 void
-printer_visit_type_node_name(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_name(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -902,7 +902,7 @@ printer_visit_type_node_name(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_array(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_array(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -911,7 +911,7 @@ printer_visit_type_node_array(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_reference(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_reference(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -920,7 +920,7 @@ printer_visit_type_node_reference(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_maybe(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_maybe(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -929,19 +929,19 @@ printer_visit_type_node_maybe(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_tuple(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_tuple(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
     PRINT("tuple");
-    FOR_EACH (struct Type_Node*, current, node->value.tuple.head) {
+    FOR_EACH (struct Tree_Type*, current, node->value.tuple.head) {
         PRINT(" ");
         VISIT(visit_type_node, current);
     }
 }
 
 void
-printer_visit_type_node_map(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_map(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -952,7 +952,7 @@ printer_visit_type_node_map(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_function(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_function(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -961,25 +961,25 @@ printer_visit_type_node_function(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_structure(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_structure(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
     PRINT("structure");
-    FOR_EACH (struct Type_Node*, current, node->value.structure.fields) {
+    FOR_EACH (struct Tree_Type*, current, node->value.structure.fields) {
         PRINT(" (field %s) ", current->value_name.data);
         VISIT(visit_type_node, current);
     }
 }
 
 void
-printer_visit_type_node_variant(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_variant(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
     PRINT("variant");
-    FOR_EACH (struct Type_Node*, current, node->value.variant.variants) {
-        if (current->type == TYPE_NODE_NONE) {
+    FOR_EACH (struct Tree_Type*, current, node->value.variant.variants) {
+        if (current->type == TREE_TYPE_NONE) {
             PRINT(" (variant %s)", current->value_name.data);
         } else {
             PRINT(" (variant %s of ", current->value_name.data);
@@ -990,12 +990,12 @@ printer_visit_type_node_variant(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_type_node_class(struct Visit* visit, struct Type_Node* node)
+tree_printer_visit_type_class(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TREE_PRINTER_PREAMBLE
 
     PRINT("class");
-    FOR_EACH (struct Type_Node*, current, node->value.class.methods) {
+    FOR_EACH (struct Tree_Type*, current, node->value.class.methods) {
         PRINT(" (method %s ", current->value_name.data);
         VISIT(visit_function_header_node, &current->value.function.header);
         PRINT(")");
@@ -1003,7 +1003,7 @@ printer_visit_type_node_class(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-printer_visit_block_node(struct Visit* visit, struct Block_Node* node)
+tree_printer_visit_block(struct Tree_Visit* visit, struct Tree_Block* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -1011,7 +1011,7 @@ printer_visit_block_node(struct Visit* visit, struct Block_Node* node)
     if (node->statements) {
         PRINT("\n");
         printer->indentation_level++;
-        FOR_EACH (struct Statement*, statement, node->statements) {
+        FOR_EACH (struct Tree_Statement*, statement, node->statements) {
             VISIT(visit_statement, statement);
             PRINT("\n");
         }
@@ -1022,7 +1022,7 @@ printer_visit_block_node(struct Visit* visit, struct Block_Node* node)
 }
 
 void
-printer_visit_bare_declaration_node(struct Visit* visit, struct Bare_Declaration_Node* node)
+tree_printer_visit_bare_declaration(struct Tree_Visit* visit, struct Tree_Bare_Declaration* node)
 {
     TREE_PRINTER_PREAMBLE
 
@@ -1031,7 +1031,7 @@ printer_visit_bare_declaration_node(struct Visit* visit, struct Bare_Declaration
         PRINT("%s ", name.data);
     })
 
-    if (node->type && node->type->type != TYPE_NODE_NONE) {
+    if (node->type && node->type->type != TREE_TYPE_NONE) {
         VISIT(visit_type_node, node->type);
         PRINT(" ");
     }
@@ -1045,11 +1045,11 @@ printer_visit_bare_declaration_node(struct Visit* visit, struct Bare_Declaration
 }
 
 void
-printer_visit_function_header(struct Visit* visit, struct Function_Header_Node* header)
+printer_visit_function_header(struct Tree_Visit* visit, struct Tree_Function_Header* header)
 {
     TREE_PRINTER_PREAMBLE
 
-    FOR_EACH (struct Type_Node*, current, header->parameters_type_and_name) {
+    FOR_EACH (struct Tree_Type*, current, header->parameters_type_and_name) {
         // if (current != header->parameters_type_and_name) PRINT(" ");
         PRINT_WHITESPACE_IF_NEEDED(" ");
 
@@ -1071,27 +1071,27 @@ printer_visit_function_header(struct Visit* visit, struct Function_Header_Node*
 }
 
 void
-printer_visit_pragma_node(struct Visit* visit, struct Pragma_Node* node)
+tree_printer_visit_pragma(struct Tree_Visit* visit, struct Tree_Pragma* node)
 {
     TREE_PRINTER_PREAMBLE
 
-    const ascii* pragma_name = pragma_type_to_string(node->type);
+    const ascii* pragma_name = tree_pragma_type_to_string(node->type);
 
     PRINT("(pragma %s", pragma_name);
     for (uint ai = 0; ai < node->argument_count; ++ai) {
-        struct Pragma_Argument* arg = &node->arguments[ai];
+        struct Tree_Pragma_Argument* arg = &node->arguments[ai];
         switch (arg->type) {
-        case PRAGMA_ARGUMENT_NUMBER:
+        case TREE_PRAGMA_ARGUMENT_NUMBER:
             PRINT(" (number %ld)", arg->value.number);
             break;
-        case PRAGMA_ARGUMENT_DECIMAL:
+        case TREE_PRAGMA_ARGUMENT_DECIMAL:
             PRINT(" (decimal %lf)", arg->value.decimal);
             break;
-        case PRAGMA_ARGUMENT_NAME_OR_STRING:
+        case TREE_PRAGMA_ARGUMENT_NAME_OR_STRING:
             PRINT(" (name/string '%s')", arg->value.name_or_string.data);
             break;
         default:
-            failure("unexpected pragma argument type in `printer_visit_pragma_node`");
+            failure("unexpected pragma argument type in `tree_printer_visit_pragma`");
         }
     }
     PRINT(")");
@@ -1103,12 +1103,12 @@ printer_visit_pragma_node(struct Visit* visit, struct Pragma_Node* node)
 }
 
 void
-printer_visit_argument_group_node(struct Visit* visit, struct Argument_Group_Node* node)
+tree_printer_visit_argument_group(struct Tree_Visit* visit, struct Tree_Argument_Group* node)
 {
     TREE_PRINTER_PREAMBLE
 
     uint i = 0;
-    FOR_EACH (struct Expression*, argument, node->arguments) {
+    FOR_EACH (struct Tree_Expression*, argument, node->arguments) {
         struct String name = *array_at(struct String, &node->argument_names, i++);
         if (name.data && name.data[0] != '\0') {
             PRINT(" (named arg '%s' ", name.data);
@@ -1120,53 +1120,53 @@ printer_visit_argument_group_node(struct Visit* visit, struct Argument_Group_Nod
     }
 }
 
-struct Visit_Table printer_visit_functions = {
-    .visit_tree = printer_visit_tree,
-
-    .visit_statement = printer_visit_statement,
-    .visit_statement_declaration = printer_visit_statement_declaration,
-    .visit_statement_conditional = printer_visit_statement_conditional,
-    .visit_statement_loop = printer_visit_statement_loop,
-    .visit_statement_return = printer_visit_statement_return,
-    .visit_statement_break = printer_visit_statement_break,
-    .visit_statement_continue = printer_visit_statement_continue,
-    .visit_statement_defer = printer_visit_statement_defer,
-
-    .visit_expression = printer_visit_expression,
-    .visit_expression_integer_literal = printer_visit_expression_integer_literal,
-    .visit_expression_float_literal = printer_visit_expression_float_literal,
-    .visit_expression_string_literal = printer_visit_expression_string_literal,
-    .visit_expression_boolean_literal = printer_visit_expression_boolean_literal,
-    .visit_expression_name = printer_visit_expression_name,
-    .visit_expression_unary_operation = printer_visit_expression_unary_operation,
-    .visit_expression_binary_operation = printer_visit_expression_binary_operation,
-    .visit_expression_group = printer_visit_expression_group,
-    .visit_expression_call = printer_visit_expression_call,
-    .visit_expression_construct = printer_visit_expression_construct,
-    .visit_expression_subscript = printer_visit_expression_subscript,
-    .visit_expression_member = printer_visit_expression_member,
-    .visit_expression_increment_decrement = printer_visit_expression_increment_decrement,
-    .visit_expression_try = printer_visit_expression_try,
-    .visit_expression_must = printer_visit_expression_must,
-    .visit_expression_function = printer_visit_expression_function,
-
-    .visit_type_node = printer_visit_type_node,
-    .visit_type_node_name = printer_visit_type_node_name,
-    .visit_type_node_array = printer_visit_type_node_array,
-    .visit_type_node_reference = printer_visit_type_node_reference,
-    .visit_type_node_maybe = printer_visit_type_node_maybe,
-    .visit_type_node_tuple = printer_visit_type_node_tuple,
-    .visit_type_node_map = printer_visit_type_node_map,
-    .visit_type_node_function = printer_visit_type_node_function,
-    .visit_type_node_structure = printer_visit_type_node_structure,
-    .visit_type_node_variant = printer_visit_type_node_variant,
-    .visit_type_node_class = printer_visit_type_node_class,
-
-    .visit_block_node = printer_visit_block_node,
-    .visit_bare_declaration_node = printer_visit_bare_declaration_node,
+struct Tree_Visit_Table tree_printer_visit_functions = {
+    .visit_tree = tree_printer_visit_tree,
+
+    .visit_statement = tree_printer_visit_statement,
+    .visit_statement_declaration = tree_printer_visit_statement_declaration,
+    .visit_statement_conditional = tree_printer_visit_statement_conditional,
+    .visit_statement_loop = tree_printer_visit_statement_loop,
+    .visit_statement_return = tree_printer_visit_statement_return,
+    .visit_statement_break = tree_printer_visit_statement_break,
+    .visit_statement_continue = tree_printer_visit_statement_continue,
+    .visit_statement_defer = tree_printer_visit_statement_defer,
+
+    .visit_expression = tree_printer_visit_expression,
+    .visit_expression_integer_literal = tree_printer_visit_expression_integer_literal,
+    .visit_expression_float_literal = tree_printer_visit_expression_float_literal,
+    .visit_expression_string_literal = tree_printer_visit_expression_string_literal,
+    .visit_expression_boolean_literal = tree_printer_visit_expression_boolean_literal,
+    .visit_expression_name = tree_printer_visit_expression_name,
+    .visit_expression_unary_operation = tree_printer_visit_expression_unary_operation,
+    .visit_expression_binary_operation = tree_printer_visit_expression_binary_operation,
+    .visit_expression_group = tree_printer_visit_expression_group,
+    .visit_expression_call = tree_printer_visit_expression_call,
+    .visit_expression_construct = tree_printer_visit_expression_construct,
+    .visit_expression_subscript = tree_printer_visit_expression_subscript,
+    .visit_expression_member = tree_printer_visit_expression_member,
+    .visit_expression_increment_decrement = tree_printer_visit_expression_increment_decrement,
+    .visit_expression_try = tree_printer_visit_expression_try,
+    .visit_expression_must = tree_printer_visit_expression_must,
+    .visit_expression_function = tree_printer_visit_expression_function,
+
+    .visit_type_node = tree_printer_visit_type,
+    .visit_type_node_name = tree_printer_visit_type_name,
+    .visit_type_node_array = tree_printer_visit_type_array,
+    .visit_type_node_reference = tree_printer_visit_type_reference,
+    .visit_type_node_maybe = tree_printer_visit_type_maybe,
+    .visit_type_node_tuple = tree_printer_visit_type_tuple,
+    .visit_type_node_map = tree_printer_visit_type_map,
+    .visit_type_node_function = tree_printer_visit_type_function,
+    .visit_type_node_structure = tree_printer_visit_type_structure,
+    .visit_type_node_variant = tree_printer_visit_type_variant,
+    .visit_type_node_class = tree_printer_visit_type_class,
+
+    .visit_block_node = tree_printer_visit_block,
+    .visit_bare_declaration_node = tree_printer_visit_bare_declaration,
     .visit_function_header_node = printer_visit_function_header,
-    .visit_argument_group_node = printer_visit_argument_group_node,
-    .visit_pragma_node = printer_visit_pragma_node,
+    .visit_argument_group_node = tree_printer_visit_argument_group,
+    .visit_pragma_node = tree_printer_visit_pragma,
 };
 
 void
@@ -1175,9 +1175,9 @@ tree_printer(struct Tree* tree)
     struct Tree_Printer printer = {
         .indentation_level = 0, .output = stdout, .did_print_last_visit = false
     };
-    struct Visit visit = { .table = &printer_visit_functions, .user_data = &printer };
+    struct Tree_Visit visit = { .table = &tree_printer_visit_functions, .user_data = &printer };
 
-    walk(&visit, tree);
+    tree_walk(&visit, tree);
 }
 
 #undef PRINT