Ast_Decl *get_or_instantiate_polymorph_type(Ast_Decl *poly, Array<Ast_Call_Item *> params) {
    return 0;
}

/* @todo
for (Ast_Iter iter = iterate_depth_first(ast); iter.ast; next(&iter)) {
    Ast *ast = iter.ast;

    switch(ast->kind) {
        case AST_CALL: {

        } break;
        case AST_CALL_END: {

        } break;
    }
}
*/

struct Ast_Iter {
    Array<Ast *> stack;
    Ast *ast;
    Ast_Kind kind;
};

Ast_Iter iterate_depth_first(Allocator *a, Ast *ast) {
    Ast_Iter result = {};
    result.stack = {a};
    result.ast = ast;
    result.kind = ast->kind;
    return result;
}

void next(Ast_Iter *iter) {
    Ast *ast = iter->ast;
    switch (ast->kind) {
        case AST_NAMESPACE: {
        } break;
        case AST_MODULE: {
        } break;
        case AST_FILE: {
        } break;
        case AST_SCOPE: {
        } break;
        case AST_VALUE: {
        } break;
        case AST_IDENT: {
        } break;
        case AST_INDEX: {
        } break;
        case AST_UNARY: {
        } break;
        case AST_BINARY: {
        } break;
        case AST_CALL_ITEM: {
        } break;
        case AST_CALL: {
        } break;
        case AST_CONSTANT_ASSERT: {
        } break;
        case AST_RUNTIME_ASSERT: {
        } break;
        case AST_SIZE_OF: {
        } break;
        case AST_LENGTH_OF: {
        } break;
        case AST_ALIGN_OF: {
        } break;
        case AST_TYPE_OF: {
        } break;
        case AST_SWITCH: {
        } break;
        case AST_SWITCH_CASE: {
        } break;
        case AST_VAR_UNPACK: {
        } break;
        case AST_BREAK: {
        } break;
        case AST_COMPOUND: {
        } break;
        case AST_TYPE: {
        } break;
        case AST_VAR: {
        } break;
        case AST_CONST: {
        } break;
        case AST_ARRAY: {
        } break;
        case AST_FOR: {
        } break;
        case AST_IF: {
        } break;
        case AST_IF_NODE: {
        } break;
        case AST_RETURN: {
        } break;
        case AST_PASS: {
        } break;
        case AST_LAMBDA: {
        } break;
        case AST_LAMBDA_EXPR: {
        } break;
        case AST_ENUM: {
        } break;
        case AST_STRUCT: {
        } break;
        case AST_UNION: {
        } break;
    }
}

