kraken/stdlib/ast_nodes.krak

import tree:*
import vector:*
import set:*
import stack:*
import map:*
import util:*
import string:*
import mem:*
import io:*
import type:*


adt ast_node {
    translation_unit: translation_unit,
    import: import,
    identifier: identifier,
    type_def: type_def,
    adt_def: adt_def,
    function: function,
    code_block: code_block,
    statement: statement,
    if_statement: if_statement,
    match_statement: match_statement,
    case_statement: case_statement,
    while_loop: while_loop,
    for_loop: for_loop,
    return_statement: return_statement,
    break_statement: break_statement,
    continue_statement: continue_statement,
    defer_statement: defer_statement,
    assignment_statement: assignment_statement,
    declaration_statement: declaration_statement,
    if_comp: if_comp,
    simple_passthrough: simple_passthrough,
    function_call: function_call,
    value: value
}
/*
total:
		ASTType type;
		Type* valueType;
		Symbol symbol;
		std::map<std::string, std::vector<NodeTree<ASTData>*>> scope;
        std::set<NodeTree<ASTData>*> closedVariables;
*/
fun ast_node_ptr(node: ast_node): *ast_node {
    var to_ret = new<ast_node>()
    to_ret->copy_construct(&node)
    return to_ret
}
fun ast_translation_unit_ptr(name: string): *ast_node {
    var obj_var.construct(name): translation_unit
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::translation_unit(obj_var))
    return ptr
}
fun is_translation_unit(node: *ast_node): bool {
    match(*node) {
        ast_node::translation_unit(backing) return true
    }
    return false
}
obj translation_unit (Object) {
    var scope: map<string, vector<*ast_node>>
    var children: vector<*ast_node>
    var name: string
    fun construct(nameIn: string): *translation_unit  {
        scope.construct()
        children.construct()
        name.copy_construct(&nameIn)
        return this
    }
    fun copy_construct(old: *translation_unit) {
        scope.copy_construct(&old->scope)
        children.copy_construct(&old->children)
        name.copy_construct(&old->name)
    }
    fun destruct() {
        scope.destruct()
        children.destruct()
        name.destruct()
    }
    fun operator=(other: ref translation_unit) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref translation_unit): bool {
        return children == other.children && name == other.name
    }
}
fun ast_import_ptr(name: string, translation_unit: *ast_node): *ast_node {
    var to_ret.construct(name, translation_unit): import
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::import(to_ret))
    return ptr
}
fun is_import(node: *ast_node): bool {
    match(*node) {
        ast_node::import(backing) return true
    }
    return false
}
obj import (Object) {
    var scope: map<string, vector<*ast_node>>
    var imported: set<string>
    var translation_unit: *ast_node
    var name: string
    fun construct(nameIn: string, translation_unit_in: *ast_node): *import  {
        scope.construct()
        imported.construct()
        name.copy_construct(&nameIn)
        translation_unit = translation_unit_in
        return this
    }
    fun copy_construct(old: *import) {
        scope.copy_construct(&old->scope)
        imported.copy_construct(&old->imported)
        name.copy_construct(&old->name)
        translation_unit = old->translation_unit
    }
    fun destruct() {
        scope.destruct()
        imported.destruct()
        name.destruct()
    }
    fun operator=(other: ref import) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref import): bool {
        return imported == other.imported && name == other.name && translation_unit == other.translation_unit
    }
}
fun ast_identifier_ptr(name: *char, type: *type): *ast_node {
    return ast_identifier_ptr(string(name), type)
}
fun ast_identifier_ptr(name: string, type: *type): *ast_node {
    var to_ret.construct(name, type): identifier
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::identifier(to_ret))
    return ptr
}
fun is_identifier(node: *ast_node): bool {
    match(*node) {
        ast_node::identifier(backing) return true
    }
    return false
}
obj identifier (Object) {
    var name: string
    var scope: map<string, vector<*ast_node>>
    var type: *type
    fun construct(name_in: string, type_in: *type): *identifier {
        name.copy_construct(&name_in)
        scope.construct()
        type = type_in
        return this
    }
    fun copy_construct(old: *identifier) {
        name.copy_construct(&old->name)
        scope.copy_construct(&old->scope)
        type = old->type
    }
    fun destruct() {
        name.destruct()
        scope.destruct()
    }
    fun operator=(other: ref identifier) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref identifier): bool {
        return name == other.name && type == other.type
    }
}
fun ast_type_def_ptr(name: string): *ast_node {
    var to_ret.construct(name): type_def
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::type_def(to_ret))
    return ptr
}
fun is_type_def(node: *ast_node): bool {
    match(*node) {
        ast_node::type_def(backing) return true
    }
    return false
}
obj type_def (Object) {
    var scope: map<string, vector<*ast_node>>
    var name: string
    fun construct(nameIn: string): *type_def  {
        scope.construct()
        name.copy_construct(&nameIn)
        return this
    }
    fun copy_construct(old: *type_def) {
        scope.copy_construct(&old->scope)
        name.copy_construct(&old->name)
    }
    fun destruct() {
        scope.destruct()
        name.destruct()
    }
    fun operator=(other: ref type_def) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref type_def): bool {
        return name == other.name
    }
}
fun ast_adt_def_ptr(name: string): *ast_node {
    var to_ret.construct(name): adt_def
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::adt_def(to_ret))
    return ptr
}
fun is_adt_def(node: *ast_node): bool {
    match(*node) {
        ast_node::adt_def(backing) return true
    }
    return false
}
obj adt_def (Object) {
    var scope: map<string, vector<*ast_node>>
    var name: string
    fun construct(nameIn: string): *adt_def  {
        scope.construct()
        name.copy_construct(&nameIn)
        return this
    }
    fun copy_construct(old: *adt_def) {
        scope.copy_construct(&old->scope)
        name.copy_construct(&old->name)
    }
    fun destruct() {
        scope.destruct()
        name.destruct()
    }
    fun operator=(other: ref adt_def) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref adt_def): bool {
        return name == other.name
    }
}
fun ast_function_ptr(name: string, type: *type, parameters: vector<*ast_node>): *ast_node {
    var to_ret.construct(name, type, parameters): function
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::function(to_ret))
    return ptr
}
fun is_function(node: *ast_node): bool {
    match(*node) {
        ast_node::function(backing) return true
    }
    return false
}
obj function (Object) {
    var name: string
    var type: *type
    var parameters: vector<*ast_node>
    var body_statement: *ast_node
    var scope: map<string, vector<*ast_node>>
    fun construct(name_in: string, type_in: *type, parameters_in: vector<*ast_node>): *function  {
        name.copy_construct(&name_in)
        parameters.copy_construct(&parameters_in)
        scope.construct()
        type = type_in
        body_statement = null<ast_node>()
        return this
    }
    fun copy_construct(old: *function) {
        name.copy_construct(&old->name)
        type = old->type
        body_statement = old->body_statement
        parameters.copy_construct(&old->parameters)
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        name.destruct()
        parameters.destruct()
        scope.destruct()
    }
    fun operator=(other: ref function) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref function): bool {
        return name == name && type == other.type && parameters == other.parameters && body_statement == other.body_statement
    }
}
fun ast_code_block_ptr(): *ast_node {
    var to_ret.construct(): code_block
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::code_block(to_ret))
    return ptr
}
fun is_code_block(node: *ast_node): bool {
    match(*node) {
        ast_node::code_block(backing) return true
    }
    return false
}
obj code_block (Object) {
    var scope: map<string, vector<*ast_node>>
    var children: vector<*ast_node>
    fun construct(): *code_block {
        scope.construct()
        children.construct()
        return this
    }
    fun copy_construct(old: *code_block) {
        scope.copy_construct(&old->scope)
        children.copy_construct(&old->children)
    }
    fun destruct() {
        scope.destruct()
        children.destruct()
    }
    fun operator=(other: ref code_block) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref code_block): bool {
        return children == other.children && scope == other.scope
    }
}
fun ast_statement_ptr(): *ast_node {
    var to_ret.construct(): statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::statement(to_ret))
    return ptr
}
fun is_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::statement(backing) return true
    }
    return false
}
obj statement (Object) {
    var scope: map<string, vector<*ast_node>>
    var child: *ast_node
    fun construct(): *statement  {
        child = null<ast_node>()
        scope.construct()
        return this
    }
    fun copy_construct(old: *statement) {
        scope.copy_construct(&old->scope)
        child = old->child
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref statement): bool {
        return child == other.child
    }
}
fun ast_if_statement_ptr(): *ast_node {
    var to_ret.construct(): if_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::if_statement(to_ret))
    return ptr
}
fun is_if_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::if_statement(backing) return true
    }
    return false
}
obj if_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *if_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *if_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref if_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref if_statement): bool {
        return true
    }
}
fun ast_match_statement_ptr(): *ast_node {
    var to_ret.construct(): match_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::match_statement(to_ret))
    return ptr
}
fun is_match_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::match_statement(backing) return true
    }
    return false
}
obj match_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *match_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *match_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref match_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref match_statement): bool {
        return true
    }
}
fun ast_case_statement_ptr(): *ast_node {
    var to_ret.construct(): case_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::case_statement(to_ret))
    return ptr
}
fun is_case_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::case_statement(backing) return true
    }
    return false
}
obj case_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *case_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *case_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref case_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref case_statement): bool {
        return true
    }
}
fun ast_while_loop_ptr(): *ast_node {
    var to_ret.construct(): while_loop
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::while_loop(to_ret))
    return ptr
}
fun is_while_loop(node: *ast_node): bool {
    match(*node) {
        ast_node::while_loop(backing) return true
    }
    return false
}
obj while_loop (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *while_loop  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *while_loop) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref while_loop) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref while_loop): bool {
        return true
    }
}
fun ast_for_loop_ptr(): *ast_node {
    var to_ret.construct(): for_loop
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::for_loop(to_ret))
    return ptr
}
fun is_for_loop(node: *ast_node): bool {
    match(*node) {
        ast_node::for_loop(backing) return true
    }
    return false
}
obj for_loop (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *for_loop  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *for_loop) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref for_loop) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref for_loop): bool {
        return true
    }
}
fun ast_return_statement_ptr(return_value: *ast_node): *ast_node {
    var to_ret.construct(return_value): return_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::return_statement(to_ret))
    return ptr
}
fun is_return_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::return_statement(backing) return true
    }
    return false
}
obj return_statement (Object) {
    var return_value: *ast_node
    var scope: map<string, vector<*ast_node>>
    fun construct(return_value_in: *ast_node): *return_statement  {
        return_value = return_value_in
        scope.construct()
        return this
    }
    fun copy_construct(old: *return_statement) {
        return_value = old->return_value
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref return_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref return_statement): bool {
        return return_value == other.return_value
    }
}
fun ast_break_statement_ptr(): *ast_node {
    var to_ret.construct(): break_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::break_statement(to_ret))
    return ptr
}
fun is_break_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::break_statement(backing) return true
    }
    return false
}
obj break_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *break_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *break_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref break_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref break_statement): bool {
        return true
    }
}
fun ast_continue_statement_ptr(): *ast_node {
    var to_ret.construct(): continue_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::continue_statement(to_ret))
    return ptr
}
fun is_continue_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::continue_statement(backing) return true
    }
    return false
}
obj continue_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *continue_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *continue_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref continue_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref continue_statement): bool {
        return true
    }
}
fun ast_defer_statement_ptr(): *ast_node {
    var to_ret.construct(): defer_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::defer_statement(to_ret))
    return ptr
}
fun is_defer_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::defer_statement(backing) return true
    }
    return false
}
obj defer_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *defer_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *defer_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref defer_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref defer_statement): bool {
        return true
    }
}
fun ast_assignment_statement_ptr(): *ast_node {
    var to_ret.construct(): assignment_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::assignment_statement(to_ret))
    return ptr
}
fun is_assignment_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::assignment_statement(backing) return true
    }
    return false
}
obj assignment_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *assignment_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *assignment_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref assignment_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref assignment_statement): bool {
        return true
    }
}
fun ast_declaration_statement_ptr(): *ast_node {
    var to_ret.construct(): declaration_statement
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::declaration_statement(to_ret))
    return ptr
}
fun is_declaration_statement(node: *ast_node): bool {
    match(*node) {
        ast_node::declaration_statement(backing) return true
    }
    return false
}
obj declaration_statement (Object) {
    var scope: map<string, vector<*ast_node>>
    fun construct(): *declaration_statement  {
        scope.construct()
        return this
    }
    fun copy_construct(old: *declaration_statement) {
        scope.copy_construct(&old->scope)
    }
    fun destruct() {
        scope.destruct()
    }
    fun operator=(other: ref declaration_statement) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref declaration_statement): bool {
        return true
    }
}
fun ast_if_comp_ptr(): *ast_node {
    var to_ret.construct(): if_comp
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::if_comp(to_ret))
    return ptr
}
fun is_if_comp(node: *ast_node): bool {
    match(*node) {
        ast_node::if_comp(backing) return true
    }
    return false
}
obj if_comp (Object) {
    var wanted_generator: string
    var statement: *ast_node
    fun construct(): *if_comp  {
        wanted_generator.construct()
        return this
    }
    fun copy_construct(old: *if_comp) {
        wanted_generator.copy_construct(&old->wanted_generator)
        statement = old->statement
    }
    fun destruct() {
        wanted_generator.destruct()
    }
    fun operator=(other: if_comp) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: if_comp): bool {
        return wanted_generator == other.wanted_generator && statement == other.statement
    }
}
fun ast_simple_passthrough_ptr(): *ast_node {
    var to_ret.construct(): simple_passthrough
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::simple_passthrough(to_ret))
    return ptr
}
fun is_simple_passthrough(node: *ast_node): bool {
    match(*node) {
        ast_node::simple_passthrough(backing) return true
    }
    return false
}
obj simple_passthrough (Object) {
    var scope: map<string, vector<*ast_node>>
    var passthrough_str: string
    fun construct(): *simple_passthrough  {
        scope.construct()
        passthrough_str.construct()
        return this
    }
    fun copy_construct(old: *simple_passthrough) {
        scope.copy_construct(&old->scope)
        passthrough_str.copy_construct(&old->passthrough_str)
    }
    fun destruct() {
        scope.destruct()
        passthrough_str.destruct()
    }
    fun operator=(other: ref simple_passthrough) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref simple_passthrough): bool {
        return scope == other.scope && passthrough_str == other.passthrough_str
    }
}
fun ast_function_call_ptr(func: *ast_node, parameters: vector<*ast_node>): *ast_node {
    var to_ret.construct(func, parameters): function_call
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::function_call(to_ret))
    return ptr
}
fun is_function_call(node: *ast_node): bool {
    match(*node) {
        ast_node::function_call(backing) return true
    }
    return false
}
obj function_call (Object) {
    var func: *ast_node
    var parameters: vector<*ast_node>
    fun construct(func_in: *ast_node, parameters_in: vector<*ast_node>): *function_call  {
        func = func_in
        parameters.copy_construct(&parameters_in)
        return this
    }
    fun copy_construct(old: *function_call) {
        func = old->func
        parameters.copy_construct(&old->parameters)
    }
    fun destruct() {
        parameters.destruct()
    }
    fun operator=(other: ref function_call) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref function_call): bool {
        return func == func && parameters == other.parameters
    }
}
fun ast_value_ptr(string_value: string, value_type: *type): *ast_node {
    var to_ret.construct(string_value, value_type): value
    var ptr = new<ast_node>()
    ptr->copy_construct(&ast_node::value(to_ret))
    return ptr
}
fun is_value(node: *ast_node): bool {
    match(*node) {
        ast_node::value(backing) return true
    }
    return false
}
obj value (Object) {
    var string_value: string
    var value_type: *type
    var scope: map<string, vector<*ast_node>>
    fun construct(string_value_in: string, value_type_in: *type): *value  {
        scope.construct()
        string_value.copy_construct(&string_value_in)
        value_type = value_type_in
        return this
    }
    fun copy_construct(old: *value) {
        scope.copy_construct(&old->scope)
        string_value.copy_construct(&old->string_value)
        value_type = old->value_type
    }
    fun destruct() {
        scope.destruct()
        string_value.destruct()
    }
    fun operator=(other: ref value) {
        destruct()
        copy_construct(&other)
    }
    fun operator==(other: ref value): bool {
        return string_value == other.string_value && value_type == other.value_type
    }
}

