Remove older non-visit tree printing code

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

2 files changed, 0 insertions, 360 deletions

diff --git a/boot/catboot.c b/boot/catboot.c
index fac6273..a62dc47 100644
--- a/boot/catboot.c
+++ b/boot/catboot.c
@@ -81,8 +81,6 @@ main(const int32 argc, const ascii* argv[])
         return EXIT_FAILURE;
     }
 
-    tree_print(&tree);
-    printf("\n");
     tree_printer(&tree);
 
     return EXIT_SUCCESS;
diff --git a/boot/tree.c b/boot/tree.c
index 1eb19a8..ea8ed69 100644
--- a/boot/tree.c
+++ b/boot/tree.c
@@ -400,8 +400,6 @@ struct Block_Node
     struct Cursor location;
 };
 
-void block_node_print(const struct Block_Node* block);
-
 // a function header, describing the parameters and return type of function.
 // used both as a type and in full function definitions.
 struct Function_Header_Node
@@ -414,8 +412,6 @@ struct Function_Header_Node
     struct Span span;
 };
 
-void function_header_node_print(const struct Function_Header_Node* header);
-
 // a declaration of a variable, constant, or other binding, without a mutability
 // signifier, like `let` or `var`.
 // the mutability is determined by some outside context, where
@@ -430,8 +426,6 @@ struct Bare_Declaration_Node
     struct Cursor location;
 };
 
-void bare_declaration_node_print(const struct Bare_Declaration_Node* declaration);
-
 enum Type_Node_Type
 {
     TYPE_NODE_NONE,
@@ -578,83 +572,6 @@ type_node_is_none(const struct Type_Node* type_node)
     return type_node->type == TYPE_NODE_NONE;
 }
 
