module checker

import v.ast

pub fn (mut c Checker) lambda_expr(mut node ast.LambdaExpr, exp_typ ast.Type) ast.Type {
    if node.is_checked {
        if c.table.cur_concrete_types.len == 0 || node.typ == exp_typ {
            return node.typ
        }
        // Re-checking with different concrete types: don't recreate the AnonFn
        // (which would mutate the shared AST and corrupt params for other
        // instantiations). Just update the scope variable types and return.
        // The cgen handles per-instantiation code generation via g.cur_concrete_types.
        exp_sym := c.table.sym(exp_typ)
        if exp_sym.info is ast.FnType {
            for idx, mut x in node.params {
                if idx < exp_sym.info.func.params.len {
                    eparam_type := exp_sym.info.func.params[idx].typ
                    c.lambda_expr_fix_type_of_param(mut node, mut x, eparam_type)
                }
            }
        }
        return node.typ
    }
    if exp_typ in [0, ast.void_type] {
        c.fatal('lambda expressions are allowed only in places expecting function callbacks',
            node.pos)
        return ast.void_type
    }
    exp_sym := c.table.sym(exp_typ)
    if exp_sym.kind != .function {
        c.error('a lambda expression was used, but `${exp_sym.kind}` was expected', node.pos)
        return ast.void_type
    }
    if exp_sym.info is ast.FnType {
        if node.params.len > exp_sym.info.func.params.len {
            c.error('lambda expression has ${node.params.len} params, but the expected fn callback needs ${exp_sym.info.func.params.len} params',
                node.pos)
            return ast.void_type
        }
        mut params := []ast.Param{}
        mut generic_names := []string{}
        for idx, mut x in node.params {
            eparam := exp_sym.info.func.params[idx]
            eparam_type := eparam.typ
            c.lambda_expr_fix_type_of_param(mut node, mut x, eparam_type)
            c.lambda_expr_push_generic_names(mut generic_names, eparam_type)
            params << ast.Param{
                pos:      x.pos
                name:     x.name
                typ:      eparam_type
                type_pos: x.pos
            }
        }
        for idx in node.params.len .. exp_sym.info.func.params.len {
            eparam_type := exp_sym.info.func.params[idx].typ
            c.lambda_expr_push_generic_names(mut generic_names, eparam_type)
        }
        c.append_omitted_callback_params(mut params, exp_sym.info.func.params, node.pos,
            '__v_lambda_unused_param_', unsafe { nil })

        is_variadic := false
        return_type := exp_sym.info.func.return_type
        return_type_pos := node.pos
        c.lambda_expr_push_generic_names(mut generic_names, return_type)

        mut stmts := []ast.Stmt{}
        mut has_return := false
        if return_type.clear_option_and_result() == ast.void_type {
            stmts << ast.ExprStmt{
                pos:     node.pos
                expr:    node.expr
                is_expr: false
                typ:     return_type
            }
            if mut node.expr is ast.CallExpr && node.expr.is_return_used {
                node.expr.is_return_used = false
            }
        } else {
            stmts << ast.Return{
                scope: node.scope
                pos:   node.pos
                exprs: [node.expr]
            }
            has_return = true
        }

        mut func := ast.Fn{
            params:      params
            is_variadic: is_variadic
            return_type: return_type
            is_method:   false
        }
        name := c.table.get_anon_fn_name(c.file.unique_prefix, func, node.pos)
        func.name = name
        idx := c.table.find_or_register_fn_type(func, true, false)
        typ := ast.new_type(idx)
        node.func = &ast.AnonFn{
            decl: ast.FnDecl{
                name:            name
                short_name:      ''
                mod:             c.file.mod.name
                stmts:           stmts
                has_return:      has_return
                return_type:     return_type
                return_type_pos: return_type_pos
                params:          params
                is_variadic:     is_variadic
                is_method:       false
                is_anon:         true
                no_body:         false
                pos:             node.pos.extend(node.pos_end)
                file:            c.file.path
                scope:           node.scope.parent
                generic_names:   generic_names
            }
            typ:  typ
        }
        if node.func.decl.generic_names.len > 0 {
            c.table.register_fn_generic_types(node.func.decl.fkey())
        }
        c.anon_fn(mut node.func)
    }
    node.is_checked = true
    node.typ = exp_typ

    return exp_typ
}

fn (mut c Checker) lambda_expr_push_generic_names(mut generic_names []string, typ ast.Type) {
    for generic_name in c.table.generic_type_names(typ) {
        if generic_name !in generic_names {
            generic_names << generic_name
        }
    }
}

pub fn (mut c Checker) lambda_expr_fix_type_of_param(mut node ast.LambdaExpr, mut pident ast.Ident, ptype ast.Type) {
    if mut v := node.scope.find_var(pident.name) {
        v.is_arg = true
        v.typ = ptype
        v.is_auto_deref = ptype.is_ptr()
        v.expr = ast.empty_expr
        if ptype.has_flag(.generic) {
            v.ct_type_var = .generic_param
        }
    }
    if pident.kind != .blank_ident {
        c.ident(mut pident)
        pident.obj.typ = ptype
    }
}

pub fn (mut c Checker) support_lambda_expr_in_sort(param_type ast.Type, return_type ast.Type, mut expr ast.LambdaExpr) {
    mut expected_fn := ast.Fn{
        params:      [
            ast.Param{
                name: 'zza'
                typ:  param_type
            },
            ast.Param{
                name: 'zzb'
                typ:  param_type
            },
        ]
        return_type: return_type
    }
    expected_fn_type := ast.new_type(c.table.find_or_register_fn_type(expected_fn, true, false))
    c.lambda_expr(mut expr, expected_fn_type)
}

pub fn (mut c Checker) support_lambda_expr_one_param(param_type ast.Type, return_type ast.Type, mut expr ast.LambdaExpr) {
    expected_fn := ast.Fn{
        params:      [
            ast.Param{
                name: 'xx'
                typ:  if c.table.final_sym(param_type).kind == .function {
                    ast.voidptr_type
                } else {
                    param_type
                }
            },
        ]
        return_type: if c.table.final_sym(return_type).kind == .function {
            ast.voidptr_type
        } else {
            return_type
        }
    }
    cb_type := c.table.find_or_register_fn_type(expected_fn, true, false)
    expected_fn_type := ast.new_type(cb_type)
    c.lambda_expr(mut expr, expected_fn_type)
}