fun get_ast_children(node: *ast_node): vector<*ast_node> {
    match (*node) {
        ast_node::translation_unit(backing) return backing.children
        ast_node::import(backing) return vector<*ast_node>()
        ast_node::identifier(backing) return vector<*ast_node>()
        ast_node::type_def(backing) return vector<*ast_node>()
        ast_node::adt_def(backing) return vector<*ast_node>()
        ast_node::function(backing) return backing.parameters + backing.body_statement
        ast_node::code_block(backing) return backing.children
        ast_node::statement(backing) return vector<*ast_node>(backing.child)
        ast_node::if_statement(backing) return vector<*ast_node>()
        ast_node::match_statement(backing) return vector<*ast_node>()
        ast_node::case_statement(backing) return vector<*ast_node>()
        ast_node::while_loop(backing) return vector<*ast_node>()
        ast_node::for_loop(backing) return vector<*ast_node>()
        ast_node::return_statement(backing) return vector(backing.return_value)
        ast_node::break_statement(backing) return vector<*ast_node>()
        ast_node::continue_statement(backing) return vector<*ast_node>()
        ast_node::defer_statement(backing) return vector<*ast_node>()
        ast_node::assignment_statement(backing) return vector<*ast_node>()
        ast_node::declaration_statement(backing) return vector<*ast_node>()
        ast_node::if_comp(backing) return vector<*ast_node>(backing.statement)
        ast_node::simple_passthrough(backing) return vector<*ast_node>()
        ast_node::function_call(backing) return vector(backing.func) + backing.parameters
        ast_node::value(backing) return vector<*ast_node>()
    }
}
fun get_ast_name(node: *ast_node): string {
    match (*node) {
        ast_node::translation_unit(backing) return string("translation_unit: ") + backing.name
        ast_node::import(backing) return string("import: ") + backing.name + "; [" + backing.imported.reduce(fun(name: string, acc: string): string return acc + " " + name;, string()) + " ]"
        ast_node::identifier(backing) return string("identifier: ") + backing.name + ": " + backing.type->to_string()
        ast_node::type_def(backing) return string("type_def: ") + backing.name
        ast_node::adt_def(backing) return string("adt_def: ") + backing.name
        ast_node::function(backing) return string("function: ") + backing.name + ": " + backing.type->to_string()
        ast_node::code_block(backing) return string("code_block")
        ast_node::statement(backing) return string("statement")
        ast_node::if_statement(backing) return string("if_statement")
        ast_node::match_statement(backing) return string("match_statement")
        ast_node::case_statement(backing) return string("case_statement")
        ast_node::while_loop(backing) return string("while_loop")
        ast_node::for_loop(backing) return string("for_loop")
        ast_node::return_statement(backing) return string("return_statement")
        ast_node::break_statement(backing) return string("break_statement")
        ast_node::continue_statement(backing) return string("continue_statement")
        ast_node::defer_statement(backing) return string("defer_statement")
        ast_node::assignment_statement(backing) return string("assignment_statement")
        ast_node::declaration_statement(backing) return string("declaration_statement")
        ast_node::if_comp(backing) return string("if_comp: ") + backing.wanted_generator
        ast_node::simple_passthrough(backing) return string("simple_passthrough: , string:") + backing.passthrough_str
        ast_node::function_call(backing) return string("function_call:(") + backing.parameters.size + ")"
        ast_node::value(backing) return string("value: ") + backing.string_value + ": " + backing.value_type->to_string()
    }
}
fun get_ast_scope(node: *ast_node): *map<string,vector<*ast_node>> {
    match (*node) {
        ast_node::translation_unit() return &node->translation_unit.scope
        ast_node::import() return &node->import.scope
        ast_node::identifier() return &node->identifier.scope
        ast_node::type_def() return &node->type_def.scope
        ast_node::adt_def() return &node->adt_def.scope
        ast_node::function() return &node->function.scope
        ast_node::code_block() return &node->code_block.scope
        ast_node::statement() return &node->statement.scope
        ast_node::if_statement() return &node->if_statement.scope
        ast_node::match_statement() return &node->match_statement.scope
        ast_node::case_statement() return &node->case_statement.scope
        ast_node::while_loop() return &node->while_loop.scope
        ast_node::for_loop() return &node->for_loop.scope
        ast_node::return_statement() return &node->return_statement.scope
        ast_node::break_statement() return &node->break_statement.scope
        ast_node::continue_statement() return &node->continue_statement.scope
        ast_node::defer_statement() return &node->defer_statement.scope
        ast_node::assignment_statement() return &node->assignment_statement.scope
        ast_node::declaration_statement() return &node->declaration_statement.scope
        ast_node::if_comp() return null<map<string,vector<*ast_node>>>()
        ast_node::simple_passthrough() return &node->simple_passthrough.scope
        ast_node::function_call() return null<map<string,vector<*ast_node>>>()
        ast_node::value() return &node->value.scope
    }
}
fun get_ast_type(node: *ast_node): *type {
    match (*node) {
        ast_node::identifier() return node->identifier.type
        ast_node::function() return node->function.type
        ast_node::function_call() return get_ast_type(node->function_call.func)
        ast_node::value() return node->value.value_type
    }
}

fun ast_to_dot(root: *ast_node): string {
    var ret = string("digraph Kaken {\n")
    var counter = 0
    var node_name_map = map<*ast_node, string>()
    var get_name = fun(node: *ast_node): string {
        if (node_name_map.contains_key(node))
            return node_name_map[node]
        var escaped = string("")
        get_ast_name(node).data.for_each(fun(c: char) {
            if (c != '"')
                escaped += c
            else
                escaped += "\\\""
        })
        escaped += to_string(counter++)
        node_name_map.set(node, escaped)
        return escaped
    }
    var helper: fun(*ast_node):void = fun(node: *ast_node) {
        get_ast_children(node).for_each(fun(child: *ast_node) {
            if (!child)
                return; // where on earth does the null come from
            ret += string("\"") + get_name(node) + "\" -> \"" + get_name(child) + "\"\n";
            helper(child)
        })
    }
    if (root)
        helper(root)
    return ret + "}"
}