module generics

// TODO do scopes need to be cloned?
import v.pref
import v.ast
import strings

// Stage for solving generics

const result_name = ast.result_name
const option_name = ast.option_name

pub struct Generics {
    pref &pref.Preferences
pub mut:
    table                &ast.Table = unsafe { nil }
    file                 &ast.File  = unsafe { nil }
    styp_cache           map[ast.Type]string
    cur_fn               &ast.FnDecl = unsafe { nil }
    cur_concrete_types   []ast.Type
    inside_struct_init   bool
    cur_struct_init_node &ast.StructInit = unsafe { nil }
    forin_types          map[string]ast.Type // maps the name of the elem variable (`for elem in my_array`) to the solved type
}

pub fn new_generics(pref_ &pref.Preferences) &Generics {
    return &Generics{
        pref: pref_
    }
}

pub fn new_generics_with_table(table &ast.Table, pref_ &pref.Preferences) &Generics {
    mut g := new_generics(pref_)
    g.table = table
    return g
}

pub fn (mut g Generics) solve_files(ast_files []&ast.File) {
    for i in 0 .. ast_files.len {
        mut file := unsafe { ast_files[i] }
        g.solve(mut file)
    }
}

pub fn (mut g Generics) solve(mut ast_file ast.File) {
    g.file = ast_file
    ast_file.stmts = g.stmts(mut ast_file.stmts)
}

pub fn (mut g Generics) stmts(mut nodes []ast.Stmt) []ast.Stmt {
    mut solved_indexes := []int{}
    mut solved_generic_fns := []ast.Stmt{}
    for i, mut stmt in nodes {
        match mut stmt {
            ast.FnDecl {
                old_cur_fn := g.cur_fn
                g.cur_fn = unsafe { &stmt }
                if stmt.generic_names.len > 0 {
                    solved_generic_fns << g.generic_fn_decl(mut stmt)
                    solved_indexes << i
                } else {
                    nodes[i] = g.stmt(mut stmt)
                }
                g.cur_fn = old_cur_fn
            }
            else {
                stmt = g.stmt(mut stmt)
            }
        }
    }
    for idx := solved_indexes.len; idx > 0; idx-- {
        nodes.delete(solved_indexes[idx - 1])
    }
    nodes << solved_generic_fns
    return nodes
}