// We are not copying module and file Ast's
// We are not copying resolved data
// @todo: Need to copy Ast->parent_scope somehow
// @todo: reserve array sizes and use perm
Ast *ast_copy(Ast *ast) {
    if (!ast) return 0;
    switch (ast->kind) {
        case AST_SCOPE: {
            Ast_Scope *src = (Ast_Scope *)ast;
            Ast_Scope *dst = push_struct_copy(pctx->perm, Ast_Scope, ast);

            dst->implicit_imports = {};
            For(src->implicit_imports) {
                Ast_Scope *copy = (Ast_Scope *)ast_copy(it);
                add(pctx->perm, &dst->implicit_imports, copy);
            }

            dst->decls = {};
            For(src->decls) {
                Ast_Decl *copy = (Ast_Decl *)ast_copy(it);
                add(pctx->perm, &dst->decls, copy);
            }

            dst->stmts = {};
            For(src->stmts) {
                Ast *copy = ast_copy(it);
                dst->stmts.add(copy);
            }
            return dst;
        } break;

        case AST_MODULE: invalid_codepath; break;
        case AST_FILE: invalid_codepath; break;

        case AST_IDENT:
        case AST_VALUE: {
            Ast_Atom *src = (Ast_Atom *)ast;
            Ast_Atom *dst = push_struct_copy(pctx->perm, Ast_Atom, ast);
            return dst;
        } break;

        case AST_INDEX: {
            Ast_Index *src = (Ast_Index *)ast;
            Ast_Index *dst = push_struct_copy(pctx->perm, Ast_Index, ast);
            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            dst->index = (Ast_Expr *)ast_copy(src->index);
            return dst;
        } break;

        case AST_UNARY: {
            Ast_Unary *src = (Ast_Unary *)ast;
            Ast_Unary *dst = push_struct_copy(pctx->perm, Ast_Unary, ast);
            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            return dst;
        } break;

        case AST_BINARY: {
            Ast_Binary *src = (Ast_Binary *)ast;
            Ast_Binary *dst = push_struct_copy(pctx->perm, Ast_Binary, ast);
            dst->left = (Ast_Expr *)ast_copy(src->left);
            dst->right = (Ast_Expr *)ast_copy(src->right);
            return dst;
        } break;

        case AST_CALL_ITEM: {
            Ast_Call_Item *src = (Ast_Call_Item *)ast;
            Ast_Call_Item *dst = push_struct_copy(pctx->perm, Ast_Call_Item, ast);
            dst->item = (Ast_Expr *)ast_copy(src->item);
            if (src->call_flags & CALL_INDEX) {
                dst->index = (Ast_Expr *)ast_copy(src->index);
            }
            else if (src->call_flags & CALL_NAME) {
                dst->name = (Ast_Atom *)ast_copy(src->name);
            }
            return dst;
        } break;

        case AST_COMPOUND:
        case AST_CALL: {
            Ast_Call *src = (Ast_Call *)ast;
            Ast_Call *dst = push_struct_copy(pctx->perm, Ast_Call, ast);
            dst->name = (Ast_Expr *)ast_copy(src->name);

            dst->exprs = {};
            For(dst->exprs) {
                auto copy = (Ast_Call_Item *)ast_copy(it);
                dst->exprs.add(copy);
            }
            return dst;
        } break;

        case AST_TYPE_OF:
        case AST_LENGTH_OF:
        case AST_ALIGN_OF:
        case AST_SIZE_OF:
        case AST_RUNTIME_ASSERT:
        case AST_CONSTANT_ASSERT: {
            Ast_Builtin *src = (Ast_Builtin *)ast;
            Ast_Builtin *dst = push_struct_copy(pctx->perm, Ast_Builtin, ast);
            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            return dst;
        } break;

        case AST_SWITCH: {
            Ast_Switch *src = (Ast_Switch *)ast;
            Ast_Switch *dst = push_struct_copy(pctx->perm, Ast_Switch, ast);
            dst->value = (Ast_Expr *)ast_copy(src->value);
            dst->default_scope = (Ast_Scope *)ast_copy(src->default_scope);
            dst->cases = {};
            For(src->cases) {
                auto copy = (Ast_Switch_Case *)ast_copy(it);
                assert(copy->kind == AST_SWITCH_CASE);
                dst->cases.add(copy);
            }
            return dst;
        } break;

        case AST_SWITCH_CASE: {
            Ast_Switch_Case *src = (Ast_Switch_Case *)ast;
            Ast_Switch_Case *dst = push_struct_copy(pctx->perm, Ast_Switch_Case, ast);

            dst->scope = (Ast_Scope *)ast_copy(src->scope);
            dst->labels = {};
            For(src->labels) {
                auto copy = (Ast_Expr *)ast_copy(it);
                dst->labels.add(copy);
            }
            return dst;
        } break;

        case AST_VAR_UNPACK: {
            Ast_Var_Unpack *src = (Ast_Var_Unpack *)ast;
            Ast_Var_Unpack *dst = push_struct_copy(pctx->perm, Ast_Var_Unpack, ast);

            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            dst->vars = {};
            For(src->vars) {
                auto copy = (Ast_Decl *)ast_copy(it);
                dst->vars.add(copy);
            }
            return dst;
        } break;

        case AST_PASS:
        case AST_BREAK: {
            Ast *src = (Ast *)ast;
            Ast *dst = push_struct_copy(pctx->perm, Ast, ast);
            return dst;
        } break;

        case AST_NAMESPACE:
        case AST_STRUCT:
        case AST_UNION:
        case AST_ENUM:
        case AST_LAMBDA:
        case AST_TYPE: // @cleanup: what is this used for?
        case AST_CONST:
        case AST_VAR: {
            Ast_Decl *src = (Ast_Decl *)ast;
            Ast_Decl *dst = push_struct_copy(pctx->perm, Ast_Decl, ast);
            dst->overload_op_info = push_struct_copy(pctx->perm, Ast_Operator_Info, src->overload_op_info);
            // omitting polymorphs
            // omitting polymorph parameters
            // For(src->polymorph_parameters) {
            //     auto copy = (Ast_Decl *)ast_copy(it);
            //     dst->polymorph_parameters.add(copy);
            // }
            dst->scope = (Ast_Scope *)ast_copy(src->scope);
            dst->typespec = (Ast_Expr *)ast_copy(src->typespec);
            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            return dst;
        } break;

        case AST_ARRAY: {
            Ast_Array *src = (Ast_Array *)ast;
            Ast_Array *dst = push_struct_copy(pctx->perm, Ast_Array, ast);
            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            return dst;
        } break;

        case AST_FOR: {
            Ast_For *src = (Ast_For *)ast;
            Ast_For *dst = push_struct_copy(pctx->perm, Ast_For, ast);
            dst->init = (Ast_Expr *)ast_copy(src->init);
            dst->cond = (Ast_Expr *)ast_copy(src->cond);
            dst->iter = (Ast_Expr *)ast_copy(src->iter);
            dst->scope = (Ast_Scope *)ast_copy(src->scope);
            return dst;
        } break;

        case AST_IF: {
            Ast_If *src = (Ast_If *)ast;
            Ast_If *dst = push_struct_copy(pctx->perm, Ast_If, ast);
            dst->ifs = {};
            For(src->ifs) {
                auto copy = (Ast_If_Node *)ast_copy(it);
                assert(copy->kind == AST_IF_NODE);
                dst->ifs.add(copy);
            }
            return dst;
        } break;

        case AST_IF_NODE: {
            Ast_If_Node *src = (Ast_If_Node *)ast;
            Ast_If_Node *dst = push_struct_copy(pctx->perm, Ast_If_Node, ast);
            dst->expr = (Ast_Expr *)ast_copy(src->expr);
            dst->init = (Ast_Binary *)ast_copy(src->init);
            dst->scope = (Ast_Scope *)ast_copy(src->scope);
            return dst;
        } break;

        case AST_RETURN: {
            Ast_Return *src = (Ast_Return *)ast;
            Ast_Return *dst = push_struct_copy(pctx->perm, Ast_Return, ast);
            For(src->expr) {
                auto copy = (Ast_Expr *)ast_copy(it);
                dst->expr.add(copy);
            }
            return dst;
        } break;

        case AST_LAMBDA_EXPR: {
            Ast_Lambda *src = (Ast_Lambda *)ast;
            Ast_Lambda *dst = push_struct_copy(pctx->perm, Ast_Lambda, ast);
            For(src->args) {
                auto copy = (Ast_Decl *)ast_copy(it);
                dst->args.add(copy);
            }
            For(src->ret) {
                auto copy = (Ast_Expr *)ast_copy(it);
                dst->ret.add(copy);
            }
            dst->scope = (Ast_Scope *)ast_copy(src->scope);
            return dst;
        } break;
    }
    invalid_return;
}