// 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 os
import strconv
import v.ast
import v.vmod
import v.token
import v.pref
import v.util
import v.util.version
import v.errors
import v.pkgconfig
import v.transformer
import v.type_resolver

// prevent stack overflows by restricting too deep recursion:
const expr_level_cutoff_limit = 40
const stmt_level_cutoff_limit = 40
const type_level_cutoff_limit = 40 // it is very rarely deeper than 4
const iface_level_cutoff_limit = 100
const generic_fn_cutoff_limit_per_fn = 10_000 // how many times post_process_generic_fns, can visit the same function before bailing out

const generic_fn_postprocess_iterations_cutoff_limit = 1_000_000

fn has_ascii_upper(s string) bool {
    for ch in s {
        if ch >= `A` && ch <= `Z` {
            return true
        }
    }
    return false
}

// array_builtin_methods contains a list of all methods on array, that return other typed arrays.
// i.e. that act as *pseudogeneric* methods, that need compiler support, so that the types of the results
// are properly checked.
// Note that methods that do not return anything, or that return known types, are not listed here, since they are just ordinary non generic methods.
pub const array_builtin_methods = ['filter', 'clone', 'repeat', 'reverse', 'map', 'slice', 'sort',
    'sort_with_compare', 'sorted', 'sorted_with_compare', 'contains', 'index', 'last_index', 'wait',
    'any', 'all', 'first', 'last', 'get', 'pop_left', 'pop', 'delete', 'insert', 'prepend', 'count']
pub const array_builtin_methods_chk = token.new_keywords_matcher_from_array_trie(array_builtin_methods)
pub const fixed_array_builtin_methods = ['contains', 'index', 'last_index', 'any', 'all', 'wait',
    'map', 'sort', 'sorted', 'sort_with_compare', 'sorted_with_compare', 'reverse',
    'reverse_in_place', 'count', 'filter']
pub const fixed_array_builtin_methods_chk = token.new_keywords_matcher_from_array_trie(fixed_array_builtin_methods)
// TODO: remove `byte` from this list when it is no longer supported
pub const reserved_type_names = ['bool', 'char', 'i8', 'i16', 'i32', 'int', 'i64', 'u8', 'u16',
    'u32', 'u64', 'f32', 'f64', 'map', 'string', 'rune', 'usize', 'isize', 'voidptr', 'thread']
pub const reserved_type_names_chk = token.new_keywords_matcher_from_array_trie(reserved_type_names)
pub const vroot_is_deprecated_message = '@VROOT is deprecated, use @VMODROOT or @VEXEROOT instead'

struct AssertAutocast {
    from_type ast.Type
    to_type   ast.Type
}

@[heap; minify]
pub struct Checker {
pub mut:
    pref &pref.Preferences = unsafe { nil } // Preferences shared from V struct

    table &ast.Table = unsafe { nil }
    file  &ast.File  = unsafe { nil }

    nr_errors     int
    nr_warnings   int
    nr_notices    int
    errors        []errors.Error
    warnings      []errors.Warning
    notices       []errors.Notice
    error_lines   map[string]bool // dedup errors
    warning_lines map[string]bool // dedup warns
    notice_lines  map[string]bool // dedup notices
    error_details []string
    should_abort  bool // when too many errors are accumulated, .should_abort becomes true. It is checked in statement/expression loops, so the checker can return early, instead of wasting time.

    expected_type               ast.Type
    expected_or_type            ast.Type // fn() or { 'this type' } eg. string. expected or block type
    expected_expr_type          ast.Type // if/match is_expr: expected_type
    mod                         string   // current module name
    has_globals_in_module       bool     // true if the current module has @[has_globals] attribute
    strict_map_index_in_module  bool     // true if the current module has @[strict_map_index] attribute
    const_var                   &ast.ConstField = unsafe { nil } // the current constant, when checking const declarations
    const_deps                  []string
    const_eval_stack            []string // names of constants currently being recursively resolved (to break cycles via anon fn bodies)
    const_names                 []string
    global_names                []string
    locked_names                []string // vars that are currently locked
    rlocked_names               []string // vars that are currently read-locked
    in_for_count                int      // if checker is currently in a for loop
    returns                     bool
    scope_returns               bool
    is_builtin_mod              bool        // true inside the 'builtin', 'os' or 'strconv' modules; TODO: remove the need for special casing this
    is_just_builtin_mod         bool        // true only inside 'builtin'
    is_generated                bool        // true for `@[generated] module xyz` .v files
    unresolved_fixed_sizes      []&ast.Stmt // funcs with unresolved array fixed size e.g. fn func() [const1]int
    inside_recheck              bool        // true when rechecking rhs assign statement
    inside_unsafe               bool        // true inside `unsafe {}` blocks
    inside_const                bool        // true inside `const ( ... )` blocks
    inside_anon_fn              bool        // true inside `fn() { ... }()`
    inside_lambda               bool        // true inside `|...| ...`
    inside_ref_lit              bool        // true inside `a := &something`
    inside_defer                bool        // true inside `defer {}` blocks
    inside_return               bool        // true inside `return ...` blocks
    inside_fn_arg               bool        // `a`, `b` in `a.f(b)`
    inside_ct_attr              bool        // true inside `[if expr]`
    inside_x_is_type            bool        // true inside the Type expression of `if x is Type {`
    inside_x_matches_type       bool        // true inside the match branch of `match x.type { Type {} }`
    anon_struct_should_be_mut   bool        // true when `mut var := struct { ... }` is used
    inside_generic_struct_init  bool
    inside_integer_literal_cast bool // true inside `int(123)`
    cur_struct_generic_types    []ast.Type
    cur_struct_concrete_types   []ast.Type
    anon_fn_generic_names       []string
    anon_fn_concrete_types      []ast.Type
    skip_flags                  bool      // should `#flag` and `#include` be skipped
    fn_level                    int       // 0 for the top level, 1 for `fn abc() {}`, 2 for a nested fn, etc
    smartcast_mut_pos           token.Pos // match mut foo, if mut foo is Foo
    smartcast_cond_pos          token.Pos // match cond
    ct_cond_stack               []ast.Expr
    ct_user_defines             map[string]bool
    ct_system_defines           map[string]bool
    cur_ct_id                   int // id counter for $if $match branches
mut:
    stmt_level int // the nesting level inside each stmts list;
    // .stmt_level is used to check for `evaluated but not used` ExprStmts like `1 << 1`
    // 1 for statements directly at each inner scope level;
    // increases for `x := if cond { statement_list1} else {statement_list2}`;
    // increases for `x := optfn() or { statement_list3 }`;
    // files                            []ast.File
    expr_level                       int // to avoid infinite recursion segfaults due to compiler bugs
    type_level                       int // to avoid infinite recursion segfaults due to compiler bugs in ensure_type_exists
    ensure_generic_type_level        int // to avoid infinite recursion segfaults in ensure_generic_type_specify_type_names
    cur_orm_ts                       ast.TypeSymbol
    cur_or_expr                      &ast.OrExpr = unsafe { nil }
    cur_anon_fn                      &ast.AnonFn = unsafe { nil }
    vmod_file_content                string     // needed for @VMOD_FILE, contents of the file, *NOT its path**
    loop_labels                      []string   // filled, when inside labelled for loops: `a_label: for x in 0..10 {`
    veb_gen_types                    []ast.Type // veb route checks
    timers                           &util.Timers = util.get_timers()
    type_resolver                    type_resolver.TypeResolver
    comptime                         &type_resolver.ResolverInfo = unsafe { nil }
    fn_scope                         &ast.Scope                  = unsafe { nil }
    main_fn_decl_node                ast.FnDecl
    match_exhaustive_cutoff_limit    int = 10
    is_last_stmt                     bool
    prevent_sum_type_unwrapping_once bool            // needed for assign new values to sum type, stopping unwrapping then
    need_recheck_generic_fns         bool            // need recheck generic fns because there are cascaded nested generic fn
    generic_fns                      map[string]bool // register generic fns that needs recheck once
    inside_sql                       bool            // to handle sql table fields pseudo variables
    inside_selector_expr             bool
    inside_or_block_value            bool // true inside or-block where its value is used `f(g() or { true })`
    inside_interface_deref           bool
    inside_decl_rhs                  bool
    inside_if_guard                  bool // true inside the guard condition of `if x := opt() {}`
    inside_assign                    bool
    assert_autocasts                 map[string]AssertAutocast
    is_js_backend                    bool
    // doing_line_info                  int    // a quick single file run when called with v -line-info (contains line nr to inspect)
    // doing_line_path                  string // same, but stores the path being parsed
    is_index_assign                      bool
    comptime_call_pos                    int                      // needed for correctly checking use before decl for templates
    generic_call_positions               map[string]token.Pos     // map from generic function key to call position
    goto_labels                          map[string]ast.GotoLabel // to check for unused goto labels
    enum_data_type                       ast.Type
    field_data_type                      ast.Type
    variant_data_type                    ast.Type
    fn_return_type                       ast.Type
    orm_table_fields                     map[string][]ast.StructField // known table structs
    short_module_names                   []string                     // to check for function names colliding with module functions
    visible_param_mutation_cache         map[string]bool
    visible_param_mutation_in_progress   map[string]bool
    immutable_alias_analysis_in_progress map[string]bool
    always_error_fn_cache                map[string]bool
    always_error_fn_in_progress          map[string]bool
    generic_parts_cache                  []i8 // type idx -> 0 unknown, 1 false, 2 true

    v_current_commit_hash string // same as old C.V_CURRENT_COMMIT_HASH
    assign_stmt_attr      string // for `x := [1,2,3] @[freed]`

    js_string           ast.Type                 = ast.void_type // when `js"string literal"` is used, `js_string` will be equal to `JS.String`
    checker_transformer &transformer.Transformer = unsafe { nil }
}

pub fn new_checker(table &ast.Table, pref_ &pref.Preferences) &Checker {
    mut timers_should_print := false
    $if time_checking ? {
        timers_should_print = true
    }
    v_current_commit_hash := if pref_.building_v {
        version.githash(pref_.vroot) or { '' }
    } else {
        vcurrent_hash()
    }
    mut checker := &Checker{
        table:                                table
        pref:                                 pref_
        timers:                               util.new_timers(
            should_print: timers_should_print
            label:        'checker'
        )
        match_exhaustive_cutoff_limit:        pref_.checker_match_exhaustive_cutoff_limit
        v_current_commit_hash:                v_current_commit_hash
        checker_transformer:                  transformer.new_transformer_with_table(table, pref_)
        visible_param_mutation_cache:         map[string]bool{}
        visible_param_mutation_in_progress:   map[string]bool{}
        immutable_alias_analysis_in_progress: map[string]bool{}
        always_error_fn_cache:                map[string]bool{}
        always_error_fn_in_progress:          map[string]bool{}
        generic_parts_cache:                  []i8{len: table.type_symbols.len}
    }
    checker.checker_transformer.skip_array_transform = true
    checker.type_resolver = type_resolver.TypeResolver.new(table, checker)
    checker.comptime = &checker.type_resolver.info
    checker.is_js_backend = checker.pref.backend.is_js()
    return checker
}

// build_generic_call_key builds a key for tracking generic function call positions
fn (c &Checker) build_generic_call_key(fkey string, concrete_types []ast.Type) string {
    mut types_str := ''
    for typ in concrete_types {
        types_str += c.table.type_to_str(typ) + ','
    }
    return '${fkey}[${types_str}]'
}

fn (mut c Checker) has_active_generic_recheck_context() bool {
    if c.inside_generic_struct_init && c.cur_struct_concrete_types.len > 0 {
        return true
    }
    if c.table.cur_fn == unsafe { nil } {
        return false
    }
    if c.table.cur_concrete_types.len > 0 {
        return true
    }
    if !c.table.cur_fn.is_method {
        return false
    }
    receiver_typ := c.table.cur_fn.receiver.typ
    if receiver_typ == 0 {
        return false
    }
    if receiver_typ.has_flag(.generic) || c.type_has_unresolved_generic_parts(receiver_typ) {
        return true
    }
    rec_sym := c.table.sym(c.unwrap_generic(receiver_typ))
    match rec_sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            return rec_sym.info.generic_types.len > 0 || rec_sym.info.concrete_types.len > 0
        }
        ast.GenericInst {
            return rec_sym.info.concrete_types.len > 0
        }
        else {
            return false
        }
    }
}

fn (mut c Checker) refresh_generic_scope_var_type_for_use(mut v ast.Var, use_pos int) ast.Type {
    if v.is_arg || v.expr is ast.EmptyExpr || v.pos.pos <= 0 || v.pos.pos >= use_pos
        || c.table.cur_fn == unsafe { nil } || !c.has_active_generic_recheck_context() {
        return v.typ
    }
    $if trace_ci_fixes ? {
        if c.file.path.contains('/datatypes/linked_list.v') {
            generic_typ_str := if v.generic_typ == 0 {
                '<none>'
            } else {
                c.table.type_to_str(v.generic_typ)
            }
            eprintln('refresh_var fn=${c.table.cur_fn.name} var=${v.name} typ=${c.table.type_to_str(v.typ)} gtyp=${generic_typ_str} expr=${v.expr}')
        }
    }
    if v.generic_typ != 0 {
        refreshed_generic_type := c.unwrap_generic(c.recheck_concrete_type(v.generic_typ))
        if refreshed_generic_type != 0 && refreshed_generic_type != ast.void_type {
            v.typ = refreshed_generic_type
            v.orig_type = ast.no_type
            v.smartcasts = []
            v.is_unwrapped = false
            return v.typ
        }
    }
    if v.expr is ast.Ident && v.expr.name == v.name {
        return v.typ
    }
    saved_expected_type := c.expected_type
    saved_expected_or_type := c.expected_or_type
    saved_expected_expr_type := c.expected_expr_type
    saved_inside_assign := c.inside_assign
    saved_inside_decl_rhs := c.inside_decl_rhs
    saved_inside_selector_expr := c.inside_selector_expr
    saved_inside_fn_arg := c.inside_fn_arg
    saved_inside_if_guard := c.inside_if_guard
    saved_prevent_sum_type_unwrapping_once := c.prevent_sum_type_unwrapping_once
    saved_inside_recheck := c.inside_recheck
    saved_anon_struct_should_be_mut := c.anon_struct_should_be_mut
    defer {
        c.expected_type = saved_expected_type
        c.expected_or_type = saved_expected_or_type
        c.expected_expr_type = saved_expected_expr_type
        c.inside_assign = saved_inside_assign
        c.inside_decl_rhs = saved_inside_decl_rhs
        c.inside_selector_expr = saved_inside_selector_expr
        c.inside_fn_arg = saved_inside_fn_arg
        c.inside_if_guard = saved_inside_if_guard
        c.prevent_sum_type_unwrapping_once = saved_prevent_sum_type_unwrapping_once
        c.inside_recheck = saved_inside_recheck
        c.anon_struct_should_be_mut = saved_anon_struct_should_be_mut
    }
    c.expected_type = ast.void_type
    c.expected_or_type = ast.void_type
    c.expected_expr_type = ast.void_type
    c.inside_assign = false
    c.inside_decl_rhs = false
    c.inside_selector_expr = false
    c.inside_fn_arg = false
    c.inside_if_guard = false
    c.prevent_sum_type_unwrapping_once = false
    c.inside_recheck = true
    c.anon_struct_should_be_mut = false
    mut expr := v.expr
    mut refreshed_type := ast.void_type
    if mut expr is ast.IfGuardExpr {
        c.expr(mut expr)
        if expr.expr_type != 0 && expr.expr_type.clear_option_and_result() != ast.void_type {
            sym := c.table.sym(expr.expr_type)
            if sym.kind == .multi_return {
                mr_info := sym.info as ast.MultiReturn
                if mr_info.types.len == expr.vars.len {
                    for vi, var in expr.vars {
                        if var.name == v.name {
                            refreshed_type = mr_info.types[vi]
                            break
                        }
                    }
                }
            } else {
                // Rechecks should keep the value type introduced by the guard variable,
                // not the `bool` condition type returned by `IfGuardExpr`.
                refreshed_type = expr.expr_type.clear_option_and_result()
            }
        }
    } else {
        refreshed_type = c.expr(mut expr)
    }
    if refreshed_type != 0 && refreshed_type != ast.void_type {
        mut expr_is_auto_deref_ident := false
        if expr is ast.Ident {
            ident := expr as ast.Ident
            expr_is_auto_deref_ident = ident.obj is ast.Var && ident.obj.is_auto_deref
            if !expr_is_auto_deref_ident {
                if source_var := ident.scope.find_var(ident.name) {
                    expr_is_auto_deref_ident = source_var.is_auto_deref
                }
            }
        }
        // Keep `mut x := param` as a value copy during generic rechecks when the
        // original parameter type was lowered from a non-pointer source type.
        // Pointer-typed mut params should keep their declared pointer type.
        if expr_is_auto_deref_ident && refreshed_type.is_ptr()
            && !c.auto_deref_source_type_is_pointer(expr) {
            refreshed_type = refreshed_type.deref()
        }
        $if trace_ci_fixes ? {
            if c.file.path.contains('/datatypes/linked_list.v') {
                eprintln('refresh_var expr fn=${c.table.cur_fn.name} var=${v.name} refreshed=${c.table.type_to_str(refreshed_type)} expr=${expr}')
            }
        }
        v.typ = c.unwrap_generic(c.recheck_concrete_type(refreshed_type))
        v.expr = expr
        v.orig_type = ast.no_type
        v.smartcasts = []
        v.is_unwrapped = false
    }
    return v.typ
}