pub fn (mut g Generics) stmt(mut node ast.Stmt) ast.Stmt {
    match mut node {
        ast.EmptyStmt {}
        ast.NodeError {}
        ast.AsmStmt {}
        ast.DebuggerStmt {}
        ast.AssertStmt {
            if g.cur_concrete_types.len > 0 {
                return ast.Stmt(ast.AssertStmt{
                    ...node
                    expr: g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.AssignStmt {
            if g.cur_concrete_types.len > 0 {
                mut right := node.right.clone()
                mut left := node.left.clone()
                return ast.Stmt(ast.AssignStmt{
                    ...node
                    right:       g.exprs(mut right)
                    left:        g.exprs(mut left)
                    left_types:  node.left_types.map(g.unwrap_generic(it))
                    right_types: node.right_types.map(g.unwrap_generic(it))
                })
            }
            node.right = g.exprs(mut node.right)
            node.left = g.exprs(mut node.left)
        }
        ast.Block {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                return ast.Stmt(ast.Block{
                    ...node
                    stmts: g.stmts(mut stmts)
                })
            }
            node.stmts = g.stmts(mut node.stmts)
        }
        ast.BranchStmt {}
        ast.ComptimeFor {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                return ast.Stmt(ast.ComptimeFor{
                    ...node
                    typ:   g.unwrap_generic(node.typ)
                    stmts: g.stmts(mut stmts)
                })
            }
            node.stmts = g.stmts(mut node.stmts)
        }
        ast.ConstDecl {
            if g.cur_concrete_types.len > 0 {
                mut fields := node.fields.clone()
                for mut field in fields {
                    field.typ = g.unwrap_generic(field.typ)
                    field.expr = g.expr(mut field.expr)
                }
                return ast.Stmt(ast.ConstDecl{
                    ...node
                    fields: fields
                })
            }
            for mut field in node.fields {
                field.expr = g.expr(mut field.expr)
            }
        }
        ast.DeferStmt {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                return ast.Stmt(ast.DeferStmt{
                    ...node
                    stmts: g.stmts(mut stmts)
                })
            }
            node.stmts = g.stmts(mut node.stmts)
        }
        ast.EnumDecl {}
        ast.ExprStmt {
            if g.cur_concrete_types.len > 0 {
                return ast.Stmt(ast.ExprStmt{
                    ...node
                    expr: g.expr(mut node.expr)
                    typ:  g.unwrap_generic(node.typ)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.FnDecl {
            if g.cur_concrete_types.len > 0 {
                old_cur_fn := g.cur_fn
                g.cur_fn = unsafe { &node }
                mut params := node.params.clone()
                for mut param in params {
                    param.typ = g.unwrap_generic(param.typ)
                }
                mut stmts := node.stmts.clone()
                stmts = g.stmts(mut stmts)
                mut defer_stmts := node.defer_stmts.clone()
                for mut defer_stmt in defer_stmts {
                    defer_stmt = g.stmt(mut defer_stmt) as ast.DeferStmt
                }
                g.cur_fn = old_cur_fn
                return ast.Stmt(ast.FnDecl{
                    ...node
                    receiver:    ast.StructField{
                        ...node.receiver
                        typ: g.unwrap_generic(node.receiver.typ)
                    }
                    return_type: g.unwrap_generic(node.return_type)
                    params:      params
                    stmts:       stmts
                    defer_stmts: defer_stmts
                })
            }
            old_cur_fn := g.cur_fn
            g.cur_fn = unsafe { &node }
            node.stmts = g.stmts(mut node.stmts)
            g.cur_fn = old_cur_fn
        }
        ast.ForCStmt {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                return ast.Stmt(ast.ForCStmt{
                    ...node
                    cond:  g.expr(mut node.cond)
                    init:  g.stmt(mut node.init)
                    inc:   g.stmt(mut node.inc)
                    stmts: g.stmts(mut stmts)
                })
            }
            if node.has_init && !node.is_multi {
                node.init = g.stmt(mut node.init)
            }

            if node.has_cond {
                node.cond = g.expr(mut node.cond)
            }

            node.stmts = g.stmts(mut node.stmts)

            if node.has_inc && !node.is_multi {
                node.inc = g.stmt(mut node.inc)
            }
        }
        ast.ForInStmt {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                if mut node.cond is ast.Ident && node.cond.ct_expr {
                    // Solve the type for elem in `for elem in my_array` when my_array is T
                    unwrapped_typ := g.unwrap_generic(node.cond_type)
                    node.val_type = g.table.value_type(unwrapped_typ)
                    if node.val_is_mut {
                        node.val_type = node.val_type.ref()
                    }
                    g.forin_types[node.val_var] = node.val_type
                    defer(fn) {
                        g.forin_types.delete(node.val_var)
                    }
                }
                mut new_node := ast.ForInStmt{
                    ...node
                    cond:      g.expr(mut node.cond)
                    high:      g.expr(mut node.high)
                    key_type:  g.unwrap_generic(node.key_type)
                    val_type:  g.unwrap_generic(node.val_type)
                    cond_type: g.unwrap_generic(node.cond_type)
                    high_type: g.unwrap_generic(node.high_type)
                    stmts:     g.stmts(mut stmts)
                }
                return ast.Stmt(new_node)
            }
            node.stmts = g.stmts(mut node.stmts)
        }
        ast.ForStmt {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                return ast.Stmt(ast.ForStmt{
                    ...node
                    cond:  g.expr(mut node.cond)
                    stmts: g.stmts(mut stmts)
                })
            }
            node.cond = g.expr(mut node.cond)
            node.stmts = g.stmts(mut node.stmts)
        }
        ast.GlobalDecl {
            if g.cur_concrete_types.len > 0 {
                mut fields := node.fields.clone()
                for mut field in fields {
                    field.typ = g.unwrap_generic(field.typ)
                    field.expr = g.expr(mut field.expr)
                }
                return ast.Stmt(ast.GlobalDecl{
                    ...node
                    fields: fields
                })
            }
            for mut field in node.fields {
                field.expr = g.expr(mut field.expr)
            }
        }
        ast.GotoLabel {}
        ast.GotoStmt {}
        ast.HashStmt {
            if g.cur_concrete_types.len > 0 {
                mut ct_conds := node.ct_conds.clone()
                return ast.Stmt(ast.HashStmt{
                    ...node
                    ct_conds: g.exprs(mut ct_conds)
                })
            }
            node.ct_conds = g.exprs(mut node.ct_conds)
        }
        ast.Import {}
        ast.InterfaceDecl {}
        ast.Module {}
        ast.Return {
            if g.cur_concrete_types.len > 0 {
                mut exprs := node.exprs.clone()
                return ast.Stmt(ast.Return{
                    ...node
                    exprs: g.exprs(mut exprs)
                    types: node.types.map(g.unwrap_generic(it))
                })
            }
            node.exprs = g.exprs(mut node.exprs)
        }
        ast.SemicolonStmt {}
        ast.SqlStmt {}
        ast.StructDecl {
            if g.cur_concrete_types.len > 0 {
                mut fields := node.fields.clone()
                for mut field in fields {
                    field.container_typ = g.unwrap_generic(field.container_typ)
                    field.default_expr_typ = g.unwrap_generic(field.default_expr_typ)
                    field.typ = g.unwrap_generic(field.typ)
                    field.unaliased_typ = g.unwrap_generic(field.unaliased_typ)
                    field.default_expr = g.expr(mut field.default_expr)
                }
                return ast.Stmt(ast.StructDecl{
                    ...node
                    fields: fields
                })
            }
            for mut field in node.fields {
                field.default_expr = g.expr(mut field.default_expr)
            }
        }
        ast.TypeDecl {}
    }

    return node
}

pub fn (mut g Generics) styp(t ast.Type) string {
    if !t.has_option_or_result() {
        return g.base_type(t)
    } else if t.has_flag(.option) {
        // Register an optional if it's not registered yet
        return g.register_option(t)
    } else {
        return g.register_result(t)
    }
}

// incomplete implementation: TODO
fn (mut g Generics) base_type(_t ast.Type) string {
    t := g.unwrap_generic(_t)
    if styp := g.styp_cache[t] {
        return styp
    }
    if g.pref.nofloat {
        if t == ast.f32_type {
            return 'u32'
        } else if t == ast.f64_type {
            return 'u64'
        }
    }
    share := t.share()
    mut styp := if share == .atomic_t { t.atomic_typename() } else { g.cc_type(t, true) }
    nr_muls := t.nr_muls()
    if nr_muls > 0 {
        styp += strings.repeat(`*`, nr_muls)
    }
    g.styp_cache[t] = styp
    return styp
}

// incomplete implementation: TODO
fn (mut g Generics) register_option(t ast.Type) string {
    styp, _ := g.option_type_name(t)
    return if !t.has_flag(.option_mut_param_t) { styp } else { '${styp}*' }
}

// incomplete implementation: TODO
fn (mut g Generics) register_result(t ast.Type) string {
    styp, _ := g.result_type_name(t)
    return styp
}

fn (mut g Generics) option_type_name(t ast.Type) (string, string) {
    mut base := g.base_type(t)
    mut styp := ''
    sym := g.table.sym(t)
    if sym.info is ast.FnType {
        base = 'anon_fn_${g.table.fn_type_signature(sym.info.func)}'
    }
    if sym.language == .c && sym.kind == .struct {
        styp = '${option_name}_${base.replace(' ', '_')}'
    } else {
        styp = '${option_name}_${base}'
    }
    if t.has_flag(.generic) || t.is_ptr() {
        styp = styp.replace('*', '_ptr')
    }
    return styp, base
}

fn (mut g Generics) result_type_name(t ast.Type) (string, string) {
    mut base := g.base_type(t)
    if t.has_flag(.option) {
        g.register_option(t)
        base = '_option_' + base
    }
    mut styp := ''
    sym := g.table.sym(t)
    if sym.info is ast.FnType {
        base = 'anon_fn_${g.table.fn_type_signature(sym.info.func)}'
    }
    if sym.language == .c && sym.kind == .struct {
        styp = '${result_name}_${base.replace(' ', '_')}'
    } else {
        styp = '${result_name}_${base}'
    }
    if t.has_flag(.generic) || t.is_ptr() {
        styp = styp.replace('*', '_ptr')
    }
    return styp, base
}

// cc_type whether to prefix 'struct' or not (C__Foo -> struct Foo)
fn (mut g Generics) cc_type(typ ast.Type, is_prefix_struct bool) string {
    sym := g.table.sym(g.unwrap_generic(typ))
    mut styp := sym.scoped_cname()
    match sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            if sym.info.is_generic && sym.generic_types.len == 0 {
                mut sgtyps := ''
                for gt in sym.info.generic_types {
                    gts := g.table.sym(g.unwrap_generic(gt))
                    sgtyps += '_T_${gts.scoped_cname()}'
                }
                styp += sgtyps
            }
        }
        else {}
    }

    if is_prefix_struct && sym.language == .c {
        styp = styp[3..]
        if sym.kind == .struct {
            info := sym.info as ast.Struct
            if info.is_anon {
                styp = 'C__' + styp
            } else if !info.is_typedef {
                styp = 'struct ${styp}'
            }
        }
    }
    return styp
}

