module checker

import strings
import v.ast
import v.util
import v.token
import os

const print_everything_fns = ['println', 'print', 'eprintln', 'eprint', 'panic']

fn first_attr_by_name(attrs []ast.Attr, name string) (ast.Attr, bool) {
    for attr in attrs {
        if attr.name == name {
            return attr, true
        }
    }
    return ast.Attr{}, false
}

fn comptime_define_attr_idx(attrs []ast.Attr) int {
    for idx in 0 .. attrs.len {
        if attrs[idx].kind == .comptime_define {
            return idx
        }
    }
    return ast.invalid_type_idx
}

@[inline]
fn (c &Checker) implicit_mutability_enabled() bool {
    return c.pref.disable_explicit_mutability
        && (!os.dir(c.file.path).contains('vlib') || c.file.path.ends_with('.vv'))
}

@[inline]
fn (c &Checker) implicit_mut_call_arg(param ast.Param, arg ast.CallArg) ast.CallArg {
    if !c.implicit_mutability_enabled() || arg.is_mut || !param.is_mut
        || param.typ.share() != .mut_t {
        return arg
    }
    return ast.CallArg{
        ...arg
        is_mut: true
    }
}

fn (mut c Checker) check_os_raw_io_call(node &ast.CallExpr, func &ast.Fn, concrete_types []ast.Type, arg_offset int) {
    if func.mod != 'os' || !func.is_method {
        return
    }
    match func.name {
        'write_struct', 'write_struct_at', 'write_raw', 'write_raw_at', 'read_struct',
        'read_struct_at' {
            if node.args.len > arg_offset {
                c.ensure_os_raw_io_type(node.args[arg_offset].typ, func.name,
                    node.args[arg_offset].pos)
            }
        }
        'read_raw', 'read_raw_at' {
            if concrete_types.len > 0 {
                c.ensure_os_raw_io_type(concrete_types.last(), func.name, node.pos)
            }
        }
        else {}
    }
}

fn (mut c Checker) refresh_generic_fn_scope_vars(node &ast.FnDecl) {
    generic_names := c.effective_fn_generic_names(node)
    if c.table.cur_concrete_types.len == 0 || generic_names.len != c.table.cur_concrete_types.len {
        return
    }
    if node.is_method {
        receiver_type := c.recheck_concrete_type(node.receiver.typ)
        if mut receiver_var := c.fn_scope.find_var(node.receiver.name) {
            if receiver_var.generic_typ == 0 && (node.receiver.typ.has_flag(.generic)
                || c.type_has_unresolved_generic_parts(node.receiver.typ)) {
                receiver_var.generic_typ = node.receiver.typ
            }
            receiver_var.typ = receiver_type
            receiver_var.orig_type = ast.no_type
            receiver_var.smartcasts = []
            receiver_var.is_unwrapped = false
        }
    }
    for param in node.params {
        param_source_type := if param.is_mut && param.orig_typ != 0
            && (param.orig_typ.has_flag(.generic)
            || c.type_has_unresolved_generic_parts(param.orig_typ)) {
            param.orig_typ
        } else {
            param.typ
        }
        param_type := c.recheck_concrete_type(param_source_type)
        if mut param_var := c.fn_scope.find_var(param.name) {
            if param_var.generic_typ == 0 && (param_source_type.has_flag(.generic)
                || c.type_has_unresolved_generic_parts(param_source_type)) {
                param_var.generic_typ = param_source_type
            }
            param_var.typ = param_type
            param_var.orig_type = ast.no_type
            param_var.smartcasts = []
            param_var.is_unwrapped = false
        }
    }
}

fn (c &Checker) struct_embeds_type(got ast.Type, expected ast.Type) bool {
    got_sym := c.table.final_sym(got)
    if got_sym.info !is ast.Struct {
        return false
    }
    got_info := got_sym.info as ast.Struct
    expected_unaliased := c.table.unaliased_type(expected)
    for embed in got_info.embeds {
        embed_unaliased := c.table.unaliased_type(embed)
        if embed_unaliased == expected_unaliased
            || c.struct_embeds_type(embed_unaliased, expected_unaliased) {
            return true
        }
    }
    return false
}

fn (c &Checker) embeds_expected_call_arg_type(got ast.Type, expected ast.Type) bool {
    if got == 0 || expected == 0 {
        return false
    }
    got_base := if got.is_ptr() { got.deref() } else { got }
    expected_base := if expected.is_ptr() { expected.deref() } else { expected }
    if got_base == expected_base {
        return false
    }
    got_sym := c.table.final_sym(got_base)
    if got_sym.info !is ast.Struct {
        return false
    }
    return c.struct_embeds_type(got_base, expected_base)
}

fn (mut c Checker) effective_fn_generic_names(node &ast.FnDecl) []string {
    if node.generic_names.len > 0 {
        return node.generic_names.clone()
    }
    if !node.is_method {
        return []string{}
    }
    if !node.receiver.typ.has_flag(.generic)
        && !c.type_has_unresolved_generic_parts(node.receiver.typ) {
        return []string{}
    }
    rec_sym := c.table.sym(c.unwrap_generic(node.receiver.typ))
    match rec_sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            if rec_sym.info.generic_types.len > 0 {
                return rec_sym.info.generic_types.map(c.table.sym(it).name)
            }
        }
        else {}
    }

    return c.table.generic_type_names(node.receiver.typ)
}

fn (mut c Checker) generic_anon_fn_can_use_current_context(generic_names []string) bool {
    if generic_names.len == 0 || c.table.cur_fn == unsafe { nil } {
        return false
    }
    current_generic_names := c.effective_fn_generic_names(c.table.cur_fn)
    if current_generic_names.len == 0 {
        return false
    }
    return generic_names.all(it in current_generic_names)
}

fn (mut c Checker) receiver_requires_generic_names(node &ast.FnDecl) bool {
    if !node.is_method {
        return false
    }
    return node.receiver.typ.has_flag(.generic)
}