fn (mut c Checker) resolve_selector_field_type(left_type ast.Type, field_name string, field ast.StructField) ast.Type {
    mut field_type := field.typ
    sym := c.table.sym(c.unwrap_generic(left_type))
    match sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            mut generic_names := sym.info.generic_types.map(c.table.sym(it).name)
            mut concrete_types := sym.info.concrete_types.clone()
            if concrete_types.len == 0 && sym.generic_types.len == generic_names.len
                && sym.generic_types != sym.info.generic_types {
                concrete_types = sym.generic_types.clone()
            }
            mut source_field_type := field.typ
            if sym.info.parent_type.has_flag(.generic) {
                parent_sym := c.table.sym(sym.info.parent_type)
                if parent_field := c.table.find_field_with_embeds(parent_sym, field_name) {
                    source_field_type = parent_field.typ
                    match parent_sym.info {
                        ast.Struct, ast.Interface, ast.SumType {
                            generic_names = parent_sym.info.generic_types.map(c.table.sym(it).name)
                        }
                        else {}
                    }
                }
            }
            if generic_names.len == concrete_types.len && concrete_types.len > 0 {
                resolved_field_type := c.table.unwrap_generic_type_ex(source_field_type,
                    generic_names, concrete_types, true)
                if resolved_field_type != source_field_type {
                    field_type = resolved_field_type
                } else if converted_field_type := c.table.convert_generic_type(source_field_type,
                    generic_names, concrete_types)
                {
                    field_type = converted_field_type
                }
            }
        }
        ast.GenericInst {
            parent_sym := c.table.sym(ast.new_type(sym.info.parent_idx))
            mut source_field_type := field.typ
            if parent_field := c.table.find_field_with_embeds(parent_sym, field_name) {
                source_field_type = parent_field.typ
            }
            match parent_sym.info {
                ast.Struct, ast.Interface, ast.SumType {
                    generic_names := parent_sym.info.generic_types.map(c.table.sym(it).name)
                    if generic_names.len == sym.info.concrete_types.len
                        && sym.info.concrete_types.len > 0 {
                        resolved_field_type := c.table.unwrap_generic_type_ex(source_field_type,
                            generic_names, sym.info.concrete_types, true)
                        if resolved_field_type != source_field_type {
                            field_type = resolved_field_type
                        } else if converted_field_type := c.table.convert_generic_type(source_field_type,
                            generic_names, sym.info.concrete_types)
                        {
                            field_type = converted_field_type
                        }
                    }
                }
                else {}
            }
        }
        else {}
    }

    $if trace_ci_fixes ? {
        if c.file.path.contains('/datatypes/linked_list.v') {
            eprintln('selector_field left=${c.table.type_to_str(left_type)} sym=${sym.name} field=${field_name} raw=${c.table.type_to_str(field.typ)} final=${c.table.type_to_str(field_type)}')
        }
    }
    return c.unwrap_generic(c.recheck_concrete_type(field_type))
}

fn (mut c Checker) reset_checker_state_at_start_of_new_file() {
    c.expected_type = ast.void_type
    c.expected_or_type = ast.void_type
    c.const_var = unsafe { nil }
    c.in_for_count = 0
    c.returns = false
    c.scope_returns = false
    c.mod = ''
    c.is_builtin_mod = false
    c.is_just_builtin_mod = false
    c.inside_unsafe = false
    c.inside_const = false
    c.inside_anon_fn = false
    c.inside_ref_lit = false
    c.inside_defer = false
    c.inside_fn_arg = false
    c.inside_ct_attr = false
    c.inside_x_is_type = false
    c.inside_x_matches_type = false
    c.inside_integer_literal_cast = false
    c.skip_flags = false
    c.fn_level = 0
    c.expr_level = 0
    c.stmt_level = 0
    c.inside_sql = false
    c.cur_orm_ts = ast.TypeSymbol{}
    c.prevent_sum_type_unwrapping_once = false
    c.loop_labels = []
    c.inside_selector_expr = false
    c.inside_interface_deref = false
    c.inside_decl_rhs = false
    c.inside_if_guard = false
    c.has_globals_in_module = false
    c.error_details.clear()
}