pub fn (mut g Generics) method_concrete_name(old_name string, concrete_types []ast.Type, receiver_type ast.Type) string {
    mut name := old_name
    if receiver_type != 0 {
        mut receiver_sym := g.table.sym(g.unwrap_generic(receiver_type))
        if receiver_sym.info is ast.Alias {
            unaliased_type := g.table.unaliased_type(g.unwrap_generic(receiver_type))
            receiver_sym = g.table.sym(unaliased_type)
        }
        if receiver_sym.info is ast.Struct {
            info := receiver_sym.info as ast.Struct
            fn_conc_types := concrete_types#[info.generic_types.len..] // concrete types without the generic types of the struct
            if fn_conc_types.len > 0 {
                name += '_T'
            }
            for typ in fn_conc_types {
                name += '_' + strings.repeat_string('__ptr__', typ.nr_muls()) +
                    g.styp(typ.set_nr_muls(0))
            }
            return name
        }
        if receiver_sym.info is ast.GenericInst {
            info := receiver_sym.info as ast.GenericInst
            parent_sym := g.table.sym(ast.idx_to_type(info.parent_idx))
            if parent_sym.info is ast.Struct {
                parent_info := parent_sym.info as ast.Struct
                fn_conc_types := concrete_types#[parent_info.generic_types.len..]
                if fn_conc_types.len > 0 {
                    name += '_T'
                }
                for typ in fn_conc_types {
                    name += '_' + strings.repeat_string('__ptr__', typ.nr_muls()) +
                        g.styp(typ.set_nr_muls(0))
                }
                return name
            }
        }
        if receiver_sym.info is ast.Interface {
            return name
        }
    }
    if concrete_types.len > 0 {
        name += '_T'
    }
    for typ in concrete_types {
        name += '_' + strings.repeat_string('__ptr__', typ.nr_muls()) + g.styp(typ.set_nr_muls(0))
    }
    return name
}

pub fn (mut g Generics) concrete_name(old_name string, concrete_types []ast.Type) string {
    mut name := old_name
    if concrete_types.len > 0 {
        name += '_T'
    }
    for typ in concrete_types {
        name += '_' + strings.repeat_string('__ptr__', typ.nr_muls()) + g.styp(typ.set_nr_muls(0))
    }
    return name
}

