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

import math
import os
import v.ast
import v.pref
import v.token
import v.util
import v.pkgconfig
import v.type_resolver
import v.errors
import strings

@[ignore_overflow]
fn comptime_power_i64(base i64, exponent i64) i64 {
    mut exp := exponent
    mut power := base
    mut value := i64(1)
    if exp < 0 {
        if base == 0 {
            return -1
        }
        return if base * base != 1 {
            0
        } else {
            if exp & 1 > 0 {
                base
            } else {
                1
            }
        }
    }
    for exp > 0 {
        if exp & 1 > 0 {
            value *= power
        }
        power *= power
        exp >>= 1
    }
    return value
}

fn comptime_power_f64(base f64, exponent f64) f64 {
    return math.pow(base, exponent)
}

fn comptime_power_value(left ast.ComptTimeConstValue, right ast.ComptTimeConstValue) ?ast.ComptTimeConstValue {
    if left_i := left.i64() {
        if right_i := right.i64() {
            return comptime_power_i64(left_i, right_i)
        }
    }
    if left_f := left.f64() {
        if right_f := right.f64() {
            return comptime_power_f64(left_f, right_f)
        }
    }
    return none
}

fn comptime_compare_i64_values(op token.Kind, left i64, right i64) ?bool {
    return match op {
        .eq { left == right }
        .ne { left != right }
        .gt { left > right }
        .lt { left < right }
        .ge { left >= right }
        .le { left <= right }
        else { none }
    }
}

fn comptime_compare_f64_values(op token.Kind, left f64, right f64) ?bool {
    return match op {
        .eq { left == right }
        .ne { left != right }
        .gt { left > right }
        .lt { left < right }
        .ge { left >= right }
        .le { left <= right }
        else { none }
    }
}

fn comptime_compare_string_values(op token.Kind, left string, right string) ?bool {
    return match op {
        .eq { left == right }
        .ne { left != right }
        else { none }
    }
}

struct ComptimeComparisonResult {
    val        bool
    keep_stmts bool
}

fn (mut c Checker) eval_comptime_type_meta_value(typ ast.Type, field_name string) ?ast.ComptTimeConstValue {
    base_type := c.unwrap_generic(typ)
    match field_name {
        'name' {
            return c.table.sym(base_type).name
        }
        'idx', 'typ' {
            return i64(int(base_type))
        }
        'unaliased_typ' {
            return i64(int(c.table.unaliased_type(base_type)))
        }
        'indirections' {
            return i64(base_type.nr_muls())
        }
        'key_type', 'value_type', 'element_type', 'pointee_type', 'payload_type' {
            resolved_type := c.type_resolver.typeof_field_type(base_type, field_name)
            if resolved_type != ast.no_type {
                return i64(int(c.unwrap_generic(resolved_type)))
            }
        }
        else {}
    }

    return none
}

fn (c &Checker) is_generic_type_expr_ident(name string) bool {
    return util.is_generic_type_name(name) && c.table.cur_fn != unsafe { nil }
        && name in c.table.cur_fn.generic_names
}

fn (c &Checker) is_comptime_type_expr(expr ast.Expr) bool {
    return match expr {
        ast.ParExpr {
            c.is_comptime_type_expr(expr.expr)
        }
        ast.TypeNode {
            true
        }
        ast.TypeOf {
            true
        }
        ast.Ident {
            c.is_generic_type_expr_ident(expr.name)
        }
        ast.SelectorExpr {
            is_array_init_type_expr_field(expr.field_name) && c.is_comptime_type_expr(expr.expr)
        }
        else {
            false
        }
    }
}

fn (mut c Checker) comptime_call_type_expr_type(mut expr ast.Expr) ast.Type {
    match mut expr {
        ast.ParExpr {
            return c.comptime_call_type_expr_type(mut expr.expr)
        }
        ast.TypeNode {
            return c.recheck_concrete_type(expr.typ)
        }
        ast.TypeOf {
            if expr.is_type {
                return c.recheck_concrete_type(expr.typ)
            }
            if expr.typ == 0 || expr.typ == ast.void_type || expr.typ == ast.no_type {
                expr.typ = c.expr(mut expr.expr)
            }
            resolved_type := c.recheck_concrete_type(expr.typ)
            if resolved_type != 0 && resolved_type != ast.void_type && resolved_type != ast.no_type {
                return resolved_type
            }
            return c.recheck_concrete_type(c.type_resolver.typeof_type(expr.expr, expr.typ))
        }
        ast.ArrayInit {
            if expr.elem_type_expr !is ast.EmptyExpr {
                c.resolve_array_init_elem_type_expr(mut expr)
                return expr.typ
            }
            return c.expr(mut expr)
        }
        ast.SelectorExpr {
            if is_array_init_type_expr_field(expr.field_name) {
                base_type := c.comptime_call_type_expr_type(mut expr.expr)
                resolved := c.type_resolver.typeof_field_type(base_type, expr.field_name)
                if resolved != ast.no_type {
                    return c.recheck_concrete_type(resolved)
                }
            }
            c.expr(mut expr)
            return c.recheck_concrete_type(c.get_expr_type(expr))
        }
        ast.Ident {
            if c.is_generic_type_expr_ident(expr.name) {
                return c.table.find_type(expr.name).set_flag(.generic)
            }
            return c.recheck_concrete_type(c.get_expr_type(expr))
        }
        else {
            return c.recheck_concrete_type(c.expr(mut expr))
        }
    }
}

fn (mut c Checker) eval_comptime_type_selector_value(expr ast.SelectorExpr) ?ast.ComptTimeConstValue {
    if expr.expr is ast.Ident && c.table.cur_fn != unsafe { nil } {
        idx := c.table.cur_fn.generic_names.index(expr.expr.name)
        if idx >= 0 && idx < c.table.cur_concrete_types.len {
            return c.eval_comptime_type_meta_value(c.table.cur_concrete_types[idx], expr.field_name)
        }
    }
    if expr.expr is ast.TypeOf {
        mut resolved_type := c.recheck_concrete_type(expr.expr.typ)
        if resolved_type == ast.void_type || resolved_type == ast.no_type {
            resolved_type = c.recheck_concrete_type(expr.name_type)
        }
        if resolved_type == ast.void_type || resolved_type == ast.no_type {
            resolved_type = c.type_resolver.typeof_type(expr.expr.expr, expr.name_type)
        }
        if resolved_type != ast.void_type && resolved_type != ast.no_type {
            return c.eval_comptime_type_meta_value(resolved_type, expr.field_name)
        }
    }
    return none
}

fn (c &Checker) comptime_expr_needs_multi_pass(expr ast.Expr) bool {
    match expr {
        ast.TypeOf {
            return true
        }
        ast.Ident {
            if c.table.cur_fn != unsafe { nil } && expr.name in c.table.cur_fn.generic_names {
                return true
            }
            if expr.obj is ast.Var && expr.obj.typ.has_flag(.generic) {
                return true
            }
            return expr.ct_expr
        }
        ast.SelectorExpr {
            if expr.expr is ast.TypeOf {
                return true
            }
            if expr.expr is ast.Ident {
                if c.table.cur_fn != unsafe { nil }
                    && expr.expr.name in c.table.cur_fn.generic_names {
                    return true
                }
            }
            return c.comptime_expr_needs_multi_pass(expr.expr)
        }
        ast.InfixExpr {
            return c.comptime_expr_needs_multi_pass(expr.left)
                || c.comptime_expr_needs_multi_pass(expr.right)
        }
        ast.CastExpr {
            return c.comptime_expr_needs_multi_pass(expr.expr)
        }
        ast.IndexExpr {
            return c.comptime_expr_needs_multi_pass(expr.left)
                || c.comptime_expr_needs_multi_pass(expr.index)
        }
        ast.ParExpr {
            return c.comptime_expr_needs_multi_pass(expr.expr)
        }
        ast.PostfixExpr {
            return c.comptime_expr_needs_multi_pass(expr.expr)
        }
        ast.PrefixExpr {
            return c.comptime_expr_needs_multi_pass(expr.right)
        }
        else {}
    }

    return false
}

fn (mut c Checker) try_eval_comptime_comparison(mut left ast.Expr, mut right ast.Expr, op token.Kind) ?ComptimeComparisonResult {
    start_errors := c.nr_errors
    left_type := c.unwrap_generic(c.expr(mut left))
    right_type := c.unwrap_generic(c.expr(mut right))
    if c.nr_errors > start_errors {
        return none
    }
    left_value := c.eval_comptime_const_expr(left, 0)?
    right_value := c.eval_comptime_const_expr(right, 0)?
    keep_stmts := c.comptime_expr_needs_multi_pass(left) || c.comptime_expr_needs_multi_pass(right)
    if left_type == ast.string_type || right_type == ast.string_type {
        return ComptimeComparisonResult{
            val:        comptime_compare_string_values(op, left_value.string()?,
                right_value.string()?)?
            keep_stmts: keep_stmts
        }
    }
    if left_type.is_float() || right_type.is_float() {
        return ComptimeComparisonResult{
            val:        comptime_compare_f64_values(op, left_value.f64()?, right_value.f64()?)?
            keep_stmts: keep_stmts
        }
    }
    return ComptimeComparisonResult{
        val:        comptime_compare_i64_values(op, left_value.i64()?, right_value.i64()?)?
        keep_stmts: keep_stmts
    }
}

fn (mut c Checker) is_string_array_type(typ ast.Type) bool {
    final_typ := c.table.unaliased_type(c.unwrap_generic(typ))
    sym := c.table.final_sym(final_typ)
    if sym.info is ast.Array {
        return c.table.unaliased_type(sym.info.elem_type) == ast.string_type
    }
    return false
}

fn (mut c Checker) check_comptime_method_string_auto_expand(mut node ast.ComptimeCall) bool {
    if c.comptime.comptime_for_method == unsafe { nil } || node.args.len == 0
        || node.args.any(it.expr is ast.ArrayDecompose) {
        return false
    }
    method := c.comptime.comptime_for_method
    if method.params.len - 1 < node.args.len {
        return false
    }
    last_arg := node.args.last()
    if !c.is_string_array_type(last_arg.typ) {
        return false
    }
    next_param := method.params[node.args.len].typ
    if c.is_string_array_type(next_param) {
        return false
    }
    c.error('to auto-expand `[]string` arguments in comptime method calls, use `...${last_arg.expr}`',
        last_arg.pos)
    return true
}