pub fn (mut c Checker) check(mut ast_file ast.File) {
    $if trace_check ? {
        eprintln('> ${@FILE}:${@LINE} | ast_file.path: ${ast_file.path}')
    }
    $if trace_checker ? {
        eprintln('start checking file: ${ast_file.path}')
    }
    c.reset_checker_state_at_start_of_new_file()
    c.change_current_file(ast_file)
    for i, ast_import in ast_file.imports {
        // Imports with the same path and name (self-imports and module name conflicts with builtin module imports)
        if c.mod == ast_import.mod {
            c.error('cannot import `${ast_import.mod}` into a module with the same name',
                ast_import.mod_pos)
        }
        // Duplicates of regular imports with the default alias (modname) and `as` imports with a custom alias
        if c.mod == ast_import.alias {
            if c.mod == ast_import.mod.all_after_last('.') {
                c.error('cannot import `${ast_import.mod}` into a module with the same name',
                    ast_import.mod_pos)
            }
            c.error('cannot import `${ast_import.mod}` as `${ast_import.alias}` into a module with the same name',
                ast_import.alias_pos)
        }
        for sym in ast_import.syms {
            full_name := ast_import.mod + '.' + sym.name
            if full_name in c.const_names {
                c.error('cannot selectively import constant `${sym.name}` from `${ast_import.mod}`, import `${ast_import.mod}` and use `${full_name}` instead',
                    sym.pos)
            }
        }

        cmp_mod_name := if ast_import.mod != ast_import.alias && ast_import.alias != '_' {
            ast_import.alias
        } else {
            ast_import.mod
        }
        for j in 0 .. i {
            if cmp_mod_name == if ast_file.imports[j].mod != ast_file.imports[j].alias
                && ast_file.imports[j].alias != '_' {
                ast_file.imports[j].alias
            } else {
                ast_file.imports[j].mod
            } {
                c.error('A module `${cmp_mod_name}` was already imported on line ${
                    ast_file.imports[j].mod_pos.line_nr + 1}`.', ast_import.mod_pos)
            }
        }
    }
    c.reorder_fns_at_the_end(mut ast_file)
    c.stmt_level = 0
    for mut stmt in ast_file.stmts {
        if stmt in [ast.ConstDecl, ast.ExprStmt] {
            c.expr_level = 0
            c.stmt(mut stmt)
        }
        if c.should_abort {
            return
        }
    }

    c.stmt_level = 0
    for mut stmt in ast_file.stmts {
        is_global_decl := stmt is ast.GlobalDecl
        if is_global_decl {
            c.expr_level = 0
            c.stmt(mut stmt)
        }
        if c.should_abort {
            return
        }
    }

    c.stmt_level = 0
    for mut stmt in ast_file.stmts {
        if stmt is ast.StructDecl || stmt is ast.InterfaceDecl || stmt is ast.EnumDecl
            || stmt is ast.TypeDecl {
            c.expr_level = 0
            c.stmt(mut stmt)
        }
        if c.should_abort {
            return
        }
    }

    c.stmt_level = 0
    for mut stmt in ast_file.stmts {
        if mut stmt is ast.FnDecl {
            return_sym := c.table.sym(stmt.return_type)
            if return_sym.info is ast.ArrayFixed
                && c.array_fixed_has_unresolved_size(return_sym.info) {
                unsafe {
                    c.unresolved_fixed_sizes << &stmt
                }
            }
        }
    }

    if c.unresolved_fixed_sizes.len > 0 {
        c.update_unresolved_fixed_sizes()
    }

    c.stmt_level = 0
    for mut stmt in ast_file.stmts {
        if stmt !in [ast.ConstDecl, ast.GlobalDecl, ast.ExprStmt] && stmt !is ast.StructDecl
            && stmt !is ast.InterfaceDecl && stmt !is ast.EnumDecl && stmt !is ast.TypeDecl {
            c.expr_level = 0
            c.stmt(mut stmt)
        }
        if c.should_abort {
            return
        }
    }

    c.check_scope_vars(c.file.scope)
    c.check_unused_labels()
}

pub fn (mut c Checker) reorder_fns_at_the_end(mut ast_file ast.File) {
    mut fdeclarations := 0
    for mut stmt in ast_file.stmts {
        if stmt is ast.FnDecl {
            fdeclarations++
        }
    }
    if fdeclarations == 0 {
        return
    }
    // eprintln('>>> ast_file: ${ast_file.path:-60s} | fdeclarations: ${fdeclarations}')
    mut stmts := []ast.Stmt{cap: ast_file.stmts.len}
    for stmt in ast_file.stmts {
        if stmt !is ast.FnDecl {
            stmts << stmt
        }
    }
    for stmt in ast_file.stmts {
        if stmt is ast.FnDecl {
            stmts << stmt
        }
    }
    ast_file.stmts = stmts
}

pub fn (mut c Checker) check_scope_vars(sc &ast.Scope) {
    if !c.pref.is_repl && !c.file.is_test {
        for _, obj in sc.objects {
            match obj {
                ast.Var {
                    if !obj.is_special && !obj.is_used && obj.name[0] != `_` {
                        if !c.pref.translated && !c.file.is_translated {
                            if obj.is_arg {
                                if c.pref.show_unused_params {
                                    c.note('unused parameter: `${obj.name}`', obj.pos)
                                }
                            } else {
                                c.warn('unused variable: `${obj.name}`', obj.pos)
                            }
                        }
                    }
                    // if obj.is_mut && !obj.is_changed && !c.is_builtin_mod && obj.name != 'it' {
                    // if obj.is_mut && !obj.is_changed && !c.is_builtin {  //TODO C error bad field not checked
                    // c.warn('`${obj.name}` is declared as mutable, but it was never changed',
                    // obj.pos)
                    // }
                }
                else {}
            }
        }
    }
    for child in sc.children {
        c.check_scope_vars(child)
    }
}

pub fn (mut c Checker) change_current_file(file &ast.File) {
    c.file = unsafe { file }
    c.vmod_file_content = ''
    c.mod = file.mod.name
    c.is_just_builtin_mod = c.mod in ['builtin', 'builtin.closure']
    c.is_builtin_mod = c.is_just_builtin_mod || c.mod in ['os', 'strconv']
    c.is_generated = file.is_generated
    c.short_module_names = ['builtin']
    for import_sym in c.file.imports {
        c.short_module_names << if import_sym.alias == '' {
            import_sym.mod.all_after_last('.')
        } else {
            import_sym.alias
        }
    }
    // Check if the current module has has_globals attribute
    c.has_globals_in_module = false
    c.strict_map_index_in_module = false
    for attr in file.mod.attrs {
        match attr.name {
            'has_globals' {
                c.has_globals_in_module = true
            }
            'strict_map_index' {
                c.strict_map_index_in_module = true
            }
            else {}
        }
    }
}

pub fn (mut c Checker) check_files(ast_files []&ast.File) {
    // println('check_files')
    // c.files = ast_files
    mut has_main_mod_file := false
    mut has_no_main_mod_file := false
    mut has_main_fn := false
    mut invalid_test_file_name := ''
    mut invalid_test_file_pos := token.Pos{}
    // Determine the project directory when using -line-info
    mut project_dir := ''
    if c.pref.is_vls && c.pref.line_info != '' {
        project_dir = if os.is_dir(c.pref.path) {
            os.real_path(c.pref.path)
        } else {
            os.real_path(os.dir(c.pref.linfo.path))
        }
    }
    unsafe {
        mut files_from_main_module := []&ast.File{}
        for i in 0 .. ast_files.len {
            mut file := ast_files[i]
            if c.pref.is_vls && c.pref.line_info == '' && file.path != c.pref.path {
                continue
            }
            if c.pref.is_vls && c.pref.line_info != '' && project_dir != '' {
                if !os.real_path(file.path).starts_with(project_dir) {
                    continue
                }
            }
            c.timers.start('checker_check ${file.path}')
            c.check(mut file)
            if file.mod.name == 'no_main' {
                has_no_main_mod_file = true
            }
            if file.mod.name == 'main' {
                files_from_main_module << file
                has_main_mod_file = true
                if c.file_has_main_fn(file) {
                    has_main_fn = true
                }
            }
            if invalid_test_file_name == '' && is_likely_invalid_test_file_name(file) {
                invalid_test_file_name = file.path_base
                invalid_test_file_pos = file.mod.pos
            }
            c.timers.show('checker_check ${file.path}')
        }
        if has_main_mod_file && !has_main_fn && files_from_main_module.len > 0 {
            if c.pref.is_script && !c.pref.is_test {
                // files_from_main_module contain preludes at the start
                mut the_main_file := files_from_main_module.last()
                the_main_file.stmts << ast.FnDecl{
                    name:        'main.main'
                    mod:         'main'
                    is_main:     true
                    file:        the_main_file.path
                    return_type: ast.void_type
                    scope:       &ast.Scope{
                        parent: nil
                    }
                }
                has_main_fn = true
            }
        }
    }
    c.timers.start('checker_post_process_generic_fns')
    mut last_file := c.file
    // c.file might be nil in vls mode, fall back to first file
    if c.pref.is_vls && last_file == unsafe { nil } && ast_files.len > 0 {
        last_file = ast_files[0]
    }
    // post process generic functions. must be done after all files have been
    // checked, to ensure all generic calls are processed, as this information
    // is needed when the generic type is auto inferred from the call argument.
    // we may have to loop several times, if there were more concrete types found.
    mut post_process_generic_fns_iterations := 0
    post_process_iterations_loop: for post_process_generic_fns_iterations <= generic_fn_postprocess_iterations_cutoff_limit {
        $if trace_post_process_generic_fns_loop ? {
            eprintln('>>>>>>>>> recheck_generic_fns loop iteration: ${post_process_generic_fns_iterations}')
        }
        for file in ast_files {
            if file.generic_fns.len > 0 {
                $if trace_post_process_generic_fns_loop ? {
                    eprintln('>> file.path: ${file.path:-40} | file.generic_fns:' +
                        file.generic_fns.map(it.name).str())
                }
                c.change_current_file(file)
                c.post_process_generic_fns() or { break post_process_iterations_loop }
            }
        }
        // Resolve newly created generic struct/interface instances to concrete types.
        // This ensures that methods of generic structs instantiated during the current
        // iteration (e.g. EluLayer[f64] created when checking elu_layer[f64]) get their
        // concrete types registered for rechecking in the next iteration.
        mut old_concrete_count := 0
        for _, v in c.table.fn_generic_types {
            old_concrete_count += v.len
        }
        c.table.generic_insts_to_concrete()
        mut new_concrete_count := 0
        for _, v in c.table.fn_generic_types {
            new_concrete_count += v.len
        }
        if new_concrete_count != old_concrete_count {
            c.need_recheck_generic_fns = true
        }
        if !c.need_recheck_generic_fns {
            break
        }
        c.need_recheck_generic_fns = false
        post_process_generic_fns_iterations++
    }
    $if trace_post_process_generic_fns_loop ? {
        eprintln('>>>>>>>>> recheck_generic_fns loop done, iteration: ${post_process_generic_fns_iterations}')
    }
    // restore the original c.file && c.mod after post processing
    c.change_current_file(last_file)
    c.timers.show('checker_post_process_generic_fns')

    c.timers.start('checker_verify_all_veb_routes')
    c.verify_all_veb_routes()
    c.timers.show('checker_verify_all_veb_routes')

    c.check_unused_declarations(ast_files)

    if c.pref.is_test {
        mut n_test_fns := 0
        for _, f in c.table.fns {
            if f.is_test {
                n_test_fns++
            }
        }
        if n_test_fns == 0 {
            c.add_error_detail('The name of a test function in V, should start with `test_`.')
            c.add_error_detail('The test function should take 0 parameters, and no return type. Example:')
            c.add_error_detail('fn test_xyz(){ assert 2 + 2 == 4 }')
            c.error('a _test.v file should have *at least* one `test_` function', token.Pos{})
        }
    }
    // Make sure fn main is defined in non lib builds
    if c.pref.build_mode == .build_module || c.pref.is_test {
        return
    }
    if c.pref.is_shared {
        // shared libs do not need to have a main
        return
    }
    if c.pref.is_o {
        // .o files also do not need main
        return
    }
    if c.pref.no_builtin {
        // `v -no-builtin module/` do not necessarily need to have a `main` function
        // This is useful for compiling linux kernel modules for example.
        return
    }
    if has_no_main_mod_file {
        return
    }
    if !has_main_mod_file {
        if invalid_test_file_name != '' {
            c.add_error_detail('Test files should have names ending with `_test.v`.')
            c.error('invalid test file name `${invalid_test_file_name}`', invalid_test_file_pos)
        } else {
            c.error('project must include a `main` module or be a shared library (compile with `v -shared`)', token.Pos{})
        }
    } else if !has_main_fn && !c.pref.is_o {
        c.error('function `main` must be declared in the main module', token.Pos{})
    }
}

fn is_likely_invalid_test_file_name(file &ast.File) bool {
    return !file.is_test && (file.path_base.ends_with('.v') || file.path_base.ends_with('.vv'))
        && file.path_base.starts_with('test_')
}

fn (mut c Checker) stmts_has_main_fn(stmts []ast.Stmt) bool {
    mut has_main_fn := false
    for stmt in stmts {
        if stmt is ast.ExprStmt {
            // top level comptime main fn
            if stmt.expr is ast.IfExpr && stmt.expr.is_comptime {
                // $if a ? { fn main(){} } $else { fn main() {} }
                for branch in stmt.expr.branches {
                    if c.stmts_has_main_fn(branch.stmts) {
                        has_main_fn = true
                    }
                }
            } else if stmt.expr is ast.MatchExpr && stmt.expr.is_comptime {
                // $match os { 'windows' { fn main() {} } ...
                for branch in stmt.expr.branches {
                    if c.stmts_has_main_fn(branch.stmts) {
                        has_main_fn = true
                    }
                }
            }
        }
        if stmt is ast.FnDecl {
            if stmt.name == 'main.main' {
                if has_main_fn {
                    c.error('function `main` is already defined', stmt.pos)
                }
                has_main_fn = true
                if stmt.params.len > 0 {
                    c.error('function `main` cannot have arguments', stmt.pos)
                }
                if stmt.return_type != ast.void_type {
                    c.error('function `main` cannot return values', stmt.pos)
                }
                if stmt.no_body {
                    c.error('function `main` must declare a body', stmt.pos)
                }
            } else if stmt.attrs.contains('console') {
                c.error('only `main` can have the `@[console]` attribute', stmt.pos)
            }
        }
    }
    return has_main_fn
}

// do checks specific to files in main module
// returns `true` if a main function is in the file
fn (mut c Checker) file_has_main_fn(file &ast.File) bool {
    return c.stmts_has_main_fn(file.stmts)
}

@[direct_array_access]
fn (mut c Checker) check_valid_snake_case(name string, identifier string, pos token.Pos) {
    if c.pref.translated || c.file.is_translated {
        return
    }
    if !c.pref.is_template && name.len > 1 && (name[0] == `_` || name.contains('._')) {
        c.error('${identifier} `${name}` cannot start with `_`', pos)
    }
    if util.contains_capital(name) {
        c.error('${identifier} `${name}` cannot contain uppercase letters, use snake_case instead',
            pos)
    }
}

fn stripped_name(name string) string {
    idx := name.last_index('.') or { -1 }
    return name[(idx + 1)..]
}

fn (mut c Checker) check_valid_pascal_case(name string, identifier string, pos token.Pos) {
    if c.pref.translated || c.file.is_translated {
        return
    }
    sname := stripped_name(name)
    if sname.len > 0 && !sname[0].is_capital() {
        c.error('${identifier} `${name}` must begin with capital letter', pos)
    }
}

fn (mut c Checker) type_decl(mut node ast.TypeDecl) {
    if node.typ == ast.invalid_type && (node is ast.AliasTypeDecl || node is ast.SumTypeDecl) {
        typ_desc := if node is ast.AliasTypeDecl { 'alias' } else { 'sum type' }
        c.error('cannot register ${typ_desc} `${node.name}`, another type with this name exists',
            node.pos)
        return
    }
    match mut node {
        ast.AliasTypeDecl { c.alias_type_decl(mut node) }
        ast.FnTypeDecl { c.fn_type_decl(mut node) }
        ast.SumTypeDecl { c.sum_type_decl(mut node) }
    }
}

fn (mut c Checker) alias_type_decl(mut node ast.AliasTypeDecl) {
    if c.file.mod.name != 'builtin' && !node.name.starts_with('C.') {
        c.check_valid_pascal_case(node.name, 'type alias', node.pos)
    }
    node.parent_type = c.preferred_c_symbol_type(node.parent_type)
    if c.pref.is_vls && c.pref.linfo.method == .definition {
        if c.vls_is_the_node(node.type_pos) {
            typ_str := c.table.type_to_str(node.parent_type)
            if np := c.name_pos_gotodef(typ_str) {
                if np.file_idx != -1 {
                    println('${c.table.filelist[np.file_idx]}:${np.line_nr + 1}:${np.col}')
                    exit(0)
                }
            }
        }
    }
    if !c.ensure_type_exists(node.parent_type, node.type_pos) {
        return
    }
    mut parent_typ_sym := c.table.sym(node.parent_type)
    if node.parent_type.has_flag(.result) {
        c.add_error_detail('Result types cannot be stored and have to be unwrapped immediately')
        c.error('cannot make an alias of Result type', node.type_pos)
    }
    match parent_typ_sym.kind {
        .placeholder, .int_literal, .float_literal, .any {
            c.error('unknown aliased type `${parent_typ_sym.name}`', node.type_pos)
        }
        .alias {
            // chained aliases (`type B = A` where `A` is itself an alias) are
            // allowed; matches Go's alias semantics and lets modules re-export
            // types from their dependencies without leaking the original module
            // name to callers (#27055). Walk the parent chain to reject cycles
            // such as `type A = B; type B = A`, which would otherwise hang
            // downstream consumers that follow aliases unconditionally.
            mut visited := []int{cap: 8}
            visited << int(node.parent_type.idx())
            mut cur := parent_typ_sym
            for cur.info is ast.Alias {
                parent_idx := int(cur.info.parent_type.idx())
                if parent_idx in visited {
                    c.error('alias `${node.name}` forms a cycle through `${parent_typ_sym.name}`',
                        node.type_pos)
                    break
                }
                visited << parent_idx
                cur = c.table.sym(cur.info.parent_type)
            }
        }
        .chan {
            c.error('aliases of `chan` types are not allowed', node.type_pos)
        }
        .thread {
            c.error('aliases of `thread` types are not allowed', node.type_pos)
        }
        .multi_return {
            c.error('aliases of function multi return types are not allowed', node.type_pos)
        }
        .void {
            c.error('aliases of the void type are not allowed', node.type_pos)
        }
        .function {
            orig_sym := c.table.type_to_str(node.parent_type)
            c.error('type `${parent_typ_sym.str()}` is an alias, use the original alias type `${orig_sym}` instead',
                node.type_pos)
        }
        .struct {
            if mut parent_typ_sym.info is ast.Struct {
                // check if the generic param types have been defined
                for ct in parent_typ_sym.info.concrete_types {
                    ct_sym := c.table.sym(ct)
                    if ct_sym.kind == .placeholder {
                        c.error('unknown type `${ct_sym.name}`', node.type_pos)
                    }
                }

                if parent_typ_sym.info.is_generic && parent_typ_sym.info.concrete_types.len == 0 {
                    c.error('${parent_typ_sym.name} type is generic struct, must specify the generic type names, e.g. ${parent_typ_sym.name}[int]',
                        node.type_pos)
                }

                // check if embed types are supported for struct embedding
                for embed_type in parent_typ_sym.info.embeds {
                    if !c.can_be_embedded_in_struct(embed_type) {
                        c.error('cannot embed non-struct `${c.table.sym(embed_type).name}`',
                            node.type_pos)
                    }
                }
                if parent_typ_sym.info.is_anon {
                    for field in parent_typ_sym.info.fields {
                        mut is_embed := false
                        field_sym := c.table.sym(field.typ)
                        if field_sym.info is ast.Alias {
                            if !c.can_be_embedded_in_struct(field.typ) {
                                c.error('cannot embed non-struct `${field_sym.name}`',
                                    field.type_pos)
                                is_embed = true
                            }
                        }
                        if !is_embed {
                            c.check_valid_snake_case(field.name, 'field name', field.pos)
                        }
                    }
                }
            }
        }
        .array {
            c.check_alias_vs_element_type_of_parent(node,
                (parent_typ_sym.info as ast.Array).elem_type, 'array')
        }
        .array_fixed {
            array_fixed_info := parent_typ_sym.info as ast.ArrayFixed
            if c.array_fixed_has_unresolved_size(array_fixed_info) {
                c.unresolved_fixed_sizes << &ast.TypeDecl(node)
            }
            c.check_alias_vs_element_type_of_parent(node, array_fixed_info.elem_type, 'fixed array')
        }
        .map {
            info := parent_typ_sym.info as ast.Map
            c.check_alias_vs_element_type_of_parent(node, info.key_type, 'map key')
            c.check_alias_vs_element_type_of_parent(node, info.value_type, 'map value')
            c.markused_used_maps(c.table.used_features.used_maps == 0)
        }
        .sum_type {
            // TODO: decide whether the following should be allowed. Note that it currently works,
            // while `type Sum = int | Sum` is explicitly disallowed:
            // type Sum = int | Alias
            // type Alias = Sum
        }
        .none {
            c.error('cannot create a type alias of `none` as it is a value', node.type_pos)
        }
        // The rest of the parent symbol kinds are also allowed, since they are either primitive types,
        // that in turn do not allow recursion, or are abstract enough so that they can not be checked at comptime:
        else {
            c.check_any_type(node.parent_type, parent_typ_sym, node.type_pos)
        }
        /*
        .voidptr, .byteptr, .charptr {}
        .char, .rune, .bool {}
        .string, .enum, .none, .any {}
        .i8, .i16, .i32, .int, .i64, .isize {}
        .u8, .u16, .u32, .u64, .usize {}
        .f32, .f64 {}
        .interface {}
        .generic_inst {}
        .aggregate {}
        */
    }
}

fn (c &Checker) preferred_c_symbol_type(typ ast.Type) ast.Type {
    sym := c.table.sym(typ)
    if sym.language != .c || sym.name == '' {
        return typ
    }
    mut public_typ := ast.invalid_type
    for i := c.table.type_symbols.len - 1; i >= 1; i-- {
        candidate := c.table.type_symbols[i]
        if candidate.language != .c || candidate.name != sym.name || candidate.kind == .placeholder {
            continue
        }
        if candidate.mod == c.mod {
            return ast.new_type(i).derive(typ)
        }
        if candidate.is_pub && public_typ == ast.invalid_type {
            public_typ = ast.new_type(i).derive(typ)
        }
    }
    if public_typ != ast.invalid_type {
        return public_typ
    }
    return typ
}

fn (mut c Checker) check_alias_vs_element_type_of_parent(node ast.AliasTypeDecl, element_type_of_parent ast.Type,
    label string) {
    if node.typ.idx() != element_type_of_parent.idx() {
        return
    }
    c.error('recursive declarations of aliases are not allowed - the alias `${node.name}` is used in the ${label}',
        node.type_pos)
}

fn (mut c Checker) check_any_type(typ ast.Type, sym &ast.TypeSymbol, pos token.Pos) {
    if sym.kind == .any && !typ.has_flag(.generic) && sym.language != .js
        && c.file.mod.name != 'builtin' {
        c.error('cannot use type `any` here', pos)
    }
}

fn (mut c Checker) fn_type_decl(mut node ast.FnTypeDecl) {
    c.check_valid_pascal_case(node.name, 'fn type', node.pos)
    typ_sym := c.table.sym(node.typ)
    fn_typ_info := typ_sym.info as ast.FnType
    fn_info := fn_typ_info.func
    c.ensure_type_exists(fn_info.return_type, fn_info.return_type_pos)
    ret_sym := c.table.sym(fn_info.return_type)
    if ret_sym.kind == .placeholder {
        c.error('unknown type `${ret_sym.name}`', fn_info.return_type_pos)
    }
    for arg in fn_info.params {
        if !c.ensure_type_exists(arg.typ, arg.type_pos) {
            return
        }
        arg_sym := c.table.sym(arg.typ)
        if arg_sym.kind == .placeholder {
            c.error('unknown type `${arg_sym.name}`', arg.type_pos)
        }
    }
}

fn (mut c Checker) sum_type_decl(mut node ast.SumTypeDecl) {
    c.check_valid_pascal_case(node.name, 'sum type', node.pos)
    if c.pref.is_vls && c.pref.linfo.method == .definition {
        for variant in node.variants {
            if c.vls_is_the_node(variant.pos) {
                typ_str := c.table.type_to_str(variant.typ)
                if np := c.name_pos_gotodef(typ_str) {
                    if np.file_idx != -1 {
                        println('${c.table.filelist[np.file_idx]}:${np.line_nr + 1}:${np.col}')
                        exit(0)
                    }
                }
            }
        }
    }
    mut names_used := []string{}
    for variant in node.variants {
        c.ensure_type_exists(variant.typ, variant.pos)
        sym := c.table.sym(variant.typ)
        if variant.typ.is_ptr() || (sym.info is ast.Alias && sym.info.parent_type.is_ptr()) {
            variant_name := sym.name.all_after_last('.')
            lb, rb := if sym.kind == .struct { '{', '}' } else { '(', ')' }
            msg := if sym.info is ast.Alias && sym.info.parent_type.is_ptr() {
                'alias as non-reference type'
            } else {
                'the sum type with non-reference types'
            }
            c.add_error_detail('declare ${msg}: `${node.name} = ${variant_name} | ...`
and use a reference to the sum type instead: `var := &${node.name}(${variant_name}${lb}val${rb})`')
            c.error('sum type cannot hold a reference type', variant.pos)
        }
        variant_name := c.table.type_to_str(variant.typ)
        if variant_name in names_used {
            c.error('sum type ${node.name} cannot hold the type `${sym.name}` more than once',
                variant.pos)
        } else if sym.kind in [.placeholder, .int_literal, .float_literal] {
            c.error('unknown type `${sym.name}`', variant.pos)
        } else if sym.kind == .interface && sym.language != .js {
            c.error('sum type cannot hold an interface', variant.pos)
        } else if sym.kind == .struct && sym.language == .js {
            c.error('sum type cannot hold a JS struct', variant.pos)
        } else if sym.info is ast.Struct {
            if sym.info.is_generic {
                if !variant.typ.has_flag(.generic) {
                    c.error('generic struct `${sym.name}` must specify generic type names, e.g. ${sym.name}[T]',
                        variant.pos)
                }
                if node.generic_types.len == 0 {
                    c.error('generic sumtype `${node.name}` must specify generic type names, e.g. ${node.name}[T]',
                        node.name_pos)
                } else {
                    for typ in sym.info.generic_types {
                        if typ !in node.generic_types {
                            sumtype_type_names :=
                                node.generic_types.map(c.table.type_to_str(it)).join(', ')
                            generic_sumtype_name := '${node.name}[${sumtype_type_names}]'
                            generic_variant_name := c.table.type_to_str(variant.typ)
                            c.error('generic type name `${c.table.sym(typ).name}` of generic struct `${generic_variant_name}` is not mentioned in sumtype `${generic_sumtype_name}`',
                                variant.pos)
                        }
                    }
                }
            }
        } else if sym.info is ast.FnType {
            if sym.info.func.generic_names.len > 0 {
                if !variant.typ.has_flag(.generic) {
                    c.error('generic fntype `${sym.name}` must specify generic type names, e.g. ${sym.name}[T]',
                        variant.pos)
                }
                if node.generic_types.len == 0 {
                    c.error('generic sumtype `${node.name}` must specify generic type names, e.g. ${node.name}[T]',
                        node.name_pos)
                }
            }
            if c.table.sym(sym.info.func.return_type).name.ends_with('.${node.name}') {
                c.error('sum type `${node.name}` cannot be defined recursively', variant.pos)
            }
            for param in sym.info.func.params {
                if c.table.sym(param.typ).name.ends_with('.${node.name}') {
                    c.error('sum type `${node.name}` cannot be defined recursively', variant.pos)
                }
            }
        } else if variant.typ.has_flag(.result) {
            c.error('sum type cannot hold a Result type', variant.pos)
        }
        c.check_any_type(variant.typ, sym, variant.pos)

        if sym.name.trim_string_left(sym.mod + '.') == node.name {
            c.error('sum type cannot hold itself', variant.pos)
        } else if sym.kind == .sum_type && sym.info is ast.SumType {
            // Check for circular references through other sum types
            mut visited := map[int]bool{}
            visited[node.typ.idx()] = true
            if c.sumtype_has_circular_ref(variant.typ, node.typ, mut visited) {
                c.error('sum type `${node.name}` cannot be defined recursively', variant.pos)
            }
        }
        names_used << variant_name
    }
}

// Checks if the sum type `sum_typ` contains `target_typ` in its variants (directly or indirectly through other sum types)
fn (mut c Checker) sumtype_has_circular_ref(sum_typ ast.Type, target_typ ast.Type, mut visited map[int]bool) bool {
    sum_sym := c.table.sym(sum_typ)
    if sum_sym.kind != .sum_type || sum_sym.info !is ast.SumType {
        return false
    }
    sum_info := sum_sym.info as ast.SumType
    for variant in sum_info.variants {
        if variant.idx() == target_typ.idx() {
            return true
        }
        // Avoid infinite recursion by tracking visited types
        if variant.idx() in visited {
            continue
        }
        variant_sym := c.table.sym(variant)
        if variant_sym.kind == .sum_type {
            visited[variant.idx()] = true
            if c.sumtype_has_circular_ref(variant, target_typ, mut visited) {
                return true
            }
        }
    }
    return false
}

fn (mut c Checker) expand_iface_embeds(idecl &ast.InterfaceDecl, level int, iface_embeds []ast.InterfaceEmbedding) []ast.InterfaceEmbedding {
    // eprintln('> expand_iface_embeds: idecl.name: ${idecl.name} | level: ${level} | iface_embeds.len: ${iface_embeds.len}')
    if level > iface_level_cutoff_limit {
        c.error('too many interface embedding levels: ${level}, for interface `${idecl.name}`',
            idecl.pos)
        return []
    }
    if iface_embeds.len == 0 {
        return []
    }
    mut res := map[int]ast.InterfaceEmbedding{}
    mut ares := []ast.InterfaceEmbedding{}
    for ie in iface_embeds {
        if iface_decl := c.table.interfaces[ie.typ] {
            mut list := iface_decl.embeds.clone()
            if !iface_decl.are_embeds_expanded {
                list = c.expand_iface_embeds(idecl, level + 1, iface_decl.embeds)
                unsafe {
                    c.table.interfaces[ie.typ].embeds = list
                }
                unsafe {
                    c.table.interfaces[ie.typ].are_embeds_expanded = true
                }
            }
            for partial in list {
                res[partial.typ] = partial
            }
        }
        res[ie.typ] = ie
    }
    for _, v in res {
        ares << v
    }
    return ares
}

fn (mut c Checker) expr_is_immutable_source(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            return match expr.obj {
                ast.Var { !expr.obj.is_mut }
                ast.ConstField { true }
                else { false }
            }
        }
        ast.SelectorExpr {
            if expr.expr_type == 0 {
                return false
            }
            typ_sym := c.table.final_sym(c.unwrap_generic(expr.expr_type))
            match typ_sym.kind {
                .struct {
                    if field_info := c.table.find_field_with_embeds(typ_sym, expr.field_name) {
                        return !field_info.is_mut || c.expr_is_immutable_source(expr.expr)
                    }
                }
                .interface {
                    interface_info := typ_sym.info as ast.Interface
                    if field_info := interface_info.find_field(expr.field_name) {
                        return !field_info.is_mut || c.expr_is_immutable_source(expr.expr)
                    }
                }
                .sum_type {
                    sumtype_info := typ_sym.info as ast.SumType
                    if field_info := sumtype_info.find_sum_type_field(expr.field_name) {
                        return !field_info.is_mut || c.expr_is_immutable_source(expr.expr)
                    }
                }
                else {}
            }

            return c.expr_is_immutable_source(expr.expr)
        }
        ast.IndexExpr {
            return c.expr_is_immutable_source(expr.left)
        }
        ast.ParExpr {
            return c.expr_is_immutable_source(expr.expr)
        }
        else {
            return false
        }
    }
}

fn (mut c Checker) type_contains_mutable_aliasing(typ ast.Type, mut checked_types []ast.Type) bool {
    unwrapped_typ := c.unwrap_generic(typ.clear_option_and_result())
    if unwrapped_typ == 0 {
        return false
    }
    if unwrapped_typ.has_flag(.shared_f) || unwrapped_typ.is_any_kind_of_pointer() {
        return true
    }
    if unwrapped_typ in checked_types {
        return false
    }
    checked_types << unwrapped_typ
    sym := c.table.sym(unwrapped_typ)
    match sym.info {
        ast.Alias {
            return c.type_contains_mutable_aliasing(sym.info.parent_type, mut checked_types)
        }
        ast.Array, ast.Map, ast.Interface {
            return true
        }
        ast.ArrayFixed {
            return c.type_contains_mutable_aliasing(sym.info.elem_type, mut checked_types)
        }
        ast.Struct {
            if sym.kind == .struct && sym.language == .v {
                for field in c.table.struct_fields(sym) {
                    if !field.is_mut {
                        continue
                    }
                    if c.type_contains_mutable_aliasing(field.typ, mut checked_types) {
                        return true
                    }
                }
            }
        }
        ast.SumType {
            for variant in sym.info.variants {
                if c.type_contains_mutable_aliasing(variant, mut checked_types) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut c Checker) type_has_mutable_aliasing(typ ast.Type) bool {
    mut checked_types := []ast.Type{}
    return c.type_contains_mutable_aliasing(typ, mut checked_types)
}

fn (mut c Checker) expr_is_mutable_alias_of_immutable_source(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            if expr.obj is ast.Var && expr.obj.is_mut && c.type_has_mutable_aliasing(expr.obj.typ) {
                match expr.obj.expr {
                    ast.UnsafeExpr {
                        return false
                    }
                    ast.Ident, ast.CallExpr, ast.CastExpr, ast.AsCast, ast.ParExpr {
                        return c.expr_is_immutable_source(expr.obj.expr)
                            || c.expr_is_mutable_alias_of_immutable_source(expr.obj.expr)
                    }
                    else {}
                }
            }
            return false
        }
        ast.CastExpr {
            return c.expr_is_mutable_alias_of_immutable_source(expr.expr)
        }
        ast.CallExpr {
            return c.call_expr_immutable_alias_source(expr) !is ast.EmptyExpr
        }
        ast.IndexExpr {
            return c.type_has_mutable_aliasing(expr.typ) && (c.expr_is_immutable_source(expr.left)
                || c.expr_is_mutable_alias_of_immutable_source(expr.left))
        }
        ast.SelectorExpr {
            if expr.expr_type == 0 {
                return false
            }
            typ_sym := c.table.final_sym(c.unwrap_generic(expr.expr_type))
            match typ_sym.kind {
                .struct {
                    if field_info := c.table.find_field_with_embeds(typ_sym, expr.field_name) {
                        mut checked_types := []ast.Type{}
                        return field_info.is_mut
                            && c.type_contains_mutable_aliasing(field_info.typ, mut checked_types)
                            && c.expr_is_mutable_alias_of_immutable_source(expr.expr)
                    }
                }
                .interface {
                    interface_info := typ_sym.info as ast.Interface
                    if field_info := interface_info.find_field(expr.field_name) {
                        mut checked_types := []ast.Type{}
                        return field_info.is_mut
                            && c.type_contains_mutable_aliasing(field_info.typ, mut checked_types)
                            && c.expr_is_mutable_alias_of_immutable_source(expr.expr)
                    }
                }
                .sum_type {
                    sumtype_info := typ_sym.info as ast.SumType
                    if field_info := sumtype_info.find_sum_type_field(expr.field_name) {
                        mut checked_types := []ast.Type{}
                        return field_info.is_mut
                            && c.type_contains_mutable_aliasing(field_info.typ, mut checked_types)
                            && c.expr_is_mutable_alias_of_immutable_source(expr.expr)
                    }
                }
                else {}
            }

            return false
        }
        ast.AsCast {
            return c.expr_is_mutable_alias_of_immutable_source(expr.expr)
        }
        ast.ParExpr {
            return c.expr_is_mutable_alias_of_immutable_source(expr.expr)
        }
        ast.UnsafeExpr {
            return c.expr_is_mutable_alias_of_immutable_source(expr.expr)
        }
        else {
            return false
        }
    }
}

fn (mut c Checker) call_arg_expr_for_param(node ast.CallExpr, func ast.Fn, param_name string) ast.Expr {
    mut arg_idx := 0
    for i, param in func.params {
        if func.is_method && i == 0 {
            continue
        }
        if arg_idx >= node.args.len {
            break
        }
        if param.name == param_name {
            return node.args[arg_idx].expr
        }
        arg_idx++
    }
    return ast.empty_expr
}

fn (mut c Checker) return_expr_immutable_alias_source(expr ast.Expr, func ast.Fn, call ast.CallExpr, allow_non_ptr bool) ast.Expr {
    match expr {
        ast.AsCast {
            return c.return_expr_immutable_alias_source(expr.expr, func, call, allow_non_ptr)
        }
        ast.CastExpr {
            return c.return_expr_immutable_alias_source(expr.expr, func, call, allow_non_ptr)
        }
        ast.CallExpr {
            return c.call_expr_immutable_alias_source(expr)
        }
        ast.Ident {
            if expr.obj is ast.Var && expr.obj.is_arg {
                arg_expr := c.call_arg_expr_for_param(call, func, expr.name)
                if arg_expr !is ast.EmptyExpr && (allow_non_ptr || expr.obj.typ.is_ptr())
                    && c.expr_is_immutable_source(arg_expr) {
                    return arg_expr
                }
            }
            if expr.obj is ast.Var && (allow_non_ptr || expr.obj.typ.is_ptr()) {
                return c.return_expr_immutable_alias_source(expr.obj.expr, func, call,
                    allow_non_ptr)
            }
            return ast.empty_expr
        }
        ast.IndexExpr {
            if c.type_has_mutable_aliasing(expr.typ) {
                return c.return_expr_immutable_alias_source(expr.left, func, call, true)
            }
            return ast.empty_expr
        }
        ast.SelectorExpr {
            if c.type_has_mutable_aliasing(expr.typ) {
                return c.return_expr_immutable_alias_source(expr.expr, func, call, true)
            }
            return ast.empty_expr
        }
        ast.ParExpr {
            return c.return_expr_immutable_alias_source(expr.expr, func, call, allow_non_ptr)
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return c.return_expr_immutable_alias_source(expr.right, func, call, true)
            }
            return ast.empty_expr
        }
        ast.UnsafeExpr {
            return c.return_expr_immutable_alias_source(expr.expr, func, call, allow_non_ptr)
        }
        else {
            return ast.empty_expr
        }
    }
}

fn (mut c Checker) node_immutable_alias_source(node ast.Node, func ast.Fn, call ast.CallExpr) ast.Expr {
    match node {
        ast.Expr {
            if node is ast.AnonFn {
                return ast.empty_expr
            }
        }
        ast.Stmt {
            if node is ast.FnDecl {
                return ast.empty_expr
            }
            if node is ast.Return {
                allow_non_ptr := !call.return_type.is_ptr()
                    && c.type_has_mutable_aliasing(call.return_type)
                for expr in node.exprs {
                    source := c.return_expr_immutable_alias_source(expr, func, call, allow_non_ptr)
                    if source !is ast.EmptyExpr {
                        return source
                    }
                }
                return ast.empty_expr
            }
        }
        else {}
    }

    for child in node.children() {
        source := c.node_immutable_alias_source(child, func, call)
        if source !is ast.EmptyExpr {
            return source
        }
    }
    return ast.empty_expr
}

fn (c &Checker) immutable_alias_call_key(node ast.CallExpr) string {
    if node.concrete_types.len > 0 {
        return c.build_generic_call_key(node.fkey(), node.concrete_types)
    }
    return node.fkey()
}

fn (mut c Checker) call_expr_immutable_alias_source(node ast.CallExpr) ast.Expr {
    if !c.type_has_mutable_aliasing(node.return_type) {
        return ast.empty_expr
    }
    func := c.get_fn_from_call_expr(node) or { return ast.empty_expr }
    call_key := c.immutable_alias_call_key(node)
    if call_key in c.immutable_alias_analysis_in_progress {
        return ast.empty_expr
    }
    c.immutable_alias_analysis_in_progress[call_key] = true
    defer {
        c.immutable_alias_analysis_in_progress.delete(call_key)
    }
    if func.source_fn == unsafe { nil } {
        return ast.empty_expr
    }
    fn_decl := unsafe { &ast.FnDecl(func.source_fn) }
    for stmt in fn_decl.stmts {
        source := c.node_immutable_alias_source(stmt, func, node)
        if source !is ast.EmptyExpr {
            return source
        }
    }
    return ast.empty_expr
}

// fail_if_immutable_to_mutable checks if there is a immutable reference on right-side of assignment for mutable var
fn (mut c Checker) fail_if_immutable_to_mutable(left_type ast.Type, right_type ast.Type, right ast.Expr) bool {
    if c.inside_unsafe || c.pref.translated || c.file.is_translated {
        return true
    }
    match right {
        ast.CastExpr {
            iface_sym := c.table.final_sym(c.unwrap_generic(right.typ))
            if iface_sym.kind == .interface && iface_sym.info is ast.Interface {
                // Only fail if the interface has mutable fields; casting an immutable
                // reference to a read-only interface is safe because no mutation is
                // possible through the interface.
                has_mut_fields := iface_sym.info.fields.any(it.is_mut)
                if has_mut_fields {
                    mut expr := right.expr
                    c.fail_if_immutable(mut expr)
                }
            }
        }
        ast.CallExpr {
            if right_type.is_ptr() {
                source := c.call_expr_immutable_alias_source(right)
                if source !is ast.EmptyExpr {
                    if source is ast.Ident && c.expr_is_immutable_source(source) {
                        c.note('`${source.name}` is immutable, cannot have a mutable reference to an immutable object',
                            source.pos)
                    } else {
                        c.note('call result aliases mutable data from an immutable value',
                            right.pos)
                    }
                    return false
                }
            }
        }
        ast.Ident {
            if right.obj is ast.Var {
                if left_type.is_ptr() && !right.is_mut() && right_type.is_ptr() {
                    c.note('`${right.name}` is immutable, cannot have a mutable reference to an immutable object',
                        right.pos)
                    return false
                }
                if !right.obj.is_mut
                    && c.table.final_sym(right_type).kind in [.array, .array_fixed, .map] {
                    c.note('left-side of assignment expects a mutable reference, but variable `${right.name}` is immutable, declare it with `mut` to make it mutable or clone it',
                        right.pos)
                    return false
                }
            }
        }
        ast.IfExpr {
            for branch in right.branches {
                stmts := branch.stmts.filter(it is ast.ExprStmt)
                if stmts.len > 0 {
                    last_expr := stmts.last() as ast.ExprStmt
                    c.fail_if_immutable_to_mutable(left_type, right_type, last_expr.expr)
                }
            }
        }
        ast.MatchExpr {
            for branch in right.branches {
                stmts := branch.stmts.filter(it is ast.ExprStmt)
                if stmts.len > 0 {
                    last_expr := stmts.last() as ast.ExprStmt
                    c.fail_if_immutable_to_mutable(left_type, right_type, last_expr.expr)
                }
            }
        }
        ast.StructInit {
            typ_sym := c.table.sym(right.typ)
            for init_field in right.init_fields {
                if field_info := c.table.find_field_with_embeds(typ_sym, init_field.name) {
                    if field_info.is_mut {
                        if init_field.expr is ast.Ident && !init_field.expr.is_mut()
                            && init_field.typ.is_ptr() {
                            c.error('`${init_field.expr.name}` is immutable, cannot have a mutable reference to an immutable object',
                                init_field.pos)
                        } else if init_field.expr is ast.PrefixExpr {
                            if init_field.expr.op == .amp && init_field.expr.right is ast.Ident
                                && !init_field.expr.right.is_mut() {
                                c.error('`${init_field.expr.right.name}` is immutable, cannot have a mutable reference to an immutable object',
                                    init_field.expr.right.pos)
                            }
                        }
                    }
                }
            }
        }
        else {
            return true
        }
    }

    return true
}

// returns name and position of variable that needs write lock
// also sets `is_changed` to true (TODO update the name to reflect this?)
fn (mut c Checker) fail_if_immutable(mut expr ast.Expr) (string, token.Pos) {
    mut to_lock := '' // name of variable that needs lock
    mut pos := token.Pos{} // and its position
    mut explicit_lock_needed := false
    match mut expr {
        ast.CastExpr {
            if c.table.final_sym(c.unwrap_generic(expr.typ)).kind == .interface {
                mut inner_expr := expr.expr
                return c.fail_if_immutable(mut inner_expr)
            }
            return '', expr.pos
        }
        ast.ComptimeSelector {
            mut expr_left := expr.left
            if mut expr.left is ast.Ident && expr.left.obj is ast.Var {
                c.fail_if_immutable(mut expr_left)
            }
            return '', expr.pos
        }
        ast.Ident {
            if mut expr.obj is ast.Var {
                if !expr.obj.is_mut && !c.pref.translated && !c.file.is_translated
                    && !c.inside_unsafe {
                    if expr.obj.smartcasts.len > 0 {
                        c.error('cannot mutate `${expr.name}` in a non-mut smartcast, use `if mut ${expr.name} ...`',
                            expr.pos)
                    } else if c.inside_anon_fn {
                        c.error('the closure copy of `${expr.name}` is immutable, declare it with `mut` to make it mutable',
                            expr.pos)
                    } else {
                        c.error('`${expr.name}` is immutable, declare it with `mut` to make it mutable',
                            expr.pos)
                    }
                }
                expr.obj.is_changed = true
                if expr.obj.typ.share() == .shared_t {
                    if expr.name !in c.locked_names {
                        if c.locked_names.len > 0 || c.rlocked_names.len > 0 {
                            if expr.name in c.rlocked_names {
                                c.error('${expr.name} has an `rlock` but needs a `lock`', expr.pos)
                            } else {
                                c.error('${expr.name} must be added to the `lock` list above',
                                    expr.pos)
                            }
                        }
                        to_lock = expr.name
                        pos = expr.pos
                    }
                }
            } else if expr.obj is ast.ConstField && expr.name in c.const_names {
                if !c.pref.translated && c.mod != 'veb' {
                    // TODO: fix this in c2v, do not allow modification of all consts
                    // in translated code
                    c.error('cannot modify constant `${expr.name}`', expr.pos)
                }
            } else if expr.obj is ast.GlobalField && expr.obj.is_const {
                if !c.pref.translated && c.mod != 'veb' {
                    c.error('cannot modify constant `${expr.name}`', expr.pos)
                }
            }
        }
        ast.IndexExpr {
            if expr.left_type == 0 {
                return to_lock, pos
            }
            left_sym := c.table.sym(expr.left_type)
            if !c.inside_unsafe && left_sym.kind == .array
                && c.expr_is_mutable_alias_of_immutable_source(expr.left) {
                c.error('`${expr.left}` aliases mutable data from an immutable value, clone it first (or use `unsafe`)',
                    expr.left.pos())
                return '', expr.pos
            }
            mut elem_type := ast.no_type
            mut kind := ''
            match left_sym.info {
                ast.Array {
                    elem_type, kind = left_sym.info.elem_type, 'array'
                }
                ast.ArrayFixed {
                    elem_type, kind = left_sym.info.elem_type, 'fixed array'
                }
                ast.Map {
                    elem_type, kind = left_sym.info.value_type, 'map'
                }
                else {}
            }

            if elem_type.has_flag(.shared_f) {
                expr_name := ast.Expr(expr).str()
                if expr_name !in c.locked_names {
                    if c.locked_names.len > 0 || c.rlocked_names.len > 0 {
                        if expr_name in c.rlocked_names {
                            c.error('${expr_name} has an `rlock` but needs a `lock`',
                                expr.left.pos().extend(expr.pos))
                        } else {
                            c.error('${expr_name} must be added to the `lock` list above',
                                expr.left.pos().extend(expr.pos))
                        }
                    } else {
                        c.error('you have to create a handle and `lock` it to modify `shared` ${kind} element',
                            expr.left.pos().extend(expr.pos))
                    }
                    return '', expr.pos
                }
                return '', expr.pos
            }
            to_lock, pos = c.fail_if_immutable(mut expr.left)
        }
        ast.ParExpr {
            to_lock, pos = c.fail_if_immutable(mut expr.expr)
        }
        ast.PrefixExpr {
            if expr.op == .mul && expr.right is ast.Ident {
                // Do not fail if dereference is immutable:
                // `*x = foo()` doesn't modify `x`
            } else {
                to_lock, pos = c.fail_if_immutable(mut expr.right)
            }
        }
        ast.PostfixExpr {
            to_lock, pos = c.fail_if_immutable(mut expr.expr)
        }
        ast.SelectorExpr {
            if expr.expr_type == 0 {
                return '', expr.pos
            }
            scope_field := expr.scope.find_struct_field(smartcast_selector_expr_str(expr),
                expr.expr_type, expr.field_name)
            mut selector_smartcast_is_mut := false
            if scope_field != unsafe { nil } {
                selector_smartcast_is_mut = scope_field.is_mut
            }
            if !selector_smartcast_is_mut {
                expr_sym := c.table.sym(expr.expr_type)
                if field := c.table.find_field(expr_sym, expr.field_name) {
                    if field.is_mut {
                        if root_ident := expr.root_ident() {
                            selector_smartcast_is_mut = root_ident.is_mut()
                            if !selector_smartcast_is_mut {
                                if v := expr.scope.find_var(root_ident.name) {
                                    selector_smartcast_is_mut = v.is_mut
                                }
                            }
                        }
                    }
                }
            }
            if scope_field != unsafe { nil } && scope_field.smartcasts.len > 0
                && !selector_smartcast_is_mut && !c.pref.translated && !c.file.is_translated
                && !c.inside_unsafe {
                expr_str := expr.str()
                c.error('cannot mutate `${expr_str}` in a non-mut smartcast, use `if mut ${expr_str} ...`',
                    expr.pos)
            }
            // retrieve ast.Field
            if !c.ensure_type_exists(expr.expr_type, expr.pos) {
                return '', expr.pos
            }
            mut typ_sym := c.table.final_sym(c.unwrap_generic(expr.expr_type))
            match typ_sym.kind {
                .struct {
                    mut has_field := true
                    mut field_info := c.table.find_field_with_embeds(typ_sym, expr.field_name) or {
                        has_field = false
                        ast.StructField{}
                    }
                    if !has_field {
                        type_str := c.table.type_to_str(expr.expr_type)
                        c.error('unknown field `${type_str}.${expr.field_name}`', expr.pos)
                        return '', expr.pos
                    }
                    if field_info.typ.has_flag(.shared_f) {
                        expr_name := '${expr.expr}.${expr.field_name}'
                        if expr_name !in c.locked_names {
                            if c.locked_names.len > 0 || c.rlocked_names.len > 0 {
                                if expr_name in c.rlocked_names {
                                    c.error('${expr_name} has an `rlock` but needs a `lock`',
                                        expr.pos)
                                } else {
                                    c.error('${expr_name} must be added to the `lock` list above',
                                        expr.pos)
                                }
                                return '', expr.pos
                            }
                            to_lock = expr_name
                            pos = expr.pos
                        }
                    } else {
                        if !field_info.is_mut && !c.pref.translated && !c.file.is_translated {
                            type_str := c.table.type_to_str(expr.expr_type)
                            c.error('field `${expr.field_name}` of struct `${type_str}` is immutable',
                                expr.pos)
                        }
                        if field_info.is_mut && expr.expr_type.is_ptr() && !c.inside_unsafe
                            && c.expr_is_mutable_alias_of_immutable_source(expr.expr) {
                            expr_str := ast.Expr(expr).str()
                            c.error('`${expr_str}` aliases mutable data from an immutable value',
                                expr.pos)
                            return '', expr.pos
                        }
                        to_lock, pos = c.fail_if_immutable(mut expr.expr)
                    }
                    if to_lock != '' {
                        // No automatic lock for struct access
                        explicit_lock_needed = true
                    }
                }
                .interface {
                    interface_info := typ_sym.info as ast.Interface
                    mut field_info := interface_info.find_field(expr.field_name) or {
                        type_str := c.table.type_to_str(expr.expr_type)
                        c.error('unknown field `${type_str}.${expr.field_name}`', expr.pos)
                        return '', expr.pos
                    }
                    if !field_info.is_mut {
                        type_str := c.table.type_to_str(expr.expr_type)
                        c.error('field `${expr.field_name}` of interface `${type_str}` is immutable',
                            expr.pos)
                        return '', expr.pos
                    }
                    if expr.expr_type.is_ptr() && !c.inside_unsafe
                        && c.expr_is_mutable_alias_of_immutable_source(expr.expr) {
                        expr_str := ast.Expr(expr).str()
                        c.error('`${expr_str}` aliases mutable data from an immutable value',
                            expr.pos)
                        return '', expr.pos
                    }
                    c.fail_if_immutable(mut expr.expr)
                }
                .sum_type {
                    sumtype_info := typ_sym.info as ast.SumType
                    mut field_info := sumtype_info.find_sum_type_field(expr.field_name) or {
                        type_str := c.table.type_to_str(expr.expr_type)
                        c.error('unknown field `${type_str}.${expr.field_name}`', expr.pos)
                        return '', expr.pos
                    }
                    if !field_info.is_mut {
                        type_str := c.table.type_to_str(expr.expr_type)
                        c.error('field `${expr.field_name}` of sumtype `${type_str}` is immutable',
                            expr.pos)
                        return '', expr.pos
                    }
                    if expr.expr_type.is_ptr() && !c.inside_unsafe
                        && c.expr_is_mutable_alias_of_immutable_source(expr.expr) {
                        expr_str := ast.Expr(expr).str()
                        c.error('`${expr_str}` aliases mutable data from an immutable value',
                            expr.pos)
                        return '', expr.pos
                    }
                    c.fail_if_immutable(mut expr.expr)
                }
                .array, .string {
                    // should only happen in `builtin` and unsafe blocks
                    inside_builtin := c.file.mod.name == 'builtin'
                    if !inside_builtin && !c.inside_unsafe {
                        c.error('`${typ_sym.kind}` can not be modified', expr.pos)
                        return '', expr.pos
                    }
                }
                .aggregate, .placeholder, .generic_inst {
                    c.fail_if_immutable(mut expr.expr)
                }
                else {
                    c.error('unexpected symbol `${typ_sym.kind}`', expr.pos)
                    return '', expr.pos
                }
            }
        }
        ast.CallExpr {
            // TODO: should only work for builtin method
            if expr.name == 'slice' {
                to_lock, pos = c.fail_if_immutable(mut expr.left)
                if to_lock != '' {
                    // No automatic lock for array slicing (yet(?))
                    explicit_lock_needed = true
                }
            }
            if !c.inside_unsafe {
                source := c.call_expr_immutable_alias_source(expr)
                if source !is ast.EmptyExpr {
                    if source is ast.Ident && c.expr_is_immutable_source(source) {
                        c.error('`${source.name}` is immutable, cannot have a mutable reference to an immutable object',
                            source.pos)
                    } else {
                        c.error('`${expr}` aliases mutable data from an immutable value', expr.pos)
                    }
                    return '', expr.pos
                }
            }
        }
        ast.ArrayInit {
            c.error('array literal can not be modified', expr.pos)
            return '', expr.pos
        }
        ast.StructInit {
            return '', expr.pos
        }
        ast.InfixExpr {
            return '', expr.pos
        }
        ast.IfExpr {
            for mut branch in expr.branches {
                mut last_expr := (branch.stmts.last() as ast.ExprStmt).expr
                c.fail_if_immutable(mut last_expr)
            }
            return '', expr.pos
        }
        ast.AsCast {
            to_lock, pos = c.fail_if_immutable(mut expr.expr)
        }
        ast.UnsafeExpr {
            to_lock, pos = c.fail_if_immutable(mut expr.expr)
        }
        ast.Nil {
            return '', expr.pos
        }
        else {
            if !expr.is_pure_literal() {
                c.error('unexpected expression `${expr.type_name()}`', expr.pos())
                return '', expr.pos()
            }
        }
    }

    if explicit_lock_needed {
        c.error('`${to_lock}` is `shared` and needs explicit lock for `${expr.type_name()}`', pos)
        to_lock = ''
    }
    return to_lock, pos
}

fn (mut c Checker) resolve_method_for_concrete_type(method ast.Fn, typ_sym &ast.TypeSymbol) ast.Fn {
    mut resolved_method := method
    concrete_types := c.concrete_types_for_type_symbol(typ_sym)
    generic_names := c.generic_names_for_type_parent(typ_sym)
    if generic_names.len == 0 || generic_names.len != concrete_types.len {
        return resolved_method
    }
    if rt := c.table.convert_generic_type(resolved_method.return_type, generic_names,
        concrete_types)
    {
        resolved_method.return_type = rt
    }
    resolved_method.params = resolved_method.params.clone()
    for mut param in resolved_method.params {
        if pt := c.table.convert_generic_type(param.typ, generic_names, concrete_types) {
            param.typ = pt
        }
    }
    return resolved_method
}

fn (c &Checker) concrete_types_for_type_symbol(typ_sym &ast.TypeSymbol) []ast.Type {
    match typ_sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            mut concrete_types := typ_sym.info.concrete_types.clone()
            if concrete_types.len == 0
                && typ_sym.generic_types.len == typ_sym.info.generic_types.len
                && typ_sym.generic_types != typ_sym.info.generic_types {
                concrete_types = typ_sym.generic_types.clone()
            }
            return concrete_types
        }
        ast.GenericInst {
            return typ_sym.info.concrete_types.clone()
        }
        else {}
    }

    return []ast.Type{}
}

fn (c &Checker) generic_names_for_type_parent(typ_sym &ast.TypeSymbol) []string {
    match typ_sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            if !typ_sym.info.parent_type.has_flag(.generic) {
                return []string{}
            }
            parent_sym := c.table.sym(typ_sym.info.parent_type)
            match parent_sym.info {
                ast.Struct, ast.Interface, ast.SumType {
                    return parent_sym.info.generic_types.map(c.table.sym(it).name)
                }
                else {}
            }
        }
        ast.GenericInst {
            parent_sym := c.table.sym(ast.new_type(typ_sym.info.parent_idx))
            match parent_sym.info {
                ast.Struct, ast.Interface, ast.SumType {
                    return parent_sym.info.generic_types.map(c.table.sym(it).name)
                }
                else {}
            }
        }
        else {}
    }

    return []string{}
}

fn (mut c Checker) type_implements(typ ast.Type, interface_type ast.Type, pos token.Pos) bool {
    return c.type_implements_with_mut_receiver(typ, interface_type, pos, false)
}

fn (mut c Checker) type_implements_allowing_mut_receiver(typ ast.Type, interface_type ast.Type, pos token.Pos) bool {
    return c.type_implements_with_mut_receiver(typ, interface_type, pos, true)
}

fn (mut c Checker) type_implements_with_mut_receiver(typ ast.Type, interface_type ast.Type, pos token.Pos, allow_mut_receiver bool) bool {
    mut resolved_interface_type := c.unwrap_generic(interface_type)
    if typ == resolved_interface_type {
        return true
    }
    $if debug_interface_type_implements ? {
        eprintln('> type_implements typ: ${typ.debug()} (`${c.table.type_to_str(typ)}`) | inter_typ: ${resolved_interface_type.debug()} (`${c.table.type_to_str(resolved_interface_type)}`)')
    }
    utyp := c.unwrap_generic(typ)
    styp := c.table.type_to_str(utyp)
    typ_sym := c.table.sym(utyp)
    mut inter_sym := c.table.final_sym(resolved_interface_type)
    if !inter_sym.is_pub && inter_sym.mod !in [typ_sym.mod, c.mod] && typ_sym.mod != 'builtin' {
        c.error('`${styp}` cannot implement private interface `${inter_sym.name}` of other module',
            pos)
        return false
    }

    // small hack for JS.Any type. Since `any` in regular V is getting deprecated we have our own JS.Any type for JS backend.
    if typ_sym.name == 'JS.Any' {
        return true
    }
    if inter_sym.kind == .interface && c.table.get_attrs(inter_sym).any(it.name == 'single_impl') {
        if pos.file_idx != -1 {
            c.error('cannot use `${styp}` as `${inter_sym.name}` without an explicit cast (e.g. `${inter_sym.name}(value)`)',
                pos)
        }
        return false
    }
    if typ_sym.kind == .function && inter_sym.name != 'JS.Any' {
        c.error('cannot implement interface `${inter_sym.name}` using function', pos)
        return false
    }
    if mut inter_sym.info is ast.Interface {
        mut generic_type := resolved_interface_type
        mut generic_info := inter_sym.info
        if inter_sym.info.parent_type.has_flag(.generic) && (inter_sym.info.concrete_types.len == 0
            || inter_sym.info.concrete_types.any(it.has_flag(.generic))) {
            parent_sym := c.table.sym(inter_sym.info.parent_type)
            if parent_sym.info is ast.Interface {
                generic_type = inter_sym.info.parent_type
                generic_info = parent_sym.info
            }
        }
        mut inferred_type := resolved_interface_type
        is_fully_concrete := inter_sym.info.concrete_types.len > 0
            && !inter_sym.info.concrete_types.any(it.has_flag(.generic))
        if generic_info.is_generic && !is_fully_concrete {
            inferred_type = c.unwrap_generic_interface(typ, generic_type, pos)
            if inferred_type == 0 {
                return false
            }
        }
        if inter_sym.info.is_generic && !is_fully_concrete {
            if inferred_type == resolved_interface_type {
                // terminate early, since otherwise we get an infinite recursion/segfault:
                return false
            }
            return c.type_implements_with_mut_receiver(typ, inferred_type, pos, allow_mut_receiver)
        }
    }
    if inter_sym.kind == .generic_inst {
        generic_inst_info := inter_sym.info as ast.GenericInst
        if !generic_inst_info.concrete_types.any(it.has_flag(.generic)) {
            c.table.generic_insts_to_concrete()
            inter_sym = c.table.final_sym(resolved_interface_type)
        }
    }
    // do not check the same type more than once
    if mut inter_sym.info is ast.Interface {
        if inter_sym.info.has_implementor(utyp, allow_mut_receiver) {
            return true
        }
    }
    if utyp.idx() == resolved_interface_type.idx() {
        // same type -> already casted to the interface
        return true
    }
    if resolved_interface_type.idx() == ast.error_type_idx && utyp.idx() == ast.none_type_idx {
        // `none` "implements" the Error interface
        return true
    }
    is_interface_upcast := typ_sym.kind == .interface && inter_sym.kind == .interface
        && !styp.starts_with('JS.') && !inter_sym.name.starts_with('JS.')
    if is_interface_upcast {
        if mut inter_sym.info is ast.Interface {
            if inter_sym.info.methods.len == 0 && inter_sym.info.fields.len == 0
                && inter_sym.info.embeds.len == 0 {
                // Preserve the source interface's known variants so the empty interface keeps
                // the original dynamic type for later `is`/`as` checks and conversions.
                mut source_types := []ast.Type{}
                match typ_sym.info {
                    ast.Interface {
                        source_types = typ_sym.info.implementor_types(true)
                    }
                    else {}
                }

                mut target_variants := c.table.iface_types[inter_sym.name]
                for variant in source_types {
                    variant_sym := c.table.sym(ast.mktyp(variant))
                    if variant in [ast.nil_type, ast.none_type] || variant_sym.kind == .interface {
                        continue
                    }
                    if !inter_sym.info.types.contains(variant) {
                        inter_sym.info.types << variant
                    }
                    if variant !in target_variants {
                        target_variants << variant
                    }
                }
                c.table.iface_types[inter_sym.name] = target_variants
                if !inter_sym.info.types.contains(ast.voidptr_type) {
                    inter_sym.info.types << ast.voidptr_type
                }
                return true
            }
        }
        if !c.table.interface_inherits_interface(utyp, resolved_interface_type) {
            c.error('cannot implement interface `${inter_sym.name}` with a different interface `${styp}`',
                pos)
            return false
        }
    }
    interface_sym := c.table.sym(resolved_interface_type)
    mut interface_generic_names := []string{}
    mut interface_concrete_types := []ast.Type{}
    mut interface_info := ast.Interface{}
    mut has_resolved_interface_info := false
    if interface_sym.kind == .interface && interface_sym.info is ast.Interface {
        // For concrete generic interfaces (has concrete_types, not generic, has parent),
        // resolve methods from the root generic parent interface to get correct method
        // signatures. The methods stored in the concrete interface's info may have been
        // resolved with wrong type parameters for nested generic types.
        if interface_sym.info.concrete_types.len > 0
            && !interface_sym.info.concrete_types.any(it.has_flag(.generic))
            && interface_sym.info.parent_type != 0 {
            mut root_type := interface_sym.info.parent_type
            for {
                rs := c.table.sym(root_type)
                if rs.info is ast.Interface {
                    if rs.info.parent_type != 0 {
                        root_type = rs.info.parent_type
                    } else {
                        break
                    }
                } else {
                    break
                }
            }
            root_sym := c.table.sym(root_type)
            if root_sym.info is ast.Interface {
                if root_sym.info.is_generic {
                    interface_info = root_sym.info
                    interface_generic_names = interface_info.generic_types.map(c.table.sym(it).name)
                    interface_concrete_types = interface_sym.info.concrete_types.clone()
                    has_resolved_interface_info = true
                }
            }
        }
        if !has_resolved_interface_info {
            interface_info = interface_sym.info
            interface_generic_names = interface_info.generic_types.map(c.table.sym(it).name)
            interface_concrete_types = interface_info.concrete_types.clone()
            if interface_concrete_types.len == 0
                && interface_sym.generic_types.len == interface_generic_names.len {
                interface_concrete_types = interface_sym.generic_types.clone()
            }
            has_resolved_interface_info = true
        }
    } else if interface_sym.kind == .generic_inst {
        parent_sym := c.table.sym(ast.new_type((interface_sym.info as ast.GenericInst).parent_idx))
        if parent_sym.info is ast.Interface {
            interface_info = parent_sym.info
            interface_generic_names = interface_info.generic_types.map(c.table.sym(it).name)
            interface_concrete_types =
                (interface_sym.info as ast.GenericInst).concrete_types.clone()
            has_resolved_interface_info = true
        }
    }
    imethods := if has_resolved_interface_info {
        mut methods := []ast.Fn{}
        for imethod in interface_info.methods {
            mut resolved_method := imethod
            if interface_generic_names.len == interface_concrete_types.len {
                if resolved_return_type := c.table.convert_generic_type(imethod.return_type,
                    interface_generic_names, interface_concrete_types)
                {
                    resolved_method.return_type = resolved_return_type
                }
                mut resolved_params := resolved_method.params.clone()
                for i in 0 .. resolved_params.len {
                    if resolved_param_type := c.table.convert_generic_type(resolved_params[i].typ,
                        interface_generic_names, interface_concrete_types)
                    {
                        resolved_params[i].typ = resolved_param_type
                    }
                }
                resolved_method.params = resolved_params
            }
            methods << resolved_method
        }
        methods
    } else {
        inter_sym.methods
    }
    mut requires_mut_receiver := false
    // voidptr is an escape hatch, it should be allowed to be passed
    if utyp != ast.voidptr_type && utyp != ast.nil_type && !(interface_type.has_flag(.option)
        && utyp == ast.none_type) {
        mut are_methods_implemented := true

        // Verify methods
        for imethod in imethods {
            if c.table.is_compatible_auto_str_method(imethod) && utyp.nr_muls() == 0
                && typ_sym.kind == .char {
                c.error("`${styp}` doesn't implement method `${imethod.name}` of interface `${inter_sym.name}`",
                    pos)
                are_methods_implemented = false
                continue
            }
            mut method := typ_sym.find_method_with_generic_parent(imethod.name) or {
                c.table.find_method_with_embeds(typ_sym, imethod.name) or {
                    if c.table.type_has_implicit_str_method(utyp, imethod) {
                        are_methods_implemented = true
                        continue
                    }
                    c.error("`${styp}` doesn't implement method `${imethod.name}` of interface `${inter_sym.name}`",
                        pos)
                    are_methods_implemented = false
                    continue
                }
            }
            method = c.resolve_method_for_concrete_type(method, typ_sym)

            mut checked_method := ast.Fn{
                ...imethod
                params: imethod.params.clone()
            }
            mut used_mut_receiver := false
            if allow_mut_receiver && checked_method.params.len > 0 && method.params.len > 0
                && !checked_method.params[0].is_mut && method.params[0].is_mut {
                checked_method.params[0] = ast.Param{
                    ...checked_method.params[0]
                    is_mut: true
                }
                used_mut_receiver = true
            }
            msg := c.table.is_same_method(checked_method, method)
            if msg.len > 0 {
                sig := c.table.fn_signature(imethod, skip_receiver: false)
                typ_sig := c.table.fn_signature(method, skip_receiver: false)
                c.add_error_detail('${inter_sym.name} has `${sig}`')
                c.add_error_detail('         ${typ_sym.name} has `${typ_sig}`')
                c.error('`${styp}` incorrectly implements method `${imethod.name}` of interface `${inter_sym.name}`: ${msg}',
                    pos)
                return false
            }
            if used_mut_receiver {
                requires_mut_receiver = true
            }
        }

        if !are_methods_implemented {
            return false
        }
    }
    // Verify fields
    if mut inter_sym.info is ast.Interface {
        for ifield in inter_sym.info.fields {
            if field := c.table.find_field_with_embeds(typ_sym, ifield.name) {
                if ifield.typ != field.typ {
                    exp := c.table.type_to_str(ifield.typ)
                    got := c.table.type_to_str(field.typ)
                    c.error('`${styp}` incorrectly implements field `${ifield.name}` of interface `${inter_sym.name}`, expected `${exp}`, got `${got}`',
                        pos)
                    return false
                } else if ifield.is_mut && !(field.is_mut || field.is_global) {
                    c.error('`${styp}` incorrectly implements interface `${inter_sym.name}`, field `${ifield.name}` must be mutable',
                        pos)
                    return false
                }
                continue
            }
            // voidptr is an escape hatch, it should be allowed to be passed
            if utyp != ast.voidptr_type && utyp != ast.nil_type {
                c.error("`${styp}` doesn't implement field `${ifield.name}` of interface `${inter_sym.name}`",
                    pos)
            }
        }
        if !is_interface_upcast && utyp != ast.voidptr_type && utyp != ast.nil_type
            && utyp != ast.none_type {
            if requires_mut_receiver {
                if !inter_sym.info.mut_types.contains(utyp) {
                    inter_sym.info.mut_types << utyp
                }
            } else if !inter_sym.info.types.contains(utyp) {
                inter_sym.info.types << utyp
            }
        }
        if !inter_sym.info.types.contains(ast.voidptr_type) {
            inter_sym.info.types << ast.voidptr_type
        }
    } else if has_resolved_interface_info {
        for ifield in interface_info.fields {
            mut resolved_ifield := ifield
            if interface_generic_names.len == interface_concrete_types.len {
                if ft := c.table.convert_generic_type(ifield.typ, interface_generic_names,
                    interface_concrete_types)
                {
                    resolved_ifield.typ = ft
                }
            }
            if field := c.table.find_field_with_embeds(typ_sym, resolved_ifield.name) {
                if resolved_ifield.typ != field.typ {
                    exp := c.table.type_to_str(resolved_ifield.typ)
                    got := c.table.type_to_str(field.typ)
                    c.error('`${styp}` incorrectly implements field `${resolved_ifield.name}` of interface `${inter_sym.name}`, expected `${exp}`, got `${got}`',
                        pos)
                    return false
                } else if resolved_ifield.is_mut && !(field.is_mut || field.is_global) {
                    c.error('`${styp}` incorrectly implements interface `${inter_sym.name}`, field `${resolved_ifield.name}` must be mutable',
                        pos)
                    return false
                }
                continue
            }
            if utyp != ast.voidptr_type && utyp != ast.nil_type {
                c.error("`${styp}` doesn't implement field `${resolved_ifield.name}` of interface `${inter_sym.name}`",
                    pos)
            }
        }
    }
    return true
}

// helper for expr_or_block_err
fn is_field_to_description(expr_name string, is_field bool) string {
    return if is_field {
        'field `${expr_name}` is not'
    } else {
        'function `${expr_name}` does not return'
    }
}

fn (mut c Checker) expr_or_block_err(kind ast.OrKind, expr_name string, pos token.Pos, is_field bool) {
    match kind {
        .absent {
            // do nothing, most common case; do not be tempted to move the call to is_field_to_description above it, since that will slow it down
        }
        .block {
            obj_does_not_return_or_is_not := is_field_to_description(expr_name, is_field)
            c.error('unexpected `or` block, the ${obj_does_not_return_or_is_not} an Option or a Result',
                pos)
        }
        .propagate_option {
            obj_does_not_return_or_is_not := is_field_to_description(expr_name, is_field)
            c.error('unexpected `?`, the ${obj_does_not_return_or_is_not} an Option', pos)
        }
        .propagate_result {
            obj_does_not_return_or_is_not := is_field_to_description(expr_name, is_field)
            c.error('unexpected `!`, the ${obj_does_not_return_or_is_not} a Result', pos)
        }
    }
}

// return the actual type of the expression, once the result or option type is handled
fn (mut c Checker) check_expr_option_or_result_call(expr ast.Expr, ret_type ast.Type) ast.Type {
    if ret_type.idx() == 0 {
        return ret_type
    }
    match expr {
        ast.CallExpr {
            mut expr_ret_type := expr.return_type
            if expr_ret_type != 0 && c.table.sym(expr_ret_type).kind == .alias {
                unaliased_ret_type := c.table.unaliased_type(expr_ret_type)
                if unaliased_ret_type.has_option_or_result() {
                    expr_ret_type = unaliased_ret_type
                }
            }
            // var with option function
            if expr.is_fn_var && expr.fn_var_type.has_option_or_result()
                && expr.or_block.kind == .absent {
                ret_sym := c.table.sym(expr.fn_var_type)
                if expr.fn_var_type.has_flag(.option) {
                    c.error('type `?${ret_sym.name}` is an Option, it must be unwrapped first',
                        expr.pos)
                } else {
                    c.error('type `?${ret_sym.name}` is an Result, it must be unwrapped first',
                        expr.pos)
                }
            }
            if expr_ret_type.has_option_or_result() {
                if expr.or_block.kind == .absent {
                    ret_sym := c.table.sym(expr_ret_type)
                    if expr_ret_type.has_flag(.result)
                        || (expr_ret_type.has_flag(.option) && ret_sym.kind == .multi_return) {
                        ret_typ_tok := if expr_ret_type.has_flag(.option) { '?' } else { '!' }
                        if c.inside_defer {
                            c.error('${expr.name}() returns `${ret_typ_tok}${ret_sym.name}`, so it should have an `or {}` block at the end',
                                expr.pos)
                        } else {
                            c.error('${expr.name}() returns `${ret_typ_tok}${ret_sym.name}`, so it should have either an `or {}` block, or `${ret_typ_tok}` at the end',
                                expr.pos)
                        }
                    }
                } else {
                    last_cur_or_expr := c.cur_or_expr
                    c.cur_or_expr = &expr.or_block
                    or_block_value_type := expr_ret_type.clear_option_and_result()
                    or_block_unaliased_value_type :=
                        c.table.fully_unaliased_type(or_block_value_type)
                    mut or_block_ret_type := or_block_value_type
                    if ret_type == ast.void_type {
                        or_block_ret_type = ret_type
                    } else if ret_type.has_option_or_result() {
                        ret_value_type :=
                            c.table.fully_unaliased_type(ret_type).clear_option_and_result()
                        if ret_value_type == or_block_unaliased_value_type {
                            or_block_ret_type = ret_type
                        }
                    }
                    c.check_or_expr(expr.or_block, or_block_ret_type, expr_ret_type, expr)
                    c.cur_or_expr = last_cur_or_expr
                }
                return if expr.or_block.kind == .absent {
                    ret_type.clear_flag(.result)
                } else {
                    ret_type.clear_flag(.option).clear_flag(.result)
                }
            } else {
                c.expr_or_block_err(expr.or_block.kind, expr.name, expr.or_block.pos, false)
            }
        }
        ast.SelectorExpr {
            if c.table.sym(ret_type).kind != .chan {
                if expr.typ.has_option_or_result() {
                    with_modifier_kind := if expr.typ.has_flag(.option) {
                        'an Option'
                    } else {
                        'a Result'
                    }
                    with_modifier := if expr.typ.has_flag(.option) { '?' } else { '!' }
                    if expr.typ.has_flag(.result) && expr.or_block.kind == .absent {
                        if c.inside_defer {
                            c.error('field `${expr.field_name}` is ${with_modifier_kind}, so it should have an `or {}` block at the end',
                                expr.pos)
                        } else {
                            c.error('field `${expr.field_name}` is ${with_modifier_kind}, so it should have either an `or {}` block, or `${with_modifier}` at the end',
                                expr.pos)
                        }
                    } else {
                        if expr.or_block.kind != .absent {
                            last_cur_or_expr := c.cur_or_expr
                            c.cur_or_expr = &expr.or_block
                            or_block_value_type := expr.typ.clear_option_and_result()
                            or_block_unaliased_value_type :=
                                c.table.fully_unaliased_type(or_block_value_type)
                            mut or_block_ret_type := or_block_value_type
                            if ret_type.has_option_or_result() {
                                ret_value_type :=
                                    c.table.fully_unaliased_type(ret_type).clear_option_and_result()
                                if ret_value_type == or_block_unaliased_value_type {
                                    or_block_ret_type = ret_type
                                }
                            }
                            c.check_or_expr(expr.or_block, or_block_ret_type, expr.typ, expr)
                            c.cur_or_expr = last_cur_or_expr
                        }
                    }
                    return if expr.or_block.kind == .absent {
                        ret_type.clear_flag(.result)
                    } else {
                        ret_type.clear_flag(.option).clear_flag(.result)
                    }
                } else {
                    c.expr_or_block_err(expr.or_block.kind, expr.field_name, expr.or_block.pos,
                        true)
                }
            }
        }
        ast.IndexExpr {
            if expr.or_expr.kind != .absent {
                // When the IndexExpr has already been processed by index_expr()
                // (indicated by expr.typ being set), skip re-checking the or block
                // since it was already validated. This prevents the duplicate call
                // from assign.v from rejecting valid `none` in option map or blocks.
                if expr.typ != 0 {
                    if ret_type.has_flag(.option)
                        && index_or_block_returns_option_value(expr.or_expr) {
                        return ret_type
                    }
                    return ret_type.clear_option_and_result()
                }
                mut return_none_or_error := false
                if expr.or_expr.stmts.len > 0 {
                    last_stmt := expr.or_expr.stmts.last()
                    if last_stmt is ast.ExprStmt {
                        if c.inside_return && last_stmt.typ in [ast.none_type, ast.error_type] {
                            return_none_or_error = true
                        }
                    }
                }
                if return_none_or_error {
                    c.check_expr_option_or_result_call(expr.or_expr, c.table.cur_fn.return_type)
                } else {
                    last_cur_or_expr := c.cur_or_expr
                    c.cur_or_expr = &expr.or_expr
                    c.check_or_expr(expr.or_expr, ret_type, ret_type.set_flag(.result), expr)
                    c.cur_or_expr = last_cur_or_expr
                }
                // When the index expression is expected to produce an option and the
                // or block returns `none`/`?T`, preserve the option type.
                if ret_type.has_flag(.option) && index_or_block_returns_option_value(expr.or_expr) {
                    return ret_type
                }
                return ret_type.clear_option_and_result()
            } else if expr.left is ast.SelectorExpr && expr.left_type.has_option_or_result() {
                with_modifier_kind := if expr.left_type.has_flag(.option) {
                    'an Option'
                } else {
                    'a Result'
                }
                with_modifier := if expr.left_type.has_flag(.option) { '?' } else { '!' }
                c.error('field `${expr.left.field_name}` is ${with_modifier_kind}, so it should have either an `or {}` block, or `${with_modifier}` at the end',
                    expr.left.pos)
            }
        }
        ast.CastExpr {
            c.check_expr_option_or_result_call(expr.expr, ret_type)
        }
        ast.AsCast {
            c.check_expr_option_or_result_call(expr.expr, ret_type)
        }
        ast.ParExpr {
            c.check_expr_option_or_result_call(expr.expr, ret_type)
        }
        ast.InfixExpr {
            left_ret_type := if expr.left_type != 0 { expr.left_type } else { ret_type }
            right_ret_type := if expr.right_type != 0 { expr.right_type } else { ret_type }
            c.check_expr_option_or_result_call(expr.left, left_ret_type)
            c.check_expr_option_or_result_call(expr.right, right_ret_type)
        }
        else {}
    }

    return ret_type
}

fn index_or_block_returns_option_value(or_expr ast.OrExpr) bool {
    if or_expr.stmts.len == 0 {
        return false
    }
    last := or_expr.stmts.last()
    if last is ast.ExprStmt {
        return last.expr is ast.None || last.typ.has_flag(.option)
    }
    return false
}

fn (mut c Checker) index_or_expr_expected_type(value_type ast.Type, expected_type ast.Type) ast.Type {
    expected_unwrapped_type := c.unwrap_generic(expected_type)
    if expected_unwrapped_type.has_flag(.option) {
        expected_value_type :=
            c.table.fully_unaliased_type(expected_unwrapped_type).clear_option_and_result()
        unwrapped_value_type := c.table.fully_unaliased_type(value_type).clear_option_and_result()
        if expected_value_type == unwrapped_value_type {
            return expected_type
        }
    }
    return value_type
}

fn (mut c Checker) expr_unhandled_option_type(expr ast.Expr) ast.Type {
    match expr {
        ast.Ident {
            if expr.or_expr.kind == .absent && expr.info is ast.IdentVar {
                return c.type_resolver.get_type_or_default(expr, expr.info.typ)
            }
        }
        ast.CallExpr {
            if expr.or_block.kind == .absent {
                return expr.return_type
            }
        }
        ast.SelectorExpr {
            if expr.or_block.kind == .absent {
                return expr.typ
            }
        }
        ast.IndexExpr {
            if expr.or_expr.kind == .absent {
                return expr.typ
            }
        }
        ast.ParExpr {
            return c.expr_unhandled_option_type(expr.expr)
        }
        else {}
    }

    return ast.void_type
}

fn (mut c Checker) check_or_expr(node ast.OrExpr, ret_type ast.Type, expr_return_type ast.Type, expr ast.Expr) {
    if node.kind == .propagate_option {
        if c.table.cur_fn != unsafe { nil } && !c.table.cur_fn.return_type.has_flag(.option)
            && !c.table.cur_fn.is_main && !c.table.cur_fn.is_test && !c.inside_const {
            c.add_instruction_for_option_type()
            if expr is ast.Ident {
                c.error('to propagate the Option, `${c.table.cur_fn.name}` must return an Option type',
                    expr.pos)
            } else {
                c.error('to propagate the call, `${c.table.cur_fn.name}` must return an Option type',
                    node.pos)
            }
        }
        if expr !in [ast.Ident, ast.SelectorExpr] && !expr_return_type.has_flag(.option) {
            if expr_return_type.has_flag(.result) {
                c.error('propagating a Result like an Option is deprecated, use `foo()!` instead of `foo()?`',
                    node.pos)
            } else {
                c.error('to propagate an Option, the call must also return an Option type',
                    node.pos)
            }
        }
        return
    }
    if node.kind == .propagate_result {
        if c.table.cur_fn != unsafe { nil } && !c.table.cur_fn.return_type.has_flag(.result)
            && !c.table.cur_fn.is_main && !c.table.cur_fn.is_test && !c.inside_const {
            c.add_instruction_for_result_type()
            c.error('to propagate the call, `${c.table.cur_fn.name}` must return a Result type',
                node.pos)
        }
        if !expr_return_type.has_flag(.result) {
            c.error('to propagate a Result, the call must also return a Result type', node.pos)
        }
        return
    }
    if node.stmts.len == 0 {
        if expr is ast.CallExpr && expr.is_return_used {
            // x := f() or {}, || f() or {} etc
            c.error('expression requires a non empty `or {}` block', node.pos)
        } else if expr !is ast.CallExpr && ret_type != ast.void_type {
            // _ := sql db {... } or { }
            c.error('expression requires a non empty `or {}` block', node.pos)
        }
        // allow `f() or {}`
        return
    } else if !node.err_used {
        if err_var := node.scope.find_var('err') {
            c.cur_or_expr.err_used = err_var.is_used
        }
    }
    mut valid_stmts := node.stmts.filter(it !is ast.SemicolonStmt)
    mut last_stmt := if valid_stmts.len > 0 { valid_stmts.last() } else { node.stmts.last() }
    if !node.err_used && c.cur_or_expr != unsafe { nil } {
        if last_stmt is ast.ExprStmt {
            if last_stmt.expr is ast.Ident && last_stmt.expr.name == 'err' {
                c.cur_or_expr.err_used = true
            }
        }
    }
    allow_none_as_option_value := expr is ast.IndexExpr && ret_type.has_flag(.option)
    default_or_type := if expr is ast.IndexExpr && ret_type.has_flag(.option) {
        ret_type
    } else {
        expr_return_type.clear_option_and_result()
    }
    if expr !is ast.CallExpr || (expr is ast.CallExpr && expr.is_return_used) {
        // requires a block returning an unwrapped type of expr return type
        c.check_or_last_stmt(mut last_stmt, ret_type, default_or_type, allow_none_as_option_value)
    } else {
        // allow f() or { var = 123 }
        c.check_or_last_stmt(mut last_stmt, ast.void_type, default_or_type,
            allow_none_as_option_value)
    }
}

fn (mut c Checker) check_or_last_stmt(mut stmt ast.Stmt, ret_type ast.Type, default_or_type ast.Type, allow_none_as_option_value bool) {
    if ret_type != ast.void_type {
        match mut stmt {
            ast.ExprStmt {
                c.expected_type = ret_type
                c.expected_or_type = default_or_type
                if stmt.expr is ast.None && allow_none_as_option_value
                    && default_or_type.has_flag(.option) {
                    // `none` is valid when the `or` block itself is expected to return an Option.
                    return
                }
                last_stmt_typ := c.expr(mut stmt.expr)
                stmt.typ = last_stmt_typ
                if last_stmt_typ.has_flag(.option) || last_stmt_typ == ast.none_type {
                    if stmt.expr in [ast.Ident, ast.SelectorExpr, ast.CallExpr, ast.None, ast.CastExpr]
                        && !(last_stmt_typ == ast.none_type && allow_none_as_option_value
                        && default_or_type.has_flag(.option)) && !(last_stmt_typ.has_flag(.option)
                        && allow_none_as_option_value && default_or_type.has_flag(.option))
                        && !(last_stmt_typ == ast.none_type && c.inside_return
                        && ret_type.has_flag(.option)) {
                        expected_type_name := c.table.type_to_str(default_or_type)
                        got_type_name := c.table.type_to_str(last_stmt_typ)
                        c.error('`or` block must provide a value of type `${expected_type_name}`, not `${got_type_name}`',
                            stmt.expr.pos())
                        return
                    }
                }

                c.expected_or_type = ast.void_type
                // A multi-return `or {}` default may supply a plain `T` element where the
                // expected slot is `?T`; the or-block codegen wraps it (see `concat_expr`'s
                // `inside_or_block` path), so allow that promotion explicitly here. The
                // strict `check_types` multi-return check above otherwise rejects it.
                type_fits := (c.check_types(last_stmt_typ, ret_type)
                    && last_stmt_typ.nr_muls() == ret_type.nr_muls())
                    || c.can_use_expected_multi_return_expr_type(last_stmt_typ, ret_type, stmt.expr)
                is_noreturn := is_noreturn_callexpr(stmt.expr)
                if type_fits || is_noreturn {
                    return
                }
                if stmt.typ == ast.void_type {
                    if mut stmt.expr is ast.IfExpr {
                        for mut branch in stmt.expr.branches {
                            if branch.stmts.len > 0 {
                                mut stmt_ := branch.stmts.last()
                                c.check_or_last_stmt(mut stmt_, ret_type, default_or_type,
                                    allow_none_as_option_value)
                            }
                        }
                        return
                    } else if mut stmt.expr is ast.MatchExpr {
                        for mut branch in stmt.expr.branches {
                            if branch.stmts.len > 0 {
                                mut stmt_ := branch.stmts.last()
                                c.check_or_last_stmt(mut stmt_, ret_type, default_or_type,
                                    allow_none_as_option_value)
                            }
                        }
                        return
                    }
                    expected_type_name := c.table.type_to_str(default_or_type)
                    c.error('`or` block must provide a default value of type `${expected_type_name}`, or return/continue/break or call a @[noreturn] function like panic(err) or exit(1)',
                        stmt.expr.pos())
                } else {
                    if ret_type.is_ptr() && last_stmt_typ.is_pointer()
                        && c.table.sym(last_stmt_typ).kind == .voidptr {
                        return
                    }
                    if last_stmt_typ == ast.none_type_idx && allow_none_as_option_value
                        && default_or_type.has_flag(.option) {
                        return
                    }
                    // allow returning a custom error type in `or {}` block of a result function
                    if ret_type.has_flag(.result) {
                        last_sym := c.table.sym(last_stmt_typ)
                        if last_sym.kind == .struct {
                            if last_sym.info is ast.Struct {
                                if last_sym.info.embeds.any(c.table.type_to_str(it) == 'Error') {
                                    return
                                }
                            }
                        }
                    }
                    type_name := c.table.type_to_str(last_stmt_typ)
                    expected_type_name := c.table.type_to_str(default_or_type)
                    if default_or_type.has_flag(.generic) {
                        return
                    }
                    c.error('wrong return type `${type_name}` in the `or {}` block, expected `${expected_type_name}`',
                        stmt.expr.pos())
                }
            }
            ast.BranchStmt {
                if stmt.kind !in [.key_continue, .key_break] {
                    c.error('only break/continue is allowed as a branch statement in the end of an `or {}` block',
                        stmt.pos)
                    return
                }
            }
            ast.Return {}
            else {
                if stmt !is ast.AssertStmt || c.inside_or_block_value {
                    expected_type_name := c.table.type_to_str(default_or_type)
                    c.error('last statement in the `or {}` block should be an expression of type `${expected_type_name}` or exit parent scope',
                        stmt.pos)
                }
            }
        }
    } else if mut stmt is ast.ExprStmt {
        match mut stmt.expr {
            ast.IfExpr {
                for mut branch in stmt.expr.branches {
                    if branch.stmts.len > 0 {
                        mut stmt_ := branch.stmts.last()
                        c.check_or_last_stmt(mut stmt_, ret_type, default_or_type,
                            allow_none_as_option_value)
                    }
                }
            }
            ast.MatchExpr {
                for mut branch in stmt.expr.branches {
                    if branch.stmts.len > 0 {
                        mut stmt_ := branch.stmts.last()
                        c.check_or_last_stmt(mut stmt_, ret_type, default_or_type,
                            allow_none_as_option_value)
                    }
                }
            }
            else {
                if stmt.typ == ast.void_type || default_or_type == ast.void_type {
                    return
                }
                if is_noreturn_callexpr(stmt.expr) {
                    return
                }
                if c.check_types(stmt.typ, default_or_type) {
                    if stmt.typ.is_ptr() == default_or_type.is_ptr()
                        || (default_or_type.is_ptr() && stmt.typ.is_pointer()
                        && c.table.sym(stmt.typ).kind == .voidptr) {
                        return
                    }
                }
                if default_or_type.has_flag(.generic) {
                    return
                }
                // opt_returning_string() or { ... 123 }
                type_name := c.table.type_to_str(stmt.typ)
                expr_return_type_name := c.table.type_to_str(default_or_type)
                c.error('the default expression type in the `or` block should be `${expr_return_type_name}`, instead you gave a value of type `${type_name}`',
                    stmt.expr.pos())
            }
        }
    }
}

fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
    prevent_sum_type_unwrapping_once := c.prevent_sum_type_unwrapping_once
    c.prevent_sum_type_unwrapping_once = false

    // T.name, typeof(expr).name
    mut name_type := 0
    mut node_expr := node.expr
    match mut node.expr {
        ast.Ident {
            name := node.expr.name
            valid_generic := util.is_generic_type_name(name) && c.table.cur_fn != unsafe { nil }
                && name in c.table.cur_fn.generic_names
            if valid_generic {
                name_type = c.table.find_type(name).set_flag(.generic)
            }
        }
        ast.TypeOf {
            // TODO: fix this weird case, since just `typeof(x)` is `string`, but `|typeof(x).| propertyname` should be the actual type,
            // so that we can get other metadata properties of the type, depending on `propertyname` (one of `name` or `idx` for now).
            // A better alternative would be a new `meta(x).propertyname`, that does not have a `meta(x)` case (an error),
            // or if it does, it should be a normal constant struct value, just filled at comptime.
            c.expr(mut node_expr)
            name_type = node.expr.typ
        }
        ast.AsCast {
            c.add_error_detail('for example `(${node.expr.expr} as ${c.table.type_to_str(node.expr.typ)}).${node.field_name}`')
            c.error('indeterminate `as` cast, use parenthesis to clarity', node.expr.pos)
        }
        else {}
    }

    if name_type > 0 {
        node.name_type = name_type
        match node.gkind_field {
            .name {
                return ast.string_type
            }
            .unaliased_typ, .typ, .indirections {
                return ast.int_type
            }
            else {
                if node.field_name == 'name' {
                    return ast.string_type
                } else if node.field_name in ['idx', 'typ', 'unaliased_typ', 'key_type', 'value_type',
                    'element_type', 'pointee_type', 'payload_type'] {
                    return ast.int_type
                } else if node.field_name == 'variant_types' {
                    return ast.new_type(c.table.find_or_register_array(ast.int_type))
                } else if node.field_name == 'indirections' {
                    return ast.int_type
                }
                c.error('invalid field `.${node.field_name}` for type `${node.expr}`', node.pos)
                return ast.string_type
            }
        }
    }
    if is_array_init_type_expr_field(node.field_name) && c.is_comptime_type_expr(node.expr) {
        mut type_expr := node.expr
        base_type := c.comptime_call_type_expr_type(mut type_expr)
        node.expr = type_expr
        resolved := c.type_resolver.typeof_field_type(base_type, node.field_name)
        if resolved != ast.no_type {
            node.name_type = base_type
            if node.field_name == 'variant_types' {
                return ast.new_type(c.table.find_or_register_array(ast.int_type))
            }
            return ast.int_type
        }
    }
    // evaluates comptime field.<name> (from T.fields)
    if c.comptime.check_comptime_is_field_selector(node) {
        if c.comptime.check_comptime_is_field_selector_bool(node) {
            node.expr_type = ast.bool_type
            return node.expr_type
        }
    }
    node.is_field_typ = node.is_field_typ || c.comptime.is_comptime_selector_type(node)
    old_selector_expr := c.inside_selector_expr
    c.inside_selector_expr = true
    mut typ := c.expr(mut node.expr)
    expr_is_auto_deref_var := node.expr.is_auto_deref_var()
    receiver_uses_wrapped_smartcast := typ.has_option_or_result()
        || c.table.sym(c.unwrap_generic(typ)).kind in [.interface, .sum_type, .any]
    if mut node.expr is ast.Ident {
        if var := node.scope.find_var(node.expr.name) {
            if var.smartcasts.len > 0 && (expr_is_auto_deref_var || receiver_uses_wrapped_smartcast) {
                typ = c.exposed_smartcast_type(var.orig_type, var.smartcasts.last(), var.is_mut)
            } else if expr_is_auto_deref_var {
                typ = var.typ
            }
        }
    }
    c.inside_selector_expr = old_selector_expr
    if typ == ast.void_type_idx {
        // This means that the field has an undefined type.
        // This error was handled before.
        c.error('`${node.expr}` does not return a value', node.pos)
        node.expr_type = ast.void_type
        return ast.void_type
    } else if c.comptime.inside_comptime_for && typ == c.enum_data_type
        && node.field_name == 'value' {
        // for comp-time enum.values
        node.expr_type = c.type_resolver.get_ct_type_or_default('${c.comptime.comptime_for_enum_var}.typ',
            node.expr_type)
        node.typ = typ
        return node.expr_type
    }
    node.expr_type = typ
    typ = c.recheck_concrete_type(typ)
    node.expr_type = typ
    const_name := c.module_qualified_selector_const_name(node)
    if const_name != '' {
        c.mark_const_decl_as_referenced(const_name)
        if mut const_obj := c.table.global_scope.find_const(node.field_name) {
            c.mark_const_decl_as_referenced(const_obj.name)
        }
    } else {
        expr := node.expr
        if expr is ast.Ident {
            if mut const_obj := c.file.global_scope.find_const('${expr.name}.${node.field_name}') {
                c.mark_const_decl_as_referenced(const_obj.name)
            }
        }
    }
    if !(node.expr is ast.Ident && node.expr.kind == .constant) {
        if node.expr_type.has_flag(.option) {
            c.error('cannot access fields of an Option, handle the error with `or {...}` or propagate it with `?`',
                node.pos)
        } else if node.expr_type.has_flag(.result) {
            c.error('cannot access fields of a Result, handle the error with `or {...}` or propagate it with `!`',
                node.pos)
        }
    }
    field_name := node.field_name
    mut sym := c.table.sym(typ)
    mut final_sym := c.table.final_sym(typ)
    if (typ.has_flag(.variadic) || final_sym.kind == .array_fixed) && field_name == 'len' {
        node.typ = ast.int_type
        return ast.int_type
    }
    if sym.kind == .chan {
        if field_name == 'closed' {
            node.typ = ast.bool_type
            return ast.bool_type
        } else if field_name in ['len', 'cap'] {
            node.typ = ast.u32_type
            return ast.u32_type
        }
    }
    mut unknown_field_msg := ''
    mut has_field := false
    mut field := ast.StructField{}
    if field_name.len > 0 && final_sym.kind == .struct && sym.language == .v
        && field_name[0].is_capital() {
        // x.Foo.y => access the embedded struct
        struct_info := final_sym.info as ast.Struct
        for embed in struct_info.embeds {
            embed_sym := c.table.sym(embed)
            if embed_sym.embed_name() == field_name {
                node.typ = embed
                return embed
            }
        }
    } else {
        if f := c.table.find_field(sym, field_name) {
            has_field = true
            field = f
        } else {
            field_err := err
            // look for embedded field
            if field_, embed_types := c.table.find_field_from_embeds(sym, field_name) {
                has_field = true
                field = field_
                node.from_embed_types = embed_types
            } else {
                first_err := err
                has_field = false
                if final_sym.kind == .sum_type {
                    if variant_typ, variant_field, variant_embed_types := c.table.find_single_field_variant(final_sym,
                        field_name)
                    {
                        old_expr := node.expr
                        node.expr = ast.ParExpr{
                            expr: ast.AsCast{
                                expr:      old_expr
                                typ:       variant_typ
                                expr_type: typ
                                pos:       old_expr.pos()
                            }
                        }
                        typ = variant_typ
                        sym = c.table.sym(typ)
                        final_sym = c.table.final_sym(typ)
                        node.expr_type = typ
                        field = variant_field
                        node.from_embed_types = variant_embed_types
                        has_field = true
                    }
                }
                if !has_field && final_sym.kind in [.aggregate, .sum_type] {
                    unknown_field_msg = if field_err.msg() != '' {
                        field_err.msg()
                    } else {
                        first_err.msg()
                    }
                    // TODO need a better way to check that we need to display sum type variants info
                    if final_sym.kind == .sum_type
                        && unknown_field_msg.contains('does not exist or have the same type in all sumtype')
                        && !unknown_field_msg.contains('variants: ') {
                        info := final_sym.info as ast.SumType
                        missing_variants := c.table.find_missing_variants(info, field_name)
                        unknown_field_msg += missing_variants
                    }
                }
                if !has_field && c.table.cur_fn != unsafe { nil }
                    && c.table.cur_fn.generic_names.len > 0 && c.table.cur_concrete_types.len == 0
                    && c.table.sym(c.unwrap_generic(typ)).kind in [.interface, .any] {
                    node.typ = ast.any_type
                    return node.typ
                }
                if !has_field && first_err.msg() != '' {
                    c.error(first_err.msg(), node.pos)
                }
            }
        }
        if !c.inside_unsafe && sym.kind == .struct {
            struct_info := sym.info as ast.Struct
            if struct_info.is_union && node.next_token !in token.assign_tokens {
                if !c.pref.translated && !c.file.is_translated {
                    c.warn('reading a union field (or its address) requires `unsafe`', node.pos)
                }
            }
        }
        if typ.has_flag(.generic) && !has_field {
            gs := c.table.sym(c.unwrap_generic(typ))
            if f := c.table.find_field(gs, field_name) {
                has_field = true
                field = f
            } else {
                // look for embedded field
                has_field = true
                mut embed_types := []ast.Type{}
                field, embed_types = c.table.find_field_from_embeds(gs, field_name) or {
                    if err.msg() != '' {
                        c.error(err.msg(), node.pos)
                    }
                    has_field = false
                    ast.StructField{}, []ast.Type{}
                }
                node.from_embed_types = embed_types
                node.generic_from_embed_types << embed_types
            }
        }
    }

    if has_field {
        is_used_outside := !c.inside_recheck && sym.mod != c.mod
        if is_used_outside && sym.language == .c && !sym.is_pub {
            c.ensure_type_exists(typ, node.pos)
            return field.typ
        }
        unwrapped_sym := c.table.sym(c.unwrap_generic(typ))
        if is_used_outside && !field.is_pub && sym.language != .c {
            c.error('field `${unwrapped_sym.name}.${field_name}` is not public', node.pos)
        }
        field_type := c.resolve_selector_field_type(typ, field_name, field)
        field_sym := c.table.sym(field_type)
        if field.is_deprecated && is_used_outside {
            c.deprecate('field', field_name, field.attrs, node.pos)
        }
        if field_sym.kind in [.sum_type, .interface] || field_type.has_flag(.option) {
            if !prevent_sum_type_unwrapping_once {
                scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name)
                if scope_field != unsafe { nil } {
                    sf_smartcast_type := c.exposed_smartcast_type(scope_field.orig_type,
                        scope_field.smartcasts.last(), scope_field.is_mut)
                    if c.inside_sql && node.or_block.kind == .absent {
                        node.typ = sf_smartcast_type
                    }
                    if node.or_block.kind == .absent {
                        return sf_smartcast_type
                    }
                }
            }
        }
        node.typ = field_type
        if node.or_block.kind != .absent {
            unwrapped_typ := c.unwrap_generic(node.typ)
            c.expected_or_type = unwrapped_typ.clear_option_and_result()
            c.stmts_ending_with_expression(mut node.or_block.stmts, c.expected_or_type)
            last_cur_or_expr := c.cur_or_expr
            c.cur_or_expr = &node.or_block
            c.check_or_expr(node.or_block, unwrapped_typ, c.expected_or_type, node)
            c.cur_or_expr = last_cur_or_expr
            c.expected_or_type = ast.void_type
        }
        return field_type
    }
    if c.table.cur_fn != unsafe { nil } && c.table.cur_fn.generic_names.len > 0
        && c.table.cur_concrete_types.len == 0
        && c.table.sym(c.unwrap_generic(typ)).kind in [.interface, .any] {
        node.typ = ast.any_type
        return node.typ
    }
    if mut method := c.table.sym(c.unwrap_generic(typ)).find_method_with_generic_parent(field_name) {
        c.mark_fn_decl_as_referenced(method.fkey())
        c.markused_comptime_call(typ.has_flag(.generic),
            '${int(method.params[0].typ)}.${field_name}')
        if c.expected_type != 0 && c.expected_type != ast.none_type {
            mut method_copy := method
            method_copy.name = ''
            fn_type := ast.new_type(c.table.find_or_register_fn_type(method_copy, false, true))
            if c.check_types(fn_type, c.expected_type) {
                c.table.used_features.anon_fn = true
                return fn_type
            }
        }
        receiver := c.unwrap_generic(method.params[0].typ)
        if receiver.nr_muls() > 0 {
            if !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.expr.pos().extend(node.pos))
                }
            }
        }
        method.params = method.params[1..]
        node.has_hidden_receiver = true
        method.name = ''
        fn_type := ast.new_type(c.table.find_or_register_fn_type(method, false, true))
        node.typ = c.unwrap_generic(fn_type)
        if c.type_has_unresolved_generic_parts(fn_type) {
            c.error('cannot use `${node.expr}.${node.field_name}` as a generic function value',
                node.pos)
            c.table.used_features.anon_fn = true
            return fn_type
        }
        c.table.used_features.anon_fn = true
        return fn_type
    }
    if sym.kind !in [.struct, .aggregate, .interface, .sum_type] {
        if sym.kind != .placeholder {
            unwrapped_sym := c.table.sym(c.unwrap_generic(typ))

            if unwrapped_sym.kind == .array_fixed && node.field_name == 'len' {
                node.typ = ast.int_type
                return ast.int_type
            }

            c.error('`${unwrapped_sym.name}` has no property `${node.field_name}`', node.pos)
        }
    } else {
        if unknown_field_msg == '' {
            if field_name == '' && c.pref.is_vls {
                // VLS will often have `foo.`, skip the no field error
                return ast.void_type
            }
            unknown_field_msg = 'type `${sym.name}` has no field named `${field_name}`'
        }
        if c.table.cur_fn != unsafe { nil } && c.table.cur_fn.generic_names.len > 0
            && c.table.cur_concrete_types.len == 0 && sym.kind in [.interface, .any] {
            node.typ = ast.any_type
            return node.typ
        }
        if final_sym.kind == .struct {
            if c.smartcast_mut_pos != token.Pos{} && !c.implicit_mutability_enabled() {
                c.note('smartcasting requires either an immutable value, or an explicit mut keyword before the value',
                    c.smartcast_mut_pos)
            }
            struct_info := final_sym.info as ast.Struct
            suggestion := util.new_suggestion(field_name, struct_info.fields.map(it.name))
            c.error(suggestion.say(unknown_field_msg), node.pos)
            return ast.void_type
        }
        if c.smartcast_mut_pos != token.Pos{} && !c.implicit_mutability_enabled() {
            c.note('smartcasting requires either an immutable value, or an explicit mut keyword before the value',
                c.smartcast_mut_pos)
        }
        if c.smartcast_cond_pos != token.Pos{} {
            c.note('smartcast can only be used on ident, selector or index expressions, e.g. match foo, match foo.bar, match foo[0]',
                c.smartcast_cond_pos)
        }
        c.error(unknown_field_msg, node.pos)
    }
    return ast.void_type
}

fn (mut c Checker) const_decl(mut node ast.ConstDecl) {
    if node.fields.len == 0 {
        c.warn('const block must have at least 1 declaration', node.pos)
    }
    if node.is_block {
        c.warn('const () groups will be an error after 2025-01-01 (`v fmt -w source.v` will fix that for you)',
            node.pos)
    }

    mut is_export := false
    mut export_name := ''
    if export_attr := node.attrs.find_fir