-void
-type_node_print(const struct Type_Node* type_node)
-{
-    printf("(type ");
-    switch (type_node->type) {
-    case TYPE_NODE_NONE:
-        printf("none");
-        break;
-    case TYPE_NODE_NAME:
-        printf("name %s", type_node->value.name.name.data);
-        break;
-    case TYPE_NODE_ARRAY:
-        printf("array of ");
-        type_node_print(type_node->value.array.element_type);
-        break;
-    case TYPE_NODE_REFERENCE:
-        printf("reference to ");
-        type_node_print(type_node->value.reference.referenced_type);
-        break;
-    case TYPE_NODE_MAYBE:
-        printf("maybe ");
-        type_node_print(type_node->value.maybe.inner_type);
-        break;
-    case TYPE_NODE_TUPLE: {
-        printf("tuple");
-        FOR_EACH (struct Type_Node*, current, type_node->value.tuple.head) {
-            printf(" ");
-            type_node_print(current);
-        }
-        break;
-    }
-    case TYPE_NODE_MAP:
-        printf("map ");
-        type_node_print(type_node->value.map.key_type);
-        printf(" = ");
-        type_node_print(type_node->value.map.value_type);
-        break;
-    case TYPE_NODE_FUNCTION: {
-        printf("function ");
-        function_header_node_print(&type_node->value.function.header);
-        break;
-    }
-    case TYPE_NODE_STRUCTURE: {
-        printf("structure");
-        FOR_EACH (struct Type_Node*, current, type_node->value.structure.fields) {
-            printf(" (field %s) ", current->value_name.data);
-            type_node_print(current);
-        }
-        break;
-    }
-    case TYPE_NODE_VARIANT: {
-        printf("variant");
-        FOR_EACH (struct Type_Node*, current, type_node->value.variant.variants) {
-            if (type_node_is_none(current)) {
-                printf(" (variant %s)", current->value_name.data);
-            } else {
-                printf(" (variant %s of ", current->value_name.data);
-                type_node_print(current);
-                printf(")");
-            }
-        }
-        break;
-    }
-    case TYPE_NODE_CLASS:
-        printf("class");
-        FOR_EACH (struct Type_Node*, current, type_node->value.class.methods) {
-            check(current->type == TYPE_NODE_FUNCTION,
-                  "expected class method type node to be a function type");
-            printf(" (method %s ", current->value_name.data);
-            function_header_node_print(&current->value.function.header);
-            printf(")");
-        }
-        break;
-    }
-    printf(")");
-}
-
 enum Expression_Kind
 {
     EXPRESSION_NONE,
@@ -812,127 +729,6 @@ expression_new(
     return expression;
 }
 
-void
-function_header_node_print(const struct Function_Header_Node* header)
-{
-    FOR_EACH (struct Type_Node*, current, header->parameters_type_and_name) {
-        if (current != header->parameters_type_and_name) printf(" ");
-
-        if (!string_is_empty(current->value_name))
-            printf("(param %s) ", current->value_name.data);
-        else
-            printf("(param) ");
-
-        type_node_print(current);
-    }
-
-    if (header->return_type) {
-        printf(" (returns ");
-        type_node_print(header->return_type);
-        printf(")");
-    }
-}
-
-void
-expression_print(const struct Expression* expression)
-{
-    printf("(expr ");
-    switch (expression->kind) {
-    case EXPRESSION_NONE:
-        printf("none");
-        break;
-    case EXPRESSION_INTEGER_LITERAL:
-        printf("%ld", expression->value.integer_literal.value);
-        break;
-    case EXPRESSION_FLOAT_LITERAL:
-        printf("%lf", expression->value.float_literal.value);
-        break;
-    case EXPRESSION_STRING_LITERAL:
-        printf("\"%s\"", expression->value.string_literal.value.data);
-        break;
-    case EXPRESSION_BOOLEAN_LITERAL:
-        printf("%s", expression->value.bool_literal.value ? "true" : "false");
-        break;
-    case EXPRESSION_NAME:
-        printf("(name %s)", expression->value.name.name.data);
-        break;
-    case EXPRESSION_UNARY_OPERATION:
-        printf("(unary %s ", unary_operation_to_string(expression->value.unary_operator.operation));
-        expression_print(expression->value.unary_operator.operand);
-        printf(")");
-        break;
-    case EXPRESSION_BINARY_OPERATION:
-        printf(
-            "(binary %s ", binary_operation_to_string(expression->value.binary_operator.operation));
-        expression_print(expression->value.binary_operator.left_operand);
-        printf(" ");
-        expression_print(expression->value.binary_operator.right_operand);
-        printf(")");
-        break;
-    case EXPRESSION_GROUP:
-        printf("(group ");
-        expression_print(expression->value.group.inner_expression);
-        printf(")");
-        break;
-    case EXPRESSION_CALL_OR_CONSTRUCT: {
-        const struct Expression_Call_Or_Construct* coc = &expression->value.call_or_construct;
-        printf("(call/construct ");
-        expression_print(coc->subject);
-        uint i = 0;
-        FOR_EACH (struct Expression*, argument, coc->arguments) {
-            struct String name = string_array_at(&coc->argument_names, i++);
-            if (!string_is_empty(name)) {
-                printf(" (named arg '%s' ", name.data);
-            } else {
-                printf(" (arg ");
-            }
-            expression_print(argument);
-            printf(")");
-        }
-        printf(")");
-        break;
-    }
-    case EXPRESSION_SUBSCRIPT:
-        printf("(subscript ");
-        expression_print(expression->value.subscript.subject);
-        printf(" ");
-        expression_print(expression->value.subscript.index);
-        printf(")");
-        break;
-    case EXPRESSION_MEMBER:
-        printf("(member of ");
-        expression_print(expression->value.member.subject);
-        printf(" named %s", expression->value.member.name.data);
-        printf(")");
-        break;
-    case EXPRESSION_INCREMENT_DECREMENT: {
-        const struct Expression_Increment_Decrement* inc_dec =
-            &expression->value.increment_decrement;
-        const ascii* prefix_or_postfix = inc_dec->prefix ? "prefix" : "postfix";
-        printf("(increment/decrement %s %s ",
-               increment_decrement_operation_to_string(inc_dec->operation), prefix_or_postfix);
-        expression_print(inc_dec->subject);
-        break;
-    }
-    case EXPRESSION_FUNCTION: {
-        const struct Expression_Function* fun = &expression->value.function;
-        printf("(function ");
-        function_header_node_print(&fun->header);
-        printf(" ");
-        block_node_print(&fun->body);
-        printf(")");
-        break;
-    }
-    case EXPRESSION_TYPE:
-        type_node_print(expression->value.type.type);
-        break;
-    default:
-        failure("unexpected expression kind passed to `expression_print`");
-        break;
-    }
-    printf(")");
-}
-
 enum Statement_Kind
 {
     STATEMENT_NONE,
@@ -1058,38 +854,6 @@ struct Statement
 
 REGION(struct Statement, statement)
 
-void statement_print(const struct Statement* statement);
-
-void
-block_node_print(const struct Block_Node* block)
-{
-    printf("(block \n");
-    FOR_EACH (struct Statement*, statement, block->statements) {
-        printf("\t");
-        statement_print(statement);
-        printf("\n");
-    }
-    printf(")");
-}
-
-void
-bare_declaration_node_print(const struct Bare_Declaration_Node* declaration)
-{
-    printf("(declaration ");
-    STRING_ARRAY_FOR_EACH (i, name, declaration->names) { printf("%s ", name.data); }
-    if (!type_node_is_none(declaration->type)) {
-        type_node_print(declaration->type);
-        printf(" ");
-    }
-
-    if (declaration->initializer) {
-        printf("(initializer ");
-        expression_print(declaration->initializer);
-        printf(")");
-    }
-    printf(")");
-}
-
 struct Statement*
 statement_new(
     enum Statement_Kind kind, union Statement_Value value, struct Span span, struct Cursor location)
@@ -1106,130 +870,8 @@ statement_new(
     return statement;
 }
 
-void
-statement_print(const struct Statement* statement)
-{
-    printf("(stmt ");
-    switch (statement->kind) {
-    case STATEMENT_NONE:
-        printf("none");
-        break;
-    case STATEMENT_EXPRESSION: {
-        const struct Expression* expression = statement->value.expression.inner;
-        expression_print(expression);
-        break;
-    }
-    case STATEMENT_DECLARATION: {
-        if (statement->value.declaration.kind == STATEMENT_DECLARATION_VARIABLE)
-            printf("(variable ");
-        else if (statement->value.declaration.kind == STATEMENT_DECLARATION_CONSTANT)
-            printf("(constant ");
-
-        bare_declaration_node_print(&statement->value.declaration.inner);
-        printf(")");
-        break;
-    }
-    case STATEMENT_BLOCK:
-        block_node_print(&statement->value.block.inner);
-        break;
-    case STATEMENT_CONDITIONAL: {
-        printf("(conditional");
-        for (uint i = 0; i < statement->value.conditional.condition_count; ++i) {
-            const struct Statement_Conditional_Branch* branch =
-                &statement->value.conditional.conditions[i];
-
-            printf(" ");
-            if (branch->when) {
-                printf("(when ");
-                expression_print(branch->when);
-                printf(") ");
-            } else {
-                printf("(always) ");
-            }
-
-            block_node_print(&branch->then);
-        }
-        printf(")");
-        break;
-    }
-    case STATEMENT_LOOP: {
-        printf("(loop ");
-
-        switch (statement->value.loop.style) {
-        case STATEMENT_LOOP_STYLE_C:
-            printf("c-style ");
-            bare_declaration_node_print(&statement->value.loop.declaration);
-            printf(" (condition ");
-            expression_print(statement->value.loop.condition);
-            printf(") (iteration ");
-            expression_print(statement->value.loop.iteration);
-            printf(") ");
-            break;
-        case STATEMENT_LOOP_STYLE_FOR_EACH:
-            printf("for-each ");
-            bare_declaration_node_print(&statement->value.loop.declaration);
-            printf(" ");
-            break;
-        case STATEMENT_LOOP_STYLE_WHILE:
-            printf("while (condition ");
-            expression_print(statement->value.loop.condition);
-            printf(") ");
-            break;
-        case STATEMENT_LOOP_STYLE_ENDLESS:
-            printf("endless ");
-            break;
-        default:
-            failure("unexpected loop style in `statement_print`");
-            break;
-        }
-
-        block_node_print(&statement->value.loop.body);
-        printf(")");
-        break;
-    }
-    case STATEMENT_RETURN: {
-        printf("(return");
-        if (statement->value.return_value.value) {
-            printf(" ");
-            expression_print(statement->value.return_value.value);
-        }
-        printf(")");
-        break;
-    }
-    case STATEMENT_BREAK:
-        printf("(break)");
-        break;
-    case STATEMENT_CONTINUE:
-        printf("(continue)");
-        break;
-    case STATEMENT_DEFER: {
-        printf("(defer ");
-        if (statement->value.defer.expression) {
-            expression_print(statement->value.defer.expression);
-        } else {
-            block_node_print(&statement->value.defer.block);
-        }
-        printf(")");
-        break;
-    }
-    default:
-        failure("unexpected statement kind passed to `statement_print`");
-        break;
-    }
-    printf(")");
-}
-
 // the top-level tree of a single catskill source file.
 struct Tree
 {
     struct Statement* top_level_statements;
 };
-
-void
-tree_print(const struct Tree* tree)
-{
-    FOR_EACH (struct Statement*, statement, tree->top_level_statements) {
-        statement_print(statement);
-        printf("\n");
-    }
-}