fn (mut c Checker) check_comptime_method_call_args(mut node ast.ComptimeCall) {
    if c.comptime.comptime_for_method == unsafe { nil } {
        return
    }
    if node.args.any(it.expr is ast.ArrayDecompose) {
        return
    }
    method := c.comptime.comptime_for_method
    if method.params.len == 0 {
        return
    }
    nr_method_args := method.params.len - 1
    if !method.is_variadic && node.args.len > nr_method_args {
        return
    }
    receiver_name := c.table.type_to_str(c.unwrap_generic(method.receiver_type).set_nr_muls(0))
    for i in 0 .. node.args.len {
        mut arg := node.args[i]
        param := if method.is_variadic && i >= nr_method_args - 1 {
            method.params.last()
        } else if i + 1 < method.params.len {
            method.params[i + 1]
        } else {
            break
        }
        arg = c.implicit_mut_call_arg(param, arg)
        node.args[i] = arg
        param_share := param.typ.share()
        if arg.is_mut {
            to_lock, pos := c.fail_if_immutable(mut arg.expr)
            if !param.is_mut {
                tok := arg.share.str()
                c.error('`${method.name}` parameter `${param.name}` is not `${tok}`, `${tok}` is not needed`',
                    arg.expr.pos())
                continue
            }
            if param_share != arg.share {
                c.error('wrong shared type `${arg.share.str()}`, expected: `${param_share.str()}`',
                    arg.expr.pos())
            }
            if to_lock != '' && param_share != .shared_t {
                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()
            c.error('method `${method.name}` parameter `${param.name}` is `${tok}`, so use `${tok} ${arg.expr}` instead',
                arg.expr.pos())
            continue
        } else {
            c.fail_if_unreadable(arg.expr, arg.typ, 'argument')
        }
        c.check_expected_call_arg(arg.typ, c.unwrap_generic(param.typ), method.language, arg) or {
            if arg.typ != ast.void_type {
                c.error('${err.msg()} in argument ${i + 1} to `${receiver_name}.${method.name}`',
                    arg.pos)
            }
        }
    }
}

fn (mut c Checker) comptime_call(mut node ast.ComptimeCall) ast.Type {
    if node.left !is ast.EmptyExpr {
        node.left_type = c.expr(mut node.left)
    }
    if node.kind == .compile_error {
        mut err_pos := node.pos
        // During generic rechecks, report the instantiation site instead of the
        // `$compile_error()` directive inside the generic body.
        if c.fn_level > 0 && c.table.cur_fn != unsafe { nil } {
            call_key := c.build_generic_call_key(c.table.cur_fn.fkey(), c.table.cur_concrete_types)
            if pos := c.generic_call_positions[call_key] {
                err_pos = pos
            }
        }
        c.error(c.comptime_call_msg(node), err_pos)
        return ast.void_type
    } else if node.kind == .compile_warn {
        c.warn(c.comptime_call_msg(node), node.pos)
        return ast.void_type
    }
    if node.kind == .env {
        env_value := util.resolve_env_value("\$env('${node.args_var}')", false) or {
            c.error(err.msg(), node.env_pos)
            return ast.string_type
        }
        node.env_value = env_value
        return ast.string_type
    }
    if node.kind == .d {
        node.resolve_compile_value(c.pref.compile_values) or {
            c.error(err.msg(), node.pos)
            return ast.void_type
        }
        return node.result_type
    }
    if node.kind in [.zero, .new] {
        if node.args.len != 1 {
            c.error('`\$${node.method_name}()` expects 1 type argument', node.pos)
            return ast.void_type
        }
        mut type_expr := node.args[0].expr
        resolved_type := c.comptime_call_type_expr_type(mut type_expr)
        node.args[0].expr = type_expr
        if resolved_type == ast.void_type || resolved_type == ast.no_type {
            c.error('`\$${node.method_name}()` expects a valid type expression', node.args[0].pos)
            return ast.void_type
        }
        node.args[0].typ = resolved_type
        node.result_type = if node.kind == .new { resolved_type.ref() } else { resolved_type }
        return node.result_type
    }
    if node.kind == .embed_file {
        if node.args.len == 1 {
            embed_arg := node.args[0]
            mut raw_path := ''
            if embed_arg.expr is ast.AtExpr {
                mut expr := embed_arg.expr
                c.at_expr(mut expr)
                raw_path = expr.val
            }
            if embed_arg.expr is ast.StringLiteral {
                raw_path = embed_arg.expr.val
            } else if embed_arg.expr is ast.Ident {
                if var := c.fn_scope.find_var(embed_arg.expr.name) {
                    if var.expr is ast.StringLiteral {
                        raw_path = var.expr.val
                    }
                }
            }
            mut escaped_path := raw_path.replace('/', os.path_separator)
            // Validate that the epath exists, and that it is actually a file.
            if escaped_path == '' {
                c.error('supply a valid relative or absolute file path to the file to embed, that is known at compile time',
                    node.pos)
                return ast.string_type
            }
            escaped_path = c.resolve_pseudo_variables(escaped_path, node.pos) or {
                return ast.string_type
            }
            abs_path := os.real_path(escaped_path)
            // check absolute path first
            if !os.exists(abs_path) {
                // ... look relative to the source file:
                escaped_path = os.real_path(os.join_path_single(os.dir(c.file.path), escaped_path))
                if !os.exists(escaped_path) {
                    c.error('"${escaped_path}" does not exist so it cannot be embedded', node.pos)
                    return ast.string_type
                }
                if !os.is_file(escaped_path) {
                    c.error('"${escaped_path}" is not a file so it cannot be embedded', node.pos)
                    return ast.string_type
                }
            } else {
                escaped_path = abs_path
            }
            node.embed_file.rpath = raw_path
            node.embed_file.apath = escaped_path
        }
        // c.file.embedded_files << node.embed_file
        if node.embed_file.compression_type !in ast.valid_comptime_compression_types {
            supported := ast.valid_comptime_compression_types.map('.${it}').join(', ')
            c.error('not supported compression type: .${node.embed_file.compression_type}. supported: ${supported}',
                node.pos)
        }
        return c.table.find_type('v.embed_file.EmbedFileData')
    }
    if node.is_template {
        // TODO: assoc parser bug
        save_cur_fn := c.table.cur_fn
        pref_ := *c.pref
        pref2 := &pref.Preferences{
            ...pref_
            is_template: true
        }
        mut c2 := new_checker(c.table, pref2)
        c2.comptime_call_pos = node.pos.pos
        template_parser_errors := node.veb_tmpl.errors.clone()
        template_parser_warnings := node.veb_tmpl.warnings.clone()
        template_parser_notices := node.veb_tmpl.notices.clone()
        c2.check(mut node.veb_tmpl)

        // Cache template file content for error display using the relative path
        // The template_paths contains full paths, but errors use relative paths from node.veb_tmpl.path
        if node.veb_tmpl.template_paths.len > 0 {
            // Cache the main template file
            main_template_path := node.veb_tmpl.template_paths[0]
            if content := os.read_file(main_template_path) {
                util.set_source_for_path(node.veb_tmpl.path, content)
            }
        }

        // Fix error line numbers using template line mapping
        line_map := node.veb_tmpl.template_line_map
        if line_map.len > 0 {
            for i, err in c2.errors {
                if err.pos.line_nr >= 0 && err.pos.line_nr < line_map.len {
                    line_info := line_map[err.pos.line_nr]
                    c2.errors[i] = errors.Error{
                        message:    err.message
                        details:    err.details
                        file_path:  line_info.tmpl_path
                        pos:        token.Pos{
                            ...err.pos
                            line_nr: line_info.tmpl_line
                        }
                        reporter:   err.reporter
                        call_stack: err.call_stack
                    }
                }
            }
            for i, warn in c2.warnings {
                if warn.pos.line_nr >= 0 && warn.pos.line_nr < line_map.len {
                    line_info := line_map[warn.pos.line_nr]
                    c2.warnings[i] = errors.Warning{
                        message:    warn.message
                        details:    warn.details
                        file_path:  line_info.tmpl_path
                        pos:        token.Pos{
                            ...warn.pos
                            line_nr: line_info.tmpl_line
                        }
                        reporter:   warn.reporter
                        call_stack: warn.call_stack
                    }
                }
            }
            for i, notice in c2.notices {
                if notice.pos.line_nr >= 0 && notice.pos.line_nr < line_map.len {
                    line_info := line_map[notice.pos.line_nr]
                    c2.notices[i] = errors.Notice{
                        message:    notice.message
                        details:    notice.details
                        file_path:  line_info.tmpl_path
                        pos:        token.Pos{
                            ...notice.pos
                            line_nr: line_info.tmpl_line
                        }
                        reporter:   notice.reporter
                        call_stack: notice.call_stack
                    }
                }
            }
        }

        c.warnings << template_parser_warnings
        c.errors << template_parser_errors
        c.notices << template_parser_notices
        c.nr_warnings += template_parser_warnings.len
        c.nr_errors += template_parser_errors.len
        c.nr_notices += template_parser_notices.len

        c.warnings << c2.warnings
        c.errors << c2.errors
        c.notices << c2.notices
        c.nr_warnings += c2.nr_warnings
        c.nr_errors += c2.nr_errors
        c.nr_notices += c2.nr_notices

        c.table.cur_fn = save_cur_fn
    }
    if node.kind == .html {
        ret_sym := c.table.sym(c.table.cur_fn.return_type)
        if ret_sym.cname != 'veb__Result' {
            c.error("`\$veb.html()` must be called inside a web method, e.g. `fn (mut app App) foo(mut ctx Context) veb.Result { return \$veb.html('index.html') }`",
                node.pos)
        }
        rtyp := c.table.find_type('veb.Result')
        node.result_type = rtyp
        return rtyp
    }
    if node.method_name == 'method' {
        if c.inside_anon_fn && 'method' !in c.cur_anon_fn.inherited_vars.map(it.name) {
            c.error('undefined ident `method` in the anonymous function', node.pos)
        }
        for i, mut arg in node.args {
            // check each arg expression
            node.args[i].typ = c.expr(mut arg.expr)
        }
        if c.check_comptime_method_string_auto_expand(mut node) {
            return ast.void_type
        }
        c.check_comptime_method_call_args(mut node)
        c.markused_comptimecall(mut node)
        c.stmts_ending_with_expression(mut node.or_block.stmts, c.expected_or_type)
        return c.type_resolver.get_type(node)
    }
    if node.kind == .res {
        if !c.inside_defer {
            c.error('`res` can only be used in defer blocks', node.pos)
            return ast.void_type
        }

        if c.fn_return_type == ast.void_type {
            c.error('`res` can only be used in functions that returns something', node.pos)
            return ast.void_type
        }

        sym := c.table.sym(c.fn_return_type)

        if c.fn_return_type.has_flag(.result) {
            c.error('`res` cannot be used in functions that returns a Result', node.pos)
            return ast.void_type
        }

        if sym.info is ast.MultiReturn {
            if node.args_var == '' {
                c.error('`res` requires an index of the returned value', node.pos)
                return ast.void_type
            }
            idx := node.args_var.int()
            if idx < 0 || idx >= sym.info.types.len {
                c.error('index ${idx} out of range of ${sym.info.types.len} return types', node.pos)
                return ast.void_type
            }
            return sym.info.types[idx]
        }

        return c.fn_return_type
    }
    if node.is_template {
        return ast.string_type
    }
    // s.$my_str()
    v := node.scope.find_var(node.method_name) or {
        c.error('unknown identifier `${node.method_name}`', node.method_pos)
        return ast.void_type
    }
    if v.typ != ast.string_type {
        s := c.expected_msg(v.typ, ast.string_type)
        c.error('invalid string method call: ${s}', node.method_pos)
        return ast.void_type
    }
    // note: we should use a compile-time evaluation function rather than handle here
    // mut variables will not work after init
    mut method_name := ''
    if v.expr is ast.StringLiteral {
        method_name = v.expr.val
    } else {
        c.error('todo: not a string literal', node.method_pos)
    }
    left_type := c.unwrap_generic(node.left_type)
    left_sym := c.table.sym(left_type)
    f := left_sym.find_method(method_name) or {
        c.error('could not find method `${method_name}`', node.method_pos)
        return ast.void_type
    }
    c.mark_fn_decl_as_referenced(f.fkey())
    c.markused_comptime_call(true, '${int(left_type)}.${method_name}')
    node.result_type = f.return_type
    return f.return_type
}

fn (mut c Checker) comptime_call_msg(node ast.ComptimeCall) string {
    return if node.args_var.len > 0 {
        node.args_var
    } else if value := c.eval_comptime_const_expr(node.args[0].expr, -1) {
        value.string() or { '' }
    } else {
        ''
    }
}

fn (mut c Checker) comptime_selector_method_value(mut node ast.ComptimeSelector) ast.Type {
    if c.comptime.comptime_for_method == unsafe { nil } {
        c.error('compile time method access can only be used when iterating over `T.methods`',
            node.field_expr.pos())
        return ast.void_type
    }
    method := c.comptime.comptime_for_method
    node.is_method = true
    fn_type := c.type_resolver.get_comptime_selector_type(node, ast.void_type)
    node.typ = c.unwrap_generic(fn_type)
    c.mark_fn_decl_as_referenced(method.fkey())
    c.markused_comptime_call(true, '${int(method.params[0].typ)}.${method.name}')
    receiver := c.unwrap_generic(method.params[0].typ)
    if receiver.nr_muls() > 0 && !c.inside_unsafe {
        rec_sym := c.table.sym(receiver.set_nr_muls(0))
        if !rec_sym.is_heap() {
            suggestion := if rec_sym.kind == .struct {
                'declaring `${rec_sym.name}` as `@[heap]`'
            } else {
                'wrapping the `${rec_sym.name}` object in a `struct` declared as `@[heap]`'
            }
            c.error('method `${c.table.type_to_str(receiver.idx_type())}.${method.name}` cannot be used as a variable outside `unsafe` blocks as its receiver might refer to an object stored on stack. Consider ${suggestion}.',
                node.left.pos().extend(node.pos))
        }
    }
    c.table.used_features.anon_fn = true
    return fn_type
}

fn (mut c Checker) comptime_selector(mut node ast.ComptimeSelector) ast.Type {
    node.left_type = c.expr(mut node.left)
    mut expr_type := c.unwrap_generic(c.expr(mut node.field_expr))
    if c.type_resolver.info.is_comptime_method_selector(node.field_expr) {
        return c.comptime_selector_method_value(mut node)
    }
    expr_sym := c.table.sym(expr_type)
    if expr_type != ast.string_type {
        c.error('expected `string` instead of `${expr_sym.name}` (e.g. `field.name`)',
            node.field_expr.pos())
    }
    if mut node.field_expr is ast.SelectorExpr {
        left_pos := node.field_expr.expr.pos()
        if c.type_resolver.type_map.len == 0 {
            c.error('compile time field access can only be used when iterating over `T.fields`',
                left_pos)
        }
        node.is_name = node.field_expr.field_name == 'name'
        if mut node.field_expr.expr is ast.Ident {
            node.typ_key = if c.comptime.comptime_for_field_value.name != '' {
                '${node.field_expr.expr.name}.typ|${c.comptime.comptime_for_field_value.name}'
            } else {
                '${node.field_expr.expr.name}.typ'
            }
        }
        expr_type = c.type_resolver.get_comptime_selector_type(node, ast.void_type)
        if expr_type != ast.void_type {
            if node.or_block.kind == .propagate_option {
                return expr_type.clear_flag(.option)
            }
            return expr_type
        }
        expr_name := node.field_expr.expr.str()
        if expr_name in c.type_resolver.type_map {
            return c.type_resolver.get_ct_type_or_default(expr_name, ast.void_type)
        }
        c.error('unknown `\$for` variable `${expr_name}`', left_pos)
    } else {
        c.error('expected selector expression e.g. `$(field.name)`', node.field_expr.pos())
    }
    return ast.void_type
}

fn (mut c Checker) comptime_for(mut node ast.ComptimeFor) {
    mut typ := if node.expr !is ast.EmptyExpr {
        node.typ = c.expr(mut node.expr)
        c.unwrap_generic(node.typ)
    } else if node.typ != ast.void_type {
        c.unwrap_generic(node.typ)
    } else {
        node.typ = c.expr(mut node.expr)
        c.unwrap_generic(node.typ)
    }
    if node.expr !is ast.EmptyExpr {
        resolved_typ := c.type_resolver.get_type(node.expr)
        if resolved_typ != ast.void_type {
            node.typ = resolved_typ
            typ = c.unwrap_generic(node.typ)
        }
    }
    // When the resolved type is FieldData, the expression refers to a comptime
    // field variable (e.g. `$for method in field.methods` where `field` comes
    // from an outer `$for field in T.fields`). In that case use the actual field
    // type from the outer comptime loop instead of the FieldData descriptor type.
    if node.typ == c.field_data_type {
        typ = c.comptime.comptime_for_field_type
    }
    sym := if node.typ != c.field_data_type {
        c.table.final_sym(typ)
    } else {
        c.table.final_sym(c.comptime.comptime_for_field_type)
    }
    if sym.kind == .placeholder || typ.has_flag(.generic) {
        c.error('\$for expects a type name or variable name to be used here, but ${sym.name} is not a type or variable name',
            node.typ_pos)
        return
    } else if sym.kind == .void {
        c.error('only known compile-time variables can be used', node.typ_pos)
        return
    }
    if node.kind == .fields {
        if sym.kind in [.struct, .interface] {
            mut fields := []ast.StructField{}
            match sym.info {
                ast.Struct {
                    fields = sym.info.fields.clone()
                }
                ast.Interface {
                    fields = sym.info.fields.clone()
                }
                else {
                    c.error('iterating over .fields is supported only for structs and interfaces, and ${sym.name} is neither',
                        node.typ_pos)
                    return
                }
            }

            has_different_types := fields.len > 1
                && !fields.all(c.check_basic(it.typ, fields[0].typ))
            if fields.len == 0 {
                // force eval `node.stmts` to set their types
                fields << ast.StructField{
                    typ: ast.error_type
                }
            }
            for field in fields {
                c.push_new_comptime_info()
                prev_inside_x_matches_type := c.inside_x_matches_type
                c.comptime.inside_comptime_for = true
                if c.field_data_type == 0 {
                    c.field_data_type = c.table.find_type('FieldData')
                }
                c.comptime.comptime_for_field_value = field
                c.comptime.comptime_for_field_var = node.val_var
                resolved_field_typ := c.unwrap_generic(field.typ)
                c.type_resolver.update_ct_type(node.val_var, c.field_data_type)
                c.type_resolver.update_ct_type('${node.val_var}.typ', resolved_field_typ)
                c.comptime.comptime_for_field_type = resolved_field_typ
                c.comptime.has_different_types = has_different_types
                c.stmts(mut node.stmts)

                if resolved_field_typ != ast.no_type {
                    unwrapped_expr_type := c.unwrap_generic(resolved_field_typ)
                    tsym := c.table.sym(unwrapped_expr_type)
                    c.markused_comptimefor(mut node, unwrapped_expr_type)
                    if tsym.kind == .array_fixed {
                        info := tsym.info as ast.ArrayFixed
                        if !info.is_fn_ret {
                            // for dumping fixed array we must register the fixed array struct to return from function
                            c.table.find_or_register_array_fixed(info.elem_type, info.size,
                                info.size_expr, true)
                        }
                    }
                }
                c.inside_x_matches_type = prev_inside_x_matches_type
                c.pop_comptime_info()
            }
        } else if node.typ != ast.void_type && c.table.generic_type_names(node.typ).len == 0
            && sym.kind != .placeholder {
            c.error('iterating over .fields is supported only for structs and interfaces, and ${sym.name} is neither',
                node.typ_pos)
            return
        }
    } else if node.kind == .values {
        if sym.kind == .enum {
            if sym.info is ast.Enum {
                for _ in sym.info.vals {
                    c.push_new_comptime_info()
                    c.comptime.inside_comptime_for = true
                    if c.enum_data_type == 0 {
                        c.enum_data_type = c.table.find_type('EnumData')
                    }
                    c.comptime.comptime_for_enum_var = node.val_var
                    c.type_resolver.update_ct_type(node.val_var, c.enum_data_type)
                    c.type_resolver.update_ct_type('${node.val_var}.typ', node.typ)
                    c.stmts(mut node.stmts)
                    c.pop_comptime_info()
                }
            }
        } else {
            c.error('iterating over .values is supported only for enums, and ${sym.name} is not an enum',
                node.typ_pos)
            return
        }
    } else if node.kind == .methods {
        mut methods := c.table.get_type_methods(typ)
        if methods.len == 0 {
            // force eval `node.stmts` to set their types
            methods << ast.Fn{}
        }
        for method in methods {
            c.push_new_comptime_info()
            c.comptime.inside_comptime_for = true
            c.comptime.comptime_for_method = unsafe { &method }
            c.comptime.comptime_for_method_var = node.val_var
            c.comptime.comptime_for_method_ret_type = method.return_type
            c.type_resolver.update_ct_type('${node.val_var}.return_type', method.return_type)
            if method.params.len > 0 {
                for j, arg in method.params[1..] {
                    c.type_resolver.update_ct_type('${node.val_var}.args[${j}].typ', arg.typ.idx())
                }
            }
            c.stmts(mut node.stmts)
            c.pop_comptime_info()
        }
    } else if node.kind == .params {
        if !(sym.kind == .function || sym.name == 'FunctionData') {
            c.error('iterating over `.params` is supported only for functions, and `${sym.name}` is not a function',
                node.typ_pos)
            return
        }

        func := if sym.info is ast.FnType { &sym.info.func } else { c.comptime.comptime_for_method }
        mut params := if func.is_method { func.params[1..] } else { func.params }
        if params.len == 0 {
            // force eval `node.stmts` to set their types
            params << ast.Param{}
        }
        // example: fn (mut d MyStruct) add(x int, y int) string
        // `d` is params[0], `x` is params[1], `y` is params[2]
        // so we at least has one param (`d`) for method
        for param in params {
            c.push_new_comptime_info()
            c.comptime.inside_comptime_for = true
            c.comptime.comptime_for_method_param_var = node.val_var
            c.type_resolver.update_ct_type('${node.val_var}.typ', param.typ)
            c.stmts(mut node.stmts)
            c.pop_comptime_info()
        }
    } else if node.kind == .attributes {
        mut attrs := c.table.get_attrs(sym)
        if attrs.len == 0 {
            // force eval `node.stmts` to set their types
            attrs << ast.Attr{}
        }
        for attr in attrs {
            c.push_new_comptime_info()
            c.comptime.inside_comptime_for = true
            c.comptime.comptime_for_attr_var = node.val_var
            c.comptime.comptime_for_attr_value = attr
            c.stmts(mut node.stmts)
            c.pop_comptime_info()
        }
    } else if node.kind == .variants {
        if c.variant_data_type == 0 {
            c.variant_data_type = c.table.find_type('VariantData')
        }
        mut variants := []ast.Type{}
        if c.comptime.comptime_for_field_var != '' && typ == c.field_data_type {
            sumtype_sym := c.table.sym(c.comptime.comptime_for_field_type)
            if sumtype_sym.kind == .sum_type {
                variants = (sumtype_sym.info as ast.SumType).variants.clone()
            }
        } else if sym.kind != .sum_type {
            c.error('${sym.name} is not Sum type to use with .variants', node.typ_pos)
        } else {
            variants = (sym.info as ast.SumType).variants.clone()
        }
        for variant in variants {
            c.push_new_comptime_info()
            c.comptime.inside_comptime_for = true
            c.comptime.comptime_for_variant_var = node.val_var
            c.type_resolver.update_ct_type(node.val_var, c.variant_data_type)
            c.type_resolver.update_ct_type('${node.val_var}.typ', variant)
            c.stmts(mut node.stmts)
            c.pop_comptime_info()
        }
    } else {
        c.stmts(mut node.stmts)
    }
}

fn (mut c Checker) find_comptime_eval_fn(node ast.CallExpr) ?ast.Fn {
    if f := c.table.find_fn(node.name) {
        return f
    }
    if node.mod != '' && !node.name.contains('.') {
        if f := c.table.find_fn('${node.mod}.${node.name}') {
            return f
        }
    }
    if !node.name.contains('.') {
        if f := c.table.find_fn('${c.mod}.${node.name}') {
            return f
        }
        if f := c.table.find_fn('builtin.${node.name}') {
            return f
        }
    }
    return none
}

fn (c &Checker) find_comptime_eval_fn_decl(func ast.Fn) ?ast.FnDecl {
    if func.source_fn != unsafe { nil } {
        fn_decl := unsafe { &ast.FnDecl(func.source_fn) }
        if fn_decl != unsafe { nil } {
            return *fn_decl
        }
    }
    if c.file != unsafe { nil } {
        for stmt in c.file.stmts {
            if stmt is ast.FnDecl && stmt.name == func.name {
                return stmt
            }
        }
    }
    return none
}

fn (mut c Checker) eval_comptime_fn_decl_value_with_locals(fn_decl ast.FnDecl, nlevel int, local_values map[string]ast.ComptTimeConstValue) ?ast.ComptTimeConstValue {
    mut stmts := fn_decl.stmts.clone()
    if stmts.len == 1 && stmts[0] is ast.Block {
        unsafe_block := stmts[0] as ast.Block
        if unsafe_block.is_unsafe {
            stmts = unsafe_block.stmts.clone()
        }
    }
    if stmts.len != 1 {
        return none
    }
    stmt := stmts[0]
    match stmt {
        ast.Return {
            if stmt.exprs.len != 1 {
                return none
            }
            return c.eval_comptime_const_expr_with_locals(stmt.exprs[0], nlevel + 1, local_values)
        }
        ast.ExprStmt {
            return c.eval_comptime_const_expr_with_locals(stmt.expr, nlevel + 1, local_values)
        }
        else {
            return none
        }
    }
}

fn (mut c Checker) eval_comptime_fn_call_expr_with_locals(node ast.CallExpr, nlevel int, local_values map[string]ast.ComptTimeConstValue) ?ast.ComptTimeConstValue {
    if node.is_method || node.is_fn_var || node.is_fn_a_const {
        return none
    }
    func := c.find_comptime_eval_fn(node) or { return none }
    if !func.attrs.contains('comptime') {
        return none
    }
    if func.is_method || func.is_variadic || func.is_c_variadic || func.no_body
        || func.generic_names.len > 0 || func.params.len != node.args.len {
        return none
    }
    fn_decl := c.find_comptime_eval_fn_decl(func) or { return none }
    mut local_args := map[string]ast.ComptTimeConstValue{}
    for idx, param in func.params {
        arg_value := c.eval_comptime_const_expr_with_locals(node.args[idx].expr, nlevel + 1,
            local_values) or { return none }
        local_args[param.name] = arg_value
    }
    return c.eval_comptime_fn_decl_value_with_locals(fn_decl, nlevel + 1, local_args)
}

fn (mut c Checker) eval_comptime_const_cast_value(value ast.ComptTimeConstValue, typ ast.Type) ?ast.ComptTimeConstValue {
    cast_typ := c.table.fully_unaliased_type(typ).clear_flags()
    if cast_typ == ast.i8_type {
        return value.i8() or { return none }
    }
    if cast_typ == ast.i16_type {
        return value.i16() or { return none }
    }
    if cast_typ == ast.i32_type {
        return value.i32() or { return none }
    }
    if cast_typ == ast.i64_type {
        return value.i64() or { return none }
    }
    if cast_typ == ast.int_type {
        return value.i64() or { return none }
    }
    //
    if cast_typ == ast.u8_type {
        return value.u8() or { return none }
    }
    if cast_typ == ast.u16_type {
        return value.u16() or { return none }
    }
    if cast_typ == ast.u32_type {
        return value.u32() or { return none }
    }
    if cast_typ == ast.u64_type {
        return value.u64() or { return none }
    }
    //
    if cast_typ == ast.f32_type {
        return value.f32() or { return none }
    }
    if cast_typ == ast.f64_type {
        return value.f64() or { return none }
    }
    if cast_typ == ast.voidptr_type || cast_typ == ast.nil_type {
        ptrvalue := value.voidptr() or { return none }
        return ast.ComptTimeConstValue(ptrvalue)
    }
    return none
}

// comptime const eval
fn (mut c Checker) eval_comptime_const_expr(expr ast.Expr, nlevel int) ?ast.ComptTimeConstValue {
    return c.eval_comptime_const_expr_with_locals(expr, nlevel,
        map[string]ast.ComptTimeConstValue{})
}

fn (mut c Checker) eval_comptime_const_expr_with_locals(expr ast.Expr, nlevel int, local_values map[string]ast.ComptTimeConstValue) ?ast.ComptTimeConstValue {
    if nlevel > 100 {
        // protect against a too deep comptime eval recursion
        return none
    }
    match expr {
        ast.ParExpr {
            return c.eval_comptime_const_expr_with_locals(expr.expr, nlevel + 1, local_values)
        }
        ast.EnumVal {
            enum_name := if expr.enum_name == '' {
                c.table.type_to_str(c.expected_type)
            } else {
                expr.enum_name
            }
            if val := c.table.find_enum_field_val(enum_name, expr.val) {
                return val
            }
        }
        ast.SizeOf {
            s, _ := c.table.type_size(c.unwrap_generic(expr.typ))
            return i64(s)
        }
        ast.FloatLiteral {
            x := expr.val.f64()
            return x
        }
        ast.IntegerLiteral {
            x := expr.val.u64()
            if x > 9223372036854775807 {
                return x
            }
            return expr.val.i64()
        }
        ast.StringLiteral {
            return util.smart_quote(expr.val, expr.is_raw)
        }
        ast.StringInterLiteral {
            if nlevel < 0 {
                mut sb := strings.new_builder(20)
                for i, val in expr.vals {
                    sb.write_string(val)
                    if e := expr.exprs[i] {
                        if value := c.eval_comptime_const_expr_with_locals(e, nlevel + 1,
                            local_values)
                        {
                            sb.write_string(value.string() or { '' })
                        } else {
                            c.error('unsupport expr `${e.str()}`', e.pos())
                        }
                    }
                }
                return sb.str()
            }
        }
        ast.CharLiteral {
            runes := expr.val.runes()
            if runes.len > 0 {
                return runes[0]
            }
            return none
        }
        ast.Ident {
            if value := local_values[expr.name] {
                return value
            }
            if expr.obj is ast.ConstField {
                // an existing constant?
                return c.eval_comptime_const_expr_with_locals(expr.obj.expr, nlevel + 1,
                    local_values)
            }
            if c.table.cur_fn != unsafe { nil } {
                idx := c.table.cur_fn.generic_names.index(expr.name)
                if typ := c.table.cur_concrete_types[idx] {
                    sym := c.table.sym(typ)
                    return sym.str()
                }
            }
        }
        ast.SelectorExpr {
            if value := c.eval_comptime_type_selector_value(expr) {
                return value
            }
        }
        ast.CastExpr {
            cast_expr_value := c.eval_comptime_const_expr_with_locals(expr.expr, nlevel + 1,
                local_values) or { return none }
            return c.eval_comptime_const_cast_value(cast_expr_value, expr.typ)
        }
        ast.CallExpr {
            return c.eval_comptime_fn_call_expr_with_locals(expr, nlevel, local_values)
        }
        ast.InfixExpr {
            left := c.eval_comptime_const_expr_with_locals(expr.left, nlevel + 1, local_values)?
            saved_expected_type := c.expected_type
            if expr.left is ast.EnumVal {
                c.expected_type = expr.left.typ
            } else if expr.left is ast.InfixExpr {
                mut infixexpr := expr
                for {
                    if infixexpr.left is ast.InfixExpr {
                        infixexpr = infixexpr.left as ast.InfixExpr
                    } else {
                        break
                    }
                }
                if mut infixexpr.left is ast.EnumVal {
                    c.expected_type = infixexpr.left.typ
                }
            }
            right := c.eval_comptime_const_expr_with_locals(expr.right, nlevel + 1, local_values)?
            c.expected_type = saved_expected_type
            if expr.op == .power {
                return comptime_power_value(left, right)
            }
            if left is string && right is string {
                match expr.op {
                    .plus {
                        return left + right
                    }
                    else {
                        return none
                    }
                }
            } else if left is u32 && right is i64 {
                match expr.op {
                    .plus { return i64(left) + right }
                    .minus { return i64(left) - right }
                    .mul { return i64(left) * right }
                    .div { return i64(left) / right }
                    .mod { return i64(left) % right }
                    .xor { return i64(left) ^ right }
                    .pipe { return i64(left) | right }
                    .amp { return i64(left) & right }
                    .left_shift { return i64(u64(left) << right) }
                    .right_shift { return i64(u64(left) >> right) }
                    .unsigned_right_shift { return i64(u64(left) >>> right) }
                    else { return none }
                }
            } else if left is i64 && right is u32 {
                match expr.op {
                    .plus { return left + i64(right) }
                    .minus { return left - i64(right) }
                    .mul { return left * i64(right) }
                    .div { return left / i64(right) }
                    .mod { return left % i64(right) }
                    .xor { return left ^ i64(right) }
                    .pipe { return left | i64(right) }
                    .amp { return left & i64(right) }
                    .left_shift { return i64(u64(left) << i64(right)) }
                    .right_shift { return i64(u64(left) >> i64(right)) }
                    .unsigned_right_shift { return i64(u64(left) >>> i64(right)) }
                    else { return none }
                }
            } else if left is u32 && right is u32 {
                match expr.op {
                    .plus { return i64(left) + i64(right) }
                    .minus { return i64(left) - i64(right) }
                    .mul { return i64(left) * i64(right) }
                    .div { return i64(left) / i64(right) }
                    .mod { return i64(left) % i64(right) }
                    .xor { return i64(left) ^ i64(right) }
                    .pipe { return i64(left) | i64(right) }
                    .amp { return i64(left) & i64(right) }
                    .left_shift { return i64(u64(left) << right) }
                    .right_shift { return i64(u64(left) >> right) }
                    .unsigned_right_shift { return i64(u64(left) >>> right) }
                    else { return none }
                }
            } else if left is u64 && right is i64 {
                match expr.op {
                    .plus { return i64(left) + i64(right) }
                    .minus { return i64(left) - i64(right) }
                    .mul { return i64(left) * i64(right) }
                    .div { return i64(left) / i64(right) }
                    .mod { return i64(left) % i64(right) }
                    .xor { return i64(left) ^ i64(right) }
                    .pipe { return i64(left) | i64(right) }
                    .amp { return i64(left) & i64(right) }
                    .left_shift { return i64(u64(left) << i64(right)) }
                    .right_shift { return i64(u64(left) >> i64(right)) }
                    .unsigned_right_shift { return i64(u64(left) >>> i64(right)) }
                    else { return none }
                }
            } else if left is i64 && right is u64 {
                match expr.op {
                    .plus { return i64(left) + i64(right) }
                    .minus { return i64(left) - i64(right) }
                    .mul { return i64(left) * i64(right) }
                    .div { return i64(left) / i64(right) }
                    .mod { return i64(left) % i64(right) }
                    .xor { return i64(left) ^ i64(right) }
                    .pipe { return i64(left) | i64(right) }
                    .amp { return i64(left) & i64(right) }
                    .left_shift { return i64(u64(left) << i64(right)) }
                    .right_shift { return i64(u64(left) >> i64(right)) }
                    .unsigned_right_shift { return i64(u64(left) >>> i64(right)) }
                    else { return none }
                }
            } else if left is u64 && right is u64 {
                match expr.op {
                    .plus { return left + right }
                    .minus { return left - right }
                    .mul { return left * right }
                    .div { return left / right }
                    .mod { return left % right }
                    .xor { return left ^ right }
                    .pipe { return left | right }
                    .amp { return left & right }
                    .left_shift { return left << right }
                    .right_shift { return left >> right }
                    .unsigned_right_shift { return left >>> right }
                    else { return none }
                }
            } else if left is i64 && right is i64 {
                match expr.op {
                    .plus { return left + right }
                    .minus { return left - right }
                    .mul { return left * right }
                    .div { return left / right }
                    .mod { return left % right }
                    .xor { return left ^ right }
                    .pipe { return left | right }
                    .amp { return left & right }
                    .left_shift { return i64(u64(left) << right) }
                    .right_shift { return i64(u64(left) >> right) }
                    .unsigned_right_shift { return i64(u64(left) >>> right) }
                    else { return none }
                }
            } else if left is u8 && right is u8 {
                match expr.op {
                    .plus { return left + right }
                    .minus { return left - right }
                    .mul { return left * right }
                    .div { return left / right }
                    .mod { return left % right }
                    .xor { return left ^ right }
                    .pipe { return left | right }
                    .amp { return left & right }
                    .left_shift { return left << right }
                    .right_shift { return left >> right }
                    .unsigned_right_shift { return left >>> right }
                    else { return none }
                }
            }
        }
        ast.IfExpr {
            if !expr.is_comptime {
                return none
            }
            for i in 0 .. expr.branches.len {
                mut branch := expr.branches[i]
                if !expr.has_else || i < expr.branches.len - 1 {
                    mut sb := strings.new_builder(256)
                    is_true, _ := c.comptime_if_cond(mut branch.cond, mut sb)
                    if is_true {
                        last_stmt := branch.stmts.last()
                        if last_stmt is ast.ExprStmt {
                            return c.eval_comptime_const_expr_with_locals(last_stmt.expr,
                                nlevel + 1, local_values)
                        }
                    }
                } else {
                    last_stmt := branch.stmts.last()
                    if last_stmt is ast.ExprStmt {
                        return c.eval_comptime_const_expr_with_locals(last_stmt.expr, nlevel + 1,
                            local_values)
                    }
                }
            }
        }
        // ast.ArrayInit {}
        // ast.PrefixExpr {
        //    c.note('prefixexpr: ${expr}', expr.pos)
        // }
        else {
            // eprintln('>>> nlevel: ${nlevel} | another ${expr.type_name()} | ${expr} ')
            return none
        }
    }

    return none
}

fn (mut c Checker) verify_veb_params_for_method(node &ast.Fn) (bool, int, int) {
    margs := node.params.len - 1 // first arg is the receiver/this
    // if node.attrs.len == 0 || (node.attrs.len == 1 && node.attrs[0].name == 'post') {
    if node.attrs.len == 0 {
        // allow non custom routed methods, with 1:1 mapping
        return true, -1, margs
    }
    mut context_params := 0
    if node.params.len > 1 {
        for param in node.params[1..] {
            if c.has_veb_context(param.typ) {
                context_params++
                continue
            }
            param_sym := c.table.final_sym(param.typ)
            if !(param_sym.is_string() || param_sym.is_number() || param_sym.is_float()
                || param_sym.kind == .bool) {
                c.error('invalid type `${param_sym.name}` for parameter `${param.name}` in veb app method `${node.name}` (only strings, numbers, and bools are allowed)',
                    param.pos)
            }
        }
    }
    mut route_attributes := 0
    for a in node.attrs {
        if a.name.starts_with('/') {
            route_attributes += a.name.count(':')
        }
    }
    return route_attributes == margs - context_params, route_attributes, margs - context_params
}

fn (mut c Checker) verify_all_veb_routes() {
    if c.veb_gen_types.len == 0 {
        return
    }
    c.table.used_features.used_veb_types = c.veb_gen_types
    typ_veb_result := c.table.find_type('veb.Result')
    old_file := c.file
    for vgt in c.veb_gen_types {
        sym_app := c.table.sym(vgt)
        for m in sym_app.methods {
            if m.return_type == typ_veb_result {
                is_ok, nroute_attributes, nargs := c.verify_veb_params_for_method(m)
                if !is_ok {
                    f := unsafe { &ast.FnDecl(m.source_fn) }
                    if f == unsafe { nil } {
                        continue
                    }
                    if f.return_type == typ_veb_result && f.receiver.typ == m.params[0].typ
                        && f.name == m.name && !f.attrs.contains('post') {
                        c.change_current_file(f.source_file) // setup of file path for the warning
                        c.warn('mismatched parameters count between veb method `${sym_app.name}.${m.name}` (${nargs}) and route attribute ${m.attrs} (${nroute_attributes})',
                            f.pos)
                    }
                }
            }
        }
    }
    c.change_current_file(old_file)
}

fn (mut c Checker) evaluate_once_comptime_if_attribute(mut node ast.Attr) bool {
    if node.ct_evaled {
        return node.ct_skip
    }
    if mut node.ct_expr is ast.Ident {
        if node.ct_opt {
            if node.ct_expr.name in ast.valid_comptime_not_user_defined {
                c.error('option `@[if expression ?]` tags, can be used only for user defined identifiers',
                    node.pos)
                node.ct_skip = true
            } else {
                node.ct_skip = node.ct_expr.name !in c.pref.compile_defines
            }
            node.ct_evaled = true
            return node.ct_skip
        } else {
            if node.ct_expr.name !in ast.valid_comptime_not_user_defined {
                c.note('`@[if ${node.ct_expr.name}]` is deprecated. Use `@[if ${node.ct_expr.name} ?]` instead',
                    node.pos)
                node.ct_skip = node.ct_expr.name !in c.pref.compile_defines
                node.ct_evaled = true
                return node.ct_skip
            } else {
                if node.ct_expr.name in c.pref.compile_defines {
                    // explicitly allow custom user overrides with `-d linux` for example, for easier testing:
                    node.ct_skip = false
                    node.ct_evaled = true
                    return node.ct_skip
                }
            }
        }
    }
    c.inside_ct_attr = true
    mut sb := strings.new_builder(256)
    is_true, _ := c.comptime_if_cond(mut node.ct_expr, mut sb)
    node.ct_skip = !is_true
    c.inside_ct_attr = false
    node.ct_evaled = true
    return node.ct_skip
}

// check if `ident` is a function generic, such as `T`
fn (mut c Checker) is_generic_ident(ident string) bool {
    if c.table.cur_fn != unsafe { nil } && ident in c.table.cur_fn.generic_names
        && c.table.cur_fn.generic_names.len == c.table.cur_concrete_types.len {
        return true
    }
    return false
}

fn (mut c Checker) get_expr_type(cond ast.Expr) ast.Type {
    match cond {
        ast.Ident {
            mut checked_type := ast.void_type
            if c.comptime.inside_comptime_for && (cond.name == c.comptime.comptime_for_variant_var
                || cond.name == c.comptime.comptime_for_method_param_var
                || cond.name == c.comptime.comptime_for_field_var) {
                // struct field
                return c.type_resolver.get_type_from_comptime_var(cond)
            } else if c.is_generic_ident(cond.name) {
                // generic type `T`
                if c.table.cur_fn != unsafe { nil } {
                    idx := c.table.cur_fn.generic_names.index(cond.name)
                    if idx >= 0 && idx < c.table.cur_concrete_types.len {
                        concrete_type := c.table.cur_concrete_types[idx]
                        if concrete_type != 0 {
                            return concrete_type
                        }
                    }
                }
                type_idx := c.table.find_type_idx(cond.name)
                return if type_idx == 0 {
                    ast.void_type
                } else {
                    ast.new_type(type_idx).set_flag(.generic)
                }
            } else if cond.name in c.type_resolver.type_map {
                return c.type_resolver.get_ct_type_or_default(cond.name, ast.void_type)
            } else if var := cond.scope.find_var(cond.name) {
                // var
                checked_type = c.unwrap_generic(var.typ)
                if var.smartcasts.len > 0 {
                    checked_type = c.unwrap_generic(c.visible_var_type_for_read(var))
                }
            }
            return checked_type
        }
        ast.TypeNode {
            return c.unwrap_generic(cond.typ)
        }
        ast.SelectorExpr {
            if c.comptime.inside_comptime_for
                && cond.field_name in ['typ', 'unaliased_typ', 'indirections', 'pointee_type', 'payload_type', 'variant_types']
                && cond.expr is ast.Ident && (cond.expr.name == c.comptime.comptime_for_variant_var
                || cond.expr.name == c.comptime.comptime_for_method_param_var
                || cond.expr.name == c.comptime.comptime_for_field_var) {
                typ := c.type_resolver.get_type_from_comptime_var(cond.expr as ast.Ident)
                if cond.field_name == 'unaliased_typ' {
                    return c.table.unaliased_type(typ)
                } else if cond.field_name in ['pointee_type', 'payload_type', 'variant_types'] {
                    return c.type_resolver.typeof_field_type(typ, cond.field_name)
                }
                // for `indirections` we also return the `typ`
                return typ
            }
            if cond.name_type != 0
                && cond.field_name in ['key_type', 'value_type', 'element_type', 'pointee_type', 'payload_type', 'variant_types'] {
                return c.type_resolver.typeof_field_type(cond.name_type, cond.field_name)
            }
            if cond.gkind_field in [.typ, .indirections, .unaliased_typ] {
                if cond.expr is ast.Ident {
                    generic_name := cond.expr.name
                    if c.table.cur_fn != unsafe { nil }
                        && generic_name in c.table.cur_fn.generic_names {
                        idx := c.table.cur_fn.generic_names.index(generic_name)
                        if idx >= 0 && idx < c.table.cur_concrete_types.len {
                            concrete_type := c.table.cur_concrete_types[idx]
                            if cond.gkind_field == .unaliased_typ {
                                return c.table.unaliased_type(concrete_type)
                            }
                            return concrete_type
                        }
                    }
                }
                unwrapped := c.unwrap_generic(cond.name_type)
                if cond.gkind_field == .unaliased_typ {
                    if unwrapped.idx() == 0 || unwrapped.has_flag(.generic) {
                        return unwrapped
                    }
                    return c.table.unaliased_type(unwrapped)
                }
                return unwrapped
            } else {
                if cond.expr is ast.TypeOf {
                    return c.type_resolver.typeof_field_type(c.type_resolver.typeof_type(cond.expr.expr,
                        cond.name_type), cond.field_name)
                }
                name := '${cond.expr}.${cond.field_name}'
                if name in c.type_resolver.type_map {
                    return c.type_resolver.get_ct_type_or_default(name, ast.void_type)
                } else {
                    return c.unwrap_generic(cond.typ)
                }
            }
        }
        ast.IntegerLiteral {
            return ast.int_type
        }
        ast.BoolLiteral {
            return ast.bool_type
        }
        ast.StringLiteral {
            return ast.string_type
        }
        ast.CharLiteral {
            return ast.char_type
        }
        ast.FloatLiteral {
            return ast.f64_type
        }
        else {
            return ast.void_type
        }
    }
}

fn (mut c Checker) check_compatible_types(left_type ast.Type, left_name string, expr ast.Expr) bool {
    mut resolved_left_type := c.unwrap_generic(left_type)
    if expr is ast.ComptimeType {
        return c.type_resolver.is_comptime_type(resolved_left_type, expr as ast.ComptimeType)
    } else if expr is ast.TypeNode {
        typ := c.get_expr_type(expr)
        right_type := c.unwrap_generic(typ)
        mut right_sym := c.table.sym(right_type)
        if right_sym.kind == .generic_inst {
            gi := right_sym.info as ast.GenericInst
            if gi.parent_idx > 0 && gi.parent_idx < c.table.type_symbols.len
                && c.table.type_symbols[gi.parent_idx].kind == .interface
                && !gi.concrete_types.any(c.type_has_unresolved_generic_parts(it)) {
                c.table.generic_insts_to_concrete()
                right_sym = c.table.sym(right_type)
            }
        }
        if c.type_resolver.bind_matching_generic_type(resolved_left_type, right_type) {
            return true
        }
        if right_sym.kind == .placeholder || right_type.has_flag(.generic) {
            c.error('unknown type `${right_sym.name}`', expr.pos)
        }
        if right_sym.kind == .interface && right_sym.info is ast.Interface {
            return resolved_left_type.has_flag(.option) == right_type.has_flag(.option)
                && c.table.does_type_implement_interface(resolved_left_type, right_type)
        }
        if right_sym.info is ast.FnType && c.comptime.comptime_for_method_var != ''
            && c.comptime.comptime_for_method != unsafe { nil }
            && c.comptime.comptime_for_method_var == left_name {
            right_fn_type := right_sym.info as ast.FnType
            return c.table.fn_signature(right_fn_type.func,
                skip_receiver: true
                type_only:     true
            ) == c.table.fn_signature(c.comptime.comptime_for_method,
                skip_receiver: true
                type_only:     true
            )
        }
        left_unaliased_type := c.table.fully_unaliased_type(resolved_left_type)
        right_unaliased_type := c.table.fully_unaliased_type(right_type)
        left_unaliased_sym := c.table.sym(left_unaliased_type)
        right_unaliased_sym := c.table.sym(right_unaliased_type)
        if left_unaliased_sym.info is ast.FnType && right_unaliased_sym.info is ast.FnType {
            same_flags := left_unaliased_type.nr_muls() == right_unaliased_type.nr_muls()
                && left_unaliased_type.has_flag(.option) == right_unaliased_type.has_flag(.option)
                && left_unaliased_type.has_flag(.result) == right_unaliased_type.has_flag(.result)
                && left_unaliased_type.has_flag(.shared_f) == right_unaliased_type.has_flag(.shared_f)
                && left_unaliased_type.has_flag(.atomic_f) == right_unaliased_type.has_flag(.atomic_f)
            return same_flags && c.table.fn_signature(left_unaliased_sym.info.func,
                skip_receiver: true
                type_only:     true
            ) == c.table.fn_signature(right_unaliased_sym.info.func,
                skip_receiver: true
                type_only:     true
            )
        } else {
            return resolved_left_type == right_type
        }
    }
    return false
}

// comptime_if_cond evaluate the `cond` and return (`is_true`, `keep_stmts`)
// `is_true` is the evaluate result of `cond`;
// `keep_stmts` meaning the branch is a `multi pass branch`, we should keep the branch stmts even `is_true` is false, such as `$if T is int {`
fn (mut c Checker) comptime_if_cond(mut cond ast.Expr, mut sb strings.Builder) (bool, bool) {
    mut should_record_ident := false
    mut is_user_ident := false
    mut ident_name := ''
    defer {
        if should_record_ident {
            // record current cond result for debugging
            if is_user_ident {
                c.ct_user_defines[ident_name] = $res(0)
            } else {
                c.ct_system_defines[ident_name] = $res(0)
            }
        }
    }
    mut is_true := false

    match mut cond {
        ast.BoolLiteral {
            c.expr(mut cond)
            is_true = cond.val
            sb.write_string('${is_true}')
            return is_true, false
        }
        ast.ParExpr {
            sb.write_string('(')
            is_true_result, multi_pass_stmts := c.comptime_if_cond(mut cond.expr, mut sb)
            sb.write_string(')')
            return is_true_result, multi_pass_stmts
        }
        ast.PrefixExpr {
            if cond.op != .not {
                c.error('invalid \$if prefix operator, only allow `!`.', cond.pos)
                return false, false
            }
            sb.write_string(cond.op.str())
            is_true_result, multi_pass_stmts := c.comptime_if_cond(mut cond.right, mut sb)
            return !is_true_result, multi_pass_stmts
        }
        ast.PostfixExpr {
            if cond.op != .question {
                c.error('invalid \$if postfix operator, only allow `?`.', cond.pos)
                return false, false
            }
            if cond.expr !is ast.Ident {
                c.error('invalid \$if postfix condition, only allow `Indent`.', cond.expr.pos())
                return false, false
            }
            cname := (cond.expr as ast.Ident).name
            // record current cond result for debugging
            should_record_ident = true
            is_user_ident = true
            ident_name = cname
            sb.write_string('defined(CUSTOM_DEFINE_${cname})')
            is_true = cname in c.pref.compile_defines
            return is_true, false
        }
        ast.InfixExpr {
            match cond.op {
                .and, .logical_or {
                    l, d1 := c.comptime_if_cond(mut cond.left, mut sb)
                    sb.write_string(' ${cond.op} ')
                    r, d2 := c.comptime_if_cond(mut cond.right, mut sb)
                    // if at least one of the cond has `keep_stmts`, we should keep stmts
                    return if cond.op == .and { l && r } else { l || r }, d1 || d2
                }
                .key_is, .not_is, .key_in, .not_in {
                    // $if T is Type
                    // $if T in [Type1, Type2]
                    if cond.left in [ast.TypeNode, ast.Ident, ast.SelectorExpr]
                        && ((cond.right in [ast.ComptimeType, ast.TypeNode]
                        && cond.op in [.key_is, .not_is])
                        || (cond.right is ast.ArrayInit && cond.op in [.key_in, .not_in])) {
                        c.expr(mut cond.left)

                        // resolve left type
                        mut left_name := ''
                        if mut cond.left is ast.Ident {
                            left_name = cond.left.name
                        } else if mut cond.left is ast.SelectorExpr {
                            left_name = '${cond.left.expr}'.all_before('.')
                        }
                        left_type := c.get_expr_type(cond.left)
                        type_array := if cond.op in [.key_is, .not_is] {
                            // construct a type array for a single `is`, `!is`
                            [cond.right]
                        } else {
                            (cond.right as ast.ArrayInit).exprs
                        }
                        // iter the `type_array`, for `is` and `!is`, it has only one element
                        for expr in type_array {
                            is_true = c.check_compatible_types(left_type, left_name, expr)
                            if is_true {
                                break
                            }
                        }
                        is_true = if cond.op in [.key_in, .key_is] { is_true } else { !is_true }
                        sb.write_string('${is_true}')
                        return is_true, true
                    }

                    if cond.left !in [ast.TypeNode, ast.Ident, ast.SelectorExpr] {
                        c.error('invalid \$if left expr: expected a Type/Ident/SelectorExpr',
                            cond.left.pos())
                        return false, false
                    }
                    if cond.right !in [ast.ComptimeType, ast.TypeNode] {
                        c.error('invalid \$if right expr: expected a type', cond.right.pos())
                        return false, false
                    }
                    c.error('invalid \$if condition: is/!is/in/!in', cond.pos)
                    return false, false
                }
                .eq, .ne, .gt, .lt, .ge, .le {
                    match mut cond.left {
                        ast.AtExpr {
                            // @OS == 'linux'
                            left_type := c.expr(mut cond.left)
                            right_type := c.expr(mut cond.right)
                            if !c.check_types(right_type, left_type) {
                                left_name := c.table.type_to_str(left_type)
                                right_name := c.table.type_to_str(right_type)
                                c.error('mismatched types `${left_name}` and `${right_name}`',
                                    cond.pos)
                            }
                            left_str := cond.left.val
                            right_str := (cond.right as ast.StringLiteral).val
                            if cond.op == .eq {
                                is_true = left_str == right_str
                            } else if cond.op == .ne {
                                is_true = left_str != right_str
                            } else {
                                c.error('string type only support `==` and `!=` operator', cond.pos)
                                return false, false
                            }
                            sb.write_string('${is_true}')
                            return is_true, false
                        }
                        ast.Ident {
                            // $if version == 2
                            left_type := c.expr(mut cond.left)
                            right_type := c.expr(mut cond.right)
                            expr := c.find_definition(cond.left) or {
                                c.error(err.msg(), cond.left.pos)
                                return false, false
                            }
                            if !c.check_types(right_type, left_type) {
                                left_name := c.table.type_to_str(left_type)
                                right_name := c.table.type_to_str(right_type)
                                c.error('mismatched types `${left_name}` and `${right_name}`',
                                    cond.pos)
                            }
                            match mut cond.right {
                                ast.StringLiteral {
                                    match cond.op {
                                        .eq {
                                            is_true = expr.str() == cond.right.str()
                                        }
                                        .ne {
                                            is_true = expr.str() != cond.right.str()
                                        }
                                        else {
                                            c.error('string type only support `==` and `!=` operator',
                                                cond.pos)
                                            return false, false
                                        }
                                    }
                                }
                                ast.IntegerLiteral {
                                    match cond.op {
                                        .eq {
                                            is_true = expr.str().i64() == cond.right.val.i64()
                                        }
                                        .ne {
                                            is_true = expr.str().i64() != cond.right.val.i64()
                                        }
                                        .gt {
                                            is_true = expr.str().i64() > cond.right.val.i64()
                                        }
                                        .lt {
                                            is_true = expr.str().i64() < cond.right.val.i64()
                                        }
                                        .ge {
                                            is_true = expr.str().i64() >= cond.right.val.i64()
                                        }
                                        .le {
                                            is_true = expr.str().i64() <= cond.right.val.i64()
                                        }
                                        else {
                                            c.error('int type only support `==` `!=` `>` `<` `>=` and `<=` operator',
                                                cond.pos)
                                            return false, false
                                        }
                                    }
                                }
                                ast.BoolLiteral {
                                    match cond.op {
                                        .eq {
                                            is_true = expr.str().bool() == cond.right.val
                                        }
                                        .ne {
                                            is_true = expr.str().bool() != cond.right.val
                                        }
                                        else {
                                            c.error('bool type only support `==` and `!=` operator',
                                                cond.pos)
                                            return false, false
                                        }
                                    }
                                }
                                else {
                                    c.error('compare only support string int and bool type',
                                        cond.pos)
                                    return false, false
                                }
                            }

                            sb.write_string('${is_true}')
                            return is_true, false
                        }
                        ast.SelectorExpr {
                            // $if field.name == 'abc'
                            c.expr(mut cond.left)
                            match mut cond.right {
                                ast.StringLiteral {
                                    if cond.left.field_name == 'name'
                                        && c.comptime.inside_comptime_for {
                                        left_name := (cond.left.expr as ast.Ident).name
                                        match left_name {
                                            c.comptime.comptime_for_method_var {
                                                is_true = c.comptime.comptime_for_method.name == cond.right.val
                                            }
                                            c.comptime.comptime_for_field_var {
                                                is_true = c.comptime.comptime_for_field_value.name == cond.right.val
                                            }
                                            c.comptime.comptime_for_attr_var {
                                                is_true = c.comptime.comptime_for_attr_value.name == cond.right.val
                                            }
                                            else {
                                                c.error('.name compare only support for \$for vars',
                                                    cond.pos)
                                                return false, false
                                            }
                                        }

                                        match cond.op {
                                            .eq {
                                                sb.write_string('${is_true}')
                                                return is_true, true
                                            }
                                            .ne {
                                                sb.write_string('${!is_true}')
                                                return !is_true, true
                                            }
                                            else {
                                                c.error('.name compare only support for `==` and `!=`',
                                                    cond.pos)
                                                return false, false
                                            }
                                        }
                                    } else {
                                        if comparison := c.try_eval_comptime_comparison(mut cond.left, mut
                                            cond.right, cond.op)
                                        {
                                            sb.write_string(if comparison.val { '1' } else { '0' })
                                            return comparison.val, comparison.keep_stmts
                                        }
                                        c.error('only support .name compare for \$for vars',
                                            cond.pos)
                                        return false, false
                                    }
                                }
                                ast.IntegerLiteral {
                                    if cond.left.field_name == 'indirections' {
                                        // field.indirections, T.indirections
                                        left_type := c.get_expr_type(ast.Expr(cond.left))
                                        left_muls := left_type.nr_muls()
                                        match cond.op {
                                            .eq {
                                                is_true = left_muls == cond.right.val.i64()
                                            }
                                            .ne {
                                                is_true = left_muls != cond.right.val.i64()
                                            }
                                            .gt {
                                                is_true = left_muls > cond.right.val.i64()
                                            }
                                            .lt {
                                                is_true = left_muls < cond.right.val.i64()
                                            }
                                            .ge {
                                                is_true = left_muls >= cond.right.val.i64()
                                            }
                                            .le {
                                                is_true = left_muls <= cond.right.val.i64()
                                            }
                                            else {
                                                c.error('.indirections only support `==` `!=` `>` `<` `>=` and `<=` operator',
                                                    cond.pos)
                                                return false, false
                                            }
                                        }

                                        sb.write_string('${is_true}')
                                        return is_true, true
                                    } else if cond.left.field_name == 'return_type' {
                                        // method.return_type
                                        left_name := (cond.left.expr as ast.Ident).name
                                        if c.comptime.inside_comptime_for
                                            && left_name == c.comptime.comptime_for_method_var {
                                            left_type_idx :=
                                                c.comptime.comptime_for_method_ret_type.idx()
                                            match cond.op {
                                                .eq {
                                                    is_true = left_type_idx == cond.right.val.i64()
                                                }
                                                .gt {
                                                    is_true = left_type_idx > cond.right.val.i64()
                                                }
                                                .lt {
                                                    is_true = left_type_idx < cond.right.val.i64()
                                                }
                                                .ge {
                                                    is_true = left_type_idx >= cond.right.val.i64()
                                                }
                                                .le {
                                                    is_true = left_type_idx <= cond.right.val.i64()
                                                }
                                                else {
                                                    c.error('.return_type only support `==` `!=` `>` `<` `>=` and `<=` operator',
                                                        cond.pos)
                                                    return false, false
                                                }
                                            }

                                            sb.write_string('${is_true}')
                                            return is_true, false
                                        } else {
                                            c.error('only support .return_type compare for \$for method',
                                                cond.pos)
                                            return false, false
                                        }
                                    } else {
                                        if comparison := c.try_eval_comptime_comparison(mut cond.left, mut
                                            cond.right, cond.op)
                                        {
                                            sb.write_string(if comparison.val { '1' } else { '0' })
                                            return comparison.val, comparison.keep_stmts
                                        }
                                        c.error('only support .indirections/.return_type compare for \$for vars and generic',
                                            cond.pos)
                                        return false, false
                                    }
                                }
                                ast.BoolLiteral {
                                    // field.is_pub == true
                                    mut left := ast.Expr(cond.left)
                                    l, _ := c.comptime_if_cond(mut left, mut sb)
                                    sb.write_string(' ${cond.op} ')
                                    r := (cond.right as ast.BoolLiteral).val
                                    sb.write_string('${r}')
                                    is_true = if cond.op == .eq { l == r } else { l != r }
                                    return is_true, true
                                }
                                else {
                                    if comparison := c.try_eval_comptime_comparison(mut cond.left, mut
                                        cond.right, cond.op)
                                    {
                                        sb.write_string(if comparison.val { '1' } else { '0' })
                                        return comparison.val, comparison.keep_stmts
                                    }
                                    c.error('definition of `${cond.left}` is unknown at compile time',
                                        cond.pos)
                                    return false, false
                                }
                            }

                            if comparison := c.try_eval_comptime_comparison(mut cond.left, mut
                                cond.right, cond.op)
                            {
                                sb.write_string(if comparison.val { '1' } else { '0' })
                                return comparison.val, comparison.keep_stmts
                            }
                            c.error('invalid \$if condition: SelectorExpr', cond.pos)
                            return false, false
                        }
                        ast.SizeOf {
                            match mut cond.right {
                                ast.IntegerLiteral {
                                    s, _ := c.table.type_size(c.unwrap_generic(cond.left.typ))
                                    match cond.op {
                                        .eq {
                                            is_true = s == cond.right.val.i64()
                                        }
                                        .ne {
                                            is_true = s != cond.right.val.i64()
                                        }
                                        .gt {
                                            is_true = s > cond.right.val.i64()
                                        }
                                        .lt {
                                            is_true = s < cond.right.val.i64()
                                        }
                                        .ge {
                                            is_true = s >= cond.right.val.i64()
                                        }
                                        .le {
                                            is_true = s <= cond.right.val.i64()
                                        }
                                        else {
                                            c.error('sizeof() only support `==` `!=` `>` `<` `>=` and `<=` operator',
                                                cond.pos)
                                            return false, false
                                        }
                                    }

                                    sb.write_string('${is_true}')
                                    return is_true, true
                                }
                                else {
                                    c.error('sizeof() can only compare with int type', cond.pos)
                                    return false, false
                                }
                            }
                        }
                        else {
                            if comparison := c.try_eval_comptime_comparison(mut cond.left, mut
                                cond.right, cond.op)
                            {
                                sb.write_string(if comparison.val { '1' } else { '0' })
                                return comparison.val, comparison.keep_stmts
                            }
                            c.error('invalid \$if condition', cond.pos)
                            return false, false
                        }
                    }

                    c.error('invalid \$if condition', cond.pos)
                    return false, false
                }
                else {
                    c.error('invalid \$if operator: ${cond.op}', cond.pos)
                    return false, false
                }
            }
        }
        ast.Ident {
            cname := cond.name
            // record current cond result for debugging
            should_record_ident = true
            is_user_ident = false
            ident_name = cname
            if cname in ast.valid_comptime_not_user_defined {
                if cname == 'threads' {
                    is_true = c.table.gostmts > 0
                } else {
                    is_true = ast.eval_comptime_not_user_defined_ident(cname, c.pref) or {
                        c.error(err.msg(), cond.pos)
                        return false, false
                    }
                }
            } else if cname !in c.pref.compile_defines_all {
                if cname == 'linux_or_macos' {
                    c.error('linux_or_macos is deprecated, use `\$if linux || macos {` instead',
                        cond.pos)
                    return false, false
                }
                // `$if some_var {}`, or `[if user_defined_tag] fn abc(){}`
                mut ident_expr := ast.Expr(cond)
                typ := c.unwrap_generic(c.expr(mut ident_expr))
                resolved_obj := if mut ident_expr is ast.Ident {
                    ident_expr.obj
                } else {
                    cond.obj
                }
                if resolved_obj !in [ast.Var, ast.ConstField, ast.GlobalField] {
                    if !c.inside_ct_attr {
                        c.error('unknown var: `${cname}`', cond.pos)
                        return false, false
                    }
                    c.error('invalid \$if condition: unknown indent `${cname}`', cond.pos)
                    return false, false
                }
                expr := c.find_obj_definition(resolved_obj) or {
                    c.error(err.msg(), cond.pos)
                    return false, false
                }
                if !c.check_types(typ, ast.bool_type) {
                    type_name := c.table.type_to_str(typ)
                    c.error('non-bool type `${type_name}` used as \$if condition', cond.pos)
                    return false, false
                }
                is_true = (expr as ast.BoolLiteral).val
            } else if cname in c.pref.compile_defines {
                is_true = true
            } else {
                c.error('invalid \$if condition: unknown indent `${cname}`', cond.pos)
                return false, false
            }
            if ifdef := ast.comptime_if_to_ifdef(cname, c.pref) {
                sb.write_string('defined(${ifdef})')
            } else {
                sb.write_string('${is_true}')
            }
            return is_true, false
        }
        ast.ComptimeCall {
            if cond.kind == .pkgconfig {
                if mut m := pkgconfig.main([cond.args_var]) {
                    if _ := m.run() {
                        is_true = true
                    } else {
                        // pkgconfig not found, do not issue error, just set false
                        is_true = false
                    }
                } else {
                    c.error(err.msg(), cond.pos)
                    is_true = false
                }
                sb.write_string('${is_true}')
                return is_true, true
            }
            if cond.kind == .d {
                cond.resolve_compile_value(c.pref.compile_values) or {
                    c.error(err.msg(), cond.pos)
                    return false, false
                }
                if cond.result_type != ast.bool_type {
                    c.error('inside \$if, only \$d() expressions that return bool are allowed',
                        cond.pos)
                    return false, false
                }
                is_true = cond.compile_value.bool()
                sb.write_string('${is_true}')
                return is_true, false
            }
            c.error('invalid \$if condition: unknown ComptimeCall', cond.pos)
            return false, false
        }
        ast.SelectorExpr {
            if c.comptime.comptime_for_field_var != '' && cond.expr is ast.Ident {
                if (cond.expr as ast.Ident).name == c.comptime.comptime_for_field_var && cond.field_name in ['is_mut', 'is_pub', 'is_embed', 'is_shared', 'is_atomic', 'is_option', 'is_array', 'is_map', 'is_chan', 'is_struct', 'is_alias', 'is_enum'] {
                    is_true = c.type_resolver.get_comptime_selector_bool_field(cond.field_name)
                    sb.write_string('${is_true}')
                    return is_true, true
                }
                c.error('unknown field `${cond.field_name}` from ${c.comptime.comptime_for_field_var}',
                    cond.pos)
            }
            if c.comptime.comptime_for_attr_var != '' && cond.expr is ast.Ident {
                if (cond.expr as ast.Ident).name == c.comptime.comptime_for_attr_var && cond.field_name == 'has_arg' {
                    is_true = c.comptime.comptime_for_attr_value.has_arg
                    sb.write_string('${is_true}')
                    return is_true, true
                }
                c.error('unknown field `${cond.field_name}` from ${c.comptime.comptime_for_attr_var}',
                    cond.pos)
            }
            if c.comptime.comptime_for_method_var != '' && cond.expr is ast.Ident {
                if (cond.expr as ast.Ident).name == c.comptime.comptime_for_method_var && cond.field_name in ['is_variadic', 'is_c_variadic', 'is_pub', 'is_ctor_new', 'is_deprecated', 'is_noreturn', 'is_unsafe', 'is_must_use', 'is_placeholder', 'is_main', 'is_test', 'is_keep_alive', 'is_method', 'is_static_type_method', 'no_body', 'is_file_translated', 'is_conditional', 'is_expand_simple_interpolation'] {
                    method := c.comptime.comptime_for_method
                    is_true = match cond.field_name {
                        'is_variadic' { method.is_variadic }
                        'is_c_variadic' { method.is_c_variadic }
                        'is_pub' { method.is_pub }
                        'is_ctor_new' { method.is_ctor_new }
                        'is_deprecated' { method.is_deprecated }
                        'is_noreturn' { method.is_noreturn }
                        'is_unsafe' { method.is_unsafe }
                        'is_must_use' { method.is_must_use }
                        'is_placeholder' { method.is_placeholder }
                        'is_main' { method.is_main }
                        'is_test' { method.is_test }
                        'is_keep_alive' { method.is_keep_alive }
                        'is_method' { method.is_method }
                        'is_static_type_method' { method.is_static_type_method }
                        'no_body' { method.no_body }
                        'is_file_translated' { method.is_file_translated }
                        'is_conditional' { method.is_conditional }
                        'is_expand_simple_interpolation' { method.is_expand_simple_interpolation }
                        else { false }
                    }

                    sb.write_string('${is_true}')
                    return is_true, true
                }
                c.error('unknown field `${cond.field_name}` from ${c.comptime.comptime_for_method_var}',
                    cond.pos)
            }
            return false, false
        }
        else {
            c.error('invalid \$if condition ${cond}', cond.pos())
            return false, false
        }
    }

    c.error('invalid \$if condition ${cond}', cond.pos())
    return false, false
}

// push_new_comptime_info saves the current comptime information
fn (mut c Checker) push_new_comptime_info() {
    c.type_resolver.info_stack << type_resolver.ResolverInfo{
        saved_type_map:               c.type_resolver.type_map.clone()
        inside_comptime_for:          c.comptime.inside_comptime_for
        inside_comptime_if:           c.comptime.inside_comptime_if
        has_different_types:          c.comptime.has_different_types
        comptime_for_variant_var:     c.comptime.comptime_for_variant_var
        comptime_for_field_var:       c.comptime.comptime_for_field_var
        comptime_for_field_type:      c.comptime.comptime_for_field_type
        comptime_for_field_value:     c.comptime.comptime_for_field_value
        comptime_for_enum_var:        c.comptime.comptime_for_enum_var
        comptime_for_attr_var:        c.comptime.comptime_for_attr_var
        comptime_for_attr_value:      c.comptime.comptime_for_attr_value
        comptime_for_method_var:      c.comptime.comptime_for_method_var
        comptime_for_method:          c.comptime.comptime_for_method
        comptime_for_method_ret_type: c.comptime.comptime_for_method_ret_type
    }
}

// pop_comptime_info pops the current comptime information frame
fn (mut c Checker) pop_comptime_info() {
    old := c.type_resolver.info_stack.pop()
    c.type_resolver.type_map = old.saved_type_map.clone()
    c.comptime.inside_comptime_for = old.inside_comptime_for
    c.comptime.inside_comptime_if = old.inside_comptime_if
    c.comptime.has_different_types = old.has_different_types
    c.comptime.comptime_for_variant_var = old.comptime_for_variant_var
    c.comptime.comptime_for_field_var = old.comptime_for_field_var
    c.comptime.comptime_for_field_type = old.comptime_for_field_type
    c.comptime.comptime_for_field_value = old.comptime_for_field_value
    c.comptime.comptime_for_enum_var = old.comptime_for_enum_var
    c.comptime.comptime_for_attr_var = old.comptime_for_attr_var
    c.comptime.comptime_for_attr_value = old.comptime_for_attr_value
    c.comptime.comptime_for_method_var = old.comptime_for_method_var
    c.comptime.comptime_for_method = old.comptime_for_method
    c.comptime.comptime_for_method_ret_type = old.comptime_for_method_ret_type
}

fn overflows_i8(val i64) bool {
    return val > max_i8 || val < min_i8
}

fn overflows_i16(val i64) bool {
    return val > max_i16 || val < min_i16
}

fn overflows_i32(val i64) bool {
    return val > max_i32 || val < min_i32
}

fn overflows_u8(val i64) bool {
    return val > max_u8 || val < min_u8
}

fn overflows_u16(val i64) bool {
    return val > max_u16 || val < min_u16
}

fn overflows_u32(val i64) bool {
    return val > max_u32 || val < min_u32
}