fn (mut c Checker) check_receiver_decl_generic_type_names(node &ast.FnDecl) {
    if !node.is_method {
        return
    }
    receiver_sym := c.table.final_sym(node.receiver.typ)
    match receiver_sym.info {
        ast.Struct {
            if receiver_sym.info.generic_types.len > 0 && !node.receiver.typ.has_flag(.generic)
                && receiver_sym.info.concrete_types.len == 0 {
                pure_sym_name := receiver_sym.embed_name()
                c.error('generic struct `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                    node.receiver.type_pos)
            }
        }
        ast.Interface {
            if receiver_sym.info.generic_types.len > 0 && !node.receiver.typ.has_flag(.generic)
                && receiver_sym.info.concrete_types.len == 0 {
                pure_sym_name := receiver_sym.embed_name()
                c.error('generic interface `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                    node.receiver.type_pos)
            }
        }
        ast.SumType {
            if receiver_sym.info.generic_types.len > 0 && !node.receiver.typ.has_flag(.generic)
                && receiver_sym.info.concrete_types.len == 0 {
                pure_sym_name := receiver_sym.embed_name()
                c.error('generic sumtype `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                    node.receiver.type_pos)
            }
        }
        else {}
    }
}

fn (mut c Checker) check_receiver_decl_generic_name_mentions(node &ast.FnDecl) {
    if !node.is_method || !node.receiver.typ.has_flag(.generic) {
        return
    }
    generic_names := c.table.generic_type_names(node.receiver.typ)
    for name in generic_names {
        if name !in node.generic_names {
            fn_generic_names := node.generic_names.join(', ')
            c.error('generic type name `${name}` is not mentioned in fn `${node.name}[${fn_generic_names}]`',
                node.receiver.type_pos)
        }
    }
}

fn (mut c Checker) fn_decl(mut node ast.FnDecl) {
    // handle vls go to definition for method receiver types
    if c.pref.is_vls {
        // Hover over fn keyword or function name on the declaration line — show full declaration.
        on_fn_name := c.vls_is_the_node(node.name_pos)
        on_fn_keyword := c.pref.linfo.line_nr == node.name_pos.line_nr
            && c.pref.linfo.col >= int(node.pos.col) - 1 && c.pref.linfo.col < node.name_pos.col
            && node.name_pos.file_idx >= 0
            && os.real_path(c.pref.linfo.path) == os.real_path(c.table.filelist[node.name_pos.file_idx])
        if c.pref.linfo.method == .completion && (on_fn_name || on_fn_keyword) {
            mut params := []string{cap: node.params.len}
            for param in node.params {
                if param.is_hidden {
                    continue
                }
                params << '${param.name} ${c.table.type_to_str(param.typ)}'
            }
            ret_str := if node.return_type != ast.no_type && node.return_type != ast.void_type {
                ' ' + c.table.type_to_str(node.return_type)
            } else {
                ''
            }
            declaration := 'fn ${node.short_name}(${params.join(', ')})${ret_str}'
            mut doc := ''
            mod := node.name.all_before_last('.')
            if info := c.table.vls_info['fn_${mod}[]${node.short_name}'] {
                doc = info.doc
            }
            c.vls_write_details([
                Detail{
                    kind:          .function
                    label:         node.short_name
                    declaration:   declaration
                    documentation: doc
                },
            ])
            exit(0)
        }
        if node.is_method && node.receiver.type_pos.line_nr > 0 {
            if c.vls_is_the_node(node.receiver.type_pos) {
                typ_str := c.table.type_to_str(node.receiver.typ)
                if np := c.name_pos_gotodef(typ_str) {
                    if np.file_idx != -1 {
                        println('${c.table.filelist[np.file_idx]}:${np.line_nr + 1}:${np.col}')
                    }
                    exit(0)
                }
            }
        }
        if node.return_type_pos.line_nr > 0 {
            if c.vls_is_the_node(node.return_type_pos) {
                typ_str := c.table.type_to_str(node.return_type)
                if np := c.name_pos_gotodef(typ_str) {
                    if np.file_idx != -1 {
                        println('${c.table.filelist[np.file_idx]}:${np.line_nr + 1}:${np.col}')
                    }
                    exit(0)
                }
            }
        }
    }
    $if trace_post_process_generic_fns_types ? {
        if node.generic_names.len > 0 {
            eprintln('>>> post processing node.name: ${node.name:-30} | ${node.generic_names} <=> ${c.table.cur_concrete_types}')
        }
    }
    if node.language in [.c, .js] && node.generic_names.len > 0 {
        lang := if node.language == .c { 'C' } else { 'JS' }
        c.error('${lang} functions cannot be declared as generic', node.pos)
    }
    // record the veb route methods (public non-generic methods):
    if node.generic_names.len > 0 && node.is_pub {
        typ_veb_result := c.table.find_type('veb.Result')
        if node.return_type == typ_veb_result {
            rec_sym := c.table.sym(node.receiver.typ)
            if rec_sym.kind == .struct {
                if _ := c.table.find_field_with_embeds(rec_sym, 'Context') {
                    // there is no point in the message here, for methods
                    // that are not public; since they will not be available as routes anyway
                    c.note('generic method routes of veb will be skipped', node.pos)
                }
            }
        }
    }
    mut need_generic_names := false
    if node.generic_names.len == 0 {
        if node.return_type.has_flag(.generic) {
            need_generic_names = true
        } else if c.receiver_requires_generic_names(node) {
            need_generic_names = true
        } else {
            for param in node.params {
                if param.typ.has_flag(.generic) {
                    need_generic_names = true
                    break
                }
            }
        }
        if need_generic_names {
            if node.is_method {
                c.add_error_detail('use `fn (r SomeType[T]) foo[T]() {`, not just `fn (r SomeType[T]) foo() {`')
                c.error('generic method declaration must specify generic type names', node.pos)
            } else {
                c.add_error_detail('use `fn foo[T](x T) {`, not just `fn foo(x T) {`')
                c.error('generic function declaration must specify generic type names', node.pos)
            }
        }
    }
    c.check_receiver_decl_generic_type_names(node)
    c.check_receiver_decl_generic_name_mentions(node)
    effective_generic_names := c.effective_fn_generic_names(node)
    if effective_generic_names.len > 0 && c.table.cur_concrete_types.len == 0 {
        // Just remember the generic function for now.
        // It will be processed later in c.post_process_generic_fns,
        // after all other normal functions are processed.
        // This is done so that all generic function calls can
        // have a chance to populate c.table.fn_generic_types with
        // the correct concrete types.
        fkey := node.fkey()
        if !c.generic_fns[fkey] {
            c.need_recheck_generic_fns = true
            c.generic_fns[fkey] = true
            c.file.generic_fns << node
        }
        return
    }
    node.ninstances++
    // save all the state that fn_decl or inner  statements/expressions
    // could potentially modify, since functions can be nested, due to
    // anonymous function support, and ensure that it is restored, when
    // fn_decl returns:
    prev_fn_scope := c.fn_scope
    prev_in_for_count := c.in_for_count
    prev_inside_defer := c.inside_defer
    prev_inside_unsafe := c.inside_unsafe
    prev_inside_anon_fn := c.inside_anon_fn
    prev_returns := c.returns
    prev_stmt_level := c.stmt_level
    prev_assert_autocasts := c.assert_autocasts.clone()
    c.fn_level++
    c.in_for_count = 0
    c.inside_defer = false
    c.inside_unsafe = node.is_unsafe
    c.returns = false
    c.assert_autocasts = map[string]AssertAutocast{}
    defer {
        c.stmt_level = prev_stmt_level
        c.fn_level--
        c.returns = prev_returns
        c.inside_anon_fn = prev_inside_anon_fn
        c.inside_unsafe = prev_inside_unsafe
        c.inside_defer = prev_inside_defer
        c.in_for_count = prev_in_for_count
        c.fn_scope = prev_fn_scope
        c.assert_autocasts = prev_assert_autocasts.clone()
    }
    // Check generics fn/method without generic type parameters
    if node.language == .v && !c.is_builtin_mod && !node.is_anon
        && !node.get_name().contains('veb_tmpl_') {
        c.check_valid_snake_case(node.get_name(), 'function name', node.pos)
        if !node.is_method && node.mod == 'main' && node.short_name in c.table.builtin_pub_fns {
            c.error('cannot redefine builtin public function `${node.short_name}`', node.pos)
        }
        c.check_module_name_conflict(node.short_name, node.pos)
    }
    if node.kind == .main_main {
        c.main_fn_decl_node = *node
    }
    if node.language == .v && node.attrs.len > 0 {
        required_args_attr := ['export', '_linker_section']
        for attr_name in required_args_attr {
            attr, has_attr := first_attr_by_name(node.attrs, attr_name)
            if has_attr {
                if attr.arg == '' {
                    c.error('missing argument for @[${attr_name}] attribute', attr.pos)
                } else if attr_name == 'export' {
                    // export fn name
                    fn_name := attr.arg
                    if !fn_name.is_identifier() {
                        c.error('export name `${fn_name}` should be a valid identifier', node.pos)
                    }
                    if fn_name in c.table.export_names.values() {
                        c.error('duplicate export name `${fn_name}`', node.pos)
                    } else {
                        mut node_name := node.name
                        if node.is_method {
                            node_name = c.table.type_to_str(node.receiver.typ) + '.' + node_name
                        }
                        c.table.export_names[node_name] = fn_name
                    }
                }
            }
        }
    }
    if node.return_type == ast.no_type {
        c.error('invalid return type in fn `${node.name}`', node.pos)
        return
    }
    c.fn_return_type = node.return_type
    return_type_unaliased := c.table.unaliased_type(node.return_type)
    if node.return_type.has_flag(.option) && return_type_unaliased.has_flag(.result) {
        c.error('the fn returns ${c.error_type_name(node.return_type)}, but ${c.error_type_name(node.return_type.clear_flag(.option))} is a Result alias, you can not mix them',
            node.return_type_pos)
    }
    if node.return_type.has_flag(.result) && return_type_unaliased.has_flag(.option) {
        c.error('the fn returns ${c.error_type_name(node.return_type)}, but ${c.error_type_name(node.return_type.clear_flag(.result))} is an Option alias, you can not mix them',
            node.return_type_pos)
    }
    if node.return_type != ast.void_type {
        if node.language == .v && node.return_type.clear_option_and_result() == ast.any_type {
            c.error('cannot use type `any` here', node.return_type_pos)
        }
        ct_attr_idx := comptime_define_attr_idx(node.attrs)
        if ct_attr_idx != ast.invalid_type_idx {
            sexpr := node.attrs[ct_attr_idx].ct_expr.str()
            c.error('only functions that do NOT return values can have `@[if ${sexpr}]` tags',
                node.pos)
        }
        if node.generic_names.len > 0 {
            gs := c.table.sym(node.return_type)
            mut has_missing_generic_return_type := false
            if gs.info is ast.Struct {
                if gs.info.is_generic && !node.return_type.has_flag(.generic) {
                    has_missing_generic_return_type = true
                    c.error('return generic struct `${gs.name}` in fn declaration must specify the generic type names, e.g. ${gs.name}[T]',
                        node.return_type_pos)
                }
            }
            if gs.kind == .struct && !has_missing_generic_return_type
                && c.needs_unwrap_generic_type(node.return_type) {
                // resolve generic Array[T], Map[T] generics, avoid recursive generic resolving type
                if c.ensure_generic_type_specify_type_names(node.return_type, node.return_type_pos,
                    false, false)
                {
                    c.table.unwrap_generic_type_ex(node.return_type, c.table.cur_fn.generic_names,
                        c.table.cur_concrete_types, true)
                }
            }
        }
        return_sym := c.table.sym(node.return_type)
        if return_sym.info is ast.Alias {
            parent_sym := c.table.sym(return_sym.info.parent_type)
            if parent_sym.info is ast.ArrayFixed {
                c.table.find_or_register_array_fixed(parent_sym.info.elem_type,
                    parent_sym.info.size, parent_sym.info.size_expr, true)
            }
            if return_sym.name == 'byte' {
                c.error('byte is deprecated, use u8 instead', node.return_type_pos)
            }
        }
        if return_sym.info is ast.ArrayFixed && c.array_fixed_has_unresolved_size(return_sym.info) {
            c.unresolved_fixed_sizes << node
        }

        final_return_sym := c.table.final_sym(node.return_type)
        if final_return_sym.info is ast.MultiReturn {
            for multi_type in final_return_sym.info.types {
                if multi_type == ast.error_type {
                    c.error('type `IError` cannot be used in multi-return, return an Option instead',
                        node.return_type_pos)
                } else if multi_type.has_flag(.result) {
                    c.error('result cannot be used in multi-return, return a Result instead',
                        node.return_type_pos)
                }
            }
        }
        // Ensure each generic type of the parameter was declared in the function's definition
        if node.return_type.has_flag(.generic) {
            ret_sym := c.table.sym(node.return_type)
            // Skip check for forward-declared types (placeholder) where the
            // generic param names haven't been resolved yet
            if ret_sym.kind != .placeholder {
                generic_names := c.table.generic_type_names(node.return_type)
                for name in generic_names {
                    if name !in node.generic_names {
                        // When a generic struct is used as return type and the struct's
                        // generic param names differ from the fn's (e.g. struct uses T
                        // but fn uses B), skip if the return type sym is the base generic
                        // struct (not yet instantiated with concrete types)
                        if ret_sym.info is ast.Struct && ret_sym.info.is_generic
                            && ret_sym.generic_types.len == 0 {
                            continue
                        }
                        fn_generic_names := node.generic_names.join(', ')
                        c.error('generic type name `${name}` is not mentioned in fn `${node.name}[${fn_generic_names}]`',
                            node.return_type_pos)
                    }
                }
            }
        }
    } else {
        for mut a in node.attrs {
            if a.kind == .comptime_define {
                node.should_be_skipped = c.evaluate_once_comptime_if_attribute(mut a)
            }
        }
    }
    if node.is_method {
        if node.receiver.name in c.global_names {
            c.error('cannot use global variable name `${node.receiver.name}` as receiver',
                node.receiver_pos)
        }
        if node.receiver.typ.has_flag(.option) {
            c.error('option types cannot have methods', node.receiver_pos)
        }
        mut sym := c.table.sym(node.receiver.typ)
        if sym.kind == .array && !c.is_builtin_mod && node.kind == .map {
            // TODO: `node.map in array_builtin_methods`
            c.error('method overrides built-in array method', node.pos)
        } else if sym.kind == .sum_type && node.kind == .type_name {
            c.error('method overrides built-in sum type method', node.pos)
        } else if sym.kind == .sum_type && node.kind == .type_idx {
            c.error('method overrides built-in sum type method', node.pos)
        } else if sym.kind == .multi_return {
            c.error('cannot define method on multi-value', node.method_type_pos)
        }
        if sym.name.len == 1 {
            // One letter types are reserved for generics.
            c.error('unknown type `${sym.name}`', node.receiver_pos)
            return
        }
        // make sure interface does not implement its own interface methods
        if mut sym.info is ast.Interface && sym.has_method(node.name) {
            // if the method is in info.methods then it is an interface method
            if sym.info.has_method(node.name) {
                c.error('interface `${sym.name}` cannot implement its own interface method `${node.name}`',
                    node.pos)
            }
        }
        if mut sym.info is ast.Struct {
            if field := c.table.find_field(sym, node.name) {
                field_sym := c.table.sym(field.typ)
                if field_sym.kind == .function {
                    c.error('type `${sym.name}` has both field and method named `${node.name}`',
                        node.pos)
                }
            }
            if node.kind == .free {
                if node.return_type != ast.void_type {
                    c.error('`.free()` methods should not have a return type', node.return_type_pos)
                }
                if !node.receiver.typ.is_ptr() {
                    tname := sym.name.after_char(`.`)
                    c.error('`.free()` methods should be defined on either a `(mut x &${tname})`, or a `(x &${tname})` receiver',
                        node.receiver_pos)
                }
                if node.params.len != 1 {
                    c.error('`.free()` methods should have 0 arguments', node.pos)
                }
            }
        }
        // needed for proper error reporting during veb route checking
        if node.method_idx < sym.methods.len {
            sym.methods[node.method_idx].source_fn = voidptr(node)
        } else {
            c.error('method index: ${node.method_idx} >= sym.methods.len: ${sym.methods.len}',
                node.pos)
        }
    }
    if node.language == .v {
        // Make sure all types are valid
        for mut param in node.params {
            param.typ = c.preferred_c_symbol_type(param.typ)
            if mut scoped_param := node.scope.find_var(param.name) {
                scoped_param.typ = param.typ
            }
            // handle vls go to definition for parameter types
            if c.pref.is_vls && c.pref.linfo.method == .definition {
                if c.vls_is_the_node(param.type_pos) {
                    typ_str := c.table.type_to_str(param.typ)
                    if np := c.name_pos_gotodef(typ_str) {
                        if np.file_idx != -1 {
                            println('${c.table.filelist[np.file_idx]}:${np.line_nr + 1}:${np.col}')
                        }
                        exit(0)
                    }
                }
            }
            if !c.ensure_type_exists(param.typ, param.type_pos) {
                return
            }
            if reserved_type_names_chk.matches(param.name) {
                c.error('invalid use of reserved type `${param.name}` as a parameter name',
                    param.pos)
            }
            if param.typ.has_flag(.result) {
                c.error('result type arguments are not supported', param.type_pos)
            }
            arg_typ_sym := c.table.sym(param.typ)
            if arg_typ_sym.language == .v && param.typ == ast.any_type
                && c.file.mod.name != 'builtin' {
                c.note('the `any` type is deprecated and will be removed soon - either use an empty interface, or a sum type',
                    param.pos)
            }
            // resolve unresolved fixed array size e.g. [mod.const]array_type
            if arg_typ_sym.info is ast.ArrayFixed
                && c.array_fixed_has_unresolved_size(arg_typ_sym.info) {
                mut size_expr := unsafe { arg_typ_sym.info.size_expr }
                param.typ = c.eval_array_fixed_sizes(mut size_expr, 0, arg_typ_sym.info.elem_type)
                mut v := node.scope.find_var(param.name) or { continue }
                v.typ = param.typ
            } else if arg_typ_sym.info is ast.Struct {
                if !param.typ.is_ptr() && arg_typ_sym.info.is_heap { // set auto_heap to promote value parameter
                    mut v := node.scope.find_var(param.name) or { continue }
                    v.is_auto_heap = true
                }
                if arg_typ_sym.info.generic_types.len > 0 && !param.typ.has_flag(.generic)
                    && arg_typ_sym.info.concrete_types.len == 0 {
                    pure_sym_name := arg_typ_sym.embed_name()
                    c.error('generic struct `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                        param.type_pos)
                }
                if param.is_mut && arg_typ_sym.info.attrs.any(it.name == 'params') {
                    c.error('declaring a mutable parameter that accepts a struct with the `@[params]` attribute is not allowed',
                        param.type_pos)
                }
            } else if arg_typ_sym.info is ast.Interface {
                if arg_typ_sym.info.generic_types.len > 0 && !param.typ.has_flag(.generic)
                    && arg_typ_sym.info.concrete_types.len == 0 {
                    pure_sym_name := arg_typ_sym.embed_name()
                    c.error('generic interface `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                        param.type_pos)
                }
            } else if arg_typ_sym.info is ast.SumType {
                if arg_typ_sym.info.generic_types.len > 0 && !param.typ.has_flag(.generic)
                    && arg_typ_sym.info.concrete_types.len == 0 {
                    pure_sym_name := arg_typ_sym.embed_name()
                    c.error('generic sumtype `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                        param.type_pos)
                }
            } else if arg_typ_sym.info is ast.FnType {
                if arg_typ_sym.info.func.generic_names.len > 0 && !param.typ.has_flag(.generic) {
                    pure_sym_name := arg_typ_sym.embed_name()
                    c.error('generic function `${pure_sym_name}` in fn declaration must specify the generic type names, e.g. ${pure_sym_name}[T]',
                        param.type_pos)
                }
            }
            // Ensure each generic type of the parameter was declared in the function's definition
            if param.typ.has_flag(.generic) {
                generic_names := c.table.generic_type_names(param.typ)
                for name in generic_names {
                    if name !in node.generic_names {
                        fn_generic_names := node.generic_names.join(', ')
                        c.error('generic type name `${name}` is not mentioned in fn `${node.name}[${fn_generic_names}]`',
                            param.type_pos)
                    }
                }
            }
            if c.pref.skip_unused {
                if param.typ.has_flag(.generic) {
                    c.table.used_features.comptime_syms[c.unwrap_generic(param.typ)] = true
                    c.table.used_features.comptime_syms[param.typ] = true
                }
                if node.return_type.has_flag(.generic) {
                    c.table.used_features.comptime_syms[c.unwrap_generic(node.return_type)] = true
                    c.table.used_features.comptime_syms[node.return_type] = true
                }
                if node.receiver.typ.has_flag(.generic) {
                    c.table.used_features.comptime_syms[node.receiver.typ] = true
                    c.table.used_features.comptime_syms[c.unwrap_generic(node.receiver.typ)] = true
                }
            }
            if param.name == node.mod && param.name != 'main' {
                c.error('duplicate of a module name `${param.name}`', param.pos)
            }
            // Check if parameter name is already registered as imported module symbol
            if c.check_import_sym_conflict(param.name) {
                c.error('duplicate of an import symbol `${param.name}`', param.pos)
            }
            if arg_typ_sym.kind == .alias && arg_typ_sym.name == 'byte' {
                c.error('byte is deprecated, use u8 instead', param.type_pos)
            }
        }
        if !node.is_method {
            // Check if function name is already registered as imported module symbol
            if c.check_import_sym_conflict(node.short_name) {
                c.error('duplicate of an import symbol `${node.short_name}`', node.pos)
            }
            if node.params.len == 0 && node.name.after_char(`.`) == 'init' {
                if node.is_pub {
                    c.error('fn `init` must not be public', node.pos)
                }
                if node.return_type != ast.void_type {
                    c.error('fn `init` cannot have a return type', node.pos)
                }
            }
            if !c.is_builtin_mod && node.mod == 'main'
                && node.name.after_char(`.`) in reserved_type_names {
                c.error('top level declaration cannot shadow builtin type', node.pos)
            }
            if node.is_static_type_method {
                if sym := c.table.find_sym(node.name.all_before('__static__')) {
                    if sym.kind == .placeholder {
                        c.error('unknown type `${sym.name}`', node.static_type_pos)
                    }
                }
            }
        }
    }
    if node.return_type != ast.no_type {
        node.return_type = c.preferred_c_symbol_type(node.return_type)
        if !c.ensure_type_exists(node.return_type, node.return_type_pos) {
            return
        }
        if node.language == .v && node.is_method && node.kind == .str {
            if node.return_type != ast.string_type {
                c.error('.str() methods should return `string`', node.pos)
            }
            if node.params.len != 1 {
                c.error('.str() methods should have 0 arguments', node.pos)
            }
        }
        if node.language == .v && node.is_method
            && node.name in ['+', '-', '*', '%', '/', '<', '=='] {
            if node.params.len != 2 {
                c.error('operator methods should have exactly 1 argument', node.pos)
            } else {
                receiver_type := node.receiver.typ
                receiver_sym := c.table.sym(receiver_type)

                param_type := node.params[1].typ
                param_sym := c.table.sym(param_type)

                if param_sym.kind == .string && receiver_sym.kind == .string {
                    // bypass check for strings
                    // TODO: there must be a better way to handle that
                } else if param_sym.kind !in [.struct, .alias]
                    || receiver_sym.kind !in [.struct, .alias] {
                    c.error('operator methods are only allowed for struct and type alias', node.pos)
                } else {
                    parent_sym := c.table.final_sym(node.receiver.typ)
                    if node.rec_mut {
                        c.error('receiver cannot be `mut` for operator overloading',
                            node.receiver_pos)
                    } else if node.params[1].is_mut {
                        c.error('argument cannot be `mut` for operator overloading', node.pos)
                    } else if !c.check_same_type_ignoring_pointers(node.receiver.typ,
                        node.params[1].typ) {
                        c.error('expected `${receiver_sym.name}` not `${param_sym.name}` - both operands must be the same type for operator overloading',
                            node.params[1].type_pos)
                    } else if node.return_type != ast.bool_type && node.name in ['<', '=='] {
                        c.error('operator comparison methods should return `bool`', node.pos)
                    } else if parent_sym.is_primitive() {
                        if node.return_type.has_option_or_result() {
                            c.error('return type cannot be Option or Result', node.return_type_pos)
                        } else if node.name in ['+', '-', '*', '**', '%', '/']
                            && node.return_type != receiver_type {
                            srtype := c.table.type_to_str(receiver_type)
                            c.error('operator `${node.name}` methods on primitive aliases should return `${srtype}`',
                                node.return_type_pos)
                        }
                        // aliases of primitive types are explicitly allowed
                    } else if receiver_type != param_type {
                        srtype := c.table.type_to_str(receiver_type)
                        sptype := c.table.type_to_str(param_type)
                        c.error('the receiver type `${srtype}` should be the same type as the operand `${sptype}`',
                            node.pos)
                    } else if node.return_type.has_option_or_result() {
                        c.error('return type cannot be Option or Result', node.return_type_pos)
                    }
                }
            }
        }
        if node.language == .v && node.is_method && node.name == '[]' {
            if node.params.len != 2 {
                c.error('index operator methods should have exactly 1 argument', node.pos)
            } else {
                receiver_type := node.receiver.typ
                receiver_sym := c.table.sym(receiver_type)
                index_sym := c.table.sym(node.params[1].typ)
                if index_sym.kind == .placeholder {
                    c.error('unknown type `${index_sym.name}`', node.params[1].type_pos)
                }
                if receiver_sym.kind !in [.struct, .alias] {
                    c.error('index operator methods are only allowed for struct and type alias',
                        node.pos)
                } else if node.rec_mut {
                    c.error('receiver cannot be `mut` for `[]`, use `[]=` for writable indexing',
                        node.receiver_pos)
                } else if node.params[1].is_mut {
                    c.error('argument cannot be `mut` for operator overloading', node.pos)
                } else if node.return_type == ast.void_type {
                    c.error('index operator methods should return a value', node.return_type_pos)
                }
            }
        }
        if node.language == .v && node.is_method && node.name == '[]=' {
            if node.params.len != 3 {
                c.error('index assignment operator methods should have exactly 2 arguments',
                    node.pos)
            } else {
                receiver_sym := c.table.sym(node.receiver.typ)
                index_sym := c.table.sym(node.params[1].typ)
                value_sym := c.table.sym(node.params[2].typ)
                if index_sym.kind == .placeholder {
                    c.error('unknown type `${index_sym.name}`', node.params[1].type_pos)
                }
                if value_sym.kind == .placeholder {
                    c.error('unknown type `${value_sym.name}`', node.params[2].type_pos)
                }
                if receiver_sym.kind !in [.struct, .alias] {
                    c.error('index assignment operator methods are only allowed for struct and type alias',
                        node.pos)
                } else if !node.rec_mut {
                    c.error('receiver must be `mut` for `[]=` operator overloading',
                        node.receiver_pos)
                } else if node.params[1].is_mut || node.params[2].is_mut {
                    c.error('arguments cannot be `mut` for operator overloading', node.pos)
                } else if node.return_type != ast.void_type {
                    c.error('index assignment operator methods cannot return a value',
                        node.return_type_pos)
                }
            }
        }
    }
    // TODO: c.pref.is_vet
    if c.file.is_test && (!node.is_method && (node.short_name.starts_with('test_')
        || node.short_name.starts_with('testsuite_')
        || node.short_name in ['before_each', 'after_each'])) {
        if !c.pref.is_test {
            // simple heuristic
            for st in node.stmts {
                if st is ast.AssertStmt {
                    c.warn('tests will not be run, because filename does not end with `_test.v`',
                        node.pos)
                    break
                }
            }
        }

        if node.params.len != 0 {
            c.error('test functions should take 0 parameters', node.pos)
        }

        if node.return_type != ast.void_type_idx
            && node.return_type.clear_flag(.option) != ast.void_type_idx
            && node.return_type.clear_flag(.result) != ast.void_type_idx {
            c.error('test functions should either return nothing at all, or be marked to return `?` or `!`',
                node.pos)
        }
    }
    c.expected_type = ast.void_type
    saved_generic_names := node.generic_names
    mut needs_generic_names_restore := false
    saved_return_type := node.return_type
    if c.table.cur_concrete_types.len > 0
        && effective_generic_names.len == c.table.cur_concrete_types.len
        && node.generic_names != effective_generic_names {
        unsafe {
            mut p := &[]string(&node.generic_names)
            *p = effective_generic_names.clone()
        }
        needs_generic_names_restore = true
    }
    c.table.cur_fn = unsafe { node }
    if c.table.cur_concrete_types.len > 0 {
        resolved_return_type := c.recheck_concrete_type(node.return_type)
        if resolved_return_type != ast.void_type && resolved_return_type != 0 {
            node.return_type = resolved_return_type
        }
    }
    // Add return if `fn(...) ? {...}` have no return at end
    if node.return_type != ast.void_type && node.return_type.has_flag(.option)
        && (node.stmts.len == 0 || node.stmts.last() !is ast.Return) {
        sym := c.table.sym(node.return_type)
        if sym.kind == .void {
            return_pos := if node.stmts.len == 0 { node.pos } else { node.stmts.last().pos }
            node.stmts << ast.Return{
                scope: node.scope
                pos:   return_pos // node.pos
            }
        }
    }
    // same for result `fn (...) ! { ... }`
    if node.return_type != ast.void_type && node.return_type.has_flag(.result)
        && (node.stmts.len == 0 || node.stmts.last() !is ast.Return) {
        sym := c.table.sym(node.return_type)
        if sym.kind == .void {
            node.stmts << ast.Return{
                scope: node.scope
                pos:   node.pos
            }
        }
    }
    c.fn_scope = node.scope
    c.refresh_generic_fn_scope_vars(node)
    // Register implicit context var
    typ_veb_result := c.table.get_veb_result_type_idx() // c.table.find_type('veb.Result')
    if node.is_method && node.return_type == typ_veb_result {
        is_veb_app_method := !c.has_veb_context(node.receiver.typ)
        for param in node.params[1..] {
            if is_veb_app_method && c.has_veb_context(param.typ) && !param.is_mut {
                c.error('veb app method `${node.name}` must declare context parameter `${param.name}` as mutable, e.g. `mut ${param.name} ${c.table.type_to_str(param.typ)}`',
                    param.pos)
                break
            }
        }
        // Find a custom user Context type first
        mut ctx_idx := c.table.find_type('main.Context')
        if ctx_idx < 1 {
            // If it doesn't exist, use veb.Context
            ctx_idx = c.table.find_type('veb.Context')
        }
        typ_veb_context := ctx_idx.set_nr_muls(1)
        // No Context type param? Add it
        if !node.params.any(c.has_veb_context(it.typ)) && node.params.len >= 1 {
            params := node.params.clone()
            ctx_param := ast.Param{
                name:   'ctx'
                typ:    typ_veb_context
                is_mut: true
            }
            node.params = [node.params[0], ctx_param]
            node.params << params[1..]
            // println('new params ${node.name}')
            // println(node.params)
            // We've added ctx to the FnDecl node.
            // Now update the existing method, already registered in Table.
            mut rec_sym := c.table.sym(node.receiver.typ)
            if mut m := c.table.find_method(rec_sym, node.name) {
                p := m.params.clone()
                m.params = [m.params[0], ctx_param]
                m.params << p[1..]
                rec_sym.update_method(m)
            }
        }
        // sym := c.table.sym(typ_veb_context)
        // println('reging ${typ_veb_context} ${sym}')
        // println(c.fn_scope)
        // println(node.params)
        // Finally add ctx to the scope
        c.fn_scope.register(ast.Var{
            name:         'ctx'
            typ:          typ_veb_context
            pos:          node.pos
            is_used:      true
            is_mut:       true
            is_stack_obj: false // true
        })
        if is_veb_app_method {
            for param in node.params[1..] {
                if c.has_veb_context(param.typ) || c.supports_veb_string_bound_param(param.typ) {
                    continue
                }
                c.error('veb app method `${node.name}` parameter `${param.name}` has unsupported type `${c.table.type_to_str(param.typ)}`; parameters after the context are populated from strings and must be `string`, integer, or `bool`',
                    param.pos)
            }
        }
    }
    c.stmts(mut node.stmts)
    node_has_top_return := c.has_top_return(node.stmts)
    node.has_return = c.returns || node_has_top_return
    c.check_noreturn_fn_decl(mut node)
    if node.language == .v && !node.no_body && node.return_type != ast.void_type && !node.has_return
        && !node.is_noreturn {
        if c.inside_anon_fn {
            c.error('missing return at the end of an anonymous function', node.pos)
        } else if !node.attrs.contains('_naked') {
            c.error('missing return at end of function `${node.name}`', node.pos)
        }
    }
    if !node.has_return {
        // for `node.has_return`, checking in `return.v` `return_stmt`
        old_inside_defer := c.inside_defer
        c.inside_defer = true
        for i := c.table.cur_fn.defer_stmts.len - 1; i >= 0; i-- {
            c.stmts(mut c.table.cur_fn.defer_stmts[i].stmts)
        }
        c.inside_defer = old_inside_defer
    }

    node.source_file = c.file

    if node.name in c.table.fns {
        if node.name != 'main.main' {
            mut dep_names := []string{}
            for stmt in node.stmts {
                dnames := c.table.dependent_names_in_stmt(stmt)
                for dname in dnames {
                    if dname in dep_names {
                        continue
                    }
                    dep_names << dname
                }
            }
            if dep_names.len > 0 {
                unsafe {
                    c.table.fns[node.name].dep_names = dep_names
                }
            }
        }
        unsafe {
            c.table.fns[node.name].source_fn = voidptr(node)
        }
    }

    if node.is_expand_simple_interpolation {
        match true {
            !node.is_method {
                c.error('@[expand_simple_interpolation] is supported only on methods', node.pos)
            }
            node.params.len != 2 {
                c.error('methods tagged with @[expand_simple_interpolation], should have exactly 1 argument',
                    node.pos)
            }
            !node.params[1].typ.is_string() {
                c.error('methods tagged with @[expand_simple_interpolation], should accept a single string',
                    node.pos)
            }
            else {}
        }
    }
    if needs_generic_names_restore {
        unsafe {
            mut p := &[]string(&node.generic_names)
            *p = saved_generic_names
        }
    }
    node.return_type = saved_return_type
}

// check_same_type_ignoring_pointers util function to check if the Types are the same, including all
// corner cases.
// FIXME: if the optimization is done after the checker, we can safely remove this util function
fn (c &Checker) check_same_type_ignoring_pointers(type_a ast.Type, type_b ast.Type) bool {
    // FIXME: if possible pass the ast.Node and check the property `is_auto_rec`
    if type_a != type_b {
        // before failing we must be sure that the parser didn't optimize the function
        clean_type_a := type_a.set_nr_muls(0)
        clean_type_b := type_b.set_nr_muls(0)
        return clean_type_a == clean_type_b
    }
    return true
}

fn (mut c Checker) expected_callback_fn() ?ast.Fn {
    if c.expected_type in [0, ast.void_type] {
        return none
    }
    expected_type := c.unwrap_generic(c.recheck_concrete_type(c.expected_type))
    expected_sym := c.table.final_sym(expected_type)
    if expected_sym.kind != .function || expected_sym.info !is ast.FnType {
        return none
    }
    return (expected_sym.info as ast.FnType).func
}

fn (mut c Checker) omitted_callback_param(expected_param ast.Param, idx int, pos token.Pos, prefix string) ast.Param {
    param_type := c.recheck_concrete_type(expected_param.typ)
    return ast.Param{
        pos:        pos
        name:       '${prefix}${idx}'
        is_mut:     expected_param.is_mut
        is_shared:  expected_param.is_shared
        is_atomic:  expected_param.is_atomic
        typ:        param_type
        orig_typ:   if expected_param.orig_typ == 0 { param_type } else { expected_param.orig_typ }
        type_pos:   pos
        on_newline: expected_param.on_newline
    }
}

fn (mut c Checker) append_omitted_callback_params(mut params []ast.Param, expected_params []ast.Param, pos token.Pos, prefix string, scope &ast.Scope) {
    if params.len >= expected_params.len {
        return
    }
    for idx in params.len .. expected_params.len {
        param := c.omitted_callback_param(expected_params[idx], idx, pos, prefix)
        params << param
        if scope != unsafe { nil } {
            unsafe {
                mut scope_ := &ast.Scope(scope)
                scope_.register(ast.Var{
                    name:          param.name
                    typ:           param.typ
                    generic_typ:   if param.typ.has_flag(.generic) { param.typ } else { ast.Type(0) }
                    is_mut:        c.implicit_mutability_enabled() || param.is_mut
                    is_auto_deref: param.is_mut
                    pos:           param.pos
                    is_used:       true
                    is_arg:        true
                    is_stack_obj:  !param.typ.has_flag(.shared_f)
                        && (param.is_mut || param.typ.is_ptr())
                })
            }
        }
    }
}

fn (mut c Checker) expand_anon_fn_callback_signature(mut node ast.AnonFn) {
    expected_fn := c.expected_callback_fn() or { return }
    if node.decl.params.len >= expected_fn.params.len || node.decl.is_variadic
        || expected_fn.is_variadic {
        return
    }
    mut params := node.decl.params.clone()
    c.append_omitted_callback_params(mut params, expected_fn.params, node.decl.pos,
        '__v_anon_unused_param_', node.decl.scope)
    node.decl.params = params
    mut func := ast.Fn{
        params:      params
        is_variadic: node.decl.is_variadic
        return_type: node.decl.return_type
        is_method:   false
    }
    name := c.table.get_anon_fn_name(c.file.unique_prefix, func, node.decl.pos)
    func.name = name
    node.decl = ast.FnDecl{
        ...node.decl
        name:   name
        params: params
    }
    idx := c.table.find_or_register_fn_type(func, true, false)
    node.typ = if node.decl.generic_names.len > 0 {
        ast.new_type(idx).set_flag(.generic)
    } else {
        ast.new_type(idx)
    }
}

fn (mut c Checker) anon_fn(mut node ast.AnonFn) ast.Type {
    keep_fn := c.table.cur_fn
    keep_inside_anon := c.inside_anon_fn
    keep_anon_fn := c.cur_anon_fn
    keep_anon_fn_generic_names := c.anon_fn_generic_names.clone()
    keep_anon_fn_concrete_types := c.anon_fn_concrete_types.clone()
    c.table.used_features.anon_fn = true
    defer {
        c.table.cur_fn = keep_fn
        c.inside_anon_fn = keep_inside_anon
        c.cur_anon_fn = keep_anon_fn
        c.anon_fn_generic_names = keep_anon_fn_generic_names
        c.anon_fn_concrete_types = keep_anon_fn_concrete_types
    }
    if node.decl.no_body {
        c.error('anonymous function must declare a body', node.decl.pos)
    }
    c.expand_anon_fn_callback_signature(mut node)
    for param in node.decl.params {
        if param.name == '' {
            c.error('use `_` to name an unused parameter', param.pos)
        }
    }
    mut can_use_outer_generic_context := node.decl.generic_names.len > 0
    c.table.cur_fn = unsafe { &node.decl }
    c.inside_anon_fn = true
    c.cur_anon_fn = unsafe { node }
    mut has_generic := false
    for mut var in node.inherited_vars {
        parent_var := node.decl.scope.parent.find_var(var.name) or {
            panic('unexpected checker error: cannot find parent of inherited variable `${var.name}`')
        }
        captures_auto_deref_by_value := parent_var.is_auto_deref && !var.is_mut
        mut declared_parent_typ := parent_var.typ
        if keep_fn != unsafe { nil } {
            if keep_fn.is_method && keep_fn.receiver.name == var.name {
                declared_parent_typ = keep_fn.receiver.typ
            } else {
                for param in keep_fn.params {
                    if param.name == var.name {
                        declared_parent_typ = param.typ
                        break
                    }
                }
            }
        }
        if var.is_mut && !parent_var.is_mut {
            c.error('original `${parent_var.name}` is immutable, declare it with `mut` to make it mutable',
                var.pos)
        }
        ptyp := c.visible_var_type_for_read(parent_var)
        node.has_ct_var = node.has_ct_var
            || var.name in [c.comptime.comptime_for_field_var, c.comptime.comptime_for_method_var]
        if declared_parent_typ != ast.no_type {
            parent_var_sym := c.table.final_sym(declared_parent_typ)
            if parent_var_sym.info is ast.FnType {
                ret_typ := parent_var_sym.info.func.return_type
                if c.type_has_unresolved_generic_parts(ret_typ) {
                    generic_names := c.table.generic_type_names(ret_typ)
                    curr_list := node.decl.generic_names.join(', ')
                    for name in generic_names {
                        if name !in node.decl.generic_names {
                            can_use_outer_generic_context = false
                            c.error('Add the generic type `${name}` to the anon fn generic list type, that is currently `[${curr_list}]`',
                                var.pos)
                        }
                    }
                }
            }
        }
        if parent_var.expr is ast.IfGuardExpr {
            sym := c.table.sym(parent_var.expr.expr_type)
            if sym.info is ast.MultiReturn {
                for i, v in parent_var.expr.vars {
                    if v.name == var.name {
                        var.typ = sym.info.types[i]
                        break
                    }
                }
            } else {
                var.typ = parent_var.expr.expr_type.clear_option_and_result()
            }
        } else {
            var.typ = ptyp
        }
        if captures_auto_deref_by_value && var.typ.is_ptr() {
            var.typ = var.typ.deref()
        }
        if c.is_nocopy_struct(var.typ) {
            c.error('cannot capture @[nocopy] struct by value: use a reference instead', var.pos)
        }
        if c.type_has_unresolved_generic_parts(declared_parent_typ) {
            has_generic = true
        }
        node.decl.scope.update_var_type(var.name, var.typ)
        if captures_auto_deref_by_value {
            if mut captured_var := node.decl.scope.find_var(var.name) {
                captured_var.is_auto_deref = false
                captured_var.typ = var.typ
                if captured_var.orig_type.is_ptr() {
                    captured_var.orig_type = captured_var.orig_type.deref()
                }
                if captured_var.smartcasts.len > 0 {
                    captured_var.smartcasts = captured_var.smartcasts.map(if it.is_ptr() {
                        it.deref()
                    } else {
                        it
                    })
                }
            }
        }
    }
    c.anon_fn_generic_names = []string{}
    c.anon_fn_concrete_types = []ast.Type{}
    if can_use_outer_generic_context && keep_fn != unsafe { nil }
        && keep_fn.generic_names.len == c.table.cur_concrete_types.len {
        for generic_name in node.decl.generic_names {
            generic_idx := keep_fn.generic_names.index(generic_name)
            if generic_idx >= 0 {
                c.anon_fn_generic_names << generic_name
                c.anon_fn_concrete_types << c.table.cur_concrete_types[generic_idx]
            }
        }
        for i, generic_name in keep_fn.generic_names {
            if generic_name !in c.anon_fn_generic_names {
                c.anon_fn_generic_names << generic_name
                c.anon_fn_concrete_types << c.table.cur_concrete_types[i]
            }
        }
    }
    if has_generic && node.decl.generic_names.len == 0 {
        c.error('generic closure fn must specify type parameter, e.g. fn [foo] [T]()',
            node.decl.pos)
    }
    // Refresh param scope vars before checking stmts, so that generic params
    // resolve to the current concrete types (not stale types from a previous
    // generic instantiation pass).
    if c.table.cur_concrete_types.len > 0 && node.decl.generic_names.len > 0
        && node.decl.generic_names.len == c.table.cur_concrete_types.len {
        for param in node.decl.params {
            param_type := if resolved := c.table.convert_generic_type(param.typ,
                node.decl.generic_names, c.table.cur_concrete_types)
            {
                c.unwrap_generic(resolved)
            } else {
                c.table.unwrap_generic_type_ex(param.typ, node.decl.generic_names,
                    c.table.cur_concrete_types, true)
            }
            if mut param_var := node.decl.scope.find_var(param.name) {
                if param_var.generic_typ == 0 && (param.typ.has_flag(.generic)
                    || c.type_has_unresolved_generic_parts(param.typ)) {
                    param_var.generic_typ = param.typ
                }
                param_var.typ = param_type
            }
        }
    }
    c.stmts(mut node.decl.stmts)
    c.fn_decl(mut node.decl)
    return node.typ
}

fn (mut c Checker) resolve_self_method_call(mut node ast.CallExpr) bool {
    if node.is_method || node.name == '' {
        return false
    }
    if c.table.cur_fn == unsafe { nil } || !c.table.cur_fn.is_method {
        return false
    }
    if node.name.contains('.') && !node.name.starts_with('${c.mod}.') {
        return false
    }
    call_name := node.name.all_after_last('.')
    current_method_name := c.table.cur_fn.name.all_after_last('.')
    if call_name != current_method_name {
        return false
    }
    receiver_name := c.table.cur_fn.receiver.name
    node.left = ast.Ident{
        pos:   node.pos
        scope: node.scope
        mod:   c.mod
        name:  receiver_name
    }
    node.name = call_name
    node.left_type = c.expr(mut node.left)
    if node.left_type == ast.void_type {
        return false
    }
    node.is_method = true
    return true
}

fn (mut c Checker) call_expr(mut node ast.CallExpr) ast.Type {
    // Check whether the inner function definition is before the call
    if node.scope != unsafe { nil } {
        if var := node.scope.find_var(node.name) {
            if var.expr is ast.AnonFn && var.pos.pos > node.pos.pos {
                c.error('unknown function: ${node.name}', node.pos)
            }
        }
    }
    // If the left expr has an or_block, it needs to be checked for legal or_block statement.
    mut left_type := ast.void_type
    match mut node.left {
        ast.SelectorExpr {
            if node.name == '' && node.left.or_block.kind != .absent {
                left_type = c.selector_expr(mut node.left)
            } else {
                left_type = c.expr(mut node.left)
            }
        }
        else {
            left_type = c.expr(mut node.left)
        }
    }

    if node.name == '' {
        left_type = c.check_expr_option_or_result_call(node.left, left_type)
    } else {
        c.check_expr_option_or_result_call(node.left, left_type)
    }
    // TODO: merge logic from method_call and fn_call
    // First check everything that applies to both fns and methods
    old_inside_fn_arg := c.inside_fn_arg
    c.inside_fn_arg = true
    mut continue_check := true
    node.left_type = left_type
    // Now call `method_call` or `fn_call` for specific checks.
    mut typ := ast.void_type
    if node.is_method {
        typ = c.method_call(mut node, mut continue_check)
    } else {
        typ = c.fn_call(mut node, mut continue_check)
    }
    if c.pref.is_vls {
        c.autocomplete_for_fn_call_expr(node)
    }
    if !continue_check {
        return ast.void_type
    }
    c.inside_fn_arg = old_inside_fn_arg
    arg0 := if node.args.len > 0 { node.args[0] } else { ast.CallArg{} }
    // autofree: mark args that have to be freed (after saving them in tmp exprs)
    free_tmp_arg_vars := c.pref.autofree && !c.is_builtin_mod && node.args.len > 0
        && !c.inside_const && !arg0.typ.has_flag(.option) && !arg0.typ.has_flag(.result)
        && !(arg0.expr is ast.CallExpr
        && (arg0.expr.return_type.has_flag(.option) || arg0.expr.return_type.has_flag(.result)))
    if free_tmp_arg_vars {
        for i, arg in node.args {
            if arg.typ != ast.string_type {
                continue
            }
            if arg.expr in [ast.Ident, ast.StringLiteral, ast.SelectorExpr, ast.ComptimeSelector]
                || autofree_expr_has_or_block_in_chain(arg.expr) {
                // Simple expressions like variables, string literals, selector expressions
                // (`x.field`) can't result in allocations and don't need to be assigned to
                // temporary vars.
                // Only expressions like `str + 'b'` need to be freed.
                // Expressions with result/option propagation in the call chain (e.g.
                // `get_str()!.to_upper()`) cannot be pre-generated safely by
                // autofree_call_pregen, because the or_block unwrapping internally calls
                // go_before_last_stmt() which garbles the output buffer.
                continue
            }
            if arg.expr is ast.CallExpr && arg.expr.name in ['json.encode', 'json.encode_pretty'] {
                continue
            }
            node.args[i].is_tmp_autofree = true
        }
        // TODO: copy pasta from above
        if node.receiver_type == ast.string_type
            && node.left !in [ast.Ident, ast.StringLiteral, ast.SelectorExpr] {
            node.free_receiver = true
        }
    }
    if node.nr_ret_values == -1 && node.return_type != 0 {
        if node.return_type == ast.void_type {
            node.nr_ret_values = 0
        } else {
            ret_sym := c.table.sym(node.return_type)
            if ret_sym.info is ast.MultiReturn {
                node.nr_ret_values = ret_sym.info.types.len
            } else {
                node.nr_ret_values = 1
            }
        }
    }
    old_expected_or_type := c.expected_or_type
    c.expected_or_type = node.return_type.clear_flag(.result)
    c.stmts_ending_with_expression(mut node.or_block.stmts, c.expected_or_type)
    if node.or_block.kind == .block && !node.or_block.err_used {
        if err_var := node.or_block.scope.find_var('err') {
            node.or_block.err_used = err_var.is_used
        }
    }

    if node.or_block.kind == .block {
        mut return_context_type := ast.no_type
        if c.inside_return && c.table.cur_fn != unsafe { nil } && node.or_block.stmts.len > 0 {
            last_stmt := node.or_block.stmts.last()
            if last_stmt is ast.ExprStmt {
                if last_stmt.typ == ast.none_type && c.table.cur_fn.return_type.has_flag(.option) {
                    return_context_type = c.table.cur_fn.return_type
                } else if last_stmt.typ == ast.error_type
                    && c.table.cur_fn.return_type.has_flag(.result) {
                    return_context_type = c.table.cur_fn.return_type
                }
            }
        }
        if return_context_type != ast.no_type {
            typ = return_context_type
        } else {
            old_inside_or_block_value := c.inside_or_block_value
            c.inside_or_block_value = true
            last_cur_or_expr := c.cur_or_expr
            c.cur_or_expr = &node.or_block
            c.check_or_expr(node.or_block, typ, c.expected_or_type, node)
            c.cur_or_expr = last_cur_or_expr
            c.inside_or_block_value = old_inside_or_block_value
        }
    }
    c.expected_or_type = old_expected_or_type
    c.markused_call_expr(left_type, mut node)
    if !c.inside_const && c.table.cur_fn != unsafe { nil } && !c.table.cur_fn.is_main
        && !c.table.cur_fn.is_test {
        // TODO: use just `if node.or_block.kind == .propagate_result && !c.table.cur_fn.return_type.has_flag(.result) {` after the deprecation for ?!Type
        if node.or_block.kind == .propagate_result && !c.table.cur_fn.return_type.has_flag(.result)
            && !c.table.cur_fn.return_type.has_flag(.option) {
            c.add_instruction_for_result_type()
            c.error('to propagate the Result call, `${c.table.cur_fn.name}` must return a Result',
                node.or_block.pos)
        }
        if node.or_block.kind == .propagate_option && !c.table.cur_fn.return_type.has_flag(.option) {
            c.add_instruction_for_option_type()
            c.error('to propagate the Option call, `${c.table.cur_fn.name}` must return an Option',
                node.or_block.pos)
        }
    }
    return typ
}

fn (mut c Checker) builtin_args(mut node ast.CallExpr, fn_name string, func &ast.Fn) {
    c.inside_interface_deref = true
    c.expected_type = ast.string_type
    if !(node.language != .js && node.args[0].expr is ast.CallExpr) {
        node.args[0].typ = c.expr(mut node.args[0].expr)
    }
    arg := node.args[0]
    c.check_expr_option_or_result_call(arg.expr, arg.typ)
    if arg.typ.is_void() {
        c.error('`${fn_name}` can not print void expressions', node.pos)
    } else if arg.typ == ast.char_type && arg.typ.nr_muls() == 0 {
        c.error('`${fn_name}` cannot print type `char` directly, print its address or cast it to an integer instead',
            node.pos)
    } else if arg.expr is ast.ArrayDecompose {
        c.error('`${fn_name}` cannot print variadic values', node.pos)
    } else if c.fail_if_private_implicit_str(arg.typ, node.pos, 'print') {
        return
    }
    c.fail_if_unreadable(arg.expr, arg.typ, 'argument to print')
    c.inside_interface_deref = false
    node.return_type = ast.void_type
    c.set_node_expected_arg_types(mut node, func)

    /*
    // TODO: optimize `struct T{} fn (t &T) str() string {return 'abc'} mut a := []&T{} a << &T{} println(a[0])`
    // It currently generates:
    // `println(T_str_no_ptr(*(*(T**)array_get(a, 0))));`
    // ... which works, but could be just:
    // `println(T_str(*(T**)array_get(a, 0)));`
    prexpr := node.args[0].expr
    prtyp := node.args[0].typ
    prtyp_sym := c.table.sym(prtyp)
    prtyp_is_ptr := prtyp.is_ptr()
    prhas_str, prexpects_ptr, prnr_args := prtyp_sym.str_method_info()
    eprintln('>>> println hack typ: ${prtyp} | sym.name: ${prtyp_sym.name} | is_ptr: ${prtyp_is_ptr} | has_str: ${prhas_str} | expects_ptr: ${prexpects_ptr} | nr_args: ${prnr_args} | expr: ${prexpr.str()} ')
    */
}

fn (mut c Checker) try_resolve_c_type_cast_call(mut node ast.CallExpr) ?ast.Type {
    if node.language != .c || !node.name.starts_with('C.') || node.args.len != 1 {
        return none
    }
    c_name := node.name.all_after('C.')
    if c_name.len == 0 || !c_name[0].is_capital() {
        return none
    }
    to_type := c.table.find_type(node.name)
    if to_type == 0 {
        return none
    }
    to_sym := c.table.sym(to_type)
    if to_sym.kind == .placeholder {
        return none
    }
    mut cast_expr := ast.CastExpr{
        typ:     to_type
        typname: to_sym.name
        expr:    node.args[0].expr
        pos:     node.pos
    }
    typ := c.cast_expr(mut cast_expr)
    node.is_c_type_cast = true
    node.args[0].expr = cast_expr.expr
    node.args[0].typ = cast_expr.expr_type
    node.return_type = typ
    return typ
}

fn (mut c Checker) needs_unwrap_generic_type(typ ast.Type) bool {
    if typ == 0 {
        return false
    }
    if c.type_has_unresolved_generic_parts(typ) {
        return true
    }
    if !typ.has_flag(.generic) {
        return false
    }
    sym := c.table.sym(typ)
    match sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            return true
        }
        ast.Array {
            return c.needs_unwrap_generic_type(sym.info.elem_type)
        }
        ast.ArrayFixed {
            return c.needs_unwrap_generic_type(sym.info.elem_type)
        }
        ast.Map {
            if c.needs_unwrap_generic_type(sym.info.key_type) {
                return true
            }
            if c.needs_unwrap_generic_type(sym.info.value_type) {
                return true
            }
        }
        ast.Chan {
            return c.needs_unwrap_generic_type(sym.info.elem_type)
        }
        ast.Thread {
            return c.needs_unwrap_generic_type(sym.info.return_type)
        }
        else {
            return false
        }
    }

    return false
}

fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.Type {
    is_va_arg := node.kind == .va_arg
    is_json_decode := node.kind == .json_decode
    is_json_encode := node.kind == .json_encode
    mut fn_name := node.name
    if node.is_static_method {
        // resolve static call T.name()
        if c.table.cur_fn != unsafe { nil } {
            node.left_type, fn_name = c.table.convert_generic_static_type_name(fn_name,
                c.table.cur_fn.generic_names, c.table.cur_concrete_types)
            c.table.used_features.comptime_calls[fn_name] = true
        }
    }
    if !c.file.is_test && node.kind == .main {
        c.error('the `main` function cannot be called in the program', node.pos)
    }
    mut has_generic := false // foo[T]() instead of foo[int]()
    mut concrete_types := []ast.Type{}
    node.concrete_types = node.raw_concrete_types
    for concrete_type in node.concrete_types {
        if concrete_type.has_flag(.generic)
            || (c.type_has_unresolved_generic_parts(concrete_type)
            && c.table.sym(concrete_type).kind != .placeholder) {
            has_generic = true
            concrete_types << c.unwrap_generic(concrete_type)
        } else {
            concrete_types << concrete_type
        }
    }
    if c.table.cur_fn != unsafe { nil } && c.table.cur_concrete_types.len == 0 && has_generic {
        c.error('generic fn using generic types cannot be called outside of generic fn', node.pos)
    }
    fkey := node.fkey()
    fn_name_has_dot := fn_name.contains('.')
    if concrete_types.len > 0 {
        mut no_exists := true
        if fn_name_has_dot {
            no_exists = c.table.register_fn_concrete_types(fkey, concrete_types)
        } else {
            no_exists = c.table.register_fn_concrete_types(c.mod + '.' + fkey, concrete_types)
            // if the generic fn does not exist in the current fn calling module, continue
            // to look in builtin module
            if !no_exists {
                no_exists = c.table.register_fn_concrete_types(fkey, concrete_types)
            }
        }
        if no_exists {
            c.need_recheck_generic_fns = true
        }
        full_fkey := if fn_name_has_dot { fkey } else { c.mod + '.' + fkey }
        c.generic_call_positions[c.build_generic_call_key(full_fkey, concrete_types)] = node.pos
    }
    mut args_len := node.args.len
    if node.kind == .jsawait {
        if node.args.len > 1 {
            c.error('JS.await expects 1 argument, a promise value (e.g `JS.await(fs.read())`',
                node.pos)
            return ast.void_type
        }

        typ := c.expr(mut node.args[0].expr)
        tsym := c.table.sym(typ)

        if !tsym.name.starts_with('Promise[') {
            c.error('JS.await: first argument must be a promise, got `${tsym.name}`', node.pos)
            return ast.void_type
        }
        if c.table.cur_fn != unsafe { nil } {
            c.table.cur_fn.has_await = true
        }
        match tsym.info {
            ast.Struct {
                mut ret_type := tsym.info.concrete_types[0]
                ret_type = ret_type.set_flag(.option)
                node.return_type = ret_type
                return ret_type
            }
            else {
                c.error('JS.await: Promise must be a struct type', node.pos)
                return ast.void_type
            }
        }

        panic('unreachable')
    } else if args_len > 0 && node.args[0].typ.has_flag(.shared_f) && node.kind == .json_encode {
        c.error('json.encode cannot handle shared data', node.pos)
        return ast.void_type
    } else if args_len > 0 && (is_va_arg || is_json_decode) {
        if args_len != 2 {
            if is_json_decode {
                c.error("json.decode expects 2 arguments, a type and a string (e.g `json.decode(T, '')`)",
                    node.pos)
            } else {
                c.error('C.va_arg expects 2 arguments, a type and va_list (e.g `C.va_arg(int, va)`)',
                    node.pos)
            }
            return ast.void_type
        }
        mut expr := node.args[0].expr
        if mut expr is ast.TypeNode {
            expr.typ = c.expr(mut expr)
            mut unwrapped_typ := c.unwrap_generic(expr.typ)
            if c.needs_unwrap_generic_type(expr.typ) {
                unwrapped_typ = c.table.unwrap_generic_type(expr.typ, c.table.cur_fn.generic_names,
                    c.table.cur_concrete_types)
            }
            sym := c.table.sym(unwrapped_typ)
            if c.table.known_type(sym.name) && sym.kind != .placeholder {
                mut kind := sym.kind
                if sym.info is ast.Alias {
                    kind = c.table.sym(sym.info.parent_type).kind
                } else if sym.kind == .generic_inst && sym.info is ast.GenericInst {
                    parent_sym := c.table.sym(ast.new_type(sym.info.parent_idx))
                    kind = parent_sym.kind
                }
                if is_json_decode && c.table.fully_unaliased_type(unwrapped_typ).is_ptr() {
                    c.error('${fn_name}: cannot decode into a pointer type', expr.pos)
                } else if is_json_decode && kind !in [.struct, .sum_type, .map, .array] {
                    c.error('${fn_name}: expected sum type, struct, map or array, found ${kind}',
                        expr.pos)
                }
            } else {
                c.error('${fn_name}: unknown type `${sym.name}`', node.pos)
            }
        } else {
            typ := expr.type_name()
            c.error('${fn_name}: first argument needs to be a type, got `${typ}`', node.pos)
            return ast.void_type
        }
        c.expected_type = ast.string_type
        node.args[1].typ = c.expr(mut node.args[1].expr)
        if is_json_decode && node.args[1].typ != ast.string_type {
            c.error('json.decode: second argument needs to be a string', node.pos)
        }
        typ := expr as ast.TypeNode
        node.return_type = if is_json_decode { typ.typ.set_flag(.result) } else { typ.typ }
        if typ.typ.has_flag(.generic) {
            c.table.used_features.comptime_syms[c.unwrap_generic(typ.typ)] = true
        }
        return node.return_type
    } else if node.kind == .addr {
        if !c.inside_unsafe {
            c.error('`__addr` must be called from an unsafe block', node.pos)
        }
        if args_len != 1 {
            c.error('`__addr` requires 1 argument', node.pos)
            return ast.void_type
        }
        typ := c.expr(mut node.args[0].expr)
        node.args[0].typ = typ
        node.return_type = typ.ref()
        return node.return_type
    }
    // look for function in format `mod.fn` or `fn` (builtin)
    mut func := ast.Fn{}
    mut found := false
    mut found_in_args := false
    defer {
        if found {
            c.check_must_use_call_result(node, func, 'function')
        }
    }
    // anon fn direct call
    if node.left is ast.AnonFn {
        // it was set to anon for checker errors, clear for gen
        node.name = ''
        left := node.left as ast.AnonFn
        if left.typ != ast.no_type {
            anon_fn_sym := c.table.sym(left.typ)
            func = (anon_fn_sym.info as ast.FnType).func
            found = true
        }
    }
    // try prefix with current module as it would have never gotten prefixed
    if !found && node.mod != 'builtin' && !fn_name_has_dot {
        name_prefixed := '${node.mod}.${fn_name}'
        if f := c.table.find_fn(name_prefixed) {
            node.name = name_prefixed
            found = true
            func = f
            unsafe { c.table.fns[name_prefixed].usages++ }
            c.mark_fn_decl_as_referenced(f.fkey())
        }
    }
    if !found && node.left is ast.IndexExpr {
        left := node.left as ast.IndexExpr
        sym := c.table.final_sym(left.left_type)
        if sym.info is ast.Array {
            elem_sym := c.table.sym(sym.info.elem_type)
            if elem_sym.info is ast.FnType {
                func = elem_sym.info.func
                found = true
                node.is_fn_var = true
                node.fn_var_type = sym.info.elem_type
            } else {
                c.error('cannot call the element of the array, it is not a function', node.pos)
            }
        } else if sym.info is ast.Map {
            value_sym := c.table.sym(sym.info.value_type)
            if value_sym.info is ast.FnType {
                func = value_sym.info.func
                found = true
                node.is_fn_var = true
                node.fn_var_type = sym.info.value_type
            } else {
                c.error('cannot call the value of the map, it is not a function', node.pos)
            }
        } else if sym.info is ast.ArrayFixed {
            elem_sym := c.table.sym(sym.info.elem_type)
            if elem_sym.info is ast.FnType {
                func = elem_sym.info.func
                found = true
                node.is_fn_var = true
                node.fn_var_type = sym.info.elem_type
            } else {
                c.error('cannot call the element of the array, it is not a function', node.pos)
            }
        }
    }
    if !found && node.left is ast.CallExpr {
        left := node.left as ast.CallExpr
        if left.return_type != 0 {
            sym := c.table.sym(left.return_type)
            if sym.info is ast.FnType {
                node.return_type = sym.info.func.return_type
                found = true
                func = sym.info.func
            }
        }
    }
    if !found && node.name == '' && node.left_type != 0 {
        left_sym := c.table.final_sym(c.unwrap_generic(node.left_type))
        if left_sym.info is ast.FnType {
            func = left_sym.info.func
            found = true
            node.is_fn_var = true
            node.fn_var_type = node.left_type
        } else if left_sym.info is ast.GenericInst {
            parent_sym := c.table.sym(ast.new_type(left_sym.info.parent_idx))
            if parent_sym.info is ast.FnType {
                func = parent_sym.info.func
                found = true
                node.is_fn_var = true
                node.fn_var_type = node.left_type
            }
        }
    }
    // already prefixed (mod.fn) or C/builtin/main
    if !found {
        if f := c.table.find_fn(fn_name) {
            found = true
            func = f
            unsafe { c.table.fns[fn_name].usages++ }
            c.mark_fn_decl_as_referenced(f.fkey())
        }
    }

    // static method resolution
    if !found && node.is_static_method {
        if index := fn_name.index('__static__') {
            owner_name := fn_name#[..index]
            // already imported symbol (static Foo.new() in another module)
            for import_sym in c.file.imports.filter(it.syms.any(it.name == owner_name)) {
                qualified_name := '${import_sym.mod}.${fn_name}'
                if f := c.table.find_fn(qualified_name) {
                    found = true
                    func = f
                    node.name = qualified_name
                    unsafe { c.table.fns[qualified_name].usages++ }
                    c.mark_fn_decl_as_referenced(f.fkey())
                    if !c.table.register_fn_concrete_types(f.name, concrete_types) {
                        c.need_recheck_generic_fns = true
                    }
                    break
                }
            }
            if !found {
                // aliased static method on current mod
                full_type_name := if !fn_name_has_dot {
                    c.mod + '.' + owner_name
                } else {
                    owner_name
                }
                typ := c.table.find_type(full_type_name)
                if typ != 0 {
                    final_sym := c.table.final_sym(typ)
                    // try to find the unaliased static method name
                    orig_name := final_sym.name + fn_name#[index..]
                    if f := c.table.find_fn(orig_name) {
                        found = true
                        func = f
                        unsafe { c.table.fns[orig_name].usages++ }
                        c.mark_fn_decl_as_referenced(f.fkey())
                        node.name = orig_name
                        node.left_type = typ
                    }
                }
            }
        }
        // Enum.from_string, `mod.Enum.from_string('item')`, `Enum.from_string('item')`
        if !found && fn_name.ends_with('__static__from_string') {
            enum_name := fn_name.all_before('__static__')
            mut full_enum_name := if !enum_name.contains('.') {
                c.mod + '.' + enum_name
            } else {
                enum_name
            }
            mut idx := c.table.type_idxs[full_enum_name]
            if idx > 0 {
                // is from another mod.
                if enum_name.contains('.') {
                    if !c.check_type_and_visibility(full_enum_name, idx, .enum, node.pos) {
                        return ast.void_type
                    }
                } else {
                    if !c.check_type_sym_kind(full_enum_name, idx, .enum, node.pos) {
                        return ast.void_type
                    }
                }
            } else if !enum_name.contains('.') {
                // find from another mods.
                for import_sym in c.file.imports {
                    full_enum_name = '${import_sym.mod}.${enum_name}'
                    idx = c.table.type_idxs[full_enum_name]
                    if idx < 1 {
                        continue
                    }
                    if !c.check_type_and_visibility(full_enum_name, idx, .enum, node.pos) {
                        return ast.void_type
                    }
                    break
                }
            }
            if idx == 0 {
                c.error('unknown enum `${enum_name}`', node.pos)
                continue_check = false
                return ast.void_type
            }

            ret_typ := ast.idx_to_type(idx).set_flag(.option)
            if args_len != 1 {
                c.error('expected 1 argument, but got ${args_len}', node.pos)
            } else {
                node.args[0].typ = c.expr(mut node.args[0].expr)
                if node.args[0].typ != ast.string_type {
                    styp := c.table.type_to_str(node.args[0].typ)
                    c.error('expected `string` argument, but got `${styp}`', node.pos)
                }
            }
            node.return_type = ret_typ
            return ret_typ
        }
    }
    if !found && c.pref.is_vsh {
        // TODO: test this hack more extensively
        os_name := 'os.${fn_name}'
        if f := c.table.find_fn(os_name) {
            if f.generic_names.len == node.concrete_types.len {
                node_alias_name := fkey
                mut existing := c.table.fn_generic_types[os_name] or { [] }
                existing << c.table.fn_generic_types[node_alias_name]
                existing << node.concrete_types
                c.table.fn_generic_types[os_name] = existing
            }
            node.name = os_name
            found = true
            func = f
            unsafe { c.table.fns[os_name].usages++ }
            c.mark_fn_decl_as_referenced(f.fkey())
        }
    }
    // check for arg (var) of fn type
    if !found {
        mut typ := ast.no_type
        if mut obj := node.scope.find(node.name) {
            match mut obj {
                ast.GlobalField {
                    typ = obj.typ
                    node.is_fn_var = true
                    node.fn_var_type = typ
                }
                ast.Var {
                    if obj.smartcasts.len != 0 {
                        typ = c.exposed_smartcast_type(obj.orig_type, obj.smartcasts.last(),
                            obj.is_mut)
                    } else {
                        if obj.typ == 0 {
                            if mut obj.expr is ast.IfGuardExpr {
                                typ = c.expr(mut obj.expr.expr).clear_option_and_result()
                            } else {
                                typ = c.expr(mut obj.expr)
                            }
                        } else {
                            typ = obj.typ
                        }
                    }
                    node.is_fn_var = true
                    node.fn_var_type = typ
                    if typ.nr_muls() > 0 {
                        c.error('function pointer must be undereferenced first', node.pos)
                    }
                }
                else {}
            }
        }

        // XTODO document
        if typ != 0 {
            if node.concrete_types.len == 0 && typ.has_flag(.generic)
                && c.table.cur_fn != unsafe { nil } && c.table.cur_fn.is_method
                && node.name == c.table.cur_fn.receiver.name
                && c.table.cur_fn.receiver.typ.has_flag(.generic)
                && c.table.cur_fn.generic_names.len == c.table.cur_concrete_types.len {
                if fn_typ := c.table.convert_generic_type(typ, c.table.cur_fn.generic_names,
                    c.table.cur_concrete_types)
                {
                    typ = fn_typ
                    node.fn_var_type = fn_typ
                }
            }
            generic_vts := c.table.final_sym(typ)
            if generic_vts.info is ast.FnType {
                func = generic_vts.info.func
                found = true
                found_in_args = true
            } else if generic_vts.info is ast.GenericInst {
                parent_sym := c.table.sym(ast.new_type(generic_vts.info.parent_idx))
                if parent_sym.info is ast.FnType {
                    func = parent_sym.info.func
                    found = true
                    found_in_args = true
                }
            } else {
                vts := c.table.sym(c.unwrap_generic(typ))
                if vts.info is ast.FnType {
                    func = vts.info.func
                    found = true
                    found_in_args = true
                } else if vts.info is ast.GenericInst {
                    parent_sym := c.table.sym(ast.new_type(vts.info.parent_idx))
                    if parent_sym.info is ast.FnType {
                        func = parent_sym.info.func
                        found = true
                        found_in_args = true
                    }
                }
            }
        }
    }
    // global fn?
    if !found {
        if obj := c.file.global_scope.find(fn_name) {
            if obj.typ != 0 {
                sym := c.table.sym(obj.typ)
                if sym.info is ast.FnType {
                    func = sym.info.func
                    found = true
                }
            }
        }
    }
    // a same module constant?
    if !found {
        // allow for `const abc = myfunc`, then calling `abc()`
        qualified_const_name := if fn_name_has_dot { fn_name } else { '${c.mod}.${fn_name}' }
        if mut obj := c.table.global_scope.find_const(qualified_const_name) {
            if obj.typ == 0 {
                obj.typ = c.expr(mut obj.expr)
            }
            if obj.typ != 0 {
                sym := c.table.sym(obj.typ)
                if sym.info is ast.FnType {
                    // at this point, the const metadata should be already known,
                    // and we are sure that it is just a function
                    unsafe { c.table.fns[qualified_const_name].usages++ }
                    unsafe { c.table.fns[func.name].usages++ }
                    found = true
                    func = sym.info.func
                    node.is_fn_a_const = true
                    node.fn_var_type = obj.typ
                    node.const_name = qualified_const_name
                    c.mark_const_decl_as_referenced(qualified_const_name)
                }
            }
        }
    }

    if !found {
        if typ := c.try_resolve_c_type_cast_call(mut node) {
            return typ
        }
        if c.resolve_self_method_call(mut node) {
            return c.method_call(mut node, mut continue_check)
        }
        continue_check = false
        if dot_index := fn_name.index('.') {
            if !fn_name[0].is_capital() {
                mod_name := fn_name#[..dot_index]
                mut mod_func_names := []string{}
                for ctfnk, ctfnv in c.table.fns {
                    if ctfnv.is_pub && ctfnk.starts_with(mod_name) {
                        mod_func_names << ctfnk
                    }
                }
                suggestion := util.new_suggestion(fn_name, mod_func_names)
                c.error(suggestion.say('unknown function: ${fn_name} '), node.pos)
                return ast.void_type
            }
        }
        name := node.get_name()
        if c.pref.experimental && name.starts_with('C.') {
            println('unknown function ${name}, ' +
                'searching for the C definition in one of the #includes')
            mut includes := []string{cap: 5}
            for stmt in c.file.stmts {
                if stmt is ast.HashStmt {
                    if stmt.kind == 'include' {
                        includes << '#include ${stmt.main}'
                    }
                }
            }
            mut tmp_c_file_with_includes := os.create('tmp.c') or { panic(err) }
            tmp_c_file_with_includes.write_string(includes.join('\n')) or { panic(err) }
            tmp_c_file_with_includes.close()

            os.execute('${os.quoted_path(@VEXE)} translate fndef ${name[2..]} tmp.c')
            x := os.read_file('__cdefs_autogen.v') or {
                for mut arg in node.args {
                    c.expr(mut arg.expr)
                }
                return ast.void_type
            }
            if x.contains('fn ${name}') {
                println(
                    'function definition for ${name} has been generated in __cdefs_autogen.v. ' +
                    'Please re-run the compilation with `v .` or `v run .`')
                os.rm('tmp.c') or {}
                exit(0)
            } else {
                println('Failed to generate function definition. Please report it via github.com/vlang/v/issues')
            }
            os.rm('tmp.c') or {}
        }
        for mut arg in node.args {
            c.expr(mut arg.expr)
        }
        if name.starts_with('C.') {
            c.error('unknown C function: `${name}`. `C.` calls are external C calls; declare the function with `fn ${name}(...)` and include/link the C header/library that provides it.',
                node.pos)
            return ast.void_type
        }
        c.error('unknown function: ${node.get_name()}', node.pos)
        return ast.void_type
    }

    node.is_file_translated = func.is_file_translated
    node.is_noreturn = func.is_noreturn
    node.is_expand_simple_interpolation = func.is_expand_simple_interpolation
    node.is_ctor_new = func.is_ctor_new
    if node.is_fn_var && node.concrete_types.len > 0 && func.generic_names.len == 0 {
        if node.raw_concrete_types.len == 0 {
            node.raw_concrete_types = node.concrete_types.clone()
        }
        node.concrete_types = []
    }
    if !found_in_args {
        if node.scope.known_var(fn_name) {
            c.error('ambiguous call to: `${fn_name}`, may refer to fn `${fn_name}` or variable `${fn_name}`',
                node.pos)
        }
    }
    if !func.is_pub && func.language == .v && func.name != '' && func.mod.len > 0
        && func.mod != c.mod && !c.pref.is_test {
        c.error('function `${func.name}` is private', node.pos)
    }
    if c.table.cur_fn != unsafe { nil } && !c.table.cur_fn.is_deprecated && func.is_deprecated {
        c.deprecate('function', func.name, func.attrs, node.pos)
    }
    if func.is_unsafe && !c.inside_unsafe
        && (func.language != .c || (func.name[2] in [`m`, `s`] && func.mod == 'builtin')) {
        // builtin C.m*, C.s* only - temp
        if !c.pref.translated && !c.file.is_translated {
            c.warn('function `${func.name}` must be called from an `unsafe` block', node.pos)
        }
    }
    node.is_keep_alive = func.is_keep_alive
    if func.language == .v && func.no_body && !c.pref.translated && !c.file.is_translated
        && !func.is_unsafe && !func.is_file_translated && func.mod != 'builtin' {
        c.error('cannot call a function that does not have a body', node.pos)
    }
    if node.concrete_types.len > 0 && func.generic_names.len > 0
        && node.concrete_types.len != func.generic_names.len {
        plural := if func.generic_names.len == 1 { '' } else { 's' }
        c.error('expected ${func.generic_names.len} generic parameter${plural}, got ${node.concrete_types.len}',
            node.concrete_list_pos)
    }
    for concrete_type in node.concrete_types {
        c.ensure_type_exists(concrete_type, node.concrete_list_pos)
    }
    if func.generic_names.len > 0 && args_len == 0 && node.concrete_types.len == 0 {
        c.error('no argument generic function must add concrete types, e.g. foo[int]()', node.pos)
        return func.return_type
    }
    if func.return_type == ast.void_type && func.is_conditional
        && func.ctdefine_idx != ast.invalid_type_idx {
        node.should_be_skipped =
            c.evaluate_once_comptime_if_attribute(mut func.attrs[func.ctdefine_idx])
    }
    if node.kind == .free && func.mod == 'builtin' && args_len == 1
        && c.table.cur_fn != unsafe { nil } && c.table.cur_fn.is_method
        && c.table.cur_fn.short_name != 'free' && !c.is_builtin_mod && !c.inside_recheck {
        if node.args[0].expr is ast.Ident {
            if node.args[0].expr.name == c.table.cur_fn.receiver.name {
                receiver_sym := c.table.sym(c.table.cur_fn.receiver.typ)
                if !receiver_sym.is_heap() {
                    c.warn('calling builtin `free()` on a method receiver will cause a' +
                        ' runtime crash when the receiver is stack-allocated; free individual fields instead',
                        node.pos)
                }
            }
        }
    }

    // dont check number of args for JS functions since arguments are not required
    if node.language != .js {
        for i, mut call_arg in node.args {
            is_call_expr := call_arg.expr is ast.CallExpr
            if is_call_expr {
                mut arg_expr := call_arg.expr
                node.args[i].typ = c.expr(mut arg_expr)
                call_arg.expr = arg_expr
            } else if mut call_arg.expr is ast.LambdaExpr {
                if node.concrete_types.len > 0 {
                    call_arg.expr.call_ctx = unsafe { node }
                }
            }
        }
        c.check_expected_arg_count(mut node, func) or {
            node.return_type = func.return_type
            return func.return_type
        }
        args_len = node.args.len
    }
    // println / eprintln / panic can print anything
    if args_len > 0 && fn_name in print_everything_fns && func.mod == 'builtin' {
        node.args[0].ct_expr = c.comptime.is_comptime(node.args[0].expr)
        c.builtin_args(mut node, fn_name, func)
        c.markused_print_call(mut node)
        return func.return_type
    }
    // `return error(err)` -> `return err`
    if args_len == 1 && node.kind == .error {
        mut arg := node.args[0]
        node.args[0].typ = c.expr(mut arg.expr)
        node.args[0].ct_expr = c.comptime.is_comptime(node.args[0].expr)
        if node.args[0].typ == ast.error_type {
            c.warn('`error(${arg})` can be shortened to just `${arg}`', node.pos)
        }
    }
    c.set_node_expected_arg_types(mut node, func)
    if !c.is_js_backend && args_len > 0 && func.params.len == 0 {
        c.error('too many arguments in call to `${func.name}` (non-js backend: ${c.pref.backend})',
            node.pos)
    }
    mut has_decompose := false
    mut has_unresolved_generic_param := false
    mut nr_multi_values := 0
    variadic_start := variadic_call_arg_start_idx(func, false)
    has_typed_variadic := func.is_variadic && !func.is_c_variadic
    for i, mut call_arg in node.args {
        mut variadic_arg_handled := false
        if func.params.len == 0 {
            continue
        }
        if !c.inside_recheck {
            call_arg.ct_expr = c.comptime.is_comptime(call_arg.expr)
        }
        if !func.is_variadic && has_decompose {
            c.error('cannot have parameter after array decompose', node.pos)
        }
        param_i := i + nr_multi_values
        mut param := call_arg_param_for_fn(func, param_i, false)
        if node.is_fn_var && param.typ.has_flag(.generic) && c.table.cur_fn != unsafe { nil }
            && c.table.cur_fn.generic_names.len > 0
            && c.table.cur_fn.generic_names.len == c.table.cur_concrete_types.len {
            mut unwrapped := param
            unwrapped.typ = c.table.unwrap_generic_param_type(param, c.table.cur_fn.generic_names,
                c.table.cur_concrete_types)
            param = unwrapped
        }
        param.typ = c.resolve_call_arg_param_type(call_arg, param, func.generic_names,
            concrete_types)
        // registers if the arg must be passed by ref to disable auto deref args
        call_arg.should_be_ptr = param.typ.is_ptr() && !param.is_mut
        if func.is_variadic && call_arg.expr is ast.ArrayDecompose {
            if param_i > variadic_start {
                c.error('too many arguments in call to `${func.name}`', node.pos)
            }
        }
        has_decompose = call_arg.expr is ast.ArrayDecompose
        if !func.is_variadic && call_arg.expr is ast.ArrayDecompose {
            array_decompose_expr := call_arg.expr as ast.ArrayDecompose
            if array_decompose_expr.expr is ast.ArrayInit {
                extra_params := func.params.len - i
                array_init := array_decompose_expr.expr as ast.ArrayInit
                if array_init.exprs.len < extra_params {
                    elem_word := if array_init.exprs.len == 1 { 'element' } else { 'elements' }
                    verb_word := if extra_params == 1 { 'is' } else { 'are' }
                    c.error('array decompose has ${array_init.exprs.len} ${elem_word} but ${extra_params} ${verb_word} needed for `${func.name}`',
                        call_arg.pos)
                }
            }
        }
        already_checked := node.language != .js && call_arg.expr is ast.CallExpr
        if has_typed_variadic && param_i >= variadic_start {
            param_sym := c.table.sym(param.typ)
            mut expected_type := param.typ
            if param_sym.info is ast.Array {
                expected_type = param_sym.info.elem_type
                c.expected_type = expected_type
            }
            typ := if already_checked && mut call_arg.expr is ast.CallExpr {
                node.args[i].typ
            } else {
                c.expr(mut call_arg.expr)
            }
            if i == args_len - 1 {
                variadic_arg_handled = c.check_variadic_arg(call_arg.expr, typ, expected_type,
                    param.typ, i + 1, func.name, func.is_method, func.is_variadic, args_len == 1
                    && i == 0, func.generic_names.len > 0, node.pos, call_arg.pos)
            }
        } else {
            c.expected_type = param.typ
        }

        e_sym := c.table.sym(c.expected_type)
        if call_arg.expr is ast.MapInit && e_sym.kind == .struct {
            c.error('cannot initialize a struct with a map', call_arg.pos)
            continue
        } else if call_arg.expr is ast.StructInit && e_sym.kind == .map
            && !call_arg.expr.typ.has_flag(.generic) {
            c.error('cannot initialize a map with a struct', call_arg.pos)
            continue
        }
        mut arg_typ := c.check_expr_option_or_result_call(call_arg.expr, if already_checked {
            node.args[i].typ
        } else {
            c.expr(mut call_arg.expr)
        })
        arg_typ = c.maybe_wrap_index_expr_smartcast(mut call_arg.expr, arg_typ)
        is_struct_init_arg := call_arg.expr is ast.StructInit
        if is_struct_init_arg {
            mut arg_expr := call_arg.expr
            arg_typ = c.expr(mut arg_expr)
        }
        node.args[i].expr = call_arg.expr
        node.args[i].typ = arg_typ
        call_arg.typ = arg_typ
        if c.comptime.comptime_for_field_var != '' {
            if mut call_arg.expr is ast.Ident
                && call_arg.expr.name == c.comptime.comptime_for_field_var
                && call_arg.expr.obj is ast.Var {
                node.args[i].typ = call_arg.expr.obj.typ
            }
        }
        // sumtype coercion
        param_type_sym := c.table.sym(param.typ)
        if param_type_sym.kind == .placeholder {
            base_type := c.table.find_type(param_type_sym.ngname)
            if base_type != 0 {
                base_sym := c.table.sym(base_type)
                if base_sym.kind == .sum_type && base_sym.info is ast.SumType {
                    base_info := base_sym.info as ast.SumType
                    arg_typ_sym := c.table.sym(arg_typ)
                    for variant in base_info.variants {
                        variant_sym := c.table.sym(variant)
                        variant_base_name := variant_sym.ngname
                        if variant_base_name == arg_typ_sym.ngname {
                            node.args[i].expr = ast.CastExpr{
                                expr:    call_arg.expr
                                typ:     param.typ
                                typname: c.table.type_to_str(param.typ)
                                pos:     call_arg.expr.pos()
                            }
                            node.args[i].typ = param.typ
                            arg_typ = param.typ
                            break
                        }
                    }
                }
            }
        }
        if param_type_sym.kind == .sum_type
            && !c.table.sumtype_has_variant(param.typ, arg_typ, false)
            && c.table.sumtype_has_variant_recursive(param.typ, arg_typ, false) {
            call_arg.expr = ast.CastExpr{
                expr:      call_arg.expr
                typ:       param.typ
                typname:   c.table.type_to_str(param.typ)
                expr_type: arg_typ
                pos:       call_arg.expr.pos()
            }
            call_arg.typ = param.typ
            node.args[i].expr = call_arg.expr
            node.args[i].typ = param.typ
            arg_typ = param.typ
        }
        mut arg_typ_sym := c.table.sym(arg_typ)
        if param.typ.has_flag(.generic) {
            if arg_typ_sym.kind == .none && !param.typ.has_flag(.option) {
                c.error('cannot use `none` as generic argument', call_arg.pos)
            }
            has_unresolved_generic_param = c.check_unresolved_generic_param(node, call_arg)
                || has_unresolved_generic_param
        }
        param_typ_sym := c.table.sym(param.typ)
        if has_typed_variadic && arg_typ.has_flag(.variadic) && args_len - 1 > i {
            c.error('when forwarding a variadic variable, it must be the final argument',
                call_arg.pos)
        }
        arg_share := param.typ.share()
        if arg_share == .shared_t && (c.locked_names.len > 0 || c.rlocked_names.len > 0) {
            c.error('function with `shared` arguments cannot be called inside `lock`/`rlock` block',
                call_arg.pos)
        }
        call_arg = c.implicit_mut_call_arg(param, call_arg)
        node.args[i] = call_arg
        if call_arg.is_mut {
            to_lock, pos := c.fail_if_immutable(mut call_arg.expr)
            call_arg_expr_pos := call_arg.expr.pos()
            if !call_arg.expr.is_lvalue() {
                if call_arg.expr is ast.StructInit {
                    c.error('cannot pass a struct initialization as `mut`, you may want to use a variable `mut var := ${ast.Expr(call_arg.expr)}`',
                        call_arg_expr_pos)
                } else {
                    c.error('cannot pass expression as `mut`', call_arg_expr_pos)
                }
            }
            if !param.is_mut {
                tok := call_arg.share.str()
                c.error('`${node.name}` parameter `${param.name}` is not `${tok}`, `${tok}` is not needed`',
                    call_arg.expr.pos())
            } else {
                if param.typ.share() != call_arg.share {
                    c.error('wrong shared type `${call_arg.share.str()}`, expected: `${param.typ.share().str()}`',
                        call_arg.expr.pos())
                }
                if to_lock != '' && !param.typ.has_flag(.shared_f) {
                    c.error('${to_lock} is `shared` and must be `lock`ed to be passed as `mut`',
                        pos)
                }
            }
        } else {
            if param.is_mut {
                tok := param.specifier()
                param_sym := c.table.sym(param.typ)
                if !(param_sym.info is ast.Struct && param_sym.info.attrs.any(it.name == 'params')) {
                    c.error('function `${node.name}` parameter `${param.name}` is `${tok}`, so use `${tok} ${call_arg.expr}` instead',
                        call_arg.expr.pos())
                }
            } else {
                c.fail_if_unreadable(call_arg.expr, arg_typ, 'argument')
            }
        }
        array_param_typ := if func.generic_names.len > 0 && concrete_types.len > 0 {
            c.table.convert_generic_param_type(param, func.generic_names, concrete_types) or {
                param.typ
            }
        } else {
            param.typ
        }
        arg_typ = c.lower_fixed_array_call_arg_to_array(mut call_arg, array_param_typ,
            node.language)
        node.args[i] = call_arg
        node.args[i].typ = arg_typ
        arg_typ_sym = c.table.sym(arg_typ)
        mut final_param_sym := unsafe { param_typ_sym }
        mut final_param_typ := param.typ
        if has_typed_variadic && param_typ_sym.info is ast.Array {
            final_param_typ = param_typ_sym.info.elem_type
            final_param_sym = c.table.sym(final_param_typ)
        }
        // Note: Casting to voidptr is used as an escape mechanism, so:
        // 1. allow passing *explicit* voidptr (native or through cast) to functions
        // expecting voidptr or ...voidptr
        // ... but 2. disallow passing non-pointers - that is very rarely what the user wanted,
        // it can lead to codegen errors (except for 'magic' functions like `json.encode` that,
        // the compiler has special codegen support for), so it should be opt in, that is it
        // should require an explicit voidptr(x) cast (and probably unsafe{} ?) .
        // V variadic ...voidptr calls are boxed in cgen, so rvalues are safe there.
        if call_arg.typ != param.typ && (param.typ == ast.voidptr_type
            || final_param_sym.idx == ast.voidptr_type_idx
            || param.typ == ast.nil_type || final_param_sym.idx == ast.nil_type_idx)
            && !call_arg.typ.is_any_kind_of_pointer() && func.language == .v
            && !call_arg.expr.is_lvalue() && !c.pref.translated && !c.file.is_translated
            && !(has_typed_variadic && final_param_sym.idx == ast.voidptr_type_idx)
            && !func.is_c_variadic && func.name !in ['json.encode', 'json.encode_pretty'] {
            c.error('expression cannot be passed as `voidptr`', call_arg.expr.pos())
        }
        // Handle expected interface
        mut is_generic_interface := false
        if final_param_sym.kind == .generic_inst {
            gi := final_param_sym.info
            if gi is ast.GenericInst {
                is_generic_interface = c.table.type_symbols[gi.parent_idx].kind == .interface
            }
        }
        if final_param_sym.kind == .interface || is_generic_interface {
            // For generic interface parameters, resolve the generic type to its concrete
            // instantiation before checking implementation.
            mut resolved_param_typ := final_param_typ
            if final_param_typ.has_flag(.generic) && func.generic_names.len > 0
                && node.concrete_types.len == func.generic_names.len {
                if t := c.table.convert_generic_type(final_param_typ, func.generic_names,
                    node.concrete_types)
                {
                    resolved_param_typ = t
                }
            }
            if c.type_implements_with_mut_receiver(arg_typ, resolved_param_typ,
                call_arg.expr.pos(), param.is_mut)
            {
                if !arg_typ.is_any_kind_of_pointer() && !c.inside_unsafe
                    && arg_typ_sym.kind != .interface {
                    c.mark_as_referenced(mut &call_arg.expr, true)
                }
            }

            // For non-generic interfaces, check pointer compatibility.
            // For generic_inst interfaces, the param.typ may still have unresolved
            // generic flags, so skip the ptr check — type_implements already validated.
            if final_param_sym.kind == .interface && arg_typ !in [ast.voidptr_type, ast.nil_type]
                && !c.check_multiple_ptr_match(arg_typ, param.typ, param, call_arg) {
                got_typ_str, expected_typ_str := c.get_string_names_of(arg_typ, param.typ)
                c.error('cannot use `${got_typ_str}` as `${expected_typ_str}` in argument ${i + 1} to `${fn_name}`',
                    call_arg.pos)
            }
            if call_arg.expr is ast.ArrayDecompose && arg_typ.idx() != final_param_typ.idx()
                && c.table.cur_concrete_types.len == 0 {
                expected_type_str := c.table.type_to_str(param.typ)
                got_type_str := c.table.type_to_str(arg_typ)
                c.error('cannot use `${got_type_str}` as `${expected_type_str}` in argument ${i + 1} to `${fn_name}`',
                    call_arg.pos)
            }
            continue
        }
        if !c.inside_unsafe && !param.is_mut && node.language == .v
            && c.is_nocopy_struct(final_param_typ) {
            c.error('cannot pass @[nocopy] struct by value: use a reference instead', call_arg.pos)
        }
        if param.typ.is_ptr() && !param.is_mut && !call_arg.typ.is_any_kind_of_pointer()
            && call_arg.expr.is_literal() && func.language == .v && !c.pref.translated {
            c.error('literal argument cannot be passed as reference parameter `${c.table.type_to_str(param.typ)}`',
                call_arg.pos)
        }
        if !variadic_arg_handled {
            c.check_expected_call_arg(arg_typ, c.unwrap_generic(param.typ), node.language, call_arg) or {
                if param.typ.has_flag(.generic) {
                    continue
                }
                // When decomposing a generic variadic arg into a non-variadic function,
                // each generic instantiation re-checks all branches (e.g. match arms),
                // so the decomposed type may not match the target param type for
                // unreachable branches. Skip the error in this case.
                if has_decompose && call_arg.expr is ast.ArrayDecompose
                    && c.table.cur_concrete_types.len > 0 {
                    continue
                }
                if param_typ_sym.info is ast.Array && arg_typ_sym.info is ast.Array {
                    param_elem_type := c.table.unaliased_type(param_typ_sym.info.elem_type)
                    arg_elem_type := c.table.unaliased_type(arg_typ_sym.info.elem_type)
                    param_nr_muls := param.typ.nr_muls()
                    arg_nr_muls := if call_arg.is_mut {
                        arg_typ.nr_muls() + 1
                    } else {
                        arg_typ.nr_muls()
                    }
                    if param.typ.has_flag(.option) == arg_typ.has_flag(.option)
                        && param.typ.has_flag(.result) == arg_typ.has_flag(.result)
                        && param_nr_muls == arg_nr_muls
                        && param_typ_sym.info.nr_dims == arg_typ_sym.info.nr_dims
                        && param_elem_type == arg_elem_type {
                        continue
                    }
                } else if arg_typ_sym.info is ast.MultiReturn {
                    arg_typs := arg_typ_sym.info.types
                    if !(has_typed_variadic && param_i >= variadic_start) {
                        if arg_typ_sym.info.types.len > func.params.len {
                            c.error('trying to pass ${arg_typ_sym.info.types.len} argument(s), but function expects ${func.params.len} argument(s)',
                                node.pos)
                            continue_check = false
                            return ast.void_type
                        }
                    }
                    if !func.is_variadic && func.params.len < (param_i + arg_typ_sym.info.types.len) {
                        c.fn_call_error_have_want(
                            nr_params: func.params.len
                            nr_args:   param_i + arg_typ_sym.info.types.len
                            params:    func.params
                            args:      node.args
                            pos:       node.pos
                        )
                        return ast.void_type
                    }
                    out: for n in 0 .. arg_typ_sym.info.types.len {
                        curr_arg := arg_typs[n]
                        multi_param := call_arg_param_for_fn(func, n + param_i, false)
                        c.check_expected_call_arg(curr_arg, c.unwrap_generic(multi_param.typ),
                            node.language, call_arg) or {
                            c.error('${err.msg()} in argument ${param_i + n + 1} to `${fn_name}` from ${c.table.type_to_str(arg_typ)}',
                                call_arg.pos)
                            continue out
                        }
                    }
                    nr_multi_values += arg_typ_sym.info.types.len - 1
                    continue
                } else if param_typ_sym.info is ast.Struct && arg_typ_sym.info is ast.Struct
                    && param_typ_sym.info.is_anon {
                    if c.is_anon_struct_compatible(param_typ_sym.info, arg_typ_sym.info) {
                        continue
                    }
                } else if c.embeds_expected_call_arg_type(arg_typ, final_param_typ) {
                    continue
                }
                if c.pref.translated || c.file.is_translated {
                    // in case of variadic make sure to use array elem type for checks
                    // check_expected_call_arg already does this before checks also.
                    param_type := if param.typ.has_flag(.variadic) {
                        param_typ_sym.array_info().elem_type
                    } else {
                        param.typ
                    }
                    // TODO: duplicated logic in check_types() (check_types.v)
                    // Allow enums to be used as ints and vice versa in translated code
                    if param_type.idx() in ast.integer_type_idxs && arg_typ_sym.kind == .enum {
                        continue
                    }
                    if arg_typ.idx() in ast.integer_type_idxs && param_typ_sym.kind == .enum {
                        continue
                    }

                    if (arg_typ == ast.bool_type && param_type.is_int())
                        || (arg_typ.is_int() && param_type == ast.bool_type) {
                        continue
                    }

                    // In C unsafe number casts are used all the time (e.g. `char*` where
                    // `int*` is expected etc), so just allow them all.
                    mut param_is_number := c.table.unaliased_type(param_type).is_number()
                    if param_type.is_ptr() {
                        param_is_number = param_type.deref().is_number()
                    }
                    mut typ_is_number := c.table.unaliased_type(arg_typ).is_number()
                    if arg_typ.is_ptr() {
                        typ_is_number = arg_typ.deref().is_number()
                    }
                    if param_is_number && typ_is_number {
                        continue
                    }
                    // Allow voidptrs for everything
                    if param_type == ast.voidptr_type_idx || param_type == ast.nil_type_idx
                        || arg_typ == ast.voidptr_type_idx || arg_typ == ast.nil_type_idx {
                        continue
                    }
                    if param_type.is_any_kind_of_pointer() && arg_typ.is_any_kind_of_pointer() {
                        continue
                    }
                    unaliased_param_sym := c.table.sym(c.table.unaliased_type(param_type))
                    unaliased_arg_sym := c.table.sym(c.table.unaliased_type(arg_typ))
                    // Allow `[32]i8` as `&i8` etc
                    arg_is_array_like := unaliased_arg_sym.kind in [.array_fixed, .array]
                    param_is_array_like := unaliased_param_sym.kind in [.array_fixed, .array]
                    if arg_is_array_like && (param_is_number
                        || c.table.unaliased_type(param_type).is_any_kind_of_pointer()) {
                        continue
                    }
                    if param_is_array_like && (typ_is_number
                        || c.table.unaliased_type(arg_typ).is_any_kind_of_pointer()) {
                        continue
                    }
                    // Allow `[N]anyptr` as `[N]anyptr`
                    if unaliased_arg_sym.info is ast.Array && unaliased_param_sym.info is ast.Array {
                        if unaliased_arg_sym.info.elem_type.is_any_kind_of_pointer()
                            && unaliased_param_sym.info.elem_type.is_any_kind_of_pointer() {
                            continue
                        }
                    } else if unaliased_arg_sym.info is ast.ArrayFixed
                        && unaliased_param_sym.info is ast.ArrayFixed {
                        if unaliased_arg_sym.info.elem_type.is_any_kind_of_pointer()
                            && unaliased_param_sym.info.elem_type.is_any_kind_of_pointer() {
                            continue
                        }
                    }
                    // Allow `int` as `&i8`
                    if param_type.is_any_kind_of_pointer() && typ_is_number {
                        continue
                    }
                    // Allow `&i8` as `int`
                    if arg_typ.is_any_kind_of_pointer() && param_is_number {
                        continue
                    }
                }
                // if first_sym.name == 'VContext' && f.params[0].name == 'ctx' { // TODO use int comparison for perf
                //}
                /*
                if param_typ_sym.info is ast.Struct && param_typ_sym.name == 'VContext' {
                    c.note('ok', call_arg.pos)
                    continue
                }
                */
                c.error('${err.msg()} in argument ${i + nr_multi_values + 1} to `${fn_name}`',
                    call_arg.pos)
            }
        }
        if final_param_sym.kind == .struct && arg_typ !in [ast.voidptr_type, ast.nil_type]
            && !c.check_multiple_ptr_match(arg_typ, param.typ, param, call_arg) {
            got_typ_str, expected_typ_str := c.get_string_names_of(arg_typ, param.typ)
            c.error('cannot use `${got_typ_str}` as `${expected_typ_str}` in argument ${i +
                nr_multi_values + 1} to `${fn_name}`', call_arg.pos)
        }
        // Warn about automatic (de)referencing, which will be removed soon.
        if func.language != .c && !c.inside_unsafe && !(call_arg.is_mut && param.is_mut) {
            if arg_typ.nr_muls() != param.typ.nr_muls()
                && param.typ !in [ast.byteptr_type, ast.charptr_type, ast.voidptr_type, ast.nil_type]
                && arg_typ != ast.voidptr_type && !(!call_arg.is_mut && !param.is_mut) //&& !(!call_arg.is_mut && !param.is_mut)
              {
                c.warn('automatic referencing/dereferencing is deprecated and will be removed soon (got: ${arg_typ.nr_muls()} references, expected: ${param.typ.nr_muls()} references)',
                    call_arg.pos)
            }
            // A special case of the check to not allow voidptr params like in the recently reported raylib
            // bug with fn...
            // fn f(p &Foo) => f(foo) -- do not allow this, force f(&foo)
            // if !c.is_builtin_mod
            else if param.typ == ast.voidptr_type && func.language == .v
                && arg_typ !in [ast.voidptr_type, ast.nil_type] && arg_typ.nr_muls() == 0
                && func.name !in ['isnil', 'ptr_str'] && !func.name.starts_with('json.')
                && arg_typ_sym.kind !in [.float_literal, .int_literal, .charptr, .function]
                && !c.is_js_backend {
                c.warn('automatic ${arg_typ_sym.name} referencing/dereferencing into voidptr is deprecated and will be removed soon; use `foo(&x)` instead of `foo(x)`',
                    call_arg.pos)
            }
        }
    }
    if has_unresolved_generic_param {
        node.return_type = func.return_type
        return func.return_type
    }
    if is_json_encode {
        // json.encode param is set voidptr, we should bound the proper type here
        node.expected_arg_types = [node.args[0].typ]
    }
    if func.generic_names.len != node.concrete_types.len {
        // no type arguments given in call, attempt implicit instantiation
        c.infer_fn_generic_types(func, mut node)
        concrete_types = node.concrete_types.map(c.unwrap_generic(it))
        need_recheck, _ := c.type_resolver.resolve_fn_generic_args(c.table.cur_fn, func, mut node)
        if need_recheck {
            c.need_recheck_generic_fns = true
        }
    }
    if func.generic_names.len > 0 {
        for i, mut call_arg in node.args {
            param := call_arg_param_for_fn(func, i, false)
            if param.typ.has_flag(.generic) {
                if unwrap_typ := c.table.convert_generic_param_type(param, func.generic_names,
                    concrete_types)
                {
                    c.expected_type = unwrap_typ
                }
            } else {
                c.expected_type = param.typ
            }
            already_checked := node.language != .js && call_arg.expr is ast.CallExpr
            mut typ := c.check_expr_option_or_result_call(call_arg.expr, if already_checked
                && mut call_arg.expr is ast.CallExpr {
                call_arg.expr.return_type
            } else {
                c.expr(mut call_arg.expr)
            })

            if param.typ.has_flag(.generic) && func.generic_names.len == node.concrete_types.len {
                if unwrap_typ := c.table.convert_generic_param_type(param, func.generic_names,
                    concrete_types)
                {
                    call_arg.typ = typ
                    typ = c.lower_fixed_array_call_arg_to_array(mut call_arg, unwrap_typ,
                        node.language)
                    node.args[i].expr = call_arg.expr
                    node.args[i].typ = typ
                    utyp := c.unwrap_generic(typ)
                    unwrap_sym := c.table.sym(unwrap_typ)
                    if unwrap_sym.kind == .interface {
                        if c.type_implements_with_mut_receiver(utyp, unwrap_typ,
                            call_arg.expr.pos(), param.is_mut)
                        {
                            if !utyp.is_any_kind_of_pointer() && !c.inside_unsafe
                                && c.table.sym(utyp).kind != .interface {
                                c.mark_as_referenced(mut &call_arg.expr, true)
                            }
                        }
                        continue
                    }
                    c.check_expected_call_arg(utyp, unwrap_typ, node.language, call_arg) or {
                        if c.type_resolver.type_map.len > 0 {
                            continue
                        }
                        if mut call_arg.expr is ast.LambdaExpr {
                            // Calling fn is generic and lambda arg also is generic
                            c.handle_generic_lambda_arg(node, func.generic_names, mut call_arg.expr)
                            continue
                        }
                        if mut call_arg.expr is ast.AnonFn {
                            c.handle_generic_anon_fn_arg(node, func.generic_names, mut
                                call_arg.expr)
                        }
                        if c.is_optional_array_arg_compatible(utyp, unwrap_typ) {
                            continue
                        }
                        c.error('${err.msg()} in argument ${i + 1} to `${fn_name}`', call_arg.pos)
                    }
                    // When check succeeds (e.g. after lambda re-check with concrete types),
                    // still set call_ctx on lambda args for generic context in cgen:
                    if mut call_arg.expr is ast.LambdaExpr {
                        c.handle_generic_lambda_arg(node, func.generic_names, mut call_arg.expr)
                    } else if mut call_arg.expr is ast.AnonFn {
                        c.handle_generic_anon_fn_arg(node, func.generic_names, mut call_arg.expr)
                    }
                }
            }
        }
        if c.pref.skip_unused && node.concrete_types.len > 0 {
            for concrete_type in node.concrete_types {
                c.table.used_features.comptime_syms[c.unwrap_generic(concrete_type)] = true
            }
        }
    }
    raw_io_arg_offset := if func.is_method { 1 } else { 0 }
    c.check_os_raw_io_call(node, func, concrete_types, raw_io_arg_offset)

    // resolve return generics struct to concrete type
    if func.generic_names.len > 0 && func.return_type.has_flag(.generic)
        && c.table.cur_fn != unsafe { nil } && c.needs_unwrap_generic_type(func.return_type) {
        node.return_type = c.table.unwrap_generic_type(func.return_type, func.generic_names,
            concrete_types)
    } else {
        node.return_type = func.return_type
    }
    if func.return_type.has_flag(.generic) {
        node.return_type_generic = func.return_type
    }
    if node.concrete_types.len > 0 && func.return_type != 0 && c.table.cur_fn != unsafe { nil }
        && c.table.cur_fn.generic_names.len == 0 {
        if typ := c.table.convert_generic_type(func.return_type, func.generic_names, concrete_types) {
            node.return_type = typ
            c.register_trace_call(node, func)
            if func.return_type.has_flag(.generic) {
                c.table.used_features.comptime_syms[typ.clear_option_and_result()] = true
                c.table.used_features.comptime_syms[func.return_type] = true
            }
            return typ
        }
    }
    if node.concrete_types.len > 0 && func.generic_names.len == 0 {
        c.error('a non generic function called like a generic one', node.concrete_list_pos)
    }

    // resolve generic fn return type
    if func.generic_names.len > 0 && node.return_type != ast.void_type {
        ret_type := c.resolve_fn_return_type(func, node, concrete_types)
        c.register_trace_call(node, func)
        node.return_type = ret_type
        if ret_type.has_flag(.generic) {
            unwrapped_ret := c.unwrap_generic(ret_type)
            if c.table.sym(unwrapped_ret).kind == .multi_return {
                c.table.used_features.comptime_syms[unwrapped_ret] = true
            }
        }
        return ret_type
    }
    c.register_trace_call(node, func)
    return func.return_type
}

// register_trace_call registers the wrapper funcs for calling funcs for callstack feature
fn (mut c Checker) register_trace_call(node &ast.CallExpr, func &ast.Fn) {
    if !(c.pref.is_callstack || c.pref.is_trace) || c.table.cur_fn == unsafe { nil }
        || node.language != .v {
        return
    }
    if node.name in ['v.debug.callstack', 'v.debug.add_after_call', 'v.debug.add_before_call',
        'v.debug.remove_after_call', 'v.debug.remove_before_call'] {
        return
    }
    if !c.file.imports.any(it.mod == 'v.debug') {
        return
    }
    hash_fn, fn_name := c.table.get_trace_fn_name(c.table.cur_fn, node)
    calling_fn := if func.is_method {
        '${c.table.type_to_str(c.unwrap_generic(node.left_type))}_${fn_name}'
    } else {
        fn_name
    }
    c.table.cur_fn.trace_fns[hash_fn] = ast.FnTrace{
        name:        calling_fn
        file:        c.file.path
        line:        node.pos.line_nr + 1
        return_type: node.return_type
        func:        &ast.Fn{
            ...func
        }
        is_fn_var:   node.is_fn_var
    }
}

// cast_fixed_array_ret casts a ArrayFixed type created to return to a non returning one
fn (mut c Checker) cast_fixed_array_ret(typ ast.Type, sym ast.TypeSymbol) ast.Type {
    if sym.info is ast.ArrayFixed && sym.info.is_fn_ret {
        return c.table.find_or_register_array_fixed(sym.info.elem_type, sym.info.size,
            sym.info.size_expr, false)
    }
    return typ
}

// cast_to_fixed_array_ret casts a ArrayFixed type created to do not return to a returning one
fn (mut c Checker) cast_to_fixed_array_ret(typ ast.Type, sym ast.TypeSymbol) ast.Type {
    if sym.info is ast.ArrayFixed && !sym.info.is_fn_ret {
        return c.table.find_or_register_array_fixed(sym.info.elem_type, sym.info.size,
            sym.info.size_expr, true)
    }
    return typ
}

// checks if a symbol kind is an expected kind
fn (mut c Checker) check_type_sym_kind(name string, type_idx int, expected_kind ast.Kind, pos token.Pos) bool {
    mut sym := c.table.sym_by_idx(type_idx)
    if sym.kind == .alias {
        parent_type := (sym.info as ast.Alias).parent_type
        sym = c.table.sym(parent_type)
    }
    if sym.kind != expected_kind {
        c.error('expected ${expected_kind}, but `${name}` is ${sym.kind}', pos)
        return false
    }
    return true
}

// checks if a type from another module is as expected and visible(`is_pub`)
fn (mut c Checker) check_type_and_visibility(name string, type_idx int, expected_kind ast.Kind, pos token.Pos) bool {
    mut sym := c.table.sym_by_idx(type_idx)
    if sym.kind == .alias {
        parent_type := (sym.info as ast.Alias).parent_type
        sym = c.table.sym(parent_type)
    }
    if sym.kind != expected_kind {
        c.error('expected ${expected_kind}, but `${name}` is ${sym.kind}', pos)
        return false
    }
    if !sym.is_pub {
        c.error('module `${sym.mod}` type `${sym.name}` is private', pos)
        return false
    }
    return true
}

fn (c &Checker) is_valid_os_file_struct_io_type(typ ast.Type) bool {
    if typ.nr_muls() > 0 || typ.has_option_or_result() {
        return false
    }
    mut current_typ := typ
    mut sym := c.table.sym(current_typ)
    for {
        if sym.info !is ast.Alias {
            break
        }
        alias_info := sym.info as ast.Alias
        current_typ = alias_info.parent_type
        if current_typ.nr_muls() > 0 || current_typ.has_option_or_result() {
            return false
        }
        sym = c.table.sym(current_typ)
    }
    return sym.kind == .struct
}

fn (mut c Checker) check_os_file_struct_io_method_call(node &ast.CallExpr, method ast.Fn, concrete_types []ast.Type) {
    if method.name !in ['read_struct', 'read_struct_at', 'write_struct', 'write_struct_at'] {
        return
    }
    if method.params.len == 0 || concrete_types.len != 1 {
        return
    }
    receiver_sym := c.table.final_sym(method.params[0].typ)
    if receiver_sym.name != 'os.File' {
        return
    }
    concrete_type := concrete_types[0]
    if concrete_type.has_flag(.generic) || c.is_valid_os_file_struct_io_type(concrete_type) {
        return
    }
    err_pos := if node.raw_concrete_types.len > 0 {
        node.concrete_list_pos
    } else if node.args.len > 0 {
        node.args[0].pos
    } else {
        node.pos
    }
    c.error('`${receiver_sym.name}.${method.name}` expects a struct type, but got `${c.table.type_to_str(concrete_type)}`',
        err_pos)
}

// is_optional_array_arg_compatible allows the generic recheck fallback for `[]?T -> []T`
// without also accepting `[]&T -> []T` or other pointedness mismatches.
fn (mut c Checker) is_optional_array_arg_compatible(got ast.Type, expected ast.Type) bool {
    if expected.has_flag(.variadic) {
        return false
    }
    if c.table.final_sym(got).kind != .array || c.table.final_sym(expected).kind != .array {
        return false
    }
    got_value_type := c.table.value_type(got)
    expected_value_type := c.table.value_type(expected)
    if !got_value_type.has_flag(.option) || expected_value_type.has_flag(.option) {
        return false
    }
    if got_value_type.nr_muls() != expected_value_type.nr_muls() {
        return false
    }
    return c.check_types(got_value_type.clear_flag(.option), expected_value_type)
}

fn (mut c Checker) fixed_array_arg_as_array_type(got ast.Type, expected ast.Type) ast.Type {
    if expected.has_flag(.variadic) {
        return ast.no_type
    }
    got_sym := c.table.final_sym(c.unwrap_generic(got).clear_option_and_result())
    expected_sym :=
        c.table.final_sym(c.unwrap_generic(expected).clear_option_and_result().set_nr_muls(0))
    if got_sym.kind != .array_fixed || expected_sym.kind != .array {
        return ast.no_type
    }
    return ast.new_type(c.table.find_or_register_array(got_sym.array_fixed_info().elem_type))
}

fn (mut c Checker) lower_fixed_array_call_arg_to_array(mut arg ast.CallArg, expected ast.Type, language ast.Language) ast.Type {
    array_typ := c.fixed_array_arg_as_array_type(arg.typ, expected)
    if array_typ == ast.no_type {
        return arg.typ
    }
    expected_array_typ := c.unwrap_generic(expected).clear_option_and_result().set_nr_muls(0)
    c.check_expected_call_arg(array_typ, expected_array_typ, language, arg) or { return arg.typ }
    original_expr := arg.expr
    arg.expr = ast.IndexExpr{
        pos:       original_expr.pos()
        left:      original_expr
        left_type: arg.typ
        index:     ast.RangeExpr{
            pos: original_expr.pos()
        }
    }
    arg.typ = c.expr(mut arg.expr)
    return arg.typ
}

fn (mut c Checker) method_call(mut node ast.CallExpr, mut continue_check &bool) ast.Type {
    // `(if true { 'foo.bar' } else { 'foo.bar.baz' }).all_after('foo.')`
    node.concrete_types = node.raw_concrete_types.clone()
    mut left_expr := node.left
    left_expr = left_expr.remove_par()
    if mut left_expr is ast.IfExpr {
        if left_expr.branches.len > 0 && left_expr.has_else {
            mut last_stmt := left_expr.branches[0].stmts.last()
            if mut last_stmt is ast.ExprStmt {
                c.expected_type = c.expr(mut last_stmt.expr)
            }
        }
    }
    left_type := node.left_type
    if left_type == ast.void_type {
        // c.error('cannot call a method using an invalid expression', node.pos)
        continue_check = false
        return ast.void_type
    }
    c.markused_method_call(mut node, mut left_expr, left_type)
    c.expected_type = left_type
    mut is_generic := left_type.has_flag(.generic)
    node.left_type = left_type
    // Set default values for .return_type & .receiver_type too,
    // or there will be hard tRo diagnose 0 type panics in cgen.
    node.return_type = left_type
    node.receiver_type = left_type

    if is_generic {
        c.table.used_features.comptime_syms[c.unwrap_generic(left_type)] = true
    }

    if c.table.cur_fn != unsafe { nil } && c.table.cur_fn.generic_names.len > 0 {
        c.table.unwrap_generic_type(left_type, c.table.cur_fn.generic_names,
            c.table.cur_concrete_types)
    }
    unwrapped_left_type := c.unwrap_generic(left_type)
    left_sym := c.table.sym(unwrapped_left_type)
    final_left_sym := c.table.final_sym(unwrapped_left_type)
    mut final_left_kind := final_left_sym.kind
    if final_left_sym.kind == .generic_inst && final_left_sym.info is ast.GenericInst {
        final_left_kind = c.table.sym(ast.new_type(final_left_sym.info.parent_idx)).kind
    }

    method_name := node.name
    if left_type.has_flag(.option) {
        c.error('Option type `${left_sym.name}` cannot be called directly, you should unwrap it first',
            node.left.pos())
        return ast.void_type
    } else if left_type.has_flag(.result) {
        c.error('Result type cannot be called directly', node.left.pos())
        return ast.void_type
    }
    if left_sym.kind in [.sum_type, .interface] {
        if node.kind == .type_name {
            return ast.string_type
        }
        if node.kind == .type_idx {
            return ast.int_type
        }
    }
    if left_type == ast.void_type {
        // No need to print this error, since this means that the variable is unknown,
        // and there already was an error before.
        // c.error('`void` type has no methods', node.left.pos())
        continue_check = false
        return ast.void_type
    }
    mut use_builtin_array_sort := false
    if final_left_sym.kind == .array && node.kind in [.sort, .sorted] && node.args.len > 0 {
        if method := left_sym.find_method(method_name) {
            use_builtin_array_sort = method.params.len == 1
        }
    }
    if final_left_sym.kind == .array && array_builtin_methods_chk.matches(method_name)
        && (!(left_sym.has_method(method_name)) || use_builtin_array_sort) {
        return c.array_builtin_method_call(mut node, left_type)
    } else if final_left_sym.kind == .array_fixed
        && fixed_array_builtin_methods_chk.matches(method_name) && !(left_sym.kind == .alias
        && left_sym.has_method(method_name)) {
        return c.fixed_array_builtin_method_call(mut node, left_type)
    } else if final_left_sym.kind == .map && node.kind in [.clone, .keys, .values, .move, .delete]
        && !(left_sym.kind == .alias && left_sym.has_method(method_name)) {
        unaliased_left_type := c.table.unaliased_type(left_type)
        return c.map_builtin_method_call(mut node, unaliased_left_type)
    } else if c.is_js_backend && left_sym.name.starts_with('Promise[') && node.kind == .wait {
        info := left_sym.info as ast.Struct
        if node.args.len > 0 {
            c.error('wait() does not have any arguments', node.args[0].pos)
        }
        if c.table.cur_fn != unsafe { nil } {
            c.table.cur_fn.has_await = true
        }
        node.return_type = info.concrete_types[0]
        node.return_type.set_flag(.option)
        return node.return_type
    } else if left_sym.info is ast.Thread && node.kind == .wait {
        if node.args.len > 0 {
            c.error('wait() does not have any arguments', node.args[0].pos)
        }
        node.return_type = left_sym.info.return_type
        return left_sym.info.return_type
    } else if left_sym.kind == .char && left_type.nr_muls() == 0 && node.kind == .str {
        c.error('calling `.str()` on type `char` is not allowed, use its address or cast it to an integer instead',
            node.left.pos().extend(node.pos))
        return ast.void_type
    }

    mut unknown_method_msg := ''
    mut method := ast.Fn{}
    mut has_method := false
    mut is_method_from_embed := false
    mut structured_receiver_concrete_types := []ast.Type{}
    mut is_structured_receiver_method := false
    defer {
        if has_method && node.is_method {
            c.check_must_use_call_result(node, method, 'method')
        }
    }
    lookup_sym := c.table.sym(left_type)
    if structured_method := c.table.find_structured_receiver_method_with_types(left_type,
        method_name)
    {
        if m := lookup_sym.find_method(method_name) {
            method = m
            has_method = true
        } else if m := c.table.find_alias_parent_exact_method(left_type, method_name) {
            method = m
            has_method = true
        } else {
            method = structured_method.method
            structured_receiver_concrete_types = structured_method.concrete_types.clone()
            is_structured_receiver_method = true
            has_method = true
        }
        if lookup_sym.kind == .interface && method.from_embedded_type != 0 {
            is_method_from_embed = true
            node.from_embed_types = [method.from_embedded_type]
        }
    } else if m := left_sym.find_method_with_generic_parent(method_name) {
        method = m
        has_method = true
        if left_sym.kind == .interface && m.from_embedded_type != 0 {
            is_method_from_embed = true
            node.from_embed_types = [m.from_embedded_type]
        }
    } else if m := c.table.find_method(left_sym, method_name) {
        method = m
        has_method = true
        if left_sym.kind == .interface && m.from_embedded_type != 0 {
            is_method_from_embed = true
            node.from_embed_types = [m.from_embedded_type]
        }
    } else {
        if final_left_sym.kind in [.struct, .sum_type, .interface, .array] {
            mut parent_type := ast.void_type
            match final_left_sym.info {
                ast.Struct, ast.SumType, ast.Interface {
                    parent_type = final_left_sym.info.parent_type
                }
                ast.Array {
                    typ := c.table.unaliased_type(final_left_sym.info.elem_type)
                    parent_type = ast.idx_to_type(c.table.find_or_register_array(typ))
                }
                else {}
            }

            if parent_type != 0 {
                type_sym := c.table.sym(parent_type)
                if m := c.table.find_method(type_sym, method_name) {
                    method = m
                    has_method = true
                    is_generic = true
                    if left_sym.kind == .interface && m.from_embedded_type != 0 {
                        is_method_from_embed = true
                        node.from_embed_types = [m.from_embedded_type]
                    }
                }
            }
        }
        if !has_method {
            has_method = true
            mut embed_types := []ast.Type{}
            method, embed_types = c.table.find_method_from_embeds(final_left_sym, method_name) or {
                emsg := err.str()
                if emsg != '' {
                    c.error(emsg, node.pos)
                }
                has_method = false
                ast.Fn{}, []ast.Type{}
            }
            if embed_types.len != 0 {
                is_method_from_embed = true
                node.from_embed_types = embed_types
                c.markused_comptime_call(node.left_type.has_flag(.generic),
                    '${int(method.receiver_type)}.${method.name}')
            }
        }
        if final_left_sym.kind == .aggregate {
            // the error message contains the problematic type
            unknown_method_msg = err.msg()
            if unknown_method_msg == 'unknown method' {
                unknown_method_msg += ' `' + method_name + '`'
            }
        }
    }

    if !has_method {
        // TODO: str methods
        if node.kind == .str {
            if left_sym.kind == .interface {
                iname := left_sym.name
                c.error('interface `${iname}` does not have a .str() method. Use typeof() instead',
                    node.pos)
            }
            if c.fail_if_private_implicit_str(left_type, node.pos,
                'call auto-generated `.str()` on')
            {
                return ast.string_type
            }
            node.receiver_type = left_type.clear_ref()
            node.return_type = ast.string_type
            if node.args.len > 0 {
                c.error('.str() method calls should have no arguments', node.pos)
            }
            c.fail_if_unreadable(node.left, left_type, 'receiver')
            if !c.is_builtin_mod {
                c.table.used_features.auto_str = true
                c.markused_auto_str_dependencies(left_type)
            }
            return ast.string_type
        } else if node.kind == .free {
            if !c.is_builtin_mod && !c.inside_unsafe && !m