pub fn (mut g Generics) generic_fn_decl(mut node ast.FnDecl) []ast.Stmt {
    mut solved_fns := []ast.Stmt{}
    nkey := node.fkey()
    generic_types_by_fn := g.table.fn_generic_types[nkey]
    for concrete_types in generic_types_by_fn {
        if g.pref.is_verbose {
            syms := concrete_types.map(g.table.sym(it))
            the_type := syms.map(it.name).join(', ')
            println('solve generic fn `${node.name}` for type `${the_type}`')
        }
        g.cur_concrete_types = concrete_types

        mut new_node := ast.FnDecl{
            ...node
        }
        new_node = g.stmt(mut new_node) as ast.FnDecl
        new_node = ast.FnDecl{
            ...new_node
            name:          if node.is_method {
                g.method_concrete_name(new_node.name, concrete_types, new_node.receiver.typ)
            } else {
                g.concrete_name(new_node.name, concrete_types)
            }
            ninstances:    0
            generic_names: []
        }
        if new_node.is_method {
            mut sym := g.table.sym(new_node.receiver.typ)
            func := ast.Fn{
                is_variadic:                    new_node.is_variadic
                is_c_variadic:                  new_node.is_c_variadic
                language:                       .v
                is_pub:                         new_node.is_pub
                is_deprecated:                  new_node.is_deprecated
                is_noreturn:                    new_node.is_noreturn
                is_unsafe:                      new_node.is_unsafe
                is_must_use:                    new_node.is_must_use
                is_keep_alive:                  new_node.is_keep_alive
                is_method:                      new_node.is_method
                is_static_type_method:          new_node.is_static_type_method
                no_body:                        new_node.no_body
                is_file_translated:             new_node.is_file_translated
                mod:                            new_node.mod
                file:                           new_node.file
                file_mode:                      new_node.file_mode
                pos:                            new_node.pos
                return_type_pos:                new_node.return_type_pos
                return_type:                    new_node.return_type
                receiver_type:                  new_node.receiver.typ
                name:                           new_node.name
                params:                         new_node.params
                generic_names:                  []
                is_conditional:                 new_node.is_conditional
                ctdefine_idx:                   new_node.ctdefine_idx
                is_expand_simple_interpolation: new_node.is_expand_simple_interpolation
            }
            g.table.find_or_register_fn_type(func, false, true)
            sym.register_method(func)
        }
        solved_fns << new_node
    }
    g.cur_concrete_types = []
    return solved_fns
}

pub fn (mut g Generics) exprs(mut nodes []ast.Expr) []ast.Expr {
    for mut e in nodes {
        e = g.expr(mut e)
    }
    return nodes
}

