// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
@[has_globals]
module ast

import v.cflag
import v.util
import v.token

@[heap; minify]
pub struct UsedFeatures {
pub mut:
    dump              bool            // filled in by markused
    anon_fn           bool            // fn () { }
    auto_str          bool            // auto str fns
    auto_str_ptr      bool            // auto str fns for ptr type
    auto_str_arr      bool            // auto str fns for array
    arr_prepend       bool            // arr.prepend()
    arr_insert        bool            // arr.insert()
    arr_first         bool            // arr.first()
    arr_last          bool            // arr.last()
    arr_pop_left      bool            // arr.pop_left()
    arr_pop           bool            // arr.pop()
    arr_delete        bool            // arr.delete()
    arr_reverse       bool            // arr.reverse()
    arr_map           bool            // []map[key]value
    print_options     bool            // print option type
    safe_int          bool            // needs safe int comparison
    print_types       map[int]bool    // print() idx types
    used_fns          map[string]bool // filled in by markused
    used_consts       map[string]bool // filled in by markused
    used_globals      map[string]bool // filled in by markused
    used_syms         map[int]bool    // filled in by markused
    referenced_fns    map[string]bool // filled in by the checker
    referenced_consts map[string]bool // filled in by the checker
    used_veb_types    []Type          // veb context types, filled in by checker
    used_maps         int             // how many times maps were used, filled in by markused
    used_none         int             // how many times `none` was used, filled in by markused
    used_closures     int             // number of used closures, either directly with `fn [state] () {}`, or indirectly (though `instance.method` promotions)
    // json             bool            // json is imported
    comptime_calls map[string]bool // resolved name to call on comptime
    comptime_syms  map[Type]bool   // resolved syms (generic)
    //
    used_attr_noreturn bool // @[noreturn]
    used_attr_hidden   bool // @[hidden]
    used_attr_weak     bool // @[weak]
}

@[unsafe]
pub fn (mut uf UsedFeatures) free() {
    unsafe {
        uf.print_types.free()
        uf.used_fns.free()
        uf.used_consts.free()
        uf.used_globals.free()
        uf.referenced_fns.free()
        uf.referenced_consts.free()
        uf.used_veb_types.free()
    }
}

@[heap; minify]
pub struct Table {
mut:
    parsing_type string // name of the type to enable recursive type parsing
pub mut:
    type_symbols       []&TypeSymbol
    type_idxs          map[string]int
    fns                map[string]Fn
    iface_types        map[string][]Type
    dumps              map[int]string // needed for efficiently generating all _v_dump_expr_TNAME() functions
    imports            []string       // List of all imports
    modules            []string       // Topologically sorted list of all modules registered by the application
    global_scope       &Scope = unsafe { nil }
    cflags             []cflag.CFlag
    redefined_fns      []string
    fn_generic_types   map[string][][]Type // for generic functions
    interfaces         map[int]InterfaceDecl
    sumtypes           map[int]SumTypeDecl
    cmod_prefix        string // needed for ast.type_to_str(Type) while vfmt; contains `os.`
    is_fmt             bool
    used_features      &UsedFeatures = &UsedFeatures{} // filled in by the builder via markused module, when pref.skip_unused = true;
    veb_res_idx_cache  int // Cache of `veb.Result` type
    veb_ctx_idx_cache  int // Cache of `veb.Context` type
    panic_handler      FnPanicHandler = default_table_panic_handler
    panic_userdata     voidptr        = unsafe { nil } // can be used to pass arbitrary data to panic_handler;
    panic_npanics      int
    cur_fn             &FnDecl     = unsafe { nil } // previously stored in Checker.cur_fn and Gen.cur_fn
    cur_lambda         &LambdaExpr = unsafe { nil } // current lambda node
    cur_concrete_types []Type // current concrete types, e.g. [int, string]
    gostmts            int    // how many `go` statements there were in the parsed files.
    // When table.gostmts > 0, __VTHREADS__ is defined, which can be checked with `$if threads {`
    enum_decls        map[string]EnumDecl
    vls_info          map[string]VlsInfo
    module_deprecated map[string]bool
    module_attrs      map[string][]Attr // module attributes
    builtin_pub_fns   map[string]bool
    pointer_size      int
    // cache for type_to_str_using_aliases
    cached_type_to_str shared map[u64]string
    // counters and maps for anon structs and unions, to avoid name conflicts.
    anon_struct_names   map[string]int // anon struct name -> struct sym idx
    anon_struct_counter int
    anon_union_names    map[string]int // anon union name -> union sym idx
    anon_union_counter  int
    comptime_is_true    map[string]ComptTimeCondResult // The evaluate cond results for different generic types combination, such as `comptime_is_true['T=int,X=string|main.v|pos ...'] = {true, '!DEFINED(WINDOWS)'}`
    new_int             bool              // use 64bit/32bit platform dependent `int`
    new_int_fmt_fix     bool              // vfmt will fix `int` to `i32`
    export_names        map[string]string // @[export] names
    filelist            []string          // all files list
}

pub struct ComptTimeCondResult {
pub mut:
    val   bool
    c_str string
}

pub struct VlsInfo {
pub mut:
    pos token.Pos
    doc string // documentation
}

// used by vls to avoid leaks
// TODO: remove manual memory management
@[unsafe]
pub fn (mut t Table) free() {
    unsafe {
        for s in t.type_symbols {
            s.free()
        }
        t.type_symbols.free()
        t.type_idxs.free()
        t.fns.free()
        t.dumps.free()
        t.imports.free()
        t.modules.free()
        t.cflags.free()
        t.redefined_fns.free()
        t.fn_generic_types.free()
        t.cmod_prefix.free()
        t.used_features.free()
    }
}

pub const fn_type_escape_seq = ['...', 'variadic_', '&', 'ref_', '[', '_T_', ']', '', ', ', '_',
    ',', '_', '(', '_', ')', '', ' ', '_', '?', 'option_', '!', 'result_', '|', '_or_', '<', '_',
    '>', '']
pub const map_cname_escape_seq = ['[', '_T_', ', ', '_', ']', '']

pub type FnPanicHandler = fn (&Table, string)

fn default_table_panic_handler(_t &Table, message string) {
    panic(message)
}

pub fn (t &Table) panic(message string) {
    mut mt := unsafe { &Table(t) }
    mt.panic_npanics++
    t.panic_handler(t, message)
}

pub fn new_table() &Table {
    mut t := &Table{
        global_scope: &Scope{
            parent: unsafe { nil }
        }
        cur_fn:       unsafe { nil }
    }
    t.register_builtin_type_symbols()
    t.is_fmt = true
    global_table = t
    return t
}

__global global_table = &Table(unsafe { nil })

// used to compare fn's & for naming anon fn's
pub fn (t &Table) fn_type_signature(f &Fn) string {
    mut sig := ''
    for i, arg in f.params {
        sig += t.fn_type_signature_part(f, i, arg)
        if i < f.params.len - 1 {
            sig += '_'
        }
    }
    if f.is_c_variadic {
        if sig.len > 0 {
            sig += '_'
        }
        sig += 'c_variadic'
    }
    if f.return_type != 0 && f.return_type != void_type {
        sig += '__${util.no_dots(t.type_to_str(f.return_type)).replace_each(fn_type_escape_seq)}'
    }
    return sig
}

fn (t &Table) fn_type_signature_part(f &Fn, i int, arg Param) string {
    mut typ := arg.typ
    mut sig := ''
    if arg.is_mut {
        if typ.is_ptr() {
            typ = typ.deref()
        }
        sig += 'mut '
    }
    if i == f.params.len - 1 && f.is_variadic && !f.is_c_variadic {
        sig += '...'
    }
    sig += t.type_to_str(typ)
    return util.no_dots(sig).replace_each(fn_type_escape_seq)
}

// fn_type_source_signature generates the signature of a function which looks like in the V source
pub fn (t &Table) fn_type_source_signature(f &Fn) string {
    import_aliases := map[string]string{}
    mut sig := '('
    for i, arg in f.params {
        mut typ := arg.typ
        if arg.is_mut {
            if typ.is_ptr() {
                typ = typ.deref()
            }
            sig += 'mut '
        }
        // Note: arg name is only added for fmt, else it would causes errors with generics
        if t.is_fmt && arg.name != '' {
            sig += '${arg.name} '
        }
        if i == f.params.len - 1 && f.is_variadic && !f.is_c_variadic {
            sig += '...'
        }
        sig += t.type_to_str_using_aliases(typ, import_aliases)
        if i < f.params.len - 1 {
            sig += ', '
        }
    }
    if f.is_c_variadic {
        if f.params.len > 0 {
            sig += ', '
        }
        sig += '...'
    }
    sig += ')'
    if f.return_type == ovoid_type {
        sig += ' ?'
    } else if f.return_type == rvoid_type {
        sig += ' !'
    } else if f.return_type != void_type && f.return_type != 0 {
        sig += ' ${t.type_to_str_using_aliases(f.return_type, import_aliases)}'
    }
    return sig
}