pub fn (mut g Generics) expr(mut node ast.Expr) ast.Expr {
    match mut node {
        ast.AnonFn {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.AnonFn{
                    ...node
                    typ:  g.unwrap_generic(node.typ)
                    decl: g.stmt(mut node.decl) as ast.FnDecl
                })
            }
            node.decl = g.stmt(mut node.decl) as ast.FnDecl
        }
        ast.ArrayDecompose {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.ArrayDecompose{
                    ...node
                    expr_type: g.unwrap_generic(node.expr_type)
                    arg_type:  g.unwrap_generic(node.arg_type)
                    expr:      g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.ArrayInit {
            if g.cur_concrete_types.len > 0 {
                mut exprs := node.exprs.clone()
                return ast.Expr(ast.ArrayInit{
                    ...node
                    exprs:      g.exprs(mut exprs)
                    expr_types: node.expr_types.map(g.unwrap_generic(it))
                    typ:        g.unwrap_generic(node.typ)
                    elem_type:  g.unwrap_generic(node.elem_type)
                    alias_type: g.unwrap_generic(node.alias_type)
                    len_expr:   g.expr(mut node.len_expr)
                    cap_expr:   g.expr(mut node.cap_expr)
                    init_type:  g.unwrap_generic(node.init_type)
                    init_expr:  g.expr(mut node.init_expr)
                })
            }
            node.exprs = g.exprs(mut node.exprs)
            if node.has_len {
                node.len_expr = g.expr(mut node.len_expr)
            }
            if node.has_cap {
                node.cap_expr = g.expr(mut node.cap_expr)
            }
            if node.has_init {
                node.init_expr = g.expr(mut node.init_expr)
            }
        }
        ast.AsCast {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.AsCast{
                    ...node
                    typ:       g.unwrap_generic(node.typ)
                    expr_type: g.unwrap_generic(node.expr_type)
                    expr:      g.expr(mut node.expr)
                })
            } else {
                node.expr = g.expr(mut node.expr)
            }
        }
        ast.CallExpr {
            if g.cur_concrete_types.len > 0 {
                mut args := node.args.clone()
                mut all_concrete_types := node.concrete_types.clone()
                mut has_ct_args := false
                for mut ct in all_concrete_types {
                    idx := g.cur_fn.generic_names.index(g.table.type_str(ct))
                    if idx != -1 {
                        ct = g.cur_concrete_types[idx]
                    }
                }
                for i, mut arg in args {
                    if arg.typ.has_flag(.generic) {
                        arg.typ = g.unwrap_generic(arg.typ)
                        arg.ct_expr = false
                    }
                    arg.expr = g.expr(mut arg.expr)
                    has_ct_args = has_ct_args || arg.ct_expr
                    if mut arg.expr is ast.Ident {
                        // Solve concrete_types when the type of one argument was elem in `for elem in my_array` when my_array is T
                        forin_type := g.forin_types[arg.expr.name]
                        if forin_type != 0 {
                            if func := g.table.find_fn(node.name) {
                                solved_type_generic_name := g.table.type_str(func.params[i].typ)
                                idx := func.generic_names.index(solved_type_generic_name)
                                if idx != -1 {
                                    all_concrete_types[idx] = forin_type
                                }
                            }
                        }
                    }
                }
                mut receiver_type := g.unwrap_generic(node.receiver_type)
                if receiver_type.has_flag(.generic) {
                    receiver_type = receiver_type.clear_flag(.generic)
                }
                call_name := if node.is_fn_var {
                    node.name
                } else if has_ct_args {
                    node.name
                } else if node.is_method {
                    g.method_concrete_name(node.name, all_concrete_types, node.receiver_type)
                } else {
                    g.concrete_name(node.name, all_concrete_types)
                }
                return ast.Expr(ast.CallExpr{
                    ...node
                    name:                call_name
                    left_type:           g.unwrap_generic(node.left_type)
                    receiver_type:       receiver_type
                    return_type:         g.unwrap_generic(node.return_type)
                    return_type_generic: ast.no_type
                    fn_var_type:         g.unwrap_generic(node.fn_var_type)
                    left:                g.expr(mut node.left)
                    expected_arg_types:  node.expected_arg_types.map(g.unwrap_generic(it))
                    args:                args
                    concrete_types:      []
                    raw_concrete_types:  node.raw_concrete_types.clone()
                    from_embed_types:    node.from_embed_types.clone()
                    or_block:            g.expr(mut node.or_block) as ast.OrExpr
                })
            }
            node.left = g.expr(mut node.left)
            mut has_ct_args := false
            for mut arg in node.args {
                arg.expr = g.expr(mut arg.expr)
                has_ct_args = has_ct_args || arg.ct_expr
            }
            node.or_block = g.expr(mut node.or_block) as ast.OrExpr
            if node.is_method && g.table.sym(node.receiver_type).info is ast.Alias {
                // Workaround needed for markused
                alias_sym := g.table.sym(g.unwrap_generic(node.receiver_type))
                unaliased_type := g.table.unaliased_type(g.unwrap_generic(node.receiver_type))
                if !alias_sym.has_method(node.name)
                    && g.table.sym(unaliased_type).has_method(node.name) {
                    node.receiver_type = unaliased_type
                }
            }
            if node.receiver_type.has_flag(.generic) {
                node.receiver_type = node.receiver_type.clear_flag(.generic)
            }
            if node.concrete_types.len > 0 {
                if func := g.table.find_fn(node.name) {
                    node.expected_arg_types = node.expected_arg_types.map(g.table.convert_generic_type(it,
                        func.generic_names, node.concrete_types) or { it })
                }
            }
            if !node.is_fn_var {
                node.name = if node.is_method {
                    if has_ct_args {
                        node.name
                    } else {
                        g.method_concrete_name(node.name, node.concrete_types, node.receiver_type)
                    }
                } else {
                    if has_ct_args {
                        node.name
                    } else {
                        g.concrete_name(node.name, node.concrete_types)
                    }
                }
            }
            return ast.Expr(ast.CallExpr{
                ...node
                concrete_types:     []
                raw_concrete_types: if node.raw_concrete_types.len > 0 {
                    node.raw_concrete_types.clone()
                } else {
                    node.concrete_types.clone()
                }
            })
        }
        ast.CastExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.CastExpr{
                    ...node
                    typ:  g.unwrap_generic(node.typ)
                    arg:  g.expr(mut node.arg)
                    expr: g.expr(mut node.expr)
                })
            }
            node.arg = g.expr(mut node.arg)
            node.expr = g.expr(mut node.expr)
        }
        ast.ChanInit {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.ChanInit{
                    ...node
                    typ:       g.unwrap_generic(node.typ)
                    elem_type: g.unwrap_generic(node.typ)
                    cap_expr:  g.expr(mut node.cap_expr)
                })
            }
            node.cap_expr = g.expr(mut node.cap_expr)
        }
        ast.ComptimeCall {
            if g.cur_concrete_types.len > 0 {
                mut args := node.args.clone()
                for mut arg in args {
                    arg.expr = g.expr(mut arg.expr)
                }
                return ast.Expr(ast.ComptimeCall{
                    ...node
                    left_type:   g.unwrap_generic(node.left_type)
                    result_type: g.unwrap_generic(node.result_type)
                    args:        args
                })
            }
            for mut arg in node.args {
                arg.expr = g.expr(mut arg.expr)
            }
        }
        ast.ComptimeSelector {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.ComptimeSelector{
                    ...node
                    left_type:  g.unwrap_generic(node.left_type)
                    typ:        g.unwrap_generic(node.typ)
                    left:       g.expr(mut node.left)
                    field_expr: g.expr(mut node.field_expr)
                })
            }
            node.left = g.expr(mut node.left)
            node.field_expr = g.expr(mut node.field_expr)
        }
        ast.ConcatExpr {
            if g.cur_concrete_types.len > 0 {
                mut vals := node.vals.clone()
                for mut val in vals {
                    val = g.expr(mut val)
                }
                return ast.Expr(ast.ConcatExpr{
                    ...node
                    return_type: g.unwrap_generic(node.return_type)
                    vals:        vals
                })
            }
            for mut val in node.vals {
                val = g.expr(mut val)
            }
        }
        ast.DumpExpr {
            if g.cur_concrete_types.len > 0 {
                name := if mut node.expr is ast.Ident {
                    // var
                    if node.expr.info is ast.IdentVar && node.expr.language == .v {
                        ident_info := node.expr.var_info()
                        g.styp(g.unwrap_generic(ident_info.typ.clear_flags(.shared_f, .result))).replace('*',
                            '')
                    } else {
                        node.cname
                    }
                } else if mut node.expr is ast.CallExpr {
                    g.styp(g.unwrap_generic(node.expr_type.clear_flags(.shared_f, .result))).replace('*',
                        '').replace('.', '__')
                } else {
                    node.cname
                }
                return ast.Expr(ast.DumpExpr{
                    ...node
                    cname:     name
                    expr_type: g.unwrap_generic(node.expr_type)
                    expr:      g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.Ident {
            match mut node.obj {
                ast.Var {
                    if g.cur_concrete_types.len > 0 {
                        is_ct_type_generic := node.obj.ct_type_var == .generic_param
                            || node.obj.ct_type_var == .generic_var
                        is_ct_type_forin_val := node.obj.ct_type_var == .value_var // elem in `for elem in my_array` when my_array is T
                        unwrapped_typ := if is_ct_type_forin_val {
                            g.forin_types[node.name]
                        } else {
                            g.unwrap_generic(node.obj.typ)
                        }
                        info := match node.info {
                            ast.IdentVar {
                                ast.IdentInfo(ast.IdentVar{
                                    ...node.info as ast.IdentVar
                                    typ: g.unwrap_generic(node.info.typ)
                                })
                            }
                            ast.IdentFn {
                                ast.IdentInfo(ast.IdentFn{
                                    ...node.info as ast.IdentFn
                                    typ: g.unwrap_generic(node.info.typ)
                                })
                            }
                        }

                        return ast.Expr(ast.Ident{
                            ...node
                            obj:     ast.Var{
                                ...node.obj
                                typ:           unwrapped_typ
                                smartcasts:    node.obj.smartcasts.map(g.unwrap_generic(it))
                                is_auto_deref: node.obj.is_auto_deref
                                    || (node.obj.typ.has_flag(.generic)
                                    && g.table.sym(unwrapped_typ).kind in [.sum_type, .interface])
                                // node.obj.orig_type = g.unwrap_generic(node.obj.orig_type)
                                ct_type_unwrapped: is_ct_type_generic || is_ct_type_forin_val
                                    || node.obj.ct_type_unwrapped
                                ct_type_var:       if is_ct_type_generic || is_ct_type_forin_val {
                                    .no_comptime
                                } else {
                                    node.obj.ct_type_var
                                }
                            }
                            info:    info
                            ct_expr: !is_ct_type_forin_val && node.ct_expr
                        })
                    }
                }
                ast.EmptyScopeObject {
                    if g.cur_concrete_types.len > 0 {
                        mut typ := node.obj.typ
                        mut name := node.name
                        if typ == 0 {
                            if g.cur_fn != unsafe { nil } {
                                idx := g.cur_fn.generic_names.index(node.name)
                                if idx != -1 {
                                    typ = g.cur_concrete_types[idx]
                                    name = g.table.type_str(typ)
                                }
                            }
                        } else {
                            typ = g.unwrap_generic(typ)
                            name = g.table.type_str(typ)
                        }
                        return ast.Expr(ast.Ident{
                            ...node
                            obj:  ast.EmptyScopeObject{
                                ...node.obj
                                typ:  typ
                                name: name
                            }
                            name: name
                        })
                    }
                }
                else {}
            }
        }
        ast.IfExpr {
            if g.cur_concrete_types.len > 0 {
                mut branches := node.branches.clone()
                for mut branch in branches {
                    branch.stmts = branch.stmts.clone()
                    branch.cond = g.expr(mut branch.cond)
                    branch.stmts = g.stmts(mut branch.stmts)
                }
                return ast.Expr(ast.IfExpr{
                    ...node
                    typ:      g.unwrap_generic(node.typ)
                    branches: branches
                    left:     g.expr(mut node.left)
                })
            }
            for mut branch in node.branches {
                branch.cond = g.expr(mut branch.cond)
                branch.stmts = g.stmts(mut branch.stmts)
            }
            node.left = g.expr(mut node.left)
        }
        ast.IfGuardExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.IfGuardExpr{
                    ...node
                    expr_type: g.unwrap_generic(node.expr_type)
                    expr:      g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.IndexExpr {
            mut indices := []ast.Expr{cap: node.indices.len}
            for mut index in node.indices {
                indices << g.expr(mut index)
            }
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.IndexExpr{
                    ...node
                    left_type: g.unwrap_generic(node.left_type)
                    typ:       g.unwrap_generic(node.typ)
                    left:      g.expr(mut node.left)
                    index:     g.expr(mut node.index)
                    indices:   indices
                    or_expr:   g.expr(mut node.or_expr) as ast.OrExpr
                })
            }
            node.left = g.expr(mut node.left)
            node.index = g.expr(mut node.index)
            node.indices = indices
            node.or_expr = g.expr(mut node.or_expr) as ast.OrExpr
        }
        ast.InfixExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.InfixExpr{
                    ...node
                    left_type:     g.unwrap_generic(node.left_type)
                    right_type:    g.unwrap_generic(node.right_type)
                    promoted_type: g.unwrap_generic(node.promoted_type)
                    left:          g.expr(mut node.left)
                    right:         g.expr(mut node.right)
                })
            }
            node.left = g.expr(mut node.left)
            node.right = g.expr(mut node.right)
        }
        ast.IsRefType {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.IsRefType{
                    ...node
                    typ:  g.unwrap_generic(node.typ)
                    expr: g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.Likely {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.Likely{
                    ...node
                    expr: g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.LockExpr {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                mut lockeds := node.lockeds.clone()
                return ast.Expr(ast.LockExpr{
                    ...node
                    typ:     g.unwrap_generic(node.typ)
                    stmts:   g.stmts(mut stmts)
                    lockeds: g.exprs(mut lockeds)
                })
            }
            node.stmts = g.stmts(mut node.stmts)
            node.lockeds = g.exprs(mut node.lockeds)
        }
        ast.MapInit {
            if g.cur_concrete_types.len > 0 {
                mut keys := node.keys.clone()
                mut vals := node.vals.clone()
                return ast.Expr(ast.MapInit{
                    typ:        g.unwrap_generic(node.typ)
                    key_type:   g.unwrap_generic(node.key_type)
                    value_type: g.unwrap_generic(node.value_type)
                    val_types:  node.val_types.map(g.unwrap_generic(it))
                    keys:       g.exprs(mut keys)
                    vals:       g.exprs(mut vals)
                })
            }
            node.keys = g.exprs(mut node.keys)
            node.vals = g.exprs(mut node.vals)
        }
        ast.MatchExpr {
            if g.cur_concrete_types.len > 0 {
                mut branches := node.branches.clone()
                for mut branch in branches {
                    branch.stmts = branch.stmts.clone()
                    branch.exprs = branch.exprs.clone()
                    branch.exprs = g.exprs(mut branch.exprs)
                    branch.stmts = g.stmts(mut branch.stmts)
                }
                return ast.Expr(ast.MatchExpr{
                    ...node
                    branches:      branches
                    return_type:   g.unwrap_generic(node.return_type)
                    cond_type:     g.unwrap_generic(node.cond_type)
                    cond:          g.expr(mut node.cond)
                    expected_type: g.unwrap_generic(node.expected_type)
                })
            }
            node.cond = g.expr(mut node.cond)
            for mut branch in node.branches {
                branch.exprs = g.exprs(mut branch.exprs)
                branch.stmts = g.stmts(mut branch.stmts)
            }
        }
        ast.OrExpr {
            if g.cur_concrete_types.len > 0 {
                mut stmts := node.stmts.clone()
                return ast.Expr(ast.OrExpr{
                    ...node
                    stmts: g.stmts(mut stmts)
                })
            }
            node.stmts = g.stmts(mut node.stmts)
        }
        ast.ParExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.ParExpr{
                    ...node
                    expr: g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.PostfixExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.PostfixExpr{
                    ...node
                    expr: g.expr(mut node.expr)
                    typ:  g.unwrap_generic(node.typ)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.PrefixExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.PrefixExpr{
                    ...node
                    right_type: g.unwrap_generic(node.right_type)
                    right:      g.expr(mut node.right)
                    or_block:   g.expr(mut node.or_block) as ast.OrExpr
                })
            }
            node.right = g.expr(mut node.right)
            node.or_block = g.expr(mut node.or_block) as ast.OrExpr
        }
        ast.RangeExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.RangeExpr{
                    ...node
                    typ:  g.unwrap_generic(node.typ)
                    low:  g.expr(mut node.low)
                    high: g.expr(mut node.high)
                })
            }
            node.low = g.expr(mut node.low)
            node.high = g.expr(mut node.high)
        }
        ast.SelectExpr {
            if g.cur_concrete_types.len > 0 {
                mut branches := node.branches.clone()
                for mut branch in node.branches {
                    branch.stmt = g.stmt(mut branch.stmt)
                    branch.stmts = branch.stmts.clone()
                    branch.stmts = g.stmts(mut branch.stmts)
                }
                return ast.Expr(ast.SelectExpr{
                    ...node
                    expected_type: g.unwrap_generic(node.expected_type)
                    branches:      branches
                })
            }
            for mut branch in node.branches {
                branch.stmt = g.stmt(mut branch.stmt)
                branch.stmts = g.stmts(mut branch.stmts)
            }
        }
        ast.SelectorExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.SelectorExpr{
                    ...node
                    expr:             g.expr(mut node.expr)
                    expr_type:        g.unwrap_generic(node.expr_type)
                    typ:              g.unwrap_generic(node.typ)
                    name_type:        g.unwrap_generic(node.name_type)
                    from_embed_types: node.from_embed_types.map(g.unwrap_generic(it))
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.SizeOf {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.SizeOf{
                    ...node
                    expr: g.expr(mut node.expr)
                    typ:  g.unwrap_generic(node.typ)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.SqlExpr {
            if g.cur_concrete_types.len > 0 {
                mut fields := node.fields.clone()
                for mut field in fields {
                    field.default_expr = g.expr(mut field.default_expr)
                }
                mut sub_structs := node.sub_structs.clone()
                for _, mut sub_struct in sub_structs {
                    sub_struct = g.expr(mut sub_struct) as ast.SqlExpr
                }
                return ast.Expr(ast.SqlExpr{
                    ...node
                    typ:         g.unwrap_generic(node.typ)
                    db_expr:     g.expr(mut node.db_expr)
                    where_expr:  g.expr(mut node.where_expr)
                    order_expr:  g.expr(mut node.order_expr)
                    limit_expr:  g.expr(mut node.limit_expr)
                    offset_expr: g.expr(mut node.offset_expr)
                    fields:      fields
                    sub_structs: sub_structs
                })
            }
            node.db_expr = g.expr(mut node.db_expr)
            if node.has_where {
                node.where_expr = g.expr(mut node.where_expr)
            }
            if node.has_order {
                node.order_expr = g.expr(mut node.order_expr)
            }
            if node.has_limit {
                node.limit_expr = g.expr(mut node.limit_expr)
            }
            if node.has_offset {
                node.offset_expr = g.expr(mut node.offset_expr)
            }
            for mut field in node.fields {
                field.default_expr = g.expr(mut field.default_expr)
            }
            for _, mut sub_struct in node.sub_structs {
                sub_struct = g.expr(mut sub_struct) as ast.SqlExpr
            }
        }
        ast.SqlQueryDataExpr {
            items := g.sql_query_data_items(node.items)
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.SqlQueryDataExpr{
                    ...node
                    items: items
                    typ:   g.unwrap_generic(node.typ)
                })
            }
            node.items = items
        }
        ast.StringInterLiteral {
            if g.cur_concrete_types.len > 0 {
                mut exprs := node.exprs.clone()
                mut fwidth_exprs := node.fwidth_exprs.clone()
                mut precision_exprs := node.precision_exprs.clone()
                return ast.Expr(ast.StringInterLiteral{
                    ...node
                    exprs:           g.exprs(mut exprs)
                    expr_types:      node.expr_types.map(g.unwrap_generic(it))
                    fwidth_exprs:    g.exprs(mut fwidth_exprs)
                    precision_exprs: g.exprs(mut precision_exprs)
                })
            }
            node.exprs = g.exprs(mut node.exprs)
            node.fwidth_exprs = g.exprs(mut node.fwidth_exprs)
            node.precision_exprs = g.exprs(mut node.precision_exprs)
        }
        ast.StructInit {
            if g.cur_concrete_types.len > 0 {
                old_inside_struct_init := g.inside_struct_init
                g.inside_struct_init = true
                old_cur_struct_init_node := g.cur_struct_init_node
                g.cur_struct_init_node = unsafe { &node }

                mut init_fields := node.init_fields.clone()
                for mut init_field in init_fields {
                    init_field.expr = g.expr(mut init_field.expr)
                    init_field.typ = g.unwrap_generic(init_field.typ)
                    init_field.expected_type = g.unwrap_generic(init_field.expected_type)
                    init_field.parent_type = g.unwrap_generic(init_field.parent_type)
                }

                out := ast.Expr(ast.StructInit{
                    ...node
                    typ:              g.unwrap_generic(node.typ)
                    typ_str:          g.table.type_str(g.unwrap_generic(node.typ))
                    generic_types:    node.generic_types.map(g.unwrap_generic(it))
                    update_expr:      g.expr(mut node.update_expr)
                    update_expr_type: g.unwrap_generic(node.update_expr_type)
                    init_fields:      init_fields
                })

                g.cur_struct_init_node = old_cur_struct_init_node
                g.inside_struct_init = old_inside_struct_init
                return out
            }
            old_inside_struct_init := g.inside_struct_init
            g.inside_struct_init = true
            node.update_expr = g.expr(mut node.update_expr)
            for mut init_field in node.init_fields {
                init_field.expr = g.expr(mut init_field.expr)
            }
            g.inside_struct_init = old_inside_struct_init
        }
        ast.TypeNode {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.TypeNode{
                    ...node
                    typ:  g.unwrap_generic(node.typ)
                    stmt: g.stmt(mut node.stmt)
                })
            }
            node.stmt = g.stmt(mut node.stmt)
        }
        ast.TypeOf {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.TypeOf{
                    ...node
                    typ:  g.unwrap_generic(node.typ)
                    expr: g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        ast.UnsafeExpr {
            if g.cur_concrete_types.len > 0 {
                return ast.Expr(ast.UnsafeExpr{
                    ...node
                    expr: g.expr(mut node.expr)
                })
            }
            node.expr = g.expr(mut node.expr)
        }
        else {}
    }

    return node
}