pub fn (t &Table) is_same_method(f &Fn, func &Fn) string {
    if f.return_type != func.return_type {
        s := t.type_to_str(f.return_type)
        return 'expected return type `${s}`'
    }
    if f.params.len != func.params.len {
        return 'expected ${f.params.len} parameter(s), not ${func.params.len}'
    }

    // interface name() other mut name() : error

    for i in 0 .. f.params.len {
        // don't check receiver for `.typ`
        has_unexpected_type := i > 0
            && t.unaliased_type(f.params[i].typ) != t.unaliased_type(func.params[i].typ)
        // temporary hack for JS ifaces
        lsym := t.sym(f.params[i].typ)
        rsym := t.sym(func.params[i].typ)
        if lsym.language == .js && rsym.language == .js {
            return ''
        }
        has_unexpected_sharetype := f.params[i].is_shared != func.params[i].is_shared
            || f.params[i].is_atomic != func.params[i].is_atomic
        has_unexpected_mutability := !f.params[i].is_mut && func.params[i].is_mut

        if has_unexpected_type || has_unexpected_sharetype || has_unexpected_mutability {
            exps := t.type_to_str(f.params[i].typ)
            gots := t.type_to_str(func.params[i].typ)
            if has_unexpected_type {
                return 'expected `${exps}`, not `${gots}` for parameter ${i}'
            } else if has_unexpected_sharetype {
                return 'expected `${t.param_type_with_specifier(f.params[i], i == 0)}`, not `${t.param_type_with_specifier(func.params[i],
                    i == 0)}` for parameter ${i}'
            } else {
                return 'expected `${exps}` which is immutable, not `mut ${gots}`'
            }
        }
    }
    return ''
}

fn (t &Table) param_type_with_specifier(p Param, is_receiver bool) string {
    mut parts := []string{}
    if p.is_mut {
        parts << 'mut'
    }
    if p.is_shared {
        parts << 'shared'
    }
    if p.is_atomic {
        parts << 'atomic'
    }
    mut ptyp := p.typ.clear_flags(.shared_f, .atomic_f)
    if is_receiver && ptyp.is_ptr() {
        ptyp = ptyp.deref()
    }
    parts << t.type_to_str(ptyp)
    return parts.join(' ')
}

// is_compatible_auto_str_method returns true when `method` matches the compiler-generated
// `str() string` signature.
pub fn (t &Table) is_compatible_auto_str_method(method &Fn) bool {
    return method.name == 'str' && method.return_type == string_type && method.params.len == 1
        && !method.params[0].is_mut
}

// type_has_implicit_str_method returns true when `typ` can satisfy `method`
// through the compiler-generated `str() string`.
pub fn (t &Table) type_has_implicit_str_method(typ Type, method &Fn) bool {
    if !t.is_compatible_auto_str_method(method) {
        return false
    }
    if typ.has_option_or_result() {
        return false
    }
    sym := t.sym(typ.clear_flag(.variadic))
    if sym.has_method_with_generic_parent('str') {
        return false
    }
    if sym.kind == .char && typ.nr_muls() == 0 {
        return false
    }
    if sym.kind == .function {
        return false
    }
    if typ.is_any_kind_of_pointer() || typ in voidptr_types || typ in byteptr_types
        || typ in charptr_types || typ == nil_type {
        return true
    }
    match sym.info {
        Alias, Array, ArrayFixed, Enum, FnType, Struct, Map, MultiReturn, SumType, Chan, Thread {
            return sym.name != 'nil'
        }
        else {
            return sym.kind in [.i8, .i16, .i32, .int, .i64, .isize, .u8, .u16, .u32, .u64, .usize,
                .f32, .f64, .rune, .bool, .string, .generic_inst]
        }
    }
}

pub fn (t &Table) find_fn(name string) ?Fn {
    if f := t.fns[name] {
        return f
    }
    return none
}

pub fn (t &Table) known_fn(name string) bool {
    t.find_fn(name) or { return false }
    return true
}

pub fn (mut t Table) register_fn(new_fn Fn) {
    t.fns[new_fn.name] = new_fn
    if new_fn.is_pub && new_fn.mod == 'builtin' {
        t.builtin_pub_fns[new_fn.name] = true
    }
}

pub fn (mut t Table) register_interface(idecl InterfaceDecl) {
    t.interfaces[idecl.typ] = idecl
}

pub fn (mut t Table) register_sumtype(sumtyp SumTypeDecl) {
    t.sumtypes[sumtyp.typ] = sumtyp
}

pub fn (mut t TypeSymbol) register_method(new_fn Fn) int {
    // returns a method index, stored in the ast.FnDecl
    // for faster lookup in the checker's fn_decl method
    t.methods << new_fn
    return t.methods.len - 1
}

pub fn (mut t TypeSymbol) update_method(f Fn) int {
    for i, m in t.methods {
        if m.name == f.name {
            t.methods[i] = f
            return i
        }
    }
    return -1
}

pub fn (t &Table) register_aggregate_method(mut sym TypeSymbol, name string) !Fn {
    if sym.kind != .aggregate {
        t.panic('table.register_aggregate_method: sym.name: ${sym.name}, sym.kind: ${sym.kind} is not an aggregate, name: ${name}')
    }
    agg_info := sym.info as Aggregate
    // an aggregate always has at least 2 types
    mut found_once := false
    mut new_fn := Fn{}
    for typ in agg_info.types {
        ts := t.sym(typ)
        if type_method := ts.find_method(name) {
            if !found_once {
                found_once = true
                new_fn = type_method
            } else if !new_fn.method_equals(type_method) {
                return error('method `${t.type_to_str(typ)}.${name}` signature is different')
            }
        } else {
            return error('unknown method: `${t.type_to_str(typ)}.${name}`')
        }
    }
    // register the method in the aggregate, so lookup is faster next time
    sym.register_method(new_fn)
    return new_fn
}

pub fn (t &Table) has_method(s &TypeSymbol, name string) bool {
    t.find_method(s, name) or { return false }
    return true
}

// get_type_methods returns methods available on `typ`.
// For aliases, it includes alias-defined methods first, then inherited parent methods.
pub fn (t &Table) get_type_methods(typ Type) []Fn {
    mut ts := t.sym(typ)
    mut methods := ts.get_methods()
    if ts.kind != .alias {
        return methods
    }
    mut seen_method_names := map[string]bool{}
    for method in methods {
        seen_method_names[method.name] = true
    }
    for ts.parent_idx != 0 {
        ts = t.type_symbols[ts.parent_idx]
        for method in ts.get_methods() {
            if method.name !in seen_method_names {
                methods << method
                seen_method_names[method.name] = true
            }
        }
    }
    return methods
}

// find_method searches from current type up through each parent looking for method
pub fn (t &Table) find_method(s &TypeSymbol, name string) !Fn {
    mut ts := unsafe { s }
    for {
        if method := ts.find_method(name) {
            return method
        }
        if ts.kind == .generic_inst {
            parent_sym := t.sym(new_type((ts.info as GenericInst).parent_idx))
            if method := parent_sym.find_method_with_generic_parent(name) {
                return method
            }
            return error('unknown method')
        }
        if ts.kind == .aggregate {
            if method := t.register_aggregate_method(mut ts, name) {
                return method
            } else {
                return err
            }
        }
        if ts.parent_idx == 0 {
            // Also try Struct/Interface/SumType parent_type for generic concrete types
            // whose parent_idx is 0 but have parent_type set.
            has_parent_type := (ts.kind == .struct && (ts.info as Struct).parent_type != 0)
                || (ts.kind == .interface && (ts.info as Interface).parent_type != 0)
                || (ts.kind == .sum_type && (ts.info as SumType).parent_type != 0)
            if has_parent_type {
                if method := ts.find_method_with_generic_parent(name) {
                    return method
                }
            }
            break
        }
        ts = t.type_symbols[ts.parent_idx]
    }
    return error('unknown method')
}

@[params]
pub struct GetEmbedsOptions {
pub:
    preceding []Type
}

// get_embeds returns all nested embedded structs
// the hierarchy of embeds is returned as a list
pub fn (t &Table) get_embeds(sym &TypeSymbol, options GetEmbedsOptions) [][]Type {
    mut embeds := [][]Type{}
    unalias_sym := if sym.info is Alias { t.sym(sym.info.parent_type) } else { sym }
    if unalias_sym.info is Struct {
        for embed in unalias_sym.info.embeds {
            embed_sym := t.sym(embed)
            mut preceding := options.preceding.clone()
            preceding << embed
            embeds << t.get_embeds(embed_sym, preceding: preceding)
        }
        if unalias_sym.info.embeds.len == 0 && options.preceding.len > 0 {
            embeds << options.preceding
        }
    }
    return embeds
}

pub fn (t &Table) find_method_from_embeds(sym &TypeSymbol, method_name string) !(Fn, []Type) {
    if sym.info is Struct {
        mut found_methods := []Fn{}
        mut embed_of_found_methods := []Type{}
        for embed in sym.info.embeds {
            embed_sym := t.sym(embed)
            if m := embed_sym.find_method_with_generic_parent(method_name) {
                found_methods << m
                embed_of_found_methods << embed
            } else {
                method, types := t.find_method_from_embeds(embed_sym, method_name) or { continue }
                found_methods << method
                embed_of_found_methods << embed
                embed_of_found_methods << types
            }
        }
        if found_methods.len == 1 {
            return found_methods[0], embed_of_found_methods
        } else if found_methods.len > 1 {
            return error('ambiguous method `${method_name}`')
        }
    } else if sym.info is Interface {
        mut found_methods := []Fn{}
        mut embed_of_found_methods := []Type{}
        for embed in sym.info.embeds {
            embed_sym := t.sym(embed)
            if m := embed_sym.find_method_with_generic_parent(method_name) {
                found_methods << m
                embed_of_found_methods << embed
            } else {
                method, types := t.find_method_from_embeds(embed_sym, method_name) or { continue }
                found_methods << method
                embed_of_found_methods << embed
                embed_of_found_methods << types
            }
        }
        if found_methods.len == 1 {
            return found_methods[0], embed_of_found_methods
        } else if found_methods.len > 1 {
            return error('ambiguous method `${method_name}`')
        }
    } else if sym.info is Aggregate {
        for typ in sym.info.types {
            agg_sym := t.sym(typ)
            method, embed_types := t.find_method_from_embeds(agg_sym, method_name) or { continue }
            if embed_types.len != 0 {
                return method, embed_types
            }
        }
    }
    return error('')
}

// find_method_with_embeds searches for a given method, also looking through embedded fields
pub fn (t &Table) find_method_with_embeds(sym &TypeSymbol, method_name string) !Fn {
    if func := t.find_method(sym, method_name) {
        return func
    } else {
        // look for embedded field
        func, _ := t.find_method_from_embeds(sym, method_name) or { return err }
        return func
    }
}

// find_enum_field_val finds the possible int value from the enum name and enum field
// (returns `none` if the value cannot be resolved at compile time)
pub fn (t &Table) find_enum_field_val(name string, field_ string) ?i64 {
    mut val := i64(0)
    enum_decl := t.enum_decls[name]
    mut enum_vals := []i64{}
    for field in enum_decl.fields {
        if field.name == field_ {
            if field.has_expr {
                if field.expr is IntegerLiteral {
                    val = field.expr.val.i64()
                    break
                }
                return none
            } else {
                if enum_vals.len > 0 {
                    val = enum_vals.last() + 1
                } else {
                    val = 0
                }
                break
            }
        } else {
            if field.has_expr {
                if field.expr is IntegerLiteral {
                    enum_vals << field.expr.val.i64()
                } else {
                    return none
                }
            } else {
                if enum_vals.len > 0 {
                    enum_vals << enum_vals.last() + 1
                } else {
                    enum_vals << 0
                }
            }
        }
    }
    return if enum_decl.is_flag { i64(u64(1) << u64(val)) } else { val }
}

pub fn (t &Table) get_enum_field_names(name string) []string {
    enum_decl := t.enum_decls[name]
    mut field_names := []string{}
    for field in enum_decl.fields {
        field_names << field.name
    }
    return field_names
}

pub fn (t &Table) get_enum_field_vals(name string) []i64 {
    enum_decl := t.enum_decls[name]
    mut enum_vals := []i64{}
    mut last_val := i64(0)
    for field in enum_decl.fields {
        if field.has_expr {
            if field.expr is IntegerLiteral {
                enum_vals << field.expr.val.i64()
                last_val = field.expr.val.i64()
            }
        } else {
            if enum_vals.len > 0 {
                enum_vals << last_val + 1
                last_val++
            } else {
                enum_vals << 0
            }
        }
    }
    return enum_vals
}

pub fn (t &Table) get_embed_methods(sym &TypeSymbol) []Fn {
    mut methods := []Fn{}
    if sym.info is Struct {
        for embed in sym.info.embeds {
            embed_sym := t.sym(embed)
            methods << embed_sym.methods
            methods << t.get_embed_methods(embed_sym)
        }
    }
    return methods
}

fn (t &Table) register_aggregate_field(mut sym TypeSymbol, name string) !StructField {
    if sym.kind != .aggregate {
        t.panic('table.register_aggregate_field: sym.name: ${sym.name}, sym.kind: ${sym.kind} is not an aggregate, name: ${name}')
    }
    mut agg_info := sym.info as Aggregate
    // an aggregate always has at least 2 types
    mut found_once := false
    mut new_field := StructField{}
    for typ in agg_info.types {
        ts := t.sym(typ)
        if type_field := t.find_field(ts, name) {
            if !found_once {
                found_once = true
                new_field = type_field
            } else if new_field.typ != type_field.typ {
                return error('field `${t.type_to_str(typ)}.${name}` type is different')
            }
            new_field = StructField{
                ...new_field
                is_mut: new_field.is_mut && type_field.is_mut
                is_pub: new_field.is_pub && type_field.is_pub
            }
        } else {
            return error('type `${t.type_to_str(typ)}` has no field or method `${name}`')
        }
    }
    agg_info.fields << new_field
    return new_field
}

pub fn (t &Table) struct_has_field(struct_ &TypeSymbol, name string) bool {
    t.find_field(struct_, name) or { return false }
    return true
}

// struct_fields returns all fields including fields from embeds
// use this instead symbol.info.fields to get all fields
pub fn (t &Table) struct_fields(sym &TypeSymbol) []StructField {
    mut fields := []StructField{}
    if sym.info is Struct {
        fields << sym.info.fields
        for embed in sym.info.embeds {
            embed_sym := t.sym(embed)
            fields << t.struct_fields(embed_sym)
        }
    }
    return fields
}

// search from current type up through each parent looking for field
pub fn (t &Table) find_field(s &TypeSymbol, name string) !StructField {
    mut ts := unsafe { s }
    for {
        match mut ts.info {
            Struct {
                if field := ts.info.find_field(name) {
                    return field
                }
            }
            Aggregate {
                if field := ts.info.find_field(name) {
                    return field
                }
                field := t.register_aggregate_field(mut ts, name) or { return err }
                return field
            }
            Interface {
                if field := ts.info.find_field(name) {
                    return field
                }
            }
            GenericInst {
                parent_sym := t.sym(new_type(ts.info.parent_idx))
                if field := t.find_field(parent_sym, name) {
                    match parent_sym.info {
                        Struct, Interface, SumType {
                            mut table := global_table
                            generic_names := parent_sym.info.generic_types.map(t.sym(it).name)
                            if generic_names.len == ts.info.concrete_types.len {
                                mut resolved_field := field
                                if ft := table.convert_generic_type(field.typ, generic_names,
                                    ts.info.concrete_types)
                                {
                                    resolved_field.typ = ft
                                }
                                if fut := table.convert_generic_type(field.unaliased_typ,
                                    generic_names, ts.info.concrete_types)
                                {
                                    resolved_field.unaliased_typ = fut
                                }
                                return resolved_field
                            }
                        }
                        else {}
                    }

                    return field
                }
            }
            SumType {
                t.resolve_common_sumtype_fields(mut ts)
                if field := ts.info.find_sum_type_field(name) {
                    return field
                }
                missing_variants := t.find_missing_variants(ts.info, name)
                return error('field `${name}` does not exist or have the same type in these sumtype `${ts.name}` variants: ${missing_variants}')
            }
            else {}
        }

        if ts.parent_idx == 0 {
            break
        }
        ts = t.type_symbols[ts.parent_idx]
    }
    return error('')
}

// find_field_from_embeds tries to find a field in the nested embeds
pub fn (t &Table) find_field_from_embeds(sym &TypeSymbol, field_name string) !(StructField, []Type) {
    if sym.info is Struct {
        mut found_fields := []StructField{}
        mut embeds_of_found_fields := []Type{}
        for embed in sym.info.embeds {
            embed_sym := t.sym(embed)
            if field := t.find_field(embed_sym, field_name) {
                found_fields << field
                embeds_of_found_fields << embed
            } else {
                field, types := t.find_field_from_embeds(embed_sym, field_name) or { continue }
                found_fields << field
                embeds_of_found_fields << embed
                embeds_of_found_fields << types
            }
        }
        if found_fields.len == 1 {
            return found_fields[0], embeds_of_found_fields
        } else if found_fields.len > 1 {
            return error('ambiguous field `${field_name}`')
        }
    } else if sym.info is Aggregate {
        for typ in sym.info.types {
            agg_sym := t.sym(typ)
            field, embed_types := t.find_field_from_embeds(agg_sym, field_name) or { continue }
            if embed_types.len > 0 {
                return field, embed_types
            }
        }
    } else if sym.info is Alias {
        unalias_sym := t.sym(sym.info.parent_type)
        return t.find_field_from_embeds(unalias_sym, field_name)
    }
    return error('')
}

// find_field_with_embeds searches for a given field, also looking through embedded fields
pub fn (t &Table) find_field_with_embeds(sym &TypeSymbol, field_name string) !StructField {
    if field := t.find_field(sym, field_name) {
        return field
    } else {
        // look for embedded field
        first_err := err
        field, _ := t.find_field_from_embeds(sym, field_name) or { return first_err }
        return field
    }
}

pub fn (t &Table) resolve_common_sumtype_fields(mut sym TypeSymbol) {
    mut info := sym.info as SumType
    if info.found_fields {
        return
    }
    mut field_map := map[string]StructField{}
    mut field_usages := map[string]int{}
    for variant in info.variants {
        mut v_sym := t.final_sym(variant)
        fields := match mut v_sym.info {
            Struct {
                t.struct_fields(v_sym)
            }
            SumType {
                t.resolve_common_sumtype_fields(mut v_sym)
                v_sym.info.fields
            }
            else {
                []StructField{}
            }
        }

        for field in fields {
            if field.name !in field_map {
                field_map[field.name] = field
                field_usages[field.name]++
            } else if field.equals(field_map[field.name]) {
                field_usages[field.name]++
            }
        }
    }
    for field, nr_definitions in field_usages {
        if nr_definitions == info.variants.len {
            info.fields << field_map[field]
        }
    }
    info.found_fields = true
    sym.info = info
    if sym.idx > 0 {
        mut mut_table := unsafe { &Table(t) }
        mut_table.type_symbols[sym.idx].info = info
    }
}

// find_single_field_variant returns a field that exists in exactly one aggregate or sumtype variant.
pub fn (t &Table) find_single_field_variant(sym &TypeSymbol, field_name string) !(Type, StructField, []Type) {
    variants := match sym.info {
        Aggregate { sym.info.types }
        SumType { sym.info.variants }
        else { []Type{} }
    }

    if variants.len == 0 {
        return error('')
    }
    mut found_variant := Type(0)
    mut found_field := StructField{}
    mut found_embed_types := []Type{}
    for variant in variants {
        variant_sym := t.final_sym(variant)
        mut field := StructField{}
        mut embed_types := []Type{}
        if f := t.find_field(variant_sym, field_name) {
            field = f
        } else {
            field, embed_types = t.find_field_from_embeds(variant_sym, field_name) or { continue }
        }
        if found_variant != 0 {
            return error('')
        }
        found_variant = variant
        found_field = field
        found_embed_types = embed_types.clone()
    }
    if found_variant == 0 {
        return error('')
    }
    return found_variant, found_field, found_embed_types
}

@[inline]
pub fn (t &Table) find_type(name string) Type {
    return idx_to_type(t.type_idxs[name])
}

@[inline]
pub fn (t &Table) find_type_idx(name string) int {
    return t.type_idxs[name]
}

@[inline]
pub fn (t &Table) find_type_idx_fn_scoped(name string, scope &Scope) int {
    if scope != unsafe { nil } {
        idx := t.type_idxs['_${name}_${scope.start_pos}']
        if idx != 0 {
            return idx
        }
    }
    return t.type_idxs[name]
}

@[inline]
pub fn (t &Table) find_sym(name string) ?&TypeSymbol {
    idx := t.type_idxs[name]
    if idx > 0 {
        return t.type_symbols[idx]
    }
    return none
}

@[inline]
pub fn (t &Table) find_sym_and_type_idx(name string) (&TypeSymbol, int) {
    idx := t.type_idxs[name]
    if idx > 0 {
        return t.type_symbols[idx], idx
    }
    return invalid_type_symbol, idx
}

pub const invalid_type_symbol = &TypeSymbol{
    idx:        invalid_type_idx
    parent_idx: invalid_type_idx
    language:   .v
    mod:        'builtin'
    kind:       .placeholder
    name:       'InvalidType'
    cname:      'InvalidType'
    is_builtin: false
}

@[inline]
pub fn (t &Table) sym_by_idx(idx int) &TypeSymbol {
    return t.type_symbols[idx]
}

@[direct_array_access]
pub fn (t &Table) sym(typ Type) &TypeSymbol {
    idx := typ.idx()
    if idx > 0 && idx < t.type_symbols.len {
        return t.type_symbols[idx]
    }
    if idx == 0 || idx == 65535 || typ == invalid_type {
        // invalid_type and idx=0 are used as sentinels during generic type resolution;
        // return a safe placeholder instead of panicking.
        return invalid_type_symbol
    }
    // this should never happen
    t.panic('table.sym: invalid type (typ=${typ} idx=${idx}). Compiler bug. This should never happen. Please report the bug using `v bug file.v`.
')
    return invalid_type_symbol
}

// final_sym follows aliases until it gets to a "real" Type
@[direct_array_access]
pub fn (t &Table) final_sym(typ Type) &TypeSymbol {
    mut idx := typ.idx()
    if idx > 0 && idx < t.type_symbols.len {
        cur_sym := t.type_symbols[idx]
        if cur_sym.info is Alias {
            idx = cur_sym.info.parent_type.idx()
        }
        return t.type_symbols[idx]
    }
    if idx == 0 {
        return invalid_type_symbol
    }
    // this should never happen
    t.panic('table.final_sym: invalid type (typ=${typ} idx=${idx}). Compiler bug. This should never happen. Please report the bug using `v bug file.v`.')
    return invalid_type_symbol
}

// final_type returns the underlying type, if the final type is an Enum it returns the enum defined type (int one) otherwise the aliased/real type is returned
pub fn (t &Table) final_type(typ Type) Type {
    mut idx := typ.idx()
    if idx > 0 && idx < t.type_symbols.len {
        cur_sym := t.type_symbols[idx]
        if cur_sym.info is Alias {
            idx = cur_sym.info.parent_type.idx()
            aliased_sym := t.type_symbols[idx]
            if aliased_sym.info is Enum {
                return aliased_sym.info.typ
            }
            return cur_sym.info.parent_type
        } else if cur_sym.info is Enum {
            return cur_sym.info.typ
        }
    }
    return typ
}

@[inline]
pub fn (t &Table) get_type_name(typ Type) string {
    return t.sym(typ).name
}

@[inline]
pub fn (t &Table) get_final_type_name(typ Type) string {
    return t.final_sym(typ).name
}

@[inline]
pub fn (t &Table) unalias_num_type(typ Type) Type {
    sym := t.sym(typ)
    if sym.info is Alias {
        if sym.info.parent_type <= char_type && sym.info.parent_type >= void_type {
            return sym.info.parent_type
        }
    }
    return typ
}

@[inline]
pub fn (t &Table) unaliased_type(typ Type) Type {
    sym := t.sym(typ)
    if sym.info is Alias {
        return sym.info.parent_type
    }
    return typ
}

// fully_unaliased_type unwraps alias chains while preserving pointer indirections and flags.
@[inline]
pub fn (t &Table) fully_unaliased_type(typ Type) Type {
    mut unaliased := typ
    mut extra_flags := u32(typ) & 0xff00_0000
    for {
        sym := t.sym(unaliased)
        if sym.info is Alias {
            parent_typ := sym.info.parent_type
            unaliased = Type(u32(parent_typ.set_nr_muls(parent_typ.nr_muls() + unaliased.nr_muls())) | extra_flags)
            extra_flags |= u32(unaliased) & 0xff00_0000
            continue
        }
        return unaliased
    }
    return unaliased
}

// update_sym_by_idx replaces the symbol on the `existing_idx`, with the new `sym`
pub fn (mut t Table) update_sym_by_idx(existing_idx int, sym &TypeSymbol) {
    t.delete_cached_type_to_str(idx_to_type(existing_idx), 0)
    t.type_symbols[existing_idx] = &TypeSymbol{
        ...sym
        idx:   existing_idx
        size:  -1 // enforce recalculation of the size, for future t.type_size(idx) calls
        align: -1
    }
    for mut esym in t.type_symbols {
        if esym.size != -1 && esym.info is Alias && esym.info.parent_type == existing_idx {
            // make sure to force recalculation, if t.type_size(idx) on an already existing alias is called again:
            esym.size = -1
            esym.align = -1
        }
    }
}

fn (mut t Table) promote_placeholder_generic_children(parent_idx int, sym TypeSymbol) {
    parent_generic_types := match sym.info {
        Struct { sym.info.generic_types }
        Interface { sym.info.generic_types }
        SumType { sym.info.generic_types }
        else { []Type{} }
    }

    for i, child in t.type_symbols {
        if child.kind != .placeholder || child.parent_idx != parent_idx
            || child.generic_types.len == 0 {
            continue
        }
        if child.generic_types == parent_generic_types {
            // The placeholder child uses the same generic types as the parent struct
            // (e.g. Iter<T> where Iter[T] uses the same T). Redirect it to the parent
            // rather than creating a redundant promoted type.
            t.type_symbols[i] = t.type_symbols[parent_idx]
            continue
        }
        t.update_sym_by_idx(i, &TypeSymbol{
            ...sym
            name:          child.name
            cname:         child.cname
            ngname:        child.ngname
            rname:         if child.rname == '' { sym.name } else { child.rname }
            parent_idx:    parent_idx
            methods:       child.methods
            generic_types: child.generic_types.clone()
        })
    }
}

fn (mut t Table) rewrite_already_registered_symbol(typ TypeSymbol, existing_idx int) int {
    existing_symbol := t.type_symbols[existing_idx]
    $if trace_rewrite_already_registered_symbol ? {
        eprintln('>> rewrite_already_registered_symbol sym: ${typ.name} | existing_idx: ${existing_idx} | existing_symbol: ${existing_symbol.name}')
    }
    if existing_symbol.kind == .placeholder {
        // override placeholder
        ngname := if typ.ngname != '' { typ.ngname } else { strip_generic_params(typ.name) }
        t.type_symbols[existing_idx] = &TypeSymbol{
            ...typ
            ngname:     ngname
            methods:    existing_symbol.methods
            idx:        existing_idx
            is_builtin: existing_symbol.is_builtin
        }
        t.promote_placeholder_generic_children(existing_idx, typ)
        return existing_idx
    }
    // Allow overwriting a generic_inst with a more complete concrete type definition
    // (struct, interface, sumtype). This happens when unwrap_generic_type creates a
    // placeholder that gets prematurely converted to generic_inst by
    // find_or_register_generic_inst during method resolution, before the full type
    // can be registered.
    if existing_symbol.kind == .generic_inst && typ.kind in [.struct, .interface, .sum_type] {
        ngname := if typ.ngname != '' { typ.ngname } else { strip_generic_params(typ.name) }
        t.type_symbols[existing_idx] = &TypeSymbol{
            ...typ
            ngname:     ngname
            methods:    existing_symbol.methods
            idx:        existing_idx
            is_builtin: existing_symbol.is_builtin
        }
        return existing_idx
    }
    // Allow C type aliases to override existing C types (e.g. `type C.WCHAR = u16`
    // on Windows where WCHAR is already registered from system headers).
    // Detect C aliases by the `C.` name prefix, since alias TypeSymbols
    // themselves don't carry .language == .c (only Alias.info.language does):
    if typ.kind == .alias && typ.name.starts_with('C.') && existing_symbol.name.starts_with('C.') {
        t.type_symbols[existing_idx] = &TypeSymbol{
            ...typ
            idx:        existing_idx
            is_builtin: existing_symbol.is_builtin
        }
        return existing_idx
    }
    // Keep concrete C type re-declarations so later modules can resolve their own
    // symbol instead of inheriting the first module's private metadata.
    if existing_symbol.language == .c && typ.language == .c {
        return -2
    }
    // Override the already registered builtin types with the actual
    // v struct declarations in the vlib/builtin module sources:
    if (existing_idx >= string_type_idx && existing_idx <= map_type_idx)
        || existing_idx == error_type_idx {
        if existing_idx == string_type_idx {
            // existing_type := t.type_symbols[existing_idx]
            unsafe {
                *existing_symbol = TypeSymbol{
                    ...typ
                    kind:       existing_symbol.kind
                    idx:        existing_idx
                    is_builtin: existing_symbol.is_builtin
                }
            }
        } else {
            t.type_symbols[existing_idx] = &TypeSymbol{
                ...typ
                idx:        existing_idx
                is_builtin: existing_symbol.is_builtin
            }
        }
        return existing_idx
    }
    return invalid_type_idx
}

@[inline]
pub fn (mut t Table) register_sym(sym TypeSymbol) int {
    mut idx := -2
    $if trace_register_sym ? {
        defer(fn) {
            eprintln('>> register_sym: ${sym.name:-60} | idx: ${idx}')
        }
    }
    sym_name := if sym.info is Struct && sym.info.scoped_name != '' {
        sym.info.scoped_name
    } else {
        sym.name
    }
    mut existing_idx := t.type_idxs[sym_name]
    if existing_idx > 0 {
        idx = t.rewrite_already_registered_symbol(sym, existing_idx)
        if idx != -2 {
            return idx
        }
    }
    if sym.mod == 'main' {
        existing_idx = t.type_idxs[sym_name.trim_string_left('main.')]
        if existing_idx > 0 {
            idx = t.rewrite_already_registered_symbol(sym, existing_idx)
            if idx != -2 {
                return idx
            }
        }
    }
    idx = t.type_symbols.len
    t.type_symbols << &TypeSymbol{
        ...sym
    }
    t.type_symbols[idx].idx = idx
    if t.type_symbols[idx].ngname == '' {
        t.type_symbols[idx].ngname = strip_generic_params(sym.name)
    }
    t.type_idxs[sym_name] = idx
    return idx
}

@[inline]
pub fn (mut t Table) register_enum_decl(enum_decl EnumDecl) {
    t.enum_decls[enum_decl.name] = enum_decl
}

@[inline]
pub fn (mut t Table) register_anon_struct(name string, sym_idx int) {
    t.anon_struct_names[name] = sym_idx
}

@[inline]
pub fn (mut t Table) register_anon_union(name string, sym_idx int) {
    t.anon_union_names[name] = sym_idx
}

pub fn (t &Table) known_type(name string) bool {
    return t.type_idxs[name] != 0 || t.parsing_type == name || name in ['i32', 'byte']
}

@[inline]
pub fn strip_generic_params(name string) string {
    return name.all_before('[')
}

pub fn split_generic_args(args string) []string {
    if args.len == 0 {
        return []string{}
    }
    mut parts := []string{}
    mut start := 0
    mut square_depth := 0
    mut paren_depth := 0
    mut brace_depth := 0
    for i, ch in args {
        match ch {
            `[` {
                square_depth++
            }
            `]` {
                if square_depth > 0 {
                    square_depth--
                }
            }
            `(` {
                paren_depth++
            }
            `)` {
                if paren_depth > 0 {
                    paren_depth--
                }
            }
            `{` {
                brace_depth++
            }
            `}` {
                if brace_depth > 0 {
                    brace_depth--
                }
            }
            `,` {
                if square_depth == 0 && paren_depth == 0 && brace_depth == 0 {
                    parts << args[start..i].trim_space()
                    start = i + 1
                }
            }
            else {}
        }
    }
    parts << args[start..].trim_space()
    return parts.filter(it.len > 0)
}

// start_parsing_type open the scope during the parsing of a type
// where the type name must include the module prefix
pub fn (mut t Table) start_parsing_type(type_name string) {
    t.parsing_type = type_name
}

pub fn (mut t Table) reset_parsing_type() {
    t.parsing_type = ''
}

pub fn (t &Table) known_type_idx(typ Type) bool {
    if typ == 0 {
        return false
    }
    sym := t.sym(typ)
    match sym.kind {
        .placeholder {
            return sym.language != .v || sym.name.starts_with('C.')
        }
        .array {
            if sym.info is Array {
                return t.known_type_idx(sym.info.elem_type)
            }
            return false
        }
        .array_fixed {
            if sym.info is ArrayFixed {
                return t.known_type_idx(sym.info.elem_type)
            }
            return false
        }
        .map {
            if sym.info is Map {
                return t.known_type_idx(sym.info.key_type) && t.known_type_idx(sym.info.value_type)
            }
            return false
        }
        else {}
    }

    return true
}

// supports_map_key_type returns true when C codegen can hash and compare the map key type.
pub fn (t &Table) supports_map_key_type(typ Type) bool {
    if typ == 0 || typ.has_flag(.generic) {
        return true
    }
    mut seen := map[int]bool{}
    return t.supports_map_key_type_in_type(typ.clear_flags(), mut seen)
}

fn (t &Table) supports_map_key_type_in_type(typ Type, mut seen map[int]bool) bool {
    current_typ := typ.clear_flags()
    if current_typ.nr_muls() > 0 {
        return false
    }
    type_idx := current_typ.idx()
    if seen[type_idx] {
        return true
    }
    seen[type_idx] = true
    sym := t.sym(current_typ)
    match sym.kind {
        .alias {
            return t.supports_map_key_type_in_type((sym.info as Alias).parent_type, mut seen)
        }
        .array_fixed {
            return t.supports_map_key_type_in_type((sym.info as ArrayFixed).elem_type, mut seen)
        }
        .u8, .i8, .char, .i16, .u16, .enum, .int, .i32, .u32, .rune, .f32, .voidptr, .u64, .i64,
        .f64, .string {
            return true
        }
        else {
            return false
        }
    }
}

// array_source_name generates the original name for the v source.
// e. g. []int
@[inline]
pub fn (t &Table) array_name(elem_type Type) string {
    elem_type_sym := t.sym(elem_type)
    ptr := if elem_type.is_ptr() { '&'.repeat(elem_type.nr_muls()) } else { '' }
    opt := if elem_type.has_flag(.option) { '?' } else { '' }
    res := if elem_type.has_flag(.result) { '!' } else { '' }
    name := if elem_type_sym.info is Struct && elem_type_sym.info.scoped_name != '' {
        elem_type_sym.info.scoped_name
    } else {
        elem_type_sym.name
    }
    return '[]${opt}${res}${ptr}${name}'
}

@[inline]
pub fn (t &Table) array_cname(elem_type Type) string {
    elem_type_sym := t.sym(elem_type)
    suffix := if elem_type.is_ptr() { '_ptr'.repeat(elem_type.nr_muls()) } else { '' }
    opt := if elem_type.has_flag(.option) { '_option_' } else { '' }
    res := if elem_type.has_flag(.result) { '_result_' } else { '' }
    cname := elem_type_sym.scoped_cname()
    if elem_type_sym.cname.contains('[') {
        type_name := cname.replace_each(map_cname_escape_seq)
        return 'Array_${opt}${res}${type_name}${suffix}'
    } else {
        return 'Array_${opt}${res}${cname}${suffix}'
    }
}

// array_fixed_source_name generates the original name for the v source.
// e. g. [16][8]int
@[inline]
pub fn (t &Table) array_fixed_name(elem_type Type, size int, size_expr Expr) string {
    elem_type_sym := t.sym(elem_type)
    ptr := if elem_type.is_ptr() { '&'.repeat(elem_type.nr_muls()) } else { '' }
    opt := if elem_type.has_flag(.option) { '?' } else { '' }
    res := if elem_type.has_flag(.result) { '!' } else { '' }
    size_str := if size_expr is EmptyExpr || size !in [0, 987654321] {
        size.str()
    } else {
        size_expr.str()
    }
    name := if elem_type_sym.info is Struct && elem_type_sym.info.scoped_name != '' {
        elem_type_sym.info.scoped_name
    } else {
        elem_type_sym.name
    }
    return '[${size_str}]${opt}${res}${ptr}${name}'
}

@[inline]
pub fn (t &Table) array_fixed_cname(elem_type Type, size int) string {
    elem_type_sym := t.sym(elem_type)
    suffix := if elem_type.is_ptr() { '_ptr${elem_type.nr_muls()}' } else { '' }
    opt := if elem_type.has_flag(.option) { '_option_' } else { '' }
    res := if elem_type.has_flag(.result) { '_result_' } else { '' }
    mut cname := elem_type_sym.scoped_cname()
    if elem_type_sym.cname.contains('[') {
        type_name := cname.replace_each(map_cname_escape_seq)
        return 'Array_fixed_${opt}${res}${type_name}${suffix}_${size}'
    } else {
        return 'Array_fixed_${opt}${res}${cname}${suffix}_${size}'
    }
}

@[inline]
pub fn (t &Table) chan_name(elem_type Type, is_mut bool) string {
    elem_type_sym := t.sym(elem_type)
    mut ptr := ''
    if is_mut {
        ptr = 'mut '
    } else if elem_type.is_ptr() {
        ptr = '&'
    }
    return 'chan ${ptr}${elem_type_sym.name}'
}

@[inline]
pub fn (t &Table) chan_cname(elem_type Type, is_mut bool) string {
    elem_type_sym := t.sym(elem_type)
    mut suffix := ''
    if is_mut {
        suffix = '_mut'
    } else if elem_type.is_ptr() {
        suffix = '_ptr'
    }
    type_name := if elem_type_sym.cname.contains('[') {
        elem_type_sym.cname.replace_each(map_cname_escape_seq)
    } else {
        elem_type_sym.cname
    }
    return 'chan_${type_name}' + suffix
}

@[inline]
pub fn (t &Table) promise_name(return_type Type) string {
    if return_type.idx() == void_type_idx {
        return 'Promise[JS.Any, JS.Any]'
    }

    return_type_sym := t.sym(return_type)
    return 'Promise[${return_type_sym.name}, JS.Any]'
}

@[inline]
pub fn (t &Table) promise_cname(return_type Type) string {
    if return_type == void_type {
        return 'Promise_Any_Any'
    }

    return_type_sym := t.sym(return_type)
    return 'Promise_${return_type_sym.name}_Any'
}

@[inline]
pub fn (t &Table) thread_name(return_type Type) string {
    if return_type.idx() == void_type_idx {
        if return_type.has_flag(.option) {
            return 'thread ?'
        } else if return_type.has_flag(.result) {
            return 'thread !'
        } else {
            return 'thread'
        }
    }
    return_type_sym := t.sym(return_type)
    ptr := if return_type.is_ptr() { '&' } else { '' }
    opt := if return_type.has_flag(.option) { '?' } else { '' }
    res := if return_type.has_flag(.result) { '!' } else { '' }
    return 'thread ${opt}${res}${ptr}${return_type_sym.name}'
}

@[inline]
pub fn (t &Table) thread_cname(return_type Type) string {
    if return_type == void_type {
        if return_type.has_flag(.option) {
            return '__v_thread_Option_void'
        } else if return_type.has_flag(.result) {
            return '__v_thread_Result_void'
        } else {
            return '__v_thread'
        }
    }
    return_type_sym := t.sym(return_type)
    suffix := if return_type.is_ptr() { '_ptr' } else { '' }
    opt := if return_type.has_flag(.option) { '_option_' } else { '' }
    res := if return_type.has_flag(.result) { '_result_' } else { '' }
    return '__v_thread_${opt}${res}${return_type_sym.cname}${suffix}'
}

// map_source_name generates the original name for the v source.
// e. g. map[string]int
@[inline]
pub fn (t &Table) map_name(key_type Type, value_type Type) string {
    key_type_sym := t.sym(key_type)
    value_type_sym := t.sym(value_type)
    ptr := if value_type.is_ptr() { '&'.repeat(value_type.nr_muls()) } else { '' }
    opt := if value_type.has_flag(.option) { '?' } else { '' }
    res := if value_type.has_flag(.result) { '!' } else { '' }
    return 'map[${key_type_sym.name}]${opt}${res}${ptr}${value_type_sym.name}'
}

@[inline]
pub fn (t &Table) map_cname(key_type Type, value_type Type) string {
    key_type_sym := t.sym(key_type)
    value_type_sym := t.sym(value_type)
    suffix := if value_type.is_ptr() { '_ptr'.repeat(value_type.nr_muls()) } else { '' }
    opt := if value_type.has_flag(.option) { '_option_' } else { '' }
    res := if value_type.has_flag(.result) { '_result_' } else { '' }
    if value_type_sym.cname.contains('[') {
        type_name := value_type_sym.cname.replace_each(map_cname_escape_seq)
        return 'Map_${key_type_sym.cname}_${opt}${res}${type_name}${suffix}'
    } else {
        return 'Map_${key_type_sym.cname}_${opt}${res}${value_type_sym.cname}${suffix}'
    }
}

pub fn (mut t Table) find_or_register_chan(elem_type Type, is_mut bool) int {
    name := t.chan_name(elem_type, is_mut)
    cname := t.chan_cname(elem_type, is_mut)
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }
    chan_sym := TypeSymbol{
        parent_idx: chan_type_idx
        kind:       .chan
        name:       name
        cname:      cname
        ngname:     strip_generic_params(name)
        info:       Chan{
            elem_type: elem_type
            is_mut:    is_mut
        }
    }
    return t.register_sym(chan_sym)
}

pub fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int {
    name := t.map_name(key_type, value_type)
    cname := t.map_cname(key_type, value_type)
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }
    map_sym := TypeSymbol{
        parent_idx: map_type_idx
        kind:       .map
        name:       name
        cname:      cname
        ngname:     strip_generic_params(name)
        info:       Map{
            key_type:   key_type
            value_type: value_type
        }
    }
    return t.register_sym(map_sym)
}

pub fn (mut t Table) find_or_register_thread(return_type Type) int {
    name := t.thread_name(return_type)
    cname := t.thread_cname(return_type)
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }
    thread_sym := TypeSymbol{
        parent_idx: thread_type_idx
        kind:       .thread
        name:       name
        cname:      cname
        ngname:     strip_generic_params(name)
        info:       Thread{
            return_type: return_type
        }
    }
    return t.register_sym(thread_sym)
}

pub fn (mut t Table) find_or_register_promise(return_type Type) int {
    name := t.promise_name(return_type)

    cname := t.promise_cname(return_type)
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }

    promise_type := TypeSymbol{
        parent_idx: t.type_idxs['Promise']
        kind:       .struct
        name:       name
        cname:      cname
        ngname:     strip_generic_params(name)
        info:       Struct{
            concrete_types: [return_type, t.type_idxs['JS.Any']]
        }
    }

    // register
    return t.register_sym(promise_type)
}

pub fn (mut t Table) find_or_register_array(elem_type Type) int {
    name := t.array_name(elem_type)
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }
    cname := t.array_cname(elem_type)
    // register
    array_type_ := TypeSymbol{
        parent_idx: array_type_idx
        kind:       .array
        name:       name
        cname:      cname
        ngname:     strip_generic_params(name)
        info:       Array{
            nr_dims:   1
            elem_type: elem_type
        }
    }
    return t.register_sym(array_type_)
}

pub fn (mut t Table) find_or_register_array_with_dims(elem_type Type, nr_dims int) int {
    if nr_dims == 1 {
        return t.find_or_register_array(elem_type)
    }
    return t.find_or_register_array(idx_to_type(t.find_or_register_array_with_dims(elem_type,
        nr_dims - 1)))
}

pub fn (mut t Table) find_or_register_array_fixed(elem_type Type, size int, size_expr Expr, is_fn_ret bool) int {
    prefix := if is_fn_ret { '_v_' } else { '' }
    name := prefix + t.array_fixed_name(elem_type, size, size_expr)
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }
    cname := prefix + t.array_fixed_cname(elem_type, size)
    // register
    array_fixed_type := TypeSymbol{
        kind:   .array_fixed
        name:   name
        cname:  cname
        ngname: strip_generic_params(name)
        info:   ArrayFixed{
            elem_type: elem_type
            size:      size
            size_expr: size_expr
            is_fn_ret: is_fn_ret
        }
    }
    return t.register_sym(array_fixed_type)
}

pub fn (mut t Table) find_or_register_multi_return(mr_typs []Type) int {
    mut name := '('
    mut cname := 'multi_return'
    for i, mr_typ in mr_typs {
        mr_type_sym := t.sym(mktyp(mr_typ))
        ref, cref := if mr_typ.is_ptr() { '&', 'ref_' } else { '', '' }
        name += if mr_typ.has_flag(.option) { '?' } else { '' }
        name += if mr_typ.has_flag(.result) { '!' } else { '' }
        name += '${ref}${mr_type_sym.name}'
        cname += if mr_typ.has_flag(.option) { '_option' } else { '' }
        cname += if mr_typ.has_flag(.result) { '_result' } else { '' }
        cname += '_${cref}${mr_type_sym.cname}'
        if i < mr_typs.len - 1 {
            name += ', '
        }
    }
    name += ')'
    // existing
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        return existing_idx
    }
    multireg_sym := TypeSymbol{
        kind:   .multi_return
        name:   name
        cname:  cname
        ngname: strip_generic_params(name)
        info:   MultiReturn{
            types: mr_typs
        }
    }
    return t.register_sym(multireg_sym)
}

pub fn (mut t Table) find_or_register_fn_type(f Fn, is_anon bool, has_decl bool) int {
    name := if f.name == '' { 'fn ${t.fn_type_source_signature(f)}' } else { f.name.clone() }
    cname := if f.name == '' {
        'anon_fn_${t.fn_type_signature(f)}'
    } else {
        util.no_dots(f.name.clone()).replace_each(fn_type_escape_seq)
    }
    anon := f.name == '' || is_anon
    existing_idx := t.type_idxs[name]
    if existing_idx > 0 {
        mut existing_sym := t.type_symbols[existing_idx]
        if existing_sym.kind != .placeholder {
            if mut existing_sym.info is FnType && !has_decl {
                existing_sym.info.has_decl = has_decl
            }
            return existing_idx
        }
    }
    return t.register_sym(
        kind:   .function
        name:   name
        cname:  cname
        ngname: strip_generic_params(name)
        mod:    f.mod
        info:   FnType{
            is_anon:  anon
            has_decl: has_decl
            func:     f
        }
    )
}

pub fn (mut t Table) find_or_register_generic_inst(parent_typ Type, concrete_types []Type) int {
    parent_sym := t.sym(parent_typ)
    expected_generic_types := match parent_sym.info {
        Struct { parent_sym.info.generic_types.len }
        Interface { parent_sym.info.generic_types.len }
        SumType { parent_sym.info.generic_types.len }
        FnType { parent_sym.info.func.generic_names.len }
        else { 0 }
    }

    if expected_generic_types == 0 || concrete_types.len != expected_generic_types {
        return 0
    }
    base_name := if parent_sym.ngname != '' {
        parent_sym.ngname
    } else {
        strip_generic_params(parent_sym.name)
    }
    mut inst_name := base_name + '['
    mut inst_cname := parent_sym.cname + '_T_'
    for i, ct in concrete_types {
        ct_sym := t.sym(ct)
        if ct.nr_muls() > 0 {
            inst_name += '&'.repeat(ct.nr_muls())
            inst_cname += '__ptr__'.repeat(ct.nr_muls())
        }
        inst_name += ct_sym.name
        inst_cname += ct_sym.scoped_cname()
        if i < concrete_types.len - 1 {
            inst_name += ', '
            inst_cname += '_T_'
        }
    }
    inst_name += ']'
    existing_idx := t.type_idxs[inst_name]
    if existing_idx > 0 {
        if t.type_symbols[existing_idx].kind == .placeholder {
            t.type_symbols[existing_idx].kind = .generic_inst
            t.type_symbols[existing_idx].ngname = parent_sym.ngname
            t.type_symbols[existing_idx].mod = parent_sym.mod
            t.type_symbols[existing_idx].info = GenericInst{
                parent_idx:     parent_typ.idx()
                concrete_types: concrete_types
            }
        }
        return existing_idx
    }
    return t.register_sym(
        kind:   .generic_inst
        name:   inst_name
        cname:  inst_cname
        ngname: parent_sym.ngname
        mod:    parent_sym.mod
        is_pub: parent_sym.is_pub
        info:   GenericInst{
            parent_idx:     parent_typ.idx()
            concrete_types: concrete_types
        }
    )
}

fn (t &Table) generic_fn_inst_name(sym &TypeSymbol, concrete_types []Type) string {
    mut name := sym.name + '['
    for i, concrete_type in concrete_types {
        concrete_sym := t.sym(concrete_type)
        if concrete_type.is_ptr() {
            name += '&'.repeat(concrete_type.nr_muls())
        }
        name += concrete_sym.name
        if i < concrete_types.len - 1 {
            name += ', '
        }
    }
    name += ']'
    return name
}

pub fn (mut t Table) add_placeholder_type(name string, cname string, language Language) int {
    mut modname := ''
    if name.contains('.') {
        modname = name.all_before_last('.')
    }
    placeholder_sym := TypeSymbol{
        kind:       .placeholder
        name:       name
        cname:      util.no_dots(cname).replace_each(['&', ''])
        ngname:     strip_generic_params(name)
        language:   language
        mod:        modname
        is_pub:     true
        is_builtin: name in builtins
    }
    return t.register_sym(placeholder_sym)
}

@[inline]
pub fn (t &Table) value_type(typ Type) Type {
    sym := t.final_sym(typ)
    if typ.has_flag(.variadic) {
        // ...string => string
        // return typ.clear_flag(.variadic)
        array_info := sym.info as Array
        return array_info.elem_type
    }
    if sym.kind == .array {
        // Check index type
        info := sym.info as Array
        return info.elem_type
    }
    if sym.kind == .array_fixed {
        info := sym.info as ArrayFixed
        return info.elem_type
    }
    if sym.kind == .map {
        info := sym.info as Map
        return info.value_type
    }
    if sym.kind == .string && typ.is_ptr() {
        // (&string)[i] => string
        return string_type
    }
    if sym.kind in [.byteptr, .string] {
        return u8_type
    }
    if typ.is_ptr() {
        // byte* => byte
        // bytes[0] is a byte, not byte*
        return typ.deref()
    }
    return void_type
}

pub fn (mut t Table) register_fn_generic_types(fn_name string) {
    t.fn_generic_types[fn_name] = [][]Type{}
}

pub fn (mut t Table) register_fn_concrete_types(fn_name string, types []Type) bool {
    if types.len == 0 {
        return false
    }
    mut a := t.fn_generic_types[fn_name] or { return false }
    if types in a {
        return false
    }
    a << types
    t.fn_generic_types[fn_name] = a
    return true
}

// TODO: there is a bug when casting sumtype the other way if its pointer
// so until fixed at least show v (not C) error `x(variant) =  y(SumType*)`
pub fn (t &Table) sumtype_has_variant(parent Type, variant Type, is_as bool) bool {
    parent_sym := t.sym(parent)
    if parent_sym.kind == .sum_type {
        parent_info := parent_sym.info as SumType
        var_sym := t.sym(variant)
        match var_sym.kind {
            .aggregate {
                return t.sumtype_check_aggregate_variant(parent, variant, is_as)
            }
            .alias {
                return t.sumtype_check_alias_variant(parent, variant, is_as)
            }
            .function {
                return t.sumtype_check_function_variant(parent_info, variant, is_as)
            }
            else {
                return t.sumtype_check_variant_in_type(parent_info, variant, is_as)
            }
        }
    }
    return false
}

pub fn (t &Table) sumtype_has_variant_recursive(parent Type, variant Type, is_as bool) bool {
    if t.sumtype_has_variant(parent, variant, is_as) {
        return true
    }
    parent_sym := t.sym(parent)
    if parent_sym.kind != .sum_type || parent_sym.info !is SumType {
        return false
    }
    parent_info := parent_sym.info as SumType
    for parent_variant in parent_info.variants {
        if nested_sumtype := t.sumtype_nested_variant_type(parent_variant) {
            if t.sumtype_has_variant_recursive(nested_sumtype, variant, is_as) {
                return true
            }
        }
    }
    return false
}

pub fn (t &Table) sumtype_matchable_variants(parent Type) []Type {
    mut variants := []Type{}
    mut seen := map[u32]bool{}
    t.collect_sumtype_matchable_variants(parent, mut seen, mut variants)
    return variants
}

pub fn (t &Table) sumtype_missing_variants(parent Type, handled []Type) []Type {
    mut missing := []Type{}
    mut seen := map[u32]bool{}
    t.collect_sumtype_missing_variants(parent, handled, mut seen, mut missing)
    return missing
}

fn (t &Table) collect_sumtype_matchable_variants(parent Type, mut seen map[u32]bool, mut variants []Type) {
    parent_sym := t.sym(parent)
    if parent_sym.kind != .sum_type || parent_sym.info !is SumType {
        return
    }
    parent_info := parent_sym.info as SumType
    for variant in parent_info.variants {
        if u32(variant) !in seen {
            seen[u32(variant)] = true
            variants << variant
        }
        if nested_sumtype := t.sumtype_nested_variant_type(variant) {
            t.collect_sumtype_matchable_variants(nested_sumtype, mut seen, mut variants)
        }
    }
}

fn (t &Table) collect_sumtype_missing_variants(parent Type, handled []Type, mut seen map[u32]bool, mut missing []Type) {
    if t.sumtype_variant_is_handled(parent, handled) {
        return
    }
    if nested_sumtype := t.sumtype_nested_variant_type(parent) {
        nested_sym := t.sym(nested_sumtype)
        if nested_sym.kind == .sum_type && nested_sym.info is SumType {
            nested_info := nested_sym.info as SumType
            for variant in nested_info.variants {
                if t.sumtype_variant_is_handled(variant, handled) {
                    continue
                }
                if nested_variant := t.sumtype_nested_variant_type(variant) {
                    t.collect_sumtype_missing_variants(nested_variant, handled, mut seen, mut
                        missing)
                } else if u32(variant) !in seen {
                    seen[u32(variant)] = true
                    missing << variant
                }
            }
            return
        }
    }
    if u32(parent) !in seen {
        seen[u32(parent)] = true
        missing << parent
    }
}

fn (t &Table) sumtype_variant_is_handled(variant Type, handled []Type) bool {
    for handled_variant in handled {
        if t.same_sumtype_variant(variant, handled_variant, true) {
            return true
        }
    }
    return false
}

fn (t &Table) same_sumtype_variant(expected Type, got Type, is_as bool) bool {
    return expected.idx() == got.idx() && expected.has_flag(.option) == got.has_flag(.option)
        && (!is_as || expected.nr_muls() == got.nr_muls())
}

fn (t &Table) sumtype_nested_variant_type(variant Type) ?Type {
    nested_sumtype := t.fully_unaliased_type(variant)
    if t.sym(nested_sumtype).kind == .sum_type {
        return nested_sumtype
    }
    return none
}

fn (t &Table) sumtype_check_function_variant(parent_info SumType, variant Type, is_as bool) bool {
    variant_fn := (t.sym(variant).info as FnType).func
    variant_fn_sig := t.fn_type_source_signature(variant_fn)

    for v in parent_info.variants {
        v_sym := t.sym(v)
        if v_sym.info is FnType {
            if t.fn_type_source_signature(v_sym.info.func) == variant_fn_sig
                && (!is_as || v.nr_muls() == variant.nr_muls()) {
                return true
            }
        }
    }
    return false
}

fn (t &Table) sumtype_check_variant_in_type(parent_info SumType, variant Type, is_as bool) bool {
    for v in parent_info.variants {
        if t.same_sumtype_variant(v, variant, is_as) {
            return true
        }
    }
    if !is_as {
        for v in parent_info.variants {
            if t.can_implicit_array_cast(variant, v) {
                return true
            }
        }
    }
    return false
}

fn (t &Table) sumtype_check_aggregate_variant(parent_type Type, aggregate_type &Type, is_as bool) bool {
    aggregate_sym := t.sym(aggregate_type).info as Aggregate
    for var_type in aggregate_sym.types {
        if !t.sumtype_has_variant(parent_type, var_type, is_as) {
            return false
        }
    }
    return true
}

fn (t &Table) sumtype_check_alias_variant(parent_type Type, alias_type Type, is_as bool) bool {
    parent_sym := t.sym(parent_type).info as SumType
    if !t.sumtype_check_variant_in_type(parent_sym, alias_type, is_as) {
        alias_info := t.sym(alias_type).info as Alias
        // The alias is an alias or of the same sumtype parent, or one
        // of the SumType variant. e.g: alias of another sum type.
        // https://github.com/vlang/v/issues/14029
        return parent_type == alias_info.parent_type
            || t.sumtype_has_variant(parent_type, alias_info.parent_type, is_as)
    }
    // the alias_type is inside one of the variant of the sum type
    return true
}

pub fn (t &Table) is_sumtype_or_in_variant(parent Type, typ Type) bool {
    if typ == 0 {
        return false
    }
    if t.sym(typ).kind == .sum_type && parent.idx() == typ.idx()
        && parent.nr_muls() == typ.nr_muls() {
        return true
    }
    return t.sumtype_has_variant(parent, typ, false)
}

// can_implicit_array_cast reports whether `got` can be converted to `expected`
// by boxing each array element into the expected interface or sum type.
pub fn (t &Table) can_implicit_array_cast(got Type, expected Type) bool {
    if got == 0 || expected == 0 || got == expected {
        return false
    }
    got_idx := got.idx()
    expected_idx := expected.idx()
    if got_idx == expected_idx {
        return false
    }
    if got_idx > 0 && got_idx < t.type_symbols.len && expected_idx > 0
        && expected_idx < t.type_symbols.len {
        got_kind := t.type_symbols[got_idx].kind
        expected_kind := t.type_symbols[expected_idx].kind
        if (got_kind != .array && got_kind != .alias)
            || (expected_kind != .array && expected_kind != .alias) {
            return false
        }
    }
    got_unaliased := t.unaliased_type(got)
    expected_unaliased := t.unaliased_type(expected)
    got_sym := t.final_sym(got_unaliased)
    expected_sym := t.final_sym(expected_unaliased)
    if got_sym.kind != .array || expected_sym.kind != .array {
        return false
    }
    got_info := got_sym.info as Array
    expected_info := expected_sym.info as Array
    if got_info.nr_dims != expected_info.nr_dims {
        return false
    }
    got_elem_type := t.unaliased_type(got_info.elem_type)
    expected_elem_type := t.unaliased_type(expected_info.elem_type)
    if got_elem_type == expected_elem_type {
        return false
    }
    match t.final_sym(expected_elem_type).kind {
        .sum_type {
            return t.is_sumtype_or_in_variant(expected_elem_type, mktyp(got_elem_type))
        }
        .interface {
            return t.does_type_implement_interface(got_elem_type, expected_elem_type)
        }
        else {
            return false
        }
    }
}

@[inline]
pub fn (t &Table) is_interface_var(var ScopeObject) bool {
    return var is Var && var.orig_type != 0 && t.sym(var.orig_type).kind == .interface
        && t.sym(var.smartcasts.last()).kind != .interface
}

@[inline]
pub fn (t &Table) is_interface_smartcast(var ScopeObject) bool {
    return var is Var && var.orig_type != 0 && t.sym(var.orig_type).kind == .interface
        && var.smartcasts.len > 0
}

// only used for debugging V compiler type bugs
pub fn (t &Table) known_type_names() []string {
    mut res := []string{cap: t.type_idxs.len}
    for _, idx in t.type_idxs {
        typ := idx_to_type(idx)
        // Skip `int_literal_type_idx` and `float_literal_type_idx` because they shouldn't be visible to the User.
        if idx !in [0, int_literal_type_idx, float_literal_type_idx] && t.known_type_idx(typ) {
            tsym := t.sym(typ)
            if tsym.kind !in [.function, .chan] {
                res << t.type_to_str(typ)
            } else if tsym.info is Chan && t.sym(tsym.info.elem_type).kind != .placeholder {
                res << t.type_to_str(tsym.info.elem_type)
            }
        }
    }
    return res
}

// has_deep_child_no_ref returns true if type is struct and has any child or nested child with the type of the given name.
// The given name consists of module and name (`mod.Name`).
// It ignores children that are references, including aliases to references.
pub fn (t &Table) has_deep_child_no_ref(ts &TypeSymbol, name string) bool {
    mut seen := map[string]bool{}
    return t.has_deep_child_no_ref_in_sym(ts, name, mut seen)
}

fn (t &Table) has_deep_child_no_ref_in_sym(ts &TypeSymbol, name string, mut seen map[string]bool) bool {
    if ts.kind == .placeholder || ts.name in seen {
        return false
    }
    seen[ts.name] = true
    match ts.info {
        Struct {
            for field in ts.info.fields {
                sym := t.sym(field.typ)
                if !field.typ.is_ptr() && !field.typ.has_flag(.option) && (sym.name == name
                    || (sym.info is Struct && t.has_deep_child_no_ref_in_sym(sym, name, mut seen))) {
                    return true
                }
            }
            for embed in ts.info.embeds {
                if t.has_deep_child_no_ref_in_embed(embed, name, mut seen) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (t &Table) has_deep_child_no_ref_in_embed(typ Type, name string, mut seen map[string]bool) bool {
    unaliased_typ := t.unaliased_type(typ)
    if unaliased_typ.is_ptr() || unaliased_typ.has_flag(.option) {
        return false
    }
    sym := t.sym(unaliased_typ)
    if sym.name == name {
        return true
    }
    return t.has_deep_child_no_ref_in_sym(sym, name, mut seen)
}

// complete_interface_check does a MxN check for all M interfaces vs all N types, to determine what types implement what interfaces.
// It short circuits most checks when an interface can not possibly be implemented by a type.
pub fn (mut t Table) complete_interface_check() {
    util.timing_start(@METHOD)
    defer {
        util.timing_measure(@METHOD)
    }
    for tk, mut tsym in t.type_symbols {
        tk_typ := idx_to_type(tk)
        if tsym.kind != .struct {
            continue
        }
        for _, mut idecl in t.interfaces {
            if idecl.typ == 0 {
                continue
            }
            // empty interface only generate type cast functions of the current module
            if idecl.methods.len == 0 && idecl.fields.len == 0 && tsym.mod != t.sym(idecl.typ).mod {
                continue
            }
            if t.does_type_implement_interface(tk_typ, idecl.typ) {
                $if trace_types_implementing_each_interface ? {
                    eprintln('>>> tsym.mod: ${tsym.mod} | tsym.name: ${tsym.name} | tk: ${tk} | idecl.name: ${idecl.name} | idecl.typ: ${idecl.typ}')
                }
                if idecl.name !in t.iface_types {
                    t.iface_types[idecl.name] = []Type{}
                }
                t.iface_types[idecl.name] << tk_typ
            }
        }
    }
    // For empty interfaces, propagate concrete types from all other interfaces
    // into the empty interface's variant list. Empty interfaces can be assigned
    // from any interface (e.g. `IError` -> `EmptyIface{}`); at runtime the empty
    // interface will hold the source interface's dynamic type, so the empty
    // interface must have cast functions for each possible concrete variant.
    mut empty_iface_typs := []Type{}
    for _, idecl in t.interfaces {
        if idecl.typ == 0 {
            continue
        }
        if idecl.methods.len == 0 && idecl.fields.len == 0 {
            empty_iface_typs << idecl.typ
        }
    }
    for iface_typ in empty_iface_typs {
        mut iface_sym := t.sym(iface_typ)
        if iface_sym.info !is Interface {
            continue
        }
        mut iface_info := iface_sym.info as Interface
        mut collected_types := []Type{}
        mut seen_cnames := map[string]bool{}
        for existing in iface_info.types {
            existing_sym := t.sym(mktyp(existing))
            seen_cnames[existing_sym.cname] = true
        }
        for _, other_sym in t.type_symbols {
            if other_sym.kind != .interface || other_sym.idx == iface_sym.idx {
                continue
            }
            if other_sym.info !is Interface {
                continue
            }
            other_info := other_sym.info as Interface
            for variant in other_info.types {
                mk_variant := mktyp(variant)
                variant_sym := t.sym(mk_variant)
                if variant_sym.kind != .struct {
                    continue
                }
                if variant_sym.cname in seen_cnames {
                    continue
                }
                seen_cnames[variant_sym.cname] = true
                collected_types << mk_variant
            }
        }
        if collected_types.len > 0 {
            iface_info.types << collected_types
            iface_sym.info = iface_info
            if iface_sym.name !in t.iface_types {
                t.iface_types[iface_sym.name] = []Type{}
            }
            mut target_variants := t.iface_types[iface_sym.name].clone()
            for variant in collected_types {
                if variant !in target_variants {
                    target_variants << variant
                }
            }
            t.iface_types[iface_sym.name] = target_variants
        }
    }
}

// bitsize_to_type returns a type corresponding to the bit_size
// Examples:
//
// `8 > i8`
//
// `32 > int`
//
// `123 > panic()`
//
// `128 > [16]u8`
//
// `608 > [76]u8`
pub fn (mut t Table) bitsize_to_type(bit_size int) Type {
    match bit_size {
        8 {
            return i8_type
        }
        16 {
            return i16_type
        }
        32 {
            return i32_type
        }
        64 {
            return i64_type
        }
        else {
            if bit_size % 8 != 0 { // there is no way to do `i2131(32)` so this should never be reached
                t.panic('table.bitsize_to_type: compiler bug: bitsizes must be multiples of 8, but passed bit_size is ${bit_size}')
            }
            return new_type(t.find_or_register_array_fixed(u8_type, bit_size / 8, empty_expr, false))
        }
    }
}

pub fn (t &Table) interface_inherits_interface(typ Type, inter_typ Type) bool {
    if typ.idx() == inter_typ.idx() {
        return true
    }
    sym := t.sym(typ)
    if sym.kind != .interface || sym.info !is Interface {
        return false
    }
    info := sym.info as Interface
    for embed in info.embeds {
        if embed.idx() == inter_typ.idx() || t.interface_inherits_interface(embed, inter_typ) {
            return true
        }
    }
    if info.parent_type != 0 && info.parent_type.idx() != 0 && info.parent_type != typ {
        parent_sym := t.sym(info.parent_type)
        if parent_sym.kind == .interface
            && t.interface_inherits_interface(info.parent_type, inter_typ) {
            return true
        }
    }
    return false
}

pub fn (t &Table) does_type_implement_interface(typ Type, inter_typ Type) bool {
    if typ.idx() == inter_typ.idx() {
        // same type -> already casted to the interface
        return true
    }
    if inter_typ.idx() == error_type_idx && typ.idx() == none_type_idx {
        // `none` "implements" the Error interface
        return true
    }
    sym := t.sym(typ)
    if sym.language != .v {
        return false
    }
    // generic struct don't generate cast interface fn
    if sym.info is Struct {
        if sym.info.is_generic {
            return false
        }
    }
    mut inter_sym := t.sym(inter_typ)
    if sym.kind == .interface && inter_sym.kind == .interface {
        inter_info := inter_sym.info as Interface
        if inter_info.methods.len == 0 && inter_info.fields.len == 0 && inter_info.embeds.len == 0 {
            return true
        }
        if !t.interface_inherits_interface(typ, inter_typ) {
            return false
        }
    }
    if mut inter_sym.info is Interface {
        attrs := unsafe { t.interfaces[inter_typ].attrs }
        for attr in attrs {
            if attr.name == 'single_impl' {
                return false
            }
        }
        // do not check the same type more than once
        for tt in inter_sym.info.types {
            if tt.idx() == typ.idx() {
                return true
            }
        }
        // verify methods
        for imethod in inter_sym.info.methods {
            if t.is_compatible_auto_str_method(imethod) && typ.nr_muls() == 0 && sym.kind == .char {
                return false
            }
            if method := t.find_method_with_embeds(sym, imethod.name) {
                msg := t.is_same_method(imethod, method)
                if msg.len > 0 {
                    return false
                }
                continue
            }
            match sym.info {
                SumType, Struct, Interface {
                    if method := sym.find_method_with_generic_parent(imethod.name) {
                        msg := t.is_same_method(imethod, method)
                        if msg.len > 0 {
                            return false
                        }
                        continue
                    }
                }
                else {}
            }

            if t.type_has_implicit_str_method(typ, imethod) {
                continue
            }
            return false
        }
        // verify fields
        for ifield in inter_sym.info.fields {
            if ifield.typ == voidptr_type || ifield.typ == nil_type {
                // Allow `voidptr` fields in interfaces for now. (for example
                // to enable .db check in veb)
                if t.struct_has_field(sym, ifield.name) {
                    continue
                } else {
                    return false
                }
            }
            if field := t.find_field_with_embeds(sym, ifield.name) {
                if ifield.typ != field.typ {
                    return false
                } else if ifield.is_mut && !(field.is_mut || field.is_global) {
                    return false
                }
                continue
            }
            return false
        }
        if sym.kind !in [.interface, .aggregate] && typ != voidptr_type && typ != nil_type
            && typ != none_type && !inter_sym.info.types.contains(typ) {
            inter_sym.info.types << typ
        }
        if !inter_sym.info.types.contains(voidptr_type) {
            inter_sym.info.types << voidptr_type
        }
        return true
    }
    return false
}

pub fn (mut t Table) convert_generic_static_type_name(fn_name string, generic_names []string, concrete_types []Type) (Type, string) {
    if index := fn_name.index('__static__') {
        if index > 0 {
            generic_name := fn_name[0..index]
            valid_generic := util.is_generic_type_name(generic_name)
                && generic_name in generic_names
            if valid_generic {
                name_type := t.find_type(generic_name).set_flag(.generic)
                if typ := t.convert_generic_type(name_type, generic_names, concrete_types) {
                    return name_type, '${t.type_to_str(typ)}${fn_name[index..]}'
                }
            }
        }
    }
    return void_type, fn_name
}

// convert_generic_type convert generics to real types (T => int) or other generics type.
pub fn (mut t Table) convert_generic_type(generic_type Type, generic_names []string, to_types []Type) ?Type {
    if generic_names.len != to_types.len {
        return none
    }
    type_idx := generic_type.idx()
    if type_idx == 0 || type_idx >= t.type_symbols.len {
        return none
    }
    mut sym := t.sym(generic_type)
    if sym.name in generic_names {
        index := generic_names.index(sym.name)
        if index >= to_types.len {
            return none
        }
        typ := to_types[index]
        if typ == 0 || typ.idx() >= t.type_symbols.len {
            return none
        }
        mut rtyp := typ.derive_add_muls(generic_type)
        if typ.has_flag(.generic) {
            rtyp = rtyp.set_flag(.generic)
        } else {
            rtyp = rtyp.clear_flag(.generic)
        }
        if !generic_type.has_flag(.result) && typ.has_flag(.option) {
            rtyp = rtyp.set_flag(.option)
            if generic_type.is_ptr() {
                rtyp = rtyp.set_flag(.option_mut_param_t)
            }
        }
        resolved_typ_sym := t.sym(t.fully_unaliased_type(typ))
        if resolved_typ_sym.info is FnType && typ.has_flag(.shared_f) {
            rtyp = rtyp.set_flag(.shared_f)
        }
        if resolved_typ_sym.info is FnType && typ.has_flag(.atomic_f) {
            rtyp = rtyp.set_flag(.atomic_f)
        }
        return rtyp
    }
    match mut sym.info {
        Array {
            dims, elem_type := t.get_array_dims(sym.info)
            if typ := t.convert_generic_type(elem_type, generic_names, to_types) {
                idx := t.find_or_register_array_with_dims(typ, dims)
                if typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        ArrayFixed {
            if typ := t.convert_generic_type(sym.info.elem_type, generic_names, to_types) {
                idx := t.find_or_register_array_fixed(typ, sym.info.size, None{}, false)
                if typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        Chan {
            if typ := t.convert_generic_type(sym.info.elem_type, generic_names, to_types) {
                idx := t.find_or_register_chan(typ, typ.nr_muls() > 0)
                if typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        Thread {
            if typ := t.convert_generic_type(sym.info.return_type, generic_names, to_types) {
                idx := t.find_or_register_thread(typ)
                if typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        FnType {
            mut func := sym.info.func
            mut has_generic := false
            return_type_sym := t.sym(func.return_type)
            if func.return_type.has_flag(.generic)
                || t.generic_type_names(func.return_type).len > 0
                || (return_type_sym.kind == .generic_inst
                && (return_type_sym.info as GenericInst).concrete_types.any(it.has_flag(.generic))) {
                if typ := t.convert_generic_type(func.return_type, generic_names, to_types) {
                    func.return_type = typ
                } else {
                    func.return_type = t.unwrap_generic_type_ex(func.return_type, generic_names,
                        to_types, true)
                }
                if func.return_type.has_flag(.generic)
                    || t.generic_type_names(func.return_type).len > 0 {
                    has_generic = true
                }
            }
            func.params = func.params.clone()
            for mut param in func.params {
                orig_param_type := param.typ
                if typ := t.convert_generic_param_type(param, generic_names, to_types) {
                    param.typ = typ
                }
                if t.sym(param.typ).kind == .placeholder {
                    param.typ =
                        t.unwrap_generic_type_ex(orig_param_type, generic_names, to_types, true)
                }
                if param.typ.has_flag(.generic) || t.generic_type_names(param.typ).len > 0 {
                    has_generic = true
                }
                if param.orig_typ.has_flag(.generic) || t.generic_type_names(param.orig_typ).len > 0 {
                    if otyp := t.convert_generic_type(param.orig_typ, generic_names, to_types) {
                        param.orig_typ = otyp
                    } else {
                        param.orig_typ = t.unwrap_generic_type_ex(param.orig_typ, generic_names,
                            to_types, true)
                    }
                }
            }
            if !sym.info.is_anon && !has_generic {
                inst_name := t.generic_fn_inst_name(sym, to_types)
                idx := t.find_type_idx(inst_name)
                if idx > 0 {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
            func.name = ''
            func.generic_names = []
            idx := t.find_or_register_fn_type(func, true, false)
            if has_generic {
                return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
            } else {
                return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
            }
        }
        GenericInst {
            mut concrete_types := sym.info.concrete_types.clone()
            mut type_changed := false
            for i, concrete_type in concrete_types {
                if typ := t.convert_generic_type(concrete_type, generic_names, to_types) {
                    concrete_types[i] = typ
                    type_changed = true
                }
            }
            if type_changed {
                idx := t.find_or_register_generic_inst(new_type(sym.info.parent_idx),
                    concrete_types)
                if idx > 0 {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        MultiReturn {
            mut types := []Type{}
            mut type_changed := false
            for ret_type in sym.info.types {
                if typ := t.convert_generic_type(ret_type, generic_names, to_types) {
                    types << typ
                    type_changed = true
                } else {
                    types << ret_type
                }
            }
            if type_changed {
                idx := t.find_or_register_multi_return(types)
                if types.any(it.has_flag(.generic)) {
                    return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        Map {
            mut type_changed := false
            mut unwrapped_key_type := sym.info.key_type
            mut unwrapped_value_type := sym.info.value_type
            if typ := t.convert_generic_type(sym.info.key_type, generic_names, to_types) {
                unwrapped_key_type = typ
                type_changed = true
            }
            if typ := t.convert_generic_type(sym.info.value_type, generic_names, to_types) {
                unwrapped_value_type = typ
                type_changed = true
            }
            if type_changed {
                // map[Type]T where T is an alias to map type
                if to_types.len == 1 && sym.info.value_type.has_flag(.generic)
                    && t.type_kind(to_types[0]) == .alias && t.final_sym(to_types[0]).kind == .map {
                    return unwrapped_value_type
                }
                idx := t.find_or_register_map(unwrapped_key_type, unwrapped_value_type)
                if unwrapped_key_type.has_flag(.generic) || unwrapped_value_type.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    return new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        Struct, Interface, SumType {
            if sym.info.is_generic {
                mut nrt := '${sym.name}['
                mut rnrt := '${sym.rname}['
                mut cnrt := '${sym.cname}_T_'
                mut converted_types := []Type{}
                mut t_generic_names := generic_names.clone()
                mut t_to_types := to_types.clone()
                mut has_unresolved_generic := false
                mut type_changed := false
                if sym.generic_types.len > 0 && sym.generic_types.len == sym.info.generic_types.len
                    && sym.generic_types != sym.info.generic_types {
                    t_generic_names = sym.info.generic_types.map(t.sym(it).name)
                    t_to_types = []
                    for t_typ in sym.generic_types {
                        if !t_typ.has_flag(.generic) {
                            t_to_types << t_typ
                        } else {
                            if tt := t.convert_generic_type(t_typ, generic_names, to_types) {
                                t_to_types << tt
                            }
                        }
                    }
                }
                for i in 0 .. sym.info.generic_types.len {
                    if ct := t.convert_generic_type(sym.info.generic_types[i], t_generic_names,
                        t_to_types)
                    {
                        converted_types << ct
                        gts := t.sym(ct)
                        if ct != sym.info.generic_types[i] {
                            type_changed = true
                        }
                        if ct.is_ptr() {
                            nrt += '&'.repeat(ct.nr_muls())
                            cnrt += '__ptr__'.repeat(ct.nr_muls())
                        }
                        nrt += gts.name
                        rnrt += gts.name
                        cnrt += gts.scoped_cname()
                        if i != sym.info.generic_types.len - 1 {
                            nrt += ', '
                            rnrt += ', '
                            cnrt += '_T_'
                        }
                        if ct.has_flag(.generic) {
                            has_unresolved_generic = true
                        }
                    } else {
                        return none
                    }
                }
                if type_changed && converted_types.len == sym.info.generic_types.len {
                    idx := t.find_or_register_generic_inst(new_type(type_idx), converted_types)
                    if idx > 0 {
                        return if has_unresolved_generic {
                            new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                        } else {
                            new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                        }
                    }
                }
                nrt += ']'
                rnrt += ']'
                mut idx := t.type_idxs[nrt]
                if idx == 0 {
                    idx = t.type_idxs[rnrt]
                    if idx == 0 {
                        idx = t.add_placeholder_type(nrt, cnrt, .v)
                    }
                }
                return if has_unresolved_generic {
                    new_type(idx).derive_add_muls(generic_type).set_flag(.generic)
                } else {
                    new_type(idx).derive_add_muls(generic_type).clear_flag(.generic)
                }
            }
        }
        UnknownTypeInfo {
            if sym.name.contains('[') && sym.name.contains(']') {
                base_name := sym.name.all_before_last('[')
                generic_part := sym.name.all_after_last('[').trim_right(']')
                mut converted_args := []string{}
                mut has_generic := false
                mut changed := false
                args := split_generic_args(generic_part)
                for arg in args {
                    if arg in generic_names {
                        idx := generic_names.index(arg)
                        if idx < to_types.len {
                            converted_type := to_types[idx]
                            converted_type_str := t.type_to_str(converted_type)
                            if converted_type_str != arg {
                                converted_args << converted_type_str
                                changed = true
                                if converted_type.has_flag(.generic) {
                                    has_generic = true
                                }
                            } else {
                                converted_args << arg
                            }
                        } else {
                            converted_args << arg
                        }
                    } else {
                        converted_args << arg
                    }
                }
                if changed {
                    new_name := base_name + '[' + converted_args.join(', ') + ']'
                    mut new_idx := t.type_idxs[new_name]
                    if new_idx == 0 {
                        new_idx = t.add_placeholder_type(new_name, util.no_dots(new_name).replace_each([
                            '[',
                            '_T_',
                            ']',
                            '',
                            ', ',
                            '_T_',
                            ',',
                            '_T_',
                            ' ',
                            '',
                        ]), sym.language)
                    }
                    return if has_generic {
                        new_type(new_idx).derive_add_muls(generic_type).set_flag(.generic)
                    } else {
                        new_type(new_idx).derive_add_muls(generic_type).clear_flag(.generic)
                    }
                }
            }
        }
        else {}
    }

    return none
}

fn (mut t Table) lower_mut_param_type(typ Type, orig_typ ...Type) Type {
    // When the pointer came from the generic type argument itself (T=&int),
    // not from the param signature (&T), we need ref() to add one more level.
    orig_was_ptr := orig_typ.len > 0 && orig_typ[0].nr_muls() > 0
    mut lowered := if typ.is_ptr() && !orig_was_ptr {
        typ.ref()
    } else {
        typ.set_nr_muls(1)
    }
    if lowered.has_flag(.option) {
        lowered = lowered.set_flag(.option_mut_param_t)
    }
    return lowered
}

pub fn (mut t Table) convert_generic_param_type(param Param, generic_names []string, to_types []Type) ?Type {
    if param.is_mut && param.orig_typ != 0 && param.orig_typ.has_flag(.generic)
        && to_types.all(!it.has_flag(.generic)) {
        if typ := t.convert_generic_type(param.orig_typ, generic_names, to_types) {
            return t.lower_mut_param_type(typ, param.orig_typ)
        }
    }
    return t.convert_generic_type(param.typ, generic_names, to_types)
}

// type_contains_placeholder returns true if the given type or any of its inner
// generic types resolves to a placeholder (i.e., an undefined/unknown type).
pub fn (t &Table) type_contains_placeholder(typ Type) bool {
    sym := t.sym(typ)
    if sym.kind == .placeholder {
        return true
    }
    return match sym.info {
        Array {
            t.type_contains_placeholder(sym.info.elem_type)
        }
        ArrayFixed {
            t.type_contains_placeholder(sym.info.elem_type)
        }
        Map {
            t.type_contains_placeholder(sym.info.key_type)
                || t.type_contains_placeholder(sym.info.value_type)
        }
        SumType {
            sym.info.concrete_types.any(t.type_contains_placeholder(it))
        }
        Struct {
            sym.info.concrete_types.any(t.type_contains_placeholder(it))
        }
        else {
            false
        }
    }
}

pub fn (mut t Table) unwrap_generic_param_type(param Param, generic_names []string, concrete_types []Type) Type {
    if param.is_mut && param.orig_typ != 0 && param.orig_typ.has_flag(.generic)
        && concrete_types.all(!it.has_flag(.generic)) {
        return t.lower_mut_param_type(t.unwrap_generic_type(param.orig_typ, generic_names,
            concrete_types))
    }
    return t.unwrap_generic_type(param.typ, generic_names, concrete_types)
}

// convert_generic_expr_type resolves generic placeholders stored inside expression metadata.
// Some synthesized concrete types use default expressions directly from type symbols, so these
// types need to be specialized eagerly instead of relying on a later checker pass.
fn (mut t Table) convert_generic_expr_type(typ Type, generic_names []string, concrete_types []Type) Type {
    if typ == 0 {
        return typ
    }
    return t.convert_generic_type(typ, generic_names, concrete_types) or { typ }
}

fn (mut t Table) convert_generic_expr_types(types []Type, generic_names []string, concrete_types []Type) []Type {
    if types.len == 0 {
        return types
    }
    mut resolved := []Type{len: types.len}
    for i, typ in types {
        resolved[i] = t.convert_generic_expr_type(typ, generic_names, concrete_types)
    }
    return resolved
}

fn (mut t Table) convert_generic_nested_expr_types(types [][]Type, generic_names []string, concrete_types []Type) [][]Type {
    if types.len == 0 {
        return types
    }
    mut resolved := [][]Type{len: types.len}
    for i, inner in types {
        resolved[i] = t.convert_generic_expr_types(inner, generic_names, concrete_types)
    }
    return resolved
}

fn (mut t Table) convert_generic_call_args(args []CallArg, generic_names []string, concrete_types []Type) []CallArg {
    if args.len == 0 {
        return args
    }
    mut resolved := []CallArg{len: args.len}
    for i, arg in args {
        resolved[i] = CallArg{
            ...arg
            expr: t.convert_generic_default_expr(arg.expr, generic_names, concrete_types)
            typ:  t.convert_generic_expr_type(arg.typ, generic_names, concrete_types)
        }
    }
    return resolved
}

fn (mut t Table) convert_generic_struct_init_fields(fields []StructInitField, generic_names []string, concrete_types []Type) []StructInitField {
    if fields.len == 0 {
        return fields
    }
    mut resolved := []StructInitField{len: fields.len}
    for i, field in fields {
        resolved[i] = StructInitField{
            ...field
            expr:          t.convert_generic_default_expr(field.expr, generic_names, concrete_types)
            typ:           t.convert_generic_expr_type(field.typ, generic_names, concrete_types)
            expected_type: t.convert_generic_expr_type(field.expected_type, generic_names,
                concrete_types)
            parent_type:   t.convert_generic_expr_type(field.parent_type, generic_names,
                concrete_types)
        }
    }
    return resolved
}

fn (mut t Table) convert_generic_default_expr(expr Expr, generic_names []string, concrete_types []Type) Expr {
    match expr {
        ArrayDecompose {
            return Expr(ArrayDecompose{
                ...expr
                expr:      t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                expr_type: t.convert_generic_expr_type(expr.expr_type, generic_names,
                    concrete_types)
                arg_type:  t.convert_generic_expr_type(expr.arg_type, generic_names, concrete_types)
            })
        }
        ArrayInit {
            mut exprs := []Expr{cap: expr.exprs.len}
            for node in expr.exprs {
                exprs << t.convert_generic_default_expr(node, generic_names, concrete_types)
            }
            return Expr(ArrayInit{
                ...expr
                exprs:      exprs
                len_expr:   t.convert_generic_default_expr(expr.len_expr, generic_names,
                    concrete_types)
                cap_expr:   t.convert_generic_default_expr(expr.cap_expr, generic_names,
                    concrete_types)
                init_expr:  t.convert_generic_default_expr(expr.init_expr, generic_names,
                    concrete_types)
                expr_types: t.convert_generic_expr_types(expr.expr_types, generic_names,
                    concrete_types)
                elem_type:  t.convert_generic_expr_type(expr.elem_type, generic_names,
                    concrete_types)
                init_type:  t.convert_generic_expr_type(expr.init_type, generic_names,
                    concrete_types)
                typ:        t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
                alias_type: t.convert_generic_expr_type(expr.alias_type, generic_names,
                    concrete_types)
            })
        }
        AsCast {
            return Expr(AsCast{
                ...expr
                typ:       t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
                expr:      t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                expr_type: t.convert_generic_expr_type(expr.expr_type, generic_names,
                    concrete_types)
            })
        }
        CallExpr {
            mut resolved_concrete_types := t.convert_generic_expr_types(expr.concrete_types,
                generic_names, concrete_types)
            mut name := expr.name
            if !expr.is_method {
                if func := t.find_fn_in_mod(expr.name, expr.mod) {
                    name = func.name
                    if func.generic_names.len > 0 && resolved_concrete_types.len == 0 {
                        for fn_generic_name in func.generic_names {
                            idx := generic_names.index(fn_generic_name)
                            if idx >= 0 && idx < concrete_types.len {
                                resolved_concrete_types << concrete_types[idx]
                            }
                        }
                    }
                    if resolved_concrete_types.len == func.generic_names.len
                        && resolved_concrete_types.all(!it.has_flag(.generic)) {
                        t.register_fn_concrete_types(func.fkey(), resolved_concrete_types)
                    }
                }
            }
            return Expr(CallExpr{
                ...expr
                name:                   name
                args:                   t.convert_generic_call_args(expr.args, generic_names,
                    concrete_types)
                expected_arg_types:     t.convert_generic_expr_types(expr.expected_arg_types,
                    generic_names, concrete_types)
                left:                   t.convert_generic_default_expr(expr.left, generic_names,
                    concrete_types)
                left_type:              t.convert_generic_expr_type(expr.left_type, generic_names,
                    concrete_types)
                receiver_type:          t.convert_generic_expr_type(expr.receiver_type,
                    generic_names, concrete_types)
                receiver_concrete_type: t.convert_generic_expr_type(expr.receiver_concrete_type,
                    generic_names, concrete_types)
                return_type:            t.convert_generic_expr_type(expr.return_type,
                    generic_names, concrete_types)
                return_type_generic:    t.convert_generic_expr_type(expr.return_type_generic,
                    generic_names, concrete_types)
                fn_var_type:            t.convert_generic_expr_type(expr.fn_var_type,
                    generic_names, concrete_types)
                concrete_types:         resolved_concrete_types
                raw_concrete_types:     if expr.raw_concrete_types.len > 0 {
                    t.convert_generic_expr_types(expr.raw_concrete_types, generic_names,
                        concrete_types)
                } else {
                    resolved_concrete_types
                }
                from_embed_types:       t.convert_generic_expr_types(expr.from_embed_types,
                    generic_names, concrete_types)
            })
        }
        CastExpr {
            return Expr(CastExpr{
                ...expr
                arg:       t.convert_generic_default_expr(expr.arg, generic_names, concrete_types)
                typ:       t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
                expr:      t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                expr_type: t.convert_generic_expr_type(expr.expr_type, generic_names,
                    concrete_types)
            })
        }
        ChanInit {
            return Expr(ChanInit{
                ...expr
                cap_expr:  t.convert_generic_default_expr(expr.cap_expr, generic_names,
                    concrete_types)
                typ:       t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
                elem_type: t.convert_generic_expr_type(expr.elem_type, generic_names,
                    concrete_types)
            })
        }
        ConcatExpr {
            mut vals := []Expr{cap: expr.vals.len}
            for node in expr.vals {
                vals << t.convert_generic_default_expr(node, generic_names, concrete_types)
            }
            return Expr(ConcatExpr{
                ...expr
                vals:        vals
                return_type: t.convert_generic_expr_type(expr.return_type, generic_names,
                    concrete_types)
            })
        }
        DumpExpr {
            return Expr(DumpExpr{
                ...expr
                expr:      t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                expr_type: t.convert_generic_expr_type(expr.expr_type, generic_names,
                    concrete_types)
            })
        }
        Ident {
            mut resolved_concrete_types := t.convert_generic_expr_types(expr.concrete_types,
                generic_names, concrete_types)
            mut info := expr.info
            mut kind := expr.kind
            mut name := expr.name
            match mut info {
                IdentFn {
                    info.typ = t.convert_generic_expr_type(info.typ, generic_names, concrete_types)
                }
                IdentVar {
                    info.typ = t.convert_generic_expr_type(info.typ, generic_names, concrete_types)
                }
            }

            mut obj := expr.obj
            match mut obj {
                AsmRegister {
                    obj.typ = t.convert_generic_expr_type(obj.typ, generic_names, concrete_types)
                }
                ConstField {
                    obj.typ = t.convert_generic_expr_type(obj.typ, generic_names, concrete_types)
                }
                EmptyScopeObject {
                    obj.typ = t.convert_generic_expr_type(obj.typ, generic_names, concrete_types)
                }
                GlobalField {
                    obj.typ = t.convert_generic_expr_type(obj.typ, generic_names, concrete_types)
                }
                Var {
                    obj.typ = t.convert_generic_expr_type(obj.typ, generic_names, concrete_types)
                    obj.orig_type = t.convert_generic_expr_type(obj.orig_type, generic_names,
                        concrete_types)
                    obj.smartcasts = t.convert_generic_expr_types(obj.smartcasts, generic_names,
                        concrete_types)
                }
            }

            if func := t.find_fn_in_mod(expr.name, expr.mod) {
                name = func.name
                mut fn_type := t.find_or_register_fn_type(func, false, true)
                if fn_type < 0 {
                    mut f := Fn{
                        ...func
                    }
                    f.name = ''
                    fn_type = t.find_or_register_fn_type(f, false, true)
                }
                if func.generic_names.len > 0 && resolved_concrete_types.len == 0 {
                    for fn_generic_name in func.generic_names {
                        idx := generic_names.index(fn_generic_name)
                        if idx >= 0 && idx < concrete_types.len {
                            resolved_concrete_types << concrete_types[idx]
                        }
                    }
                }
                if func.generic_names.len > 0 {
                    if typ_ := t.convert_generic_type(fn_type, func.generic_names,
                        resolved_concrete_types)
                    {
                        fn_type = typ_
                    }
                }
                if fn_type > 0 {
                    kind = .function
                    info = IdentFn{
                        typ: fn_type
                    }
                }
                if resolved_concrete_types.len == func.generic_names.len
                    && resolved_concrete_types.all(!it.has_flag(.generic)) {
                    t.register_fn_concrete_types(func.fkey(), resolved_concrete_types)
                }
            }
            return Expr(Ident{
                ...expr
                name:           name
                obj:            obj
                info:           info
                kind:           kind
                concrete_types: resolved_concrete_types
            })
        }
        IfGuardExpr {
            return Expr(IfGuardExpr{
                ...expr
                expr:      t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                expr_type: t.convert_generic_expr_type(expr.expr_type, generic_names,
                    concrete_types)
            })
        }
        IndexExpr {
            return Expr(IndexExpr{
                ...expr
                index:           t.convert_generic_default_expr(expr.index, generic_names,
                    concrete_types)
                left:            t.convert_generic_default_expr(expr.left, generic_names,
                    concrete_types)
                left_type:       t.convert_generic_expr_type(expr.left_type, generic_names,
                    concrete_types)
                index_type:      t.convert_generic_expr_type(expr.index_type, generic_names,
                    concrete_types)
                setter_arg_type: t.convert_generic_expr_type(expr.setter_arg_type, generic_names,
                    concrete_types)
                typ:             t.convert_generic_expr_type(expr.typ, generic_names,
                    concrete_types)
            })
        }
        InfixExpr {
            return Expr(InfixExpr{
                ...expr
                left:          t.convert_generic_default_expr(expr.left, generic_names,
                    concrete_types)
                right:         t.convert_generic_default_expr(expr.right, generic_names,
                    concrete_types)
                left_type:     t.convert_generic_expr_type(expr.left_type, generic_names,
                    concrete_types)
                right_type:    t.convert_generic_expr_type(expr.right_type, generic_names,
                    concrete_types)
                promoted_type: t.convert_generic_expr_type(expr.promoted_type, generic_names,
                    concrete_types)
            })
        }
        IsRefType {
            return Expr(IsRefType{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                typ:  t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
            })
        }
        Likely {
            return Expr(Likely{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
            })
        }
        MapInit {
            mut keys := []Expr{cap: expr.keys.len}
            for node in expr.keys {
                keys << t.convert_generic_default_expr(node, generic_names, concrete_types)
            }
            mut vals := []Expr{cap: expr.vals.len}
            for node in expr.vals {
                vals << t.convert_generic_default_expr(node, generic_names, concrete_types)
            }
            return Expr(MapInit{
                ...expr
                keys:        keys
                vals:        vals
                val_types:   t.convert_generic_expr_types(expr.val_types, generic_names,
                    concrete_types)
                typ:         t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
                key_type:    t.convert_generic_expr_type(expr.key_type, generic_names,
                    concrete_types)
                value_type:  t.convert_generic_expr_type(expr.value_type, generic_names,
                    concrete_types)
                update_expr: t.convert_generic_default_expr(expr.update_expr, generic_names,
                    concrete_types)
            })
        }
        OffsetOf {
            return Expr(OffsetOf{
                ...expr
                struct_type: t.convert_generic_expr_type(expr.struct_type, generic_names,
                    concrete_types)
            })
        }
        ParExpr {
            return Expr(ParExpr{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
            })
        }
        PostfixExpr {
            return Expr(PostfixExpr{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                typ:  t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
            })
        }
        PrefixExpr {
            return Expr(PrefixExpr{
                ...expr
                right_type: t.convert_generic_expr_type(expr.right_type, generic_names,
                    concrete_types)
                right:      t.convert_generic_default_expr(expr.right, generic_names,
                    concrete_types)
            })
        }
        RangeExpr {
            return Expr(RangeExpr{
                ...expr
                low:  t.convert_generic_default_expr(expr.low, generic_names, concrete_types)
                high: t.convert_generic_default_expr(expr.high, generic_names, concrete_types)
                typ:  t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
            })
        }
        SelectorExpr {
            return Expr(SelectorExpr{
                ...expr
                expr:                     t.convert_generic_default_expr(expr.expr, generic_names,
                    concrete_types)
                expr_type:                t.convert_generic_expr_type(expr.expr_type,
                    generic_names, concrete_types)
                typ:                      t.convert_generic_expr_type(expr.typ, generic_names,
                    concrete_types)
                name_type:                t.convert_generic_expr_type(expr.name_type,
                    generic_names, concrete_types)
                from_embed_types:         t.convert_generic_expr_types(expr.from_embed_types,
                    generic_names, concrete_types)
                generic_from_embed_types: t.convert_generic_nested_expr_types(expr.generic_from_embed_types,
                    generic_names, concrete_types)
            })
        }
        SizeOf {
            return Expr(SizeOf{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                typ:  t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
            })
        }
        StringInterLiteral {
            mut exprs := []Expr{cap: expr.exprs.len}
            for node in expr.exprs {
                exprs << t.convert_generic_default_expr(node, generic_names, concrete_types)
            }
            return Expr(StringInterLiteral{
                ...expr
                exprs:      exprs
                expr_types: t.convert_generic_expr_types(expr.expr_types, generic_names,
                    concrete_types)
            })
        }
        StructInit {
            return Expr(StructInit{
                ...expr
                generic_typ:      t.convert_generic_expr_type(expr.generic_typ, generic_names,
                    concrete_types)
                typ:              t.convert_generic_expr_type(expr.typ, generic_names,
                    concrete_types)
                update_expr:      t.convert_generic_default_expr(expr.update_expr, generic_names,
                    concrete_types)
                update_expr_type: t.convert_generic_expr_type(expr.update_expr_type, generic_names,
                    concrete_types)
                init_fields:      t.convert_generic_struct_init_fields(expr.init_fields,
                    generic_names, concrete_types)
                generic_types:    t.convert_generic_expr_types(expr.generic_types, generic_names,
                    concrete_types)
            })
        }
        TypeNode {
            return Expr(TypeNode{
                ...expr
                typ: t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
            })
        }
        TypeOf {
            return Expr(TypeOf{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
                typ:  t.convert_generic_expr_type(expr.typ, generic_names, concrete_types)
            })
        }
        UnsafeExpr {
            return Expr(UnsafeExpr{
                ...expr
                expr: t.convert_generic_default_expr(expr.expr, generic_names, concrete_types)
            })
        }
        else {}
    }

    return expr
}

fn generic_names_push_with_filter(mut to_names []string, from_names []string) {
    for name in from_names {
        if name !in to_names {
            to_names << name
        }
    }
}

fn (ts &TypeSymbol) has_generic_type_info() bool {
    return match ts.info {
        Struct, Interface, SumType { ts.info.is_generic }
        else { false }
    }
}

fn (t &Table) find_fn_in_mod(name string, mod string) ?Fn {
    if func := t.find_fn(name) {
        return func
    }
    if mod != '' && !name.contains('.') {
        if func := t.find_fn('${mod}.${name}') {
            return func
        }
    }
    return none
}

pub fn (mut t Table) generic_type_names(generic_type Type) []string {
    mut names := []string{}
    idx := generic_type.idx()
    if idx == 0 || idx >= t.type_symbols.len {
        return names
    }
    mut sym := t.sym(generic_type)
    if sym.name.len == 1 && sym.name[0].is_capital() {
        names << sym.name
        return names
    }
    match mut sym.info {
        Array {
            _, elem_type := t.get_array_dims(sym.info)
            names << t.generic_type_names(elem_type)
        }
        ArrayFixed {
            names << t.generic_type_names(sym.info.elem_type)
        }
        Chan {
            names << t.generic_type_names(sym.info.elem_type)
        }
        FnType {
            for param in sym.info.func.params {
                generic_names_push_with_filter(mut names, t.generic_type_names(param.typ))
                if param.orig_typ != 0 {
                    generic_names_push_with_filter(mut names, t.generic_type_names(param.orig_typ))
                }
            }
            generic_names_push_with_filter(mut names,
                t.generic_type_names(sym.info.func.return_type))
            if names.len == 0 {
                generic_names_push_with_filter(mut names, sym.info.func.generic_names)
            }
        }
        MultiReturn {
            for ret_type in sym.info.types {
                generic_names_push_with_filter(mut names, t.generic_type_names(ret_type))
            }
        }
        Map {
            names << t.generic_type_names(sym.info.key_type)
            generic_names_push_with_filter(mut names, t.generic_type_names(sym.info.value_type))
        }
        Struct, Interface, SumType {
            if sym.info.is_generic {
                if sym.generic_types.len > 0 {
                    // Foo[U] (declaration: Foo[T])
                    for typ in sym.generic_types {
                        if typ.has_flag(.generic) && t.sym(typ).kind == .any {
                            names << t.sym(typ).name
                        }
                    }
                } else {
                    names << sym.info.generic_types.map(t.sym(it).name)
                }
            }
        }
        else {
            // For placeholder types (forward-declared generic structs),
            // check generic_types on the symbol itself
            if sym.generic_types.len > 0 {
                for typ in sym.generic_types {
                    if typ.has_flag(.generic) && t.sym(typ).kind == .any {
                        names << t.sym(typ).name
                    }
                }
            }
        }
    }

    return names
}

// unwrap_generic_type resolves generic symbols to their concrete types.
pub fn (mut t Table) unwrap_generic_type(typ Type, generic_names []string, concrete_types []Type) Type {
    return t.unwrap_generic_type_ex(typ, generic_names, concrete_types, false)
}

// unwrap_generic_type_ex resolves generic symbols to concrete types and can recheck nested concrete fields.
pub fn (mut t Table) unwrap_generic_type_ex(typ Type, generic_names []string, concrete_types []Type, recheck_concrete_types bool) Type {
    return t.unwrap_generic_type_ex_with_depth(typ, generic_names, concrete_types,
        recheck_concrete_types, []string{})
}

fn (mut t Table) unwrap_generic_type_ex_with_depth(typ Type, generic_names []string, concrete_types []Type, recheck_concrete_types bool, depth_guard []string) Type {
    mut final_concrete_types := []Type{}
    mut fields := []StructField{}
    mut nrt := ''
    mut c_nrt := ''
    mut new_depth_guard := []string{}
    type_idx := typ.idx()
    if type_idx == 0 || type_idx >= t.type_symbols.len {
        return typ
    }
    for ct in concrete_types {
        if ct.idx() == 0 || ct.idx() >= t.type_symbols.len {
            return typ
        }
    }
    ts := t.type_symbols[type_idx]
    match ts.info {
        Array {
            dims, elem_type := t.get_array_dims(ts.info)
            unwrap_typ := t.unwrap_generic_type_ex_with_depth(elem_type, generic_names,
                concrete_types, recheck_concrete_types, depth_guard)
            idx := t.find_or_register_array_with_dims(unwrap_typ, dims)
            if idx <= 0 {
                return typ
            }
            return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
        }
        ArrayFixed {
            unwrap_typ := t.unwrap_generic_type_ex_with_depth(ts.info.elem_type, generic_names,
                concrete_types, recheck_concrete_types, depth_guard)
            idx := t.find_or_register_array_fixed(unwrap_typ, ts.info.size, None{}, false)
            if idx <= 0 {
                return typ
            }
            return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
        }
        Chan {
            unwrap_typ := t.unwrap_generic_type(ts.info.elem_type, generic_names, concrete_types)
            idx := t.find_or_register_chan(unwrap_typ, unwrap_typ.nr_muls() > 0)
            if idx <= 0 {
                return typ
            }
            return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
        }
        Thread {
            unwrap_typ := t.unwrap_generic_type_ex_with_depth(ts.info.return_type, generic_names,
                concrete_types, recheck_concrete_types, depth_guard)
            idx := t.find_or_register_thread(unwrap_typ)
            if idx <= 0 {
                return typ
            }
            return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
        }
        Map {
            unwrap_key_type := t.unwrap_generic_type_ex_with_depth(ts.info.key_type, generic_names,
                concrete_types, recheck_concrete_types, depth_guard)
            unwrap_value_type := t.unwrap_generic_type_ex_with_depth(ts.info.value_type,
                generic_names, concrete_types, recheck_concrete_types, depth_guard)
            idx := t.find_or_register_map(unwrap_key_type, unwrap_value_type)
            if idx <= 0 {
                return typ
            }
            return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
        }
        FnType {
            mut unwrapped_fn := ts.info.func
            unwrapped_fn.params = unwrapped_fn.params.clone()
            mut has_generic := false
            for i, param in unwrapped_fn.params {
                if param.typ.has_flag(.generic) || t.generic_type_names(param.typ).len > 0 {
                    unwrapped_fn.params[i].typ = t.unwrap_generic_param_type(param, generic_names,
                        concrete_types)
                    has_generic = true
                }
                if param.orig_typ.has_flag(.generic) || t.generic_type_names(param.orig_typ).len > 0 {
                    unwrapped_fn.params[i].orig_typ = t.unwrap_generic_type(param.orig_typ,
                        generic_names, concrete_types)
                }
            }
            if unwrapped_fn.return_type.has_flag(.generic)
                || t.generic_type_names(unwrapped_fn.return_type).len > 0
                || (unwrapped_fn.return_type.idx() > 0 && unwrapped_fn.return_type.idx() < t.type_symbols.len
                && t.sym(unwrapped_fn.return_type).kind == .generic_inst&& (t.sym(unwrapped_fn.return_type).info as GenericInst).concrete_types.any(it.has_flag(.generic))) {
                unwrapped_fn.return_type = t.unwrap_generic_type_ex_with_depth(unwrapped_fn.return_type,
                    generic_names, concrete_types, recheck_concrete_types, depth_guard)
                has_generic = true
            }
            if has_generic {
                if !ts.info.is_anon {
                    inst_name := t.generic_fn_inst_name(ts, concrete_types)
                    idx := t.find_type_idx(inst_name)
                    if idx > 0 {
                        return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
                    }
                }
                // Clear the name so find_or_register_fn_type registers a new anonymous fn
                // type with the resolved concrete param/return types, instead of returning
                // the existing generic fn type entry (matched by name).
                unwrapped_fn.name = ''
                unwrapped_fn.generic_names = []
                idx := t.find_or_register_fn_type(unwrapped_fn, true, false)
                if idx <= 0 {
                    return typ
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
            return typ
        }
        Struct, Interface, SumType {
            if !ts.info.is_generic {
                return typ
            }
            mut t_generic_names := generic_names.clone()
            mut t_concrete_types := concrete_types.clone()
            if ts.generic_types.len > 0 && ts.generic_types.len == ts.info.generic_types.len
                && ts.generic_types != ts.info.generic_types {
                t_generic_names = ts.info.generic_types.map(t.sym(it).name)
                t_concrete_types = []
                for t_typ in ts.generic_types {
                    if !t_typ.has_flag(.generic) {
                        t_concrete_types << t_typ
                    } else {
                        t_concrete_types << t.unwrap_generic_type(t_typ, generic_names,
                            concrete_types)
                    }
                }
            }
            base_name := if ts.ngname == '' { ts.name } else { ts.ngname }
            nrt = '${base_name}['
            c_nrt = '${ts.cname}_T_'
            for i in 0 .. ts.info.generic_types.len {
                if ct := t.convert_generic_type(ts.info.generic_types[i], t_generic_names,
                    t_concrete_types)
                {
                    gts := t.sym(ct)
                    if ct.is_ptr() {
                        nrt += '&'.repeat(ct.nr_muls())
                        c_nrt += '__ptr__'.repeat(ct.nr_muls())
                    }
                    nrt += gts.name
                    c_nrt += gts.scoped_cname()
                    if i != ts.info.generic_types.len - 1 {
                        nrt += ', '
                        c_nrt += '_T_'
                    }
                } else {
                    return typ
                }
            }
            nrt += ']'
            mut idx := t.type_idxs[nrt]
            if idx != 0 && t.type_symbols[idx].kind != .placeholder {
                if recheck_concrete_types {
                    // Rechecking an already-registered concrete generic can revisit the same
                    // self-referential type through one of its fields.
                    if nrt in depth_guard {
                        if idx <= 0 {
                            return typ
                        }
                        return new_type(idx).derive(typ).clear_flag(.generic)
                    }
                    new_depth_guard = []string{cap: depth_guard.len + 1}
                    new_depth_guard << depth_guard
                    new_depth_guard << nrt
                    fields = ts.info.fields.clone()
                    for i in 0 .. fields.len {
                        resolved_field_typ := t.unwrap_generic_type_ex_with_depth(fields[i].typ,
                            t_generic_names, t_concrete_types, recheck_concrete_types,
                            new_depth_guard)
                        if resolved_field_typ != fields[i].typ {
                            fields[i].typ = resolved_field_typ
                        }
                    }
                    // update concrete types
                    for i in 0 .. ts.info.generic_types.len {
                        if t_typ := t.convert_generic_type(ts.info.generic_types[i],
                            t_generic_names, t_concrete_types)
                        {
                            final_concrete_types << t_typ
                        }
                    }
                    if final_concrete_types.len > 0 {
                        t.unwrap_method_types(ts, generic_names, concrete_types)
                    }
                }
                if idx <= 0 {
                    return typ
                }
                return new_type(idx).derive(typ).clear_flag(.generic)
            }
            if idx == 0 {
                idx = t.add_placeholder_type(nrt, c_nrt, .v)
            }
            if nrt in depth_guard {
                // The concrete type is currently being built higher in the stack.
                // Reuse its placeholder to avoid recursive generic unwrapping loops.
                if idx <= 0 {
                    return typ
                }
                return new_type(idx).derive(typ).clear_flag(.generic)
            }
            new_depth_guard = []string{cap: depth_guard.len + 1}
            new_depth_guard << depth_guard
            new_depth_guard << nrt
            // fields type translate to concrete type
            fields = ts.info.fields.clone()
            for i in 0 .. fields.len {
                orig_type := fields[i].typ
                resolved_field_typ := t.unwrap_generic_type_ex_with_depth(orig_type,
                    t_generic_names, t_concrete_types, recheck_concrete_types, new_depth_guard)
                if resolved_field_typ != orig_type {
                    fields[i].typ = resolved_field_typ
                    // Update type in `info.embeds`, if it's embed
                    if fields[i].is_embed {
                        mut parent_sym := t.sym(typ)
                        mut parent_info := parent_sym.info
                        if mut parent_info is Struct {
                            for mut embed in parent_info.embeds {
                                if embed == orig_type {
                                    embed = fields[i].typ
                                    break
                                }
                            }
                        }
                    }
                }
                if fields[i].has_default_expr {
                    if fields[i].default_expr_typ != 0 && fields[i].default_expr_typ != nil_type {
                        fields[i].default_expr_typ = t.convert_generic_expr_type(fields[i].default_expr_typ,
                            t_generic_names, t_concrete_types)
                        fields[i].default_expr = t.convert_generic_default_expr(fields[i].default_expr,
                            t_generic_names, t_concrete_types)
                    } else if fields[i].default_expr_typ == 0
                        || fields[i].default_expr_typ == nil_type {
                        if fields[i].default_expr.is_nil() && fields[i].typ.is_any_kind_of_pointer() {
                            fields[i].default_expr_typ = fields[i].typ
                        }
                    }
                }
            }
            // update concrete types
            for i in 0 .. ts.info.generic_types.len {
                if t_typ := t.convert_generic_type(ts.info.generic_types[i], t_generic_names,
                    t_concrete_types)
                {
                    final_concrete_types << t_typ
                }
            }
            // If concrete types still contain generic parameters (e.g. Vec3[U] where U
            // is unresolved), don't create a partially-resolved struct entry. The struct
            // will be properly instantiated when all type parameters are known.
            //
            // Structural check via generic_type_names catches entries like `[]T`
            // whose `.generic` Type-flag has been cleared but whose type structure
            // still references an unresolved generic parameter. Without this check,
            // such entries reach register_sym below and leak into codegen as
            // `Array_T` / placeholder-typed struct fields.
            if final_concrete_types.any(it.has_flag(.generic))
                || final_concrete_types.any(t.generic_type_names(it).len > 0) {
                return typ
            }
        }
        GenericInst {
            // Resolve GenericInst concrete_types that still contain generic parameters.
            // E.g. CacheStore[K, &CacheItem[K, V]] with K=string, V=int becomes
            // CacheStore[string, &CacheItem[string, int]].
            mut resolved_cts := ts.info.concrete_types.clone()
            mut changed := false
            for i in 0 .. resolved_cts.len {
                if resolved_cts[i].has_flag(.generic) {
                    new_ct := t.unwrap_generic_type_ex_with_depth(resolved_cts[i], generic_names,
                        concrete_types, recheck_concrete_types, depth_guard)
                    if new_ct != resolved_cts[i] {
                        resolved_cts[i] = new_ct
                        changed = true
                    }
                }
            }
            if changed {
                parent_typ := new_type(ts.info.parent_idx)
                idx := t.find_or_register_generic_inst(parent_typ, resolved_cts)
                if idx > 0 {
                    return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
                }
            }
            return typ
        }
        else {}
    }

    match ts.info {
        Struct {
            mut info := ts.info
            info.is_generic = false
            info.concrete_types = final_concrete_types
            info.parent_type = typ.set_flag(.generic)
            info.fields = fields
            new_idx := t.register_sym(
                kind:       .struct
                name:       nrt
                cname:      util.no_dots(c_nrt)
                parent_idx: typ.idx()
                mod:        ts.mod
                info:       info
                is_pub:     ts.is_pub
            )
            if final_concrete_types.len > 0 {
                t.unwrap_method_types(ts, generic_names, concrete_types)
            }
            if new_idx <= 0 {
                existing := t.type_idxs[nrt]
                if existing > 0 {
                    return new_type(existing).derive(typ).clear_flag(.generic)
                }
                return typ
            }
            return new_type(new_idx).derive(typ).clear_flag(.generic)
        }
        SumType {
            mut variants := ts.info.variants.clone()
            gn_names := ts.info.generic_types.map(t.sym(it).name)
            for i in 0 .. variants.len {
                sym := t.sym(variants[i])
                if variants[i].has_flag(.generic) || sym.kind == .generic_inst
                    || (sym.kind in [.struct, .sum_type, .interface] && sym.has_generic_type_info()) {
                    if sym.kind in [.struct, .sum_type, .interface] {
                        variants[i] = t.unwrap_generic_type_ex_with_depth(variants[i], gn_names,
                            final_concrete_types, false, new_depth_guard)
                    } else {
                        if t_typ := t.convert_generic_type(variants[i], gn_names,
                            final_concrete_types)
                        {
                            variants[i] = t_typ
                        }
                    }
                }
            }
            mut info := ts.info
            info.is_generic = false
            info.concrete_types = final_concrete_types
            info.parent_type = typ.set_flag(.generic)
            info.fields = fields
            info.variants = variants
            new_idx := t.register_sym(
                kind:       .sum_type
                name:       nrt
                cname:      util.no_dots(c_nrt)
                parent_idx: typ.idx()
                mod:        ts.mod
                info:       info
                is_pub:     ts.is_pub
            )
            if final_concrete_types.len > 0 {
                t.unwrap_method_types(ts, generic_names, concrete_types)
            }
            if new_idx <= 0 {
                existing := t.type_idxs[nrt]
                if existing > 0 {
                    return new_type(existing).derive(typ).clear_flag(.generic)
                }
                return typ
            }
            return new_type(new_idx).derive(typ).clear_flag(.generic)
        }
        Interface {
            // resolve generic types inside methods
            mut imethods := ts.info.methods.clone()
            gn_names := t.get_real_generic_names(typ, generic_names)
            // Use final_concrete_types (the interface's own resolved concrete types)
            // instead of concrete_types (the outer struct's types) so that nested
            // generic type arguments like CacheStore[K, &CacheItem[K, V]] resolve
            // V to &CacheItem[string, int] rather than plain int.
            iface_concrete := if final_concrete_types.len == gn_names.len {
                final_concrete_types
            } else {
                concrete_types[..gn_names.len]
            }
            for mut method in imethods {
                if unwrap_typ := t.convert_generic_type(method.return_type, gn_names,
                    iface_concrete)
                {
                    method.return_type = unwrap_typ
                }
                for mut param in method.params {
                    if unwrap_typ := t.convert_generic_param_type(param, gn_names, iface_concrete) {
                        param.typ = unwrap_typ
                    }
                }
            }
            mut all_methods := ts.methods.clone()
            for imethod in imethods {
                for mut method in all_methods {
                    if imethod.name == method.name {
                        method = imethod
                    }
                }
            }
            mut info := ts.info
            info.is_generic = false
            info.concrete_types = final_concrete_types
            info.parent_type = typ.set_flag(.generic)
            info.fields = fields
            info.methods = imethods
            new_idx := t.register_sym(
                kind:       .interface
                name:       nrt
                cname:      util.no_dots(c_nrt)
                parent_idx: typ.idx()
                mod:        ts.mod
                info:       info
                is_pub:     ts.is_pub
            )
            if new_idx > 0 {
                mut ts_copy := t.sym(idx_to_type(new_idx))
                for method in all_methods {
                    ts_copy.register_method(method)
                }
            }
            if final_concrete_types.len > 0 {
                t.unwrap_method_types(ts, generic_names, concrete_types)
            }
            if new_idx <= 0 {
                // register_sym can fail when convert_generic_type (used above to
                // resolve method parameter types) calls find_or_register_generic_inst,
                // which converts the placeholder we created earlier into a generic_inst.
                // In that case, look up the existing entry and use it — the
                // generic_insts_to_concrete pass will resolve it later.
                existing := t.type_idxs[nrt]
                if existing > 0 {
                    return new_type(existing).derive(typ).clear_flag(.generic)
                }
                return typ
            }
            return new_type(new_idx).derive(typ).clear_flag(.generic)
        }
        else {
            if typ.has_flag(.generic) {
                if converted := t.convert_generic_type(typ, generic_names, concrete_types) {
                    return converted
                }
            }
        }
    }

    return typ
}

fn concrete_type_lists_match(a []Type, b []Type) bool {
    if a.len != b.len {
        return false
    }
    for i, typ in a {
        if typ != b[i] {
            return false
        }
    }
    return true
}

fn (t &Table) type_contains_transformed_parent_inst(typ Type, parent_idx int, concrete_types []Type) bool {
    if typ == 0 {
        return false
    }
    sym := t.sym(typ)
    match sym.info {
        Array {
            return t.type_contains_transformed_parent_inst(sym.info.elem_type, parent_idx,
                concrete_types)
        }
        ArrayFixed {
            return t.type_contains_transformed_parent_inst(sym.info.elem_type, parent_idx,
                concrete_types)
        }
        Chan {
            return t.type_contains_transformed_parent_inst(sym.info.elem_type, parent_idx,
                concrete_types)
        }
        Thread {
            return t.type_contains_transformed_parent_inst(sym.info.return_type, parent_idx,
                concrete_types)
        }
        Map {
            return
                t.type_contains_transformed_parent_inst(sym.info.key_type, parent_idx, concrete_types)
                || t.type_contains_transformed_parent_inst(sym.info.value_type, parent_idx, concrete_types)
        }
        FnType {
            if t.type_contains_transformed_parent_inst(sym.info.func.return_type, parent_idx,
                concrete_types)
            {
                return true
            }
            for param in sym.info.func.params {
                if t.type_contains_transformed_parent_inst(param.typ, parent_idx, concrete_types)
                    || t.type_contains_transformed_parent_inst(param.orig_typ, parent_idx, concrete_types) {
                    return true
                }
            }
        }
        GenericInst {
            if sym.info.parent_idx == parent_idx
                && !concrete_type_lists_match(sym.info.concrete_types, concrete_types) {
                return true
            }
            for ct in sym.info.concrete_types {
                if t.type_contains_transformed_parent_inst(ct, parent_idx, concrete_types) {
                    return true
                }
            }
        }
        Struct {
            if sym.parent_idx == parent_idx
                && !concrete_type_lists_match(sym.info.concrete_types, concrete_types) {
                return true
            }
            for ct in sym.info.concrete_types {
                if t.type_contains_transformed_parent_inst(ct, parent_idx, concrete_types) {
                    return true
                }
            }
        }
        Interface {
            if sym.parent_idx == parent_idx
                && !concrete_type_lists_match(sym.info.concrete_types, concrete_types) {
                return true
            }
            for ct in sym.info.concrete_types {
                if t.type_contains_transformed_parent_inst(ct, parent_idx, concrete_types) {
                    return true
                }
            }
        }
        SumType {
            if sym.parent_idx == parent_idx
                && !concrete_type_lists_match(sym.info.concrete_types, concrete_types) {
                return true
            }
            for ct in sym.info.concrete_types {
                if t.type_contains_transformed_parent_inst(ct, parent_idx, concrete_types) {
                    return true
                }
            }
        }
        MultiReturn {
            for mr_typ in sym.info.types {
                if t.type_contains_transformed_parent_inst(mr_typ, parent_idx, concrete_types) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut t Table) should_auto_register_concrete_method(method Fn, parent_type Type, concrete_types []Type) bool {
    parent_idx := parent_type.clear_flag(.generic).idx()
    if parent_idx == 0 || method.generic_names.len != concrete_types.len {
        return false
    }
    for i in 1 .. method.params.len {
        param := method.params[i]
        mut param_typ := param.typ
        if param.typ.has_flag(.generic) || t.generic_type_names(param.typ).len > 0 {
            if pt := t.convert_generic_param_type(param, method.generic_names, concrete_types) {
                param_typ = pt
            } else {
                param_typ = t.unwrap_generic_type_ex(param.typ, method.generic_names,
                    concrete_types, true)
            }
        }
        if t.type_contains_transformed_parent_inst(param_typ, parent_idx, concrete_types) {
            return false
        }
    }
    mut return_type := method.return_type
    if method.return_type.has_flag(.generic) || t.generic_type_names(method.return_type).len > 0 {
        if rt := t.convert_generic_type(method.return_type, method.generic_names, concrete_types) {
            return_type = rt
        } else {
            return_type = t.unwrap_generic_type_ex(method.return_type, method.generic_names,
                concrete_types, true)
        }
    }
    return !t.type_contains_transformed_parent_inst(return_type, parent_idx, concrete_types)
}

fn (mut t Table) unwrap_method_types(ts &TypeSymbol, generic_names []string, concrete_types []Type) {
    mut needs_unwrap_types := []Type{}
    for method in ts.get_methods() {
        for i in 1 .. method.params.len {
            if method.params[i].typ.has_flag(.generic)
                && method.params[i].typ != method.params[0].typ {
                if method.params[i].typ !in needs_unwrap_types {
                    needs_unwrap_types << method.params[i].typ
                }
            }
        }
        // Check return type outside the parameter loop so methods with no
        // non-receiver params (e.g. `magnitude()`) are also covered.
        if method.return_type.has_flag(.generic) && method.return_type != method.params[0].typ {
            if method.return_type !in needs_unwrap_types {
                needs_unwrap_types << method.return_type
            }
        }
    }
    for typ_ in needs_unwrap_types {
        t.unwrap_generic_type(typ_, generic_names, concrete_types)
    }
}

fn (mut t Table) specialize_generic_fn_method_type(typ Type, parent_type Type, concrete_type Type, generic_names []string, concrete_types []Type) Type {
    if typ.clear_flag(.generic).idx() == parent_type.clear_flag(.generic).idx() {
        return concrete_type.derive(typ).clear_flag(.generic)
    }
    sym := t.sym(typ)
    match sym.info {
        Array {
            dims, elem_type := t.get_array_dims(sym.info)
            elem_typ := t.specialize_generic_fn_method_type(elem_type, parent_type, concrete_type,
                generic_names, concrete_types)
            if elem_typ != elem_type {
                idx := t.find_or_register_array_with_dims(elem_typ, dims)
                if elem_typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(typ).set_flag(.generic)
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
        }
        ArrayFixed {
            elem_typ := t.specialize_generic_fn_method_type(sym.info.elem_type, parent_type,
                concrete_type, generic_names, concrete_types)
            if elem_typ != sym.info.elem_type {
                idx := t.find_or_register_array_fixed(elem_typ, sym.info.size, None{}, false)
                if elem_typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(typ).set_flag(.generic)
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
        }
        Chan {
            elem_typ := t.specialize_generic_fn_method_type(sym.info.elem_type, parent_type,
                concrete_type, generic_names, concrete_types)
            if elem_typ != sym.info.elem_type {
                idx := t.find_or_register_chan(elem_typ, elem_typ.nr_muls() > 0)
                if elem_typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(typ).set_flag(.generic)
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
        }
        Thread {
            ret_typ := t.specialize_generic_fn_method_type(sym.info.return_type, parent_type,
                concrete_type, generic_names, concrete_types)
            if ret_typ != sym.info.return_type {
                idx := t.find_or_register_thread(ret_typ)
                if ret_typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(typ).set_flag(.generic)
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
        }
        MultiReturn {
            mut resolved_types := []Type{cap: sym.info.types.len}
            mut type_changed := false
            for ret_typ in sym.info.types {
                resolved_typ := t.specialize_generic_fn_method_type(ret_typ, parent_type,
                    concrete_type, generic_names, concrete_types)
                if resolved_typ != ret_typ {
                    type_changed = true
                }
                resolved_types << resolved_typ
            }
            if type_changed {
                idx := t.find_or_register_multi_return(resolved_types)
                if resolved_types.any(it.has_flag(.generic)) {
                    return new_type(idx).derive_add_muls(typ).set_flag(.generic)
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
        }
        Map {
            key_typ := t.specialize_generic_fn_method_type(sym.info.key_type, parent_type,
                concrete_type, generic_names, concrete_types)
            value_typ := t.specialize_generic_fn_method_type(sym.info.value_type, parent_type,
                concrete_type, generic_names, concrete_types)
            if key_typ != sym.info.key_type || value_typ != sym.info.value_type {
                idx := t.find_or_register_map(key_typ, value_typ)
                if key_typ.has_flag(.generic) || value_typ.has_flag(.generic) {
                    return new_type(idx).derive_add_muls(typ).set_flag(.generic)
                }
                return new_type(idx).derive_add_muls(typ).clear_flag(.generic)
            }
        }
        else {}
    }

    if typ.has_flag(.generic) {
        if resolved_typ := t.convert_generic_type(typ, generic_names, concrete_types) {
            return resolved_typ
        }
    }
    return typ
}

fn (mut t Table) specialize_generic_fn_type_methods(parent_type Type, mut concrete_sym TypeSymbol, generic_names []string, concrete_types []Type) {
    parent_sym := t.sym(parent_type)
    if parent_sym.info !is FnType || parent_sym.methods.len == 0 {
        return
    }
    concrete_type := idx_to_type(concrete_sym.idx)
    concrete_sym.methods = []Fn{}
    for method in parent_sym.methods {
        mut concrete_method := method.new_method_with_receiver_type(concrete_type)
        concrete_method.generic_names = method.generic_names.clone()
        concrete_method.return_type = t.specialize_generic_fn_method_type(method.return_type,
            parent_type, concrete_type, generic_names, concrete_types)
        for i in 1 .. concrete_method.params.len {
            concrete_method.params[i].typ = t.specialize_generic_fn_method_type(method.params[i].typ,
                parent_type, concrete_type, generic_names, concrete_types)
        }
        concrete_method.receiver_type = concrete_method.params[0].typ
        concrete_sym.register_method(concrete_method)
    }
}

// generic struct instantiations to concrete types
pub fn (mut t Table) generic_insts_to_concrete() {
    for mut sym in t.type_symbols {
        if sym.kind == .generic_inst {
            info := sym.info as GenericInst
            if info.parent_idx <= 0 || info.parent_idx >= t.type_symbols.len {
                continue
            }
            parent := t.type_symbols[info.parent_idx]
            if info.concrete_types.any(it.has_flag(.generic))
                && (parent.info is Struct || parent.info is Interface || parent.info is SumType) {
                continue
            }
            if parent.kind == .placeholder {
                sym.kind = .placeholder
                continue
            }
            match parent.info {
                Struct {
                    mut parent_info := parent.info as Struct
                    if !parent_info.is_generic {
                        util.verror('generic error',
                            'struct `${parent.name}` is not a generic struct, cannot instantiate to the concrete types')
                        continue
                    }
                    mut fields := parent_info.fields.clone()
                    if parent_info.generic_types.len == info.concrete_types.len {
                        generic_names := t.get_generic_names(parent_info.generic_types)
                        for i in 0 .. fields.len {
                            if fields[i].typ.has_flag(.generic) {
                                orig_type := fields[i].typ
                                if fields[i].typ.idx() != info.parent_idx {
                                    fields[i].typ = t.unwrap_generic_type(fields[i].typ,
                                        generic_names, info.concrete_types)
                                }

                                if t_typ := t.convert_generic_type(fields[i].typ, generic_names,
                                    info.concrete_types)
                                {
                                    fields[i].typ = t_typ
                                }
                                // Update type in `info.embeds`, if it's embed
                                if fields[i].is_embed {
                                    for mut embed in parent_info.embeds {
                                        if embed == orig_type {
                                            embed = fields[i].typ
                                            break
                                        }
                                    }
                                }
                            }
                            if fields[i].has_default_expr {
                                if fields[i].default_expr_typ != 0
                                    && fields[i].default_expr_typ != nil_type {
                                    fields[i].default_expr_typ = t.convert_generic_expr_type(fields[i].default_expr_typ,
                                        generic_names, info.concrete_types)
                                }
                                fields[i].default_expr = t.convert_generic_default_expr(fields[i].default_expr,
                                    generic_names, info.concrete_types)
                            }
                        }
                        parent_info.is_generic = false
                        parent_info.concrete_types = info.concrete_types.clone()
                        parent_info.fields = fields
                        parent_info.parent_type = new_type(info.parent_idx).set_flag(.generic)
                        sym.info = Struct{
                            ...parent_info
                            is_generic:     false
                            concrete_types: info.concrete_types.clone()
                            scoped_name:    sym.name
                        }
                        sym.is_pub = true
                        sym.kind = parent.kind

                        parent_sym := t.sym(parent_info.parent_type)
                        for method in parent_sym.methods {
                            if method.generic_names.len == info.concrete_types.len
                                && t.should_auto_register_concrete_method(method, parent_info.parent_type, info.concrete_types) {
                                t.register_fn_concrete_types(method.fkey(), info.concrete_types)
                            }
                        }
                    } else {
                        util.verror('generic error',
                            'the number of generic types of struct `${parent.name}` is inconsistent with the concrete types')
                    }
                }
                Interface {
                    mut parent_info := parent.info as Interface
                    if !parent_info.is_generic {
                        util.verror('generic error',
                            'interface `${parent.name}` is not a generic interface, cannot instantiate to the concrete types')
                        continue
                    }
                    if parent_info.generic_types.len == info.concrete_types.len {
                        mut fields := parent_info.fields.clone()
                        generic_names := t.get_generic_names(parent_info.generic_types)
                        for i in 0 .. fields.len {
                            if t_typ := t.convert_generic_type(fields[i].typ, generic_names,
                                info.concrete_types)
                            {
                                fields[i].typ = t_typ
                            }
                        }
                        mut imethods := parent_info.methods.clone()
                        for mut method in imethods {
                            method.generic_names.clear()
                            if pt := t.convert_generic_type(method.return_type, generic_names,
                                info.concrete_types)
                            {
                                method.return_type = pt
                            }
                            method.params = method.params.clone()
                            for mut param in method.params {
                                if pt := t.convert_generic_param_type(param, generic_names,
                                    info.concrete_types)
                                {
                                    param.typ = pt
                                }
                            }
                            sym.register_method(method)
                        }
                        mut all_methods := parent.methods.clone()
                        for imethod in imethods {
                            for mut method in all_methods {
                                if imethod.name == method.name {
                                    method = imethod
                                }
                            }
                        }
                        sym.info = Interface{
                            ...parent_info
                            is_generic:     false
                            concrete_types: info.concrete_types.clone()
                            fields:         fields
                            methods:        imethods
                            parent_type:    new_type(info.parent_idx).set_flag(.generic)
                        }
                        sym.is_pub = true
                        sym.kind = parent.kind
                        sym.methods = all_methods
                    } else {
                        util.verror('generic error',
                            'the number of generic types of interface `${parent.name}` is inconsistent with the concrete types')
                    }
                }
                SumType {
                    mut parent_info := parent.info as SumType
                    if !parent_info.is_generic {
                        util.verror('generic error',
                            'sumtype `${parent.name}` is not a generic sumtype, cannot instantiate to the concrete types')
                        continue
                    }
                    if parent_info.generic_types.len == info.concrete_types.len {
                        mut fields := parent_info.fields.clone()
                        mut variants := parent_info.variants.clone()
                        generic_names := t.get_generic_names(parent_info.generic_types)
                        for i in 0 .. fields.len {
                            if t_typ := t.convert_generic_type(fields[i].typ, generic_names,
                                info.concrete_types)
                            {
                                fields[i].typ = t_typ
                            }
                        }
                        for i in 0 .. variants.len {
                            t_sym := t.sym(variants[i])
                            if variants[i].has_flag(.generic)
                                || t_sym.kind == .generic_inst
                                || (t_sym.kind in [.struct, .sum_type, .interface]
                                && t_sym.has_generic_type_info()) {
                                if t_sym.kind == .struct && variants[i].idx() != info.parent_idx {
                                    variants[i] = t.unwrap_generic_type(variants[i], generic_names,
                                        info.concrete_types)
                                } else {
                                    if t_typ := t.convert_generic_type(variants[i], generic_names,
                                        info.concrete_types)
                                    {
                                        variants[i] = t_typ
                                    }
                                }
                            }
                        }
                        sym.info = SumType{
                            ...parent_info
                            is_generic:     false
                            concrete_types: info.concrete_types.clone()
                            fields:         fields
                            variants:       variants
                            parent_type:    new_type(info.parent_idx).set_flag(.generic)
                        }
                        sym.is_pub = true
                        sym.kind = parent.kind
                    } else {
                        util.verror('generic error',
                            'the number of generic types of sumtype `${parent.name}` is inconsistent with the concrete types')
                    }
                }
                FnType {
                    mut parent_info := parent.info as FnType
                    mut function := parent_info.func
                    function.params = function.params.clone()
                    for mut param in function.params {
                        if param.typ.has_flag(.generic) || t.generic_type_names(param.typ).len > 0 {
                            if t_typ := t.convert_generic_param_type(param, function.generic_names,
                                info.concrete_types)
                            {
                                param.typ = t_typ
                            } else {
                                param.typ = t.unwrap_generic_type_ex(param.typ,
                                    function.generic_names, info.concrete_types, true)
                            }
                        }
                        if param.orig_typ.has_flag(.generic)
                            || t.generic_type_names(param.orig_typ).len > 0 {
                            if t_typ := t.convert_generic_type(param.orig_typ,
                                function.generic_names, info.concrete_types)
                            {
                                param.orig_typ = t_typ
                            } else {
                                param.orig_typ = t.unwrap_generic_type_ex(param.orig_typ,
                                    function.generic_names, info.concrete_types, true)
                            }
                        }
                    }
                    return_type_sym := t.sym(function.return_type)
                    if function.return_type.has_flag(.generic)
                        || t.generic_type_names(function.return_type).len > 0
                        || (return_type_sym.kind == .generic_inst&& (return_type_sym.info as GenericInst).concrete_types.any(it.has_flag(.generic))) {
                        if t_typ := t.convert_generic_type(function.return_type,
                            function.generic_names, info.concrete_types)
                        {
                            function.return_type = t_typ
                        } else {
                            function.return_type = t.unwrap_generic_type_ex(function.return_type,
                                function.generic_names, info.concrete_types, true)
                        }
                    }
                    function.generic_names = []
                    sym.info = FnType{
                        ...parent_info
                        func: function
                    }
                    sym.parent_idx = info.parent_idx
                    sym.is_pub = true
                    sym.kind = parent.kind
                    sym.generic_types = info.concrete_types.clone()
                    for method in parent.methods {
                        if method.generic_names.len == info.concrete_types.len
                            && t.should_auto_register_concrete_method(method, new_type(info.parent_idx).set_flag(.generic), info.concrete_types) {
                            t.register_fn_concrete_types(method.fkey(), info.concrete_types)
                        }
                    }
                    t.specialize_generic_fn_type_methods(new_type(info.parent_idx).set_flag(.generic), mut
                        sym, parent_info.func.generic_names, info.concrete_types)
                }
                else {}
            }

            if sym.kind != .generic_inst && sym.language == .v && sym.name.contains('[') {
                sym.cname = sym.name.replace('.', '__').replace_each([
                    '[',
                    '_T_',
                    ']',
                    '',
                    ', ',
                    '_T_',
                    ',',
                    '_T_',
                    ' ',
                    '',
                    '&',
                    '__ptr__',
                    '(',
                    '_',
                    ')',
                    '_',
                ])
            }
        }
    }
    // Second pass: register method concrete types for Struct types that were
    // already converted from GenericInst (e.g. by unwrap_generic_type_ex)
    // but whose methods haven't been registered yet.
    for sym in t.type_symbols {
        if sym.kind != .struct {
            continue
        }
        if sym.info is Struct {
            if sym.info.concrete_types.len > 0 && sym.info.parent_type.has_flag(.generic)
                && !sym.info.concrete_types.any(it.has_flag(.generic))
                && !sym.info.concrete_types.any(t.generic_type_names(it).len > 0) {
                parent_sym := t.sym(sym.info.parent_type)
                for method in parent_sym.methods {
                    if method.generic_names.len == sym.info.concrete_types.len
                        && t.should_auto_register_concrete_method(method, sym.info.parent_type, sym.info.concrete_types) {
                        t.register_fn_concrete_types(method.fkey(), sym.info.concrete_types)
                    }
                }
            }
        }
    }
}

// Extracts all generic names from Type<A>[B] => B when <A>[B] is present
// otherwise generic_names is returned
pub fn (t &Table) get_real_generic_names(typ Type, generic_names []string) []string {
    if typ.has_flag(.generic) {
        typ_name := t.type_to_str(typ)
        if typ_name.contains('>[') {
            return typ_name.split('>[')[1].all_before_last(']').split(',')
        }
    }
    return generic_names
}

// Extracts all type names from given types, notice that MultiReturn will be decompose
// and will not included in returned string
pub fn (t &Table) get_generic_names(generic_types []Type) []string {
    mut generic_names := []string{cap: generic_types.len}
    for typ in generic_types {
        if !typ.has_flag(.generic) {
            continue
        }

        sym := t.sym(typ)
        info := sym.info

        match info {
            MultiReturn {
                generic_names << t.get_generic_names(info.types)
            }
            else {
                generic_names << sym.name
            }
        }
    }
    return generic_names
}

// check_if_elements_need_unwrap checks if the elements of a container (arrays, maps) need to be unwrapped to a concrete type
pub fn (mut t Table) check_if_elements_need_unwrap(root_typ Type, typ Type) bool {
    sym := t.sym(typ)
    if sym.kind !in [.array, .array_fixed, .map] {
        return false
    }

    mut typs := []Type{}
    match sym.info {
        Array {
            typs << (sym.info as Array).elem_type
        }
        ArrayFixed {
            typs << (sym.info as ArrayFixed).elem_type
        }
        Map {
            typs << (sym.info as Map).key_type
            typs << (sym.info as Map).value_type
        }
        else {}
    }

    for typ_ in typs {
        if typ_.has_flag(.generic) {
            t_sym := t.sym(typ_)
            match t_sym.info {
                Struct, Interface, SumType {
                    if t_sym.info.is_generic && t_sym.info.generic_types.len > 0
                        && t_sym.info.concrete_types.len == 0 && typ_.idx() != root_typ.idx() {
                        return true
                    }
                }
                else {}
            }
        }
        if t.check_if_elements_need_unwrap(root_typ, typ_) {
            return true
        }
    }
    return false
}

pub fn (t &Table) dependent_names_in_expr(expr Expr) []string {
    mut names := []string{}
    match expr {
        ArrayInit {
            for elem_expr in expr.exprs {
                names << t.dependent_names_in_expr(elem_expr)
            }
            if expr.has_len {
                names << t.dependent_names_in_expr(expr.len_expr)
            }
            if expr.has_cap {
                names << t.dependent_names_in_expr(expr.cap_expr)
            }
            if expr.has_init {
                names << t.dependent_names_in_expr(expr.init_expr)
            }
        }
        CallExpr {
            if expr.is_method {
                names << t.dependent_names_in_expr(expr.left)
            }
            for arg in expr.args {
                names << t.dependent_names_in_expr(arg.expr)
            }
            if func := t.find_fn(expr.name) {
                names << func.dep_names
            }
        }
        CastExpr {
            names << t.dependent_names_in_expr(expr.expr)
            names << t.dependent_names_in_expr(expr.arg)
        }
        Ident {
            if expr.kind in [.global, .constant] {
                names << util.no_dots(expr.name)
            }
        }
        IndexExpr {
            names << t.dependent_names_in_expr(expr.left)
        }
        IfExpr {
            for branch in expr.branches {
                names << t.dependent_names_in_expr(branch.cond)
                for stmt in branch.stmts {
                    names << t.dependent_names_in_stmt(stmt)
                }
            }
        }
        InfixExpr {
            names << t.dependent_names_in_expr(expr.left)
            names << t.dependent_names_in_expr(expr.right)
        }
        MapInit {
            for key in expr.keys {
                names << t.dependent_names_in_expr(key)
            }
            for val in expr.vals {
                names << t.dependent_names_in_expr(val)
            }
        }
        MatchExpr {
            names << t.dependent_names_in_expr(expr.cond)
            for branch in expr.branches {
                for stmt in branch.stmts {
                    names << t.dependent_names_in_stmt(stmt)
                }
            }
        }
        ParExpr {
            names << t.dependent_names_in_expr(expr.expr)
        }
        PostfixExpr {
            names << t.dependent_names_in_expr(expr.expr)
        }
        PrefixExpr {
            names << t.dependent_names_in_expr(expr.right)
        }
        StringInterLiteral {
            for inter_expr in expr.exprs {
                names << t.dependent_names_in_expr(inter_expr)
            }
        }
        SelectorExpr {
            names << t.dependent_names_in_expr(expr.expr)
        }
        StructInit {
            if expr.has_update_expr {
                names << t.dependent_names_in_expr(expr.update_expr)
            }
            for field in expr.init_fields {
                names << t.dependent_names_in_expr(field.expr)
            }
        }
        else {}
    }

    return names
}

pub fn (t &Table) dependent_names_in_stmt(stmt Stmt) []string {
    mut names := []string{}
    match stmt {
        AssignStmt {
            for expr in stmt.left {
                names << t.dependent_names_in_expr(expr)
            }
            for expr in stmt.right {
                names << t.dependent_names_in_expr(expr)
            }
        }
        ExprStmt {
            names << t.dependent_names_in_expr(stmt.expr)
        }
        ForInStmt {
            names << t.dependent_names_in_expr(stmt.cond)
            for stmt_ in stmt.stmts {
                names << t.dependent_names_in_stmt(stmt_)
            }
        }
        ForStmt {
            for stmt_ in stmt.stmts {
                names << t.dependent_names_in_stmt(stmt_)
            }
        }
        ForCStmt {
            names << t.dependent_names_in_stmt(stmt.init)
            names << t.dependent_names_in_expr(stmt.cond)
            names << t.dependent_names_in_stmt(stmt.inc)
            for stmt_ in stmt.stmts {
                names << t.dependent_names_in_stmt(stmt_)
            }
        }
        Return {
            for expr in stmt.exprs {
                names << t.dependent_names_in_expr(expr)
            }
        }
        else {}
    }

    return names
}

pub fn (t &Table) get_array_dims(arr Array) (int, Type) {
    mut dims := 1
    mut elem_type := arr.elem_type
    mut elem_sym := t.sym(elem_type)
    for mut elem_sym.info is Array {
        dims++
        elem_type = elem_sym.info.elem_type
        elem_sym = t.sym(elem_type)
    }
    return dims, elem_type
}

pub fn (t &Table) get_trace_fn_name(cur_fn FnDecl, node CallExpr) (string, string) {
    generic_name := node.concrete_types.map(t.type_to_str(it)).join('_')
    hash_fn := '_v__trace__${cur_fn.name}_${node.name}_${generic_name}_${node.pos.line_nr}'
    fn_name := if node.concrete_types.len > 0 { '${node.name}_T_${generic_name}' } else { node.name }
    return hash_fn, fn_name
}

// get_attrs retrieve the attribrutes from the type symbol
pub fn (t &Table) get_attrs(sym TypeSymbol) []Attr {
    match sym.info {
        Enum {
            return t.enum_decls[sym.name].attrs
        }
        Struct {
            return sym.info.attrs
        }
        FnType {
            return sym.info.func.attrs
        }
        Interface {
            return unsafe { t.interfaces[sym.idx].attrs }
        }
        SumType {
            return unsafe { t.sumtypes[sym.idx].attrs }
        }
        else {
            return []
        }
    }
}

pub fn (mut t Table) get_veb_result_type_idx() int {
    if t.veb_res_idx_cache > 0 {
        return t.veb_res_idx_cache
    }

    t.veb_res_idx_cache = t.find_type('veb.Result')
    return t.veb_res_idx_cache
}

@[inline]
pub fn (mut t Table) register_vls_info(key string, val VlsInfo) {
    t.vls_info[key] = val
}

pub fn (t &Table) unwrap(typ Type) Type {
    ts := t.sym(typ)
    return if ts.info is Alias { t.unwrap(ts.info.parent_type) } else { typ }
}