fn (mut g Generics) sql_query_data_items(items []ast.SqlQueryDataItem) []ast.SqlQueryDataItem {
    mut new_items := []ast.SqlQueryDataItem{cap: items.len}
    for item in items {
        mut item_copy := item
        new_items << g.sql_query_data_item(mut item_copy)
    }
    return new_items
}

fn (mut g Generics) sql_query_data_item(mut item ast.SqlQueryDataItem) ast.SqlQueryDataItem {
    match mut item {
        ast.SqlQueryDataLeaf {
            item.expr = g.expr(mut item.expr)
        }
        ast.SqlQueryDataIf {
            for mut branch in item.branches {
                branch.cond = g.expr(mut branch.cond)
                branch.items = g.sql_query_data_items(branch.items)
            }
        }
    }

    return item
}

fn (mut g Generics) unwrap_generic(typ ast.Type) ast.Type {
    if typ.has_flag(.generic) {
        if g.cur_fn != unsafe { nil } && g.cur_fn.generic_names.len > 0 {
            if t_typ := g.table.convert_generic_type(typ, g.cur_fn.generic_names,
                g.cur_concrete_types)
            {
                return t_typ
            }
        }
        if g.inside_struct_init && g.cur_struct_init_node != unsafe { nil } {
            if g.cur_struct_init_node.typ != 0 {
                sym := g.table.sym(g.cur_struct_init_node.typ)
                if sym.info is ast.Struct {
                    if sym.info.generic_types.len > 0 {
                        generic_names := sym.info.generic_types.map(g.table.sym(it).name)
                        if t_typ := g.table.convert_generic_type(typ, generic_names,
                            g.cur_struct_init_node.generic_types.map(g.unwrap_generic(it)))
                        {
                            return t_typ
                        }
                    }
                }
            }
        } else if g.table.sym(typ).kind == .struct {
            // resolve selector `a.foo` where `a` is struct[T] on non generic function
            sym := g.table.sym(typ)
            if sym.info is ast.Struct {
                if sym.info.generic_types.len > 0 {
                    generic_names := sym.info.generic_types.map(g.table.sym(it).name)
                    if t_typ := g.table.convert_generic_type(typ, generic_names,
                        sym.info.concrete_types)
                    {
                        return t_typ
                    }

                    if t_typ := g.table.convert_generic_type(typ, generic_names,
                        g.cur_concrete_types)
                    {
                        return t_typ
                    }
                }
            }
        }
    }
    return typ
}