// Copyright (c) 2026 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 markused

import v2.ast
import v2.token
import v2.types

// Guard functions for ARM64 backend where default-initialized sum types have NULL data pointers.
fn sumtype_payload_word_is_valid(tag_word u64, data_word u64) bool {
    if data_word == 0 {
        return false
    }
    // Native v2 backends use `(tag, data_ptr)` for sumtypes. If the first word
    // looks like a small tag, the payload must be a real pointer, not a leaked
    // enum/default value like `3`.
    if tag_word < 256 {
        return data_word >= 0x10000 && data_word < 0x0000800000000000
    }
    return true
}

fn string_ok(s string) bool {
    if s.len == 0 {
        return true
    }
    if s.len < 0 || s.len > 1024 {
        return false
    }
    ptr := unsafe { u64(s.str) }
    return ptr >= 0x10000 && ptr < 0x0000800000000000
}

fn expr_ok(expr ast.Expr) bool {
    tag_word := unsafe { (&u64(&expr))[0] }
    data_word := unsafe { (&u64(&expr))[1] }
    return sumtype_payload_word_is_valid(tag_word, data_word)
}

fn stmt_ok(stmt ast.Stmt) bool {
    tag_word := unsafe { (&u64(&stmt))[0] }
    data_word := unsafe { (&u64(&stmt))[1] }
    return sumtype_payload_word_is_valid(tag_word, data_word)
}

fn type_ok(typ types.Type) bool {
    tag_word := unsafe { (&u64(&typ))[0] }
    data_word := unsafe { (&u64(&typ))[1] }
    if data_word == 0 {
        return false
    }
    return sumtype_payload_word_is_valid(tag_word, data_word)
}

const builtin_cast_type_names = [
    'bool',
    'byte',
    'byteptr',
    'char',
    'charptr',
    'f32',
    'f64',
    'i8',
    'i16',
    'i32',
    'i64',
    'int',
    'isize',
    'rune',
    'u8',
    'u16',
    'u32',
    'u64',
    'usize',
    'voidptr',
]

struct FnInfo {
    key  string
    mod  string
    file string
    decl ast.FnDecl
    // decl_id is the FlatNodeId of the FnDecl in the source FlatAst, or
    // -1 when the FnInfo was produced by the legacy []ast.File path that
    // has no flat backing. When >= 0, walk_collected_from_flat iterates
    // the body via Cursor instead of info.decl.stmts so future PRs can
    // port walk_stmt arms to cursor input one at a time.
    decl_id ast.FlatNodeId = -1
    // has_body is true when the FnDecl has a non-empty body. In flat mode
    // the body is not decoded into info.decl.stmts (signature-only
    // decode), so we precompute the bit at collect time from the body
    // edge's child count. In legacy mode it mirrors info.decl.stmts.len > 0.
    has_body bool
}

struct Walker {
    files []ast.File
    env   &types.Environment = unsafe { nil }
    opts  MarkUsedOptions
mut:
    fns               []FnInfo
    queue             []int
    queued_fn_indices map[int]bool

    used_keys map[string]bool

    module_names                   map[string]bool
    module_alias_to_real           map[string]string
    type_names                     map[string]bool
    interface_type_names           map[string]bool
    interface_method_names         map[string][]string
    interface_embedded_names       map[string][]string
    methods_by_receiver            map[string][]int
    struct_field_receivers         map[string][]string
    struct_embedded_receivers      map[string][]string
    struct_fn_fields               map[string]bool
    global_interface_names         map[string]string
    const_fn_value_aliases         map[string]string
    selective_import_fn_targets    map[string]string
    called_fn_name_candidate_cache map[string][]string

    lookup map[string][]int

    cur_fn_scope &types.Scope = unsafe { nil }
    cur_fn_decl  ast.FnDecl
    cur_fn_file  string
}

pub struct MarkUsedOptions {
pub:
    minimal_runtime_roots bool
}

// mark_used walks reachable function/method bodies and returns declaration keys
// for the functions that are used at least once.
pub fn mark_used(files []ast.File, env &types.Environment) map[string]bool {
    mut w := new_walker(files, env, MarkUsedOptions{})
    return w.walk()
}

pub fn mark_used_with_options(files []ast.File, env &types.Environment, opts MarkUsedOptions) map[string]bool {
    mut w := new_walker(files, env, opts)
    return w.walk()
}

// decl_key computes the stable key used by mark_used for a function declaration.
pub fn decl_key(module_name string, decl ast.FnDecl, env &types.Environment) string {
    mod_name := normalize_module_name(module_name)
    if is_method_decl(decl) {
        receiver := receiver_primary_name(mod_name, decl, env)
        return '${mod_name}|m|${receiver}|${normalize_method_name(decl.name)}'
    }
    return '${mod_name}|f|${decl.name}'
}

// decl_key_from_cursor computes the stable markused key for a flat FnDecl cursor.
pub fn decl_key_from_cursor(module_name string, c ast.Cursor, env &types.Environment) string {
    decl := c.fn_decl_signature()
    if decl.name == '' {
        return ''
    }
    return decl_key(module_name, decl, env)
}

fn new_walker(files []ast.File, env &types.Environment, opts MarkUsedOptions) Walker {
    return Walker{
        files:                          files
        env:                            unsafe { env }
        opts:                           opts
        used_keys:                      map[string]bool{}
        queued_fn_indices:              map[int]bool{}
        module_names:                   map[string]bool{}
        type_names:                     map[string]bool{}
        interface_type_names:           map[string]bool{}
        interface_method_names:         map[string][]string{}
        interface_embedded_names:       map[string][]string{}
        methods_by_receiver:            map[string][]int{}
        struct_field_receivers:         map[string][]string{}
        struct_embedded_receivers:      map[string][]string{}
        struct_fn_fields:               map[string]bool{}
        global_interface_names:         map[string]string{}
        const_fn_value_aliases:         map[string]string{}
        selective_import_fn_targets:    map[string]string{}
        called_fn_name_candidate_cache: map[string][]string{}
        lookup:                         map[string][]int{}
    }
}

fn (mut w Walker) walk() map[string]bool {
    w.collect_defs()
    return w.walk_collected()
}

// walk_collected runs the body-walking phase after collect_defs (or
// collect_defs_from_flat) has populated w.fns. Split out so flat-input
// entry points can substitute their own collect step.
fn (mut w Walker) walk_collected() map[string]bool {
    if w.fns.len == 0 {
        return map[string]bool{}
    }
    if !w.seed_roots() {
        mut all := map[string]bool{}
        for info in w.fns {
            all[info.key] = true
        }
        return all
    }
    mut qi := 0
    for qi < w.queue.len {
        idx := w.queue[qi]
        qi++
        info := w.fns[idx]
        w.cur_fn_scope = w.lookup_fn_scope(info)
        w.cur_fn_decl = info.decl
        w.cur_fn_file = info.file
        w.walk_stmts(info.decl.stmts, info.mod)
        w.cur_fn_scope = unsafe { nil }
        w.cur_fn_file = ''
    }
    return w.used_keys
}

// walk_collected_from_flat mirrors walk_collected but, for FnInfos that
// originated from flat input (decl_id >= 0), iterates the body via Cursor
// instead of the pre-rehydrated info.decl.stmts slice. For now each body
// stmt is decoded back to ast.Stmt before being dispatched to walk_stmt —
// later PRs port walk_stmt arms to accept cursor input directly so the
// per-stmt rehydration can drop out. FnInfos without a flat backing
// (decl_id < 0) fall back to the legacy slice walk.
fn (mut w Walker) walk_collected_from_flat(flat &ast.FlatAst) map[string]bool {
    if w.fns.len == 0 {
        return map[string]bool{}
    }
    if !w.seed_roots_from_flat(flat) {
        mut all := map[string]bool{}
        for info in w.fns {
            all[info.key] = true
        }
        return all
    }
    mut qi := 0
    for qi < w.queue.len {
        idx := w.queue[qi]
        qi++
        info := w.fns[idx]
        w.cur_fn_scope = w.lookup_fn_scope(info)
        w.cur_fn_decl = info.decl
        w.cur_fn_file = info.file
        if info.decl_id >= 0 {
            w.walk_fn_body_cursor(flat, info.decl_id, info.mod)
        } else {
            w.walk_stmts(info.decl.stmts, info.mod)
        }
        w.cur_fn_scope = unsafe { nil }
        w.cur_fn_file = ''
    }
    return w.used_keys
}

// walk_fn_body_cursor iterates an FnDecl body (edge 3 of stmt_fn_decl) via
// CursorList and dispatches each child through walk_stmt_cursor. Arms that
// have been ported to cursor input avoid per-stmt rehydration; un-ported
// arms decode back to ast.Stmt and call walk_stmt.
fn (mut w Walker) walk_fn_body_cursor(flat &ast.FlatAst, decl_id ast.FlatNodeId, mod_name string) {
    body := ast.Cursor{
        flat: unsafe { flat }
        id:   decl_id
    }.list_at(3)
    for i in 0 .. body.len() {
        w.walk_stmt_cursor(body.at(i), mod_name)
    }
}

// walk_stmt_cursor is the cursor-input analogue of walk_stmt. Arms that have
// been ported operate directly on the FlatNode (no Stmt rehydration); the
// fallback decodes the stmt and delegates to walk_stmt so partial coverage
// stays bit-identical with the legacy walker.
//
// Ported arms: stmt_assert, stmt_assign, stmt_attributes, stmt_block,
// stmt_comptime, stmt_const_decl, stmt_defer, stmt_enum_decl, stmt_expr,
// stmt_for, stmt_for_in, stmt_global_decl, stmt_label, stmt_return,
// stmt_struct_decl, stmt_type_decl — every kind the legacy walk_stmt
// matched explicitly. Nested expressions are still routed through
// walk_expr (decoded per edge) until walk_expr itself gets a cursor-input
// port. The else arm catches stmt kinds the legacy walker ignored
// (stmt_asm/_directive/_empty/_flow_control/_fn_decl/_import/_interface_decl
// /_module) plus any future kinds; it stays in place as a safety net.
fn (mut w Walker) walk_stmt_cursor(c ast.Cursor, mod_name string) {
    if !c.is_valid() {
        return
    }
    match c.kind() {
        .stmt_assert {
            w.walk_expr_cursor_edge(c, 0, mod_name)
            w.walk_expr_cursor_edge(c, 1, mod_name)
        }
        .stmt_attributes {
            // edge 0 = aux_list of aux_attribute children; each attribute has
            // edge 0 = value expr, edge 1 = comptime_cond expr.
            attrs := c.list_at(0)
            for i in 0 .. attrs.len() {
                attr := attrs.at(i)
                if !attr.is_valid() {
                    continue
                }
                w.walk_expr_cursor_edge(attr, 0, mod_name)
                w.walk_expr_cursor_edge(attr, 1, mod_name)
            }
        }
        .stmt_assign {
            ec := c.edge_count()
            lhs_len := c.extra_int()
            // Mirror the legacy ordering: first the interface-conversion
            // checks across paired (lhs[i], rhs[i]) edges, then walk all
            // lhs exprs, then all rhs exprs.
            pair_len := if lhs_len < ec - lhs_len { lhs_len } else { ec - lhs_len }
            for i in 0 .. pair_len {
                lhs_c := c.edge(i)
                rhs_c := c.edge(lhs_len + i)
                if !lhs_c.is_valid() || !rhs_c.is_valid() {
                    continue
                }
                w.mark_assignment_interface_conversion_cursor(lhs_c, rhs_c, mod_name)
            }
            for i in lhs_len .. ec {
                w.mark_fn_value_expr_cursor(c.edge(i), mod_name)
            }
            for i in 0 .. ec {
                w.walk_expr_cursor_edge(c, i, mod_name)
            }
        }
        .stmt_block {
            for i in 0 .. c.edge_count() {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        .stmt_comptime {
            w.mark_comptime_method_loop_receivers_cursor(c.edge(0), mod_name)
            w.walk_stmt_cursor(c.edge(0), mod_name)
        }
        .stmt_const_decl {
            // edge 0 = fields (aux_field_init list); each field edge 0 = value expr.
            w.walk_field_value_list(c, 0, mod_name)
        }
        .stmt_defer {
            for i in 0 .. c.edge_count() {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        .stmt_enum_decl {
            // edge 2 = fields (aux_field_decl list); each field edge 1 = value expr.
            w.walk_field_decl_list(c, 2, mod_name, false)
        }
        .stmt_expr {
            w.walk_expr_cursor_edge(c, 0, mod_name)
        }
        .stmt_for {
            w.walk_stmt_cursor(c.edge(0), mod_name)
            w.walk_expr_cursor_edge(c, 1, mod_name)
            w.walk_stmt_cursor(c.edge(2), mod_name)
            for i in 3 .. c.edge_count() {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        .stmt_for_in {
            w.walk_expr_cursor_edge(c, 0, mod_name)
            w.walk_expr_cursor_edge(c, 1, mod_name)
            w.walk_expr_cursor_edge(c, 2, mod_name)
        }
        .stmt_global_decl {
            // edge 1 = fields (aux_field_decl list); each field walks typ+value.
            w.walk_field_decl_list(c, 1, mod_name, true)
        }
        .stmt_label {
            w.walk_stmt_cursor(c.edge(0), mod_name)
        }
        .stmt_return {
            for i in 0 .. c.edge_count() {
                ec := c.edge(i)
                if !ec.is_valid() {
                    continue
                }
                w.mark_fn_value_expr_cursor(ec, mod_name)
                w.walk_expr_cursor(ec, mod_name)
                w.mark_interface_conversion_methods_cursor(w.cur_fn_decl.typ.return_type, ec,
                    mod_name)
                w.mark_result_error_return_methods_cursor(w.cur_fn_decl.typ.return_type, ec,
                    mod_name)
            }
        }
        .stmt_struct_decl {
            // edge 4 = fields (aux_field_decl list); each field walks typ+value.
            w.walk_field_decl_list(c, 4, mod_name, true)
        }
        .stmt_type_decl {
            // edge 0 = base_type (expr); edge 3 = variants (aux expr list).
            w.walk_expr_cursor_edge(c, 0, mod_name)
            variants := c.list_at(3)
            for i in 0 .. variants.len() {
                vc := variants.at(i)
                if !vc.is_valid() {
                    continue
                }
                w.walk_expr_cursor(vc, mod_name)
            }
        }
        // Kinds intentionally ignored by the walker (mirror of legacy
        // walk_stmt's `else {}`): stmt_asm, stmt_directive, stmt_empty,
        // stmt_flow_control (break/continue/goto — common in fn bodies,
        // hence worth avoiding a decode_stmt), stmt_fn_decl,
        // stmt_import, stmt_interface_decl, stmt_module. The legacy
        // walker walks none of these so neither do we.
        else {}
    }
}

// walk_expr_cursor_edge dispatches child edge `edge_i` of `parent` through
// walk_expr_cursor. Kept as a tiny helper so callers don't have to do the
// edge-+-validity dance inline.
fn (mut w Walker) walk_expr_cursor_edge(parent ast.Cursor, edge_i int, mod_name string) {
    w.walk_expr_cursor(parent.edge(edge_i), mod_name)
}

// walk_expr_cursor is the cursor-input analogue of walk_expr. Ported arms
// operate directly on the FlatNode; un-ported arms decode the expr and
// delegate to walk_expr so partial coverage stays bit-identical with the
// legacy walker.
//
// Ported arms (no per-node decoding):
//   * leaves: expr_basic_literal, expr_empty, expr_ident, typ_nil, typ_none
//   * single-edge recursers: expr_comptime, expr_lambda, expr_modifier,
//     expr_paren, expr_postfix, expr_prefix, expr_sql, typ_array,
//     typ_option, typ_pointer, typ_result, typ_thread
//   * two-edge recursers: expr_as_cast, expr_generic_arg_or_index,
//     expr_index, expr_range, typ_array_fixed, typ_channel, typ_map
//   * N-edge recursers: expr_keyword_operator, expr_tuple, typ_tuple
//   * nested-stmt / packed-shape arms: expr_array_init, expr_fn_literal,
//     expr_if, expr_if_guard, expr_lock, expr_map_init, expr_match,
//     expr_or, expr_select, expr_unsafe, typ_anon_struct, typ_fn,
//     typ_generic
//   * no-mark structural arms: expr_assoc, expr_generic_args
//
// The remaining un-ported arms (expr_call, expr_call_or_cast, expr_cast,
// expr_infix, expr_init, expr_selector, expr_string_inter) all invoke
// mark_* helpers that take decoded ast.Expr / ast.CallExpr / ast.InfixExpr
// today. Porting them buys little until those helpers grow cursor-input
// variants; the else fallback decodes + delegates and stays bit-identical.
fn (mut w Walker) walk_expr_cursor(c ast.Cursor, mod_name string) {
    if !c.is_valid() {
        return
    }
    match c.kind() {
        // Leaves with no children and no walker side-effects. The legacy
        // walk_expr arms for Keyword / StringLiteral / Lifetime hit its
        // else {}, so they belong here too.
        .expr_basic_literal, .expr_empty, .expr_keyword, .expr_lifetime, .expr_string, .typ_nil,
        .typ_none {}
        .expr_ident {
            name := c.name()
            w.mark_ierror_wrapper_dependencies(name, mod_name)
            if (!w.opts.minimal_runtime_roots || should_mark_ident_as_fn(name))
                && !w.is_cast_type_name(name) {
                w.mark_fn_name(name, mod_name)
            }
        }
        // Single-edge recursers — child at edge 0.
        .expr_comptime, .expr_lambda, .expr_modifier, .expr_paren, .expr_postfix, .expr_prefix,
        .expr_sql, .typ_array, .typ_option, .typ_pointer, .typ_result, .typ_thread {
            w.walk_expr_cursor(c.edge(0), mod_name)
        }
        // Two-edge recursers.
        .expr_as_cast, .expr_generic_arg_or_index, .expr_index, .expr_range, .typ_array_fixed,
        .typ_channel, .typ_map {
            w.walk_expr_cursor(c.edge(0), mod_name)
            w.walk_expr_cursor(c.edge(1), mod_name)
        }
        // N-edge recursers — every direct edge is an Expr to walk.
        .expr_keyword_operator, .typ_tuple {
            for i in 0 .. c.edge_count() {
                w.walk_expr_cursor(c.edge(i), mod_name)
            }
        }
        .expr_tuple {
            for i in 0 .. c.edge_count() {
                value_c := c.edge(i)
                w.mark_fn_value_expr_cursor(value_c, mod_name)
                w.walk_expr_cursor(value_c, mod_name)
            }
        }
        // typ_generic packs name as edge 0 and generic params at edges 1..N;
        // the legacy walker calls walk_expr on each of them in order.
        .typ_generic {
            for i in 0 .. c.edge_count() {
                w.walk_expr_cursor(c.edge(i), mod_name)
            }
        }
        // expr_array_init: edge 0 = typ, 1 = init, 2 = cap, 3 = len,
        // 4 = update_expr, 5.. = exprs. Legacy walk order is typ, exprs,
        // init, cap, len, update_expr.
        .expr_array_init {
            ec := c.edge_count()
            w.walk_expr_cursor(c.edge(0), mod_name)
            for i in 5 .. ec {
                item_c := c.edge(i)
                w.mark_fn_value_expr_cursor(item_c, mod_name)
                w.walk_expr_cursor(item_c, mod_name)
            }
            w.mark_fn_value_expr_cursor(c.edge(1), mod_name)
            w.walk_expr_cursor(c.edge(1), mod_name)
            w.walk_expr_cursor(c.edge(2), mod_name)
            w.walk_expr_cursor(c.edge(3), mod_name)
            w.walk_expr_cursor(c.edge(4), mod_name)
        }
        // expr_map_init: edge 0 = typ, 1..1+keys_len = keys,
        // 1+keys_len.. = vals. keys_len is packed in `extra`.
        .expr_map_init {
            keys_len := c.extra_int()
            ec := c.edge_count()
            w.walk_expr_cursor(c.edge(0), mod_name)
            for i in 1 .. (1 + keys_len) {
                key_c := c.edge(i)
                w.mark_fn_value_expr_cursor(key_c, mod_name)
                w.walk_expr_cursor(key_c, mod_name)
            }
            for i in (1 + keys_len) .. ec {
                value_c := c.edge(i)
                w.mark_fn_value_expr_cursor(value_c, mod_name)
                w.walk_expr_cursor(value_c, mod_name)
            }
        }
        // expr_lock: lock_len + rlock_len are packed in `extra` (low/high u16).
        // Layout is lock_exprs, rlock_exprs, stmts.
        .expr_lock {
            packed := c.extra_int()
            lock_len := packed & 0xFFFF
            rlock_len := (packed >> 16) & 0xFFFF
            ec := c.edge_count()
            for i in 0 .. lock_len {
                w.walk_expr_cursor(c.edge(i), mod_name)
            }
            for i in lock_len .. (lock_len + rlock_len) {
                w.walk_expr_cursor(c.edge(i), mod_name)
            }
            for i in (lock_len + rlock_len) .. ec {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        // expr_if: edge 0 = cond, edge 1 = else_expr, edges 2.. = stmts.
        // Legacy walks cond → stmts → else_expr.
        .expr_if {
            ec := c.edge_count()
            w.walk_expr_cursor(c.edge(0), mod_name)
            for i in 2 .. ec {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
            w.walk_expr_cursor(c.edge(1), mod_name)
        }
        // expr_if_guard: edge 0 = the embedded AssignStmt.
        .expr_if_guard {
            w.walk_stmt_cursor(c.edge(0), mod_name)
        }
        // expr_or: edge 0 = expr, edges 1.. = stmts.
        .expr_or {
            w.walk_expr_cursor(c.edge(0), mod_name)
            for i in 1 .. c.edge_count() {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        // expr_unsafe: all edges are stmts.
        .expr_unsafe {
            for i in 0 .. c.edge_count() {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        // expr_fn_literal: edge 0 = fn_typ, edges 1..1+cap_len = captured
        // (not walked by the legacy walker), edges 1+cap_len.. = stmts.
        // cap_len is packed in `extra`.
        .expr_fn_literal {
            cap_len := c.extra_int()
            for i in (1 + cap_len) .. c.edge_count() {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
        }
        // expr_select: edge 0 = stmt, edge 1 = next (expr), edges 2.. = stmts.
        // Legacy walks stmt → stmts → next.
        .expr_select {
            ec := c.edge_count()
            w.walk_stmt_cursor(c.edge(0), mod_name)
            for i in 2 .. ec {
                w.walk_stmt_cursor(c.edge(i), mod_name)
            }
            w.walk_expr_cursor(c.edge(1), mod_name)
        }
        // expr_match: edge 0 = scrutinee expr, edges 1.. = aux_match_branch.
        // Each match_branch has edge 0 = aux_list of cond exprs, edge 1 =
        // aux_list of stmts.
        .expr_match {
            w.walk_expr_cursor(c.edge(0), mod_name)
            for i in 1 .. c.edge_count() {
                branch := c.edge(i)
                if !branch.is_valid() {
                    continue
                }
                conds := branch.list_at(0)
                for j in 0 .. conds.len() {
                    w.walk_expr_cursor(conds.at(j), mod_name)
                }
                stmts := branch.list_at(1)
                for j in 0 .. stmts.len() {
                    w.walk_stmt_cursor(stmts.at(j), mod_name)
                }
            }
        }
        // typ_fn: edge 0 = generic_params (not walked by legacy), edge 1 =
        // aux_list of aux_parameter, edge 2 = return_type. Each parameter
        // node has edge 0 = its type.
        .typ_fn {
            params_list := c.list_at(1)
            for i in 0 .. params_list.len() {
                param := params_list.at(i)
                if !param.is_valid() {
                    continue
                }
                w.walk_expr_cursor(param.edge(0), mod_name)
            }
            w.walk_expr_cursor(c.edge(2), mod_name)
        }
        // typ_anon_struct: edge 0 = generic_params (not walked by legacy),
        // edge 1 = embedded (aux_list of exprs), edge 2 = fields
        // (aux_list of aux_field_decl).
        .typ_anon_struct {
            embedded := c.list_at(1)
            for i in 0 .. embedded.len() {
                w.walk_expr_cursor(embedded.at(i), mod_name)
            }
            w.walk_field_decl_list(c, 2, mod_name, true)
        }
        // expr_assoc: edge 0 = typ, edge 1 = expr, edges 2.. = aux_field_init
        // nodes (each with edge 0 = value expr). No mark side-effects, so the
        // arm is purely structural.
        .expr_assoc {
            w.walk_expr_cursor(c.edge(0), mod_name)
            w.walk_expr_cursor(c.edge(1), mod_name)
            for i in 2 .. c.edge_count() {
                field := c.edge(i)
                if !field.is_valid() {
                    continue
                }
                value_c := field.edge(0)
                w.mark_fn_value_expr_cursor(value_c, mod_name)
                w.walk_expr_cursor(value_c, mod_name)
            }
        }
        // expr_generic_args: edge 0 = lhs, edges 1.. = args. No mark
        // side-effects — every edge is a walked expr.
        .expr_generic_args {
            for i in 0 .. c.edge_count() {
                w.walk_expr_cursor(c.edge(i), mod_name)
            }
        }
        // expr_call: edge 0 = lhs, edges 1.. = args. Cursor port uses
        // mark_call_lhs_cursor + mark_call_arg_interface_conversions_cursor —
        // both decode lhs.lhs (selector receiver fallback) and args (only
        // when the matching param is an interface) on demand. Everything
        // else is structural.
        .expr_call {
            lhs_c := c.edge(0)
            w.mark_call_lhs_cursor(lhs_c, mod_name)
            w.mark_call_arg_interface_conversions_cursor(c, mod_name)
            w.walk_expr_cursor(lhs_c, mod_name)
            for i in 1 .. c.edge_count() {
                arg_c := c.edge(i)
                if arg_c.is_valid() && arg_c.kind() == .aux_field_init {
                    value_c := arg_c.edge(0)
                    if value_c.is_valid() && value_c.kind() == .expr_selector
                        && value_c.edge(0).kind() != .expr_empty {
                        w.mark_selector_fn_value_cursor_with_fallback(value_c, mod_name, true)
                    }
                    w.mark_fn_value_expr_cursor(value_c, mod_name)
                    w.walk_expr_cursor(value_c, mod_name)
                    continue
                }
                w.mark_fn_value_expr_cursor(arg_c, mod_name)
                w.walk_expr_cursor(arg_c, mod_name)
            }
        }
        // expr_call_or_cast: edge 0 = lhs, edge 1 = inner. When lhs is an
        // Ident naming a cast type, behaves like a cast — call
        // mark_interface_conversion_methods and walk only the inner expr.
        // Otherwise behaves like a call (mark_call_lhs + the single-arg
        // interface conversion check).
        .expr_call_or_cast {
            lhs_c := c.edge(0)
            expr_c := c.edge(1)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_ident && w.is_cast_type_name(lhs_c.name()) {
                iface_name := w.interface_name_from_cursor(lhs_c, mod_name)
                if iface_name != '' && expr_c.is_valid() {
                    w.mark_interface_conversion_methods_for_name_cursor(iface_name, expr_c,
                        mod_name)
                }
                w.walk_expr_cursor(expr_c, mod_name)
            } else {
                w.mark_call_lhs_cursor(lhs_c, mod_name)
                w.mark_call_or_cast_arg_interface_conversion_cursor(c, mod_name)
                w.walk_expr_cursor(lhs_c, mod_name)
                w.mark_fn_value_expr_cursor(expr_c, mod_name)
                w.walk_expr_cursor(expr_c, mod_name)
            }
        }
        // expr_cast: edge 0 = typ, edge 1 = value. Legacy walker calls
        // mark_interface_conversion_methods(typ, value) which is a no-op unless
        // typ resolves to a known interface. We peek typ via
        // interface_name_from_cursor (only matches Ident / SelectorExpr,
        // both cheap), and only when it fires do we decode the value subtree
        // to feed receiver_candidates_for_expr.
        .expr_cast {
            typ_c := c.edge(0)
            expr_c := c.edge(1)
            iface_name := w.interface_name_from_cursor(typ_c, mod_name)
            if iface_name != '' && expr_c.is_valid() {
                w.mark_interface_conversion_methods_for_name_cursor(iface_name, expr_c, mod_name)
            }
            w.walk_expr_cursor(typ_c, mod_name)
            w.walk_expr_cursor(expr_c, mod_name)
        }
        // expr_init: edge 0 = typ, edges 1.. = aux_field_init (edge 0 = value).
        // Legacy walker calls mark_interface_conversion_methods(typ, expr)
        // where the value_expr is the whole InitExpr; receiver_candidates_for_
        // cursor's expr_init branch reads pos + recurses into the typ cursor,
        // so passing this cursor directly matches the legacy semantics.
        .expr_init {
            typ_c := c.edge(0)
            iface_name := w.interface_name_from_cursor(typ_c, mod_name)
            if iface_name != '' {
                w.mark_interface_conversion_methods_for_name_cursor(iface_name, c, mod_name)
            }
            w.walk_expr_cursor(typ_c, mod_name)
            for i in 1 .. c.edge_count() {
                field := c.edge(i)
                if !field.is_valid() {
                    continue
                }
                value_c := field.edge(0)
                if value_c.is_valid() && value_c.kind() == .expr_selector
                    && w.init_field_is_fn_value_cursor(typ_c, field.name(), mod_name) {
                    w.mark_selector_fn_value_cursor_with_fallback(value_c, mod_name, true)
                }
                w.mark_fn_value_expr_cursor(value_c, mod_name)
                w.walk_expr_cursor(value_c, mod_name)
            }
        }
        // expr_infix: aux = op (Token int), edge 0 = lhs, edge 1 = rhs.
        // mark_infix_operator_method is a no-op for ops outside the method-
        // dispatching set, so we gate the decode on the op kind. When the op
        // does qualify, we decode just the lhs subtree to feed
        // receiver_candidates_for_expr, then walk both children via cursor.
        .expr_infix {
            op := unsafe { token.Token(int(c.aux())) }
            if infix_operator_may_use_method(op) {
                method_name := op.str()
                receivers := w.receiver_candidates_for_cursor(c.edge(0), mod_name)
                if receivers.len > 0 {
                    w.mark_method_name(method_name, receivers)
                } else {
                    w.mark_method_name_fallback(method_name)
                }
            }
            w.walk_expr_cursor(c.edge(0), mod_name)
            w.walk_expr_cursor(c.edge(1), mod_name)
        }
        // expr_string_inter: edge 0 = aux_list of value strings (not walked),
        // edge 1 = aux_list of inter nodes. Each inter has edge 0 = expr,
        // edge 1 = format_expr. Legacy walker calls
        // mark_string_interpolation_str_dependency(inter.expr) which needs a
        // decoded ast.Expr to feed receiver_candidates_for_expr. We decode
        // just that subtree per inter and walk both children via cursor —
        // format_expr's subtree never gets decoded.
        .expr_string_inter {
            inters := c.list_at(1)
            for i in 0 .. inters.len() {
                inter := inters.at(i)
                if !inter.is_valid() {
                    continue
                }
                expr_c := inter.edge(0)
                if expr_c.is_valid() {
                    w.mark_string_interpolation_str_dependency_cursor(expr_c, mod_name)
                }
                w.walk_expr_cursor(expr_c, mod_name)
                w.walk_expr_cursor(inter.edge(1), mod_name)
            }
        }
        // expr_selector: edge 0 = lhs, edge 1 = rhs (Ident). Legacy walker calls
        // mark_selector_fn_value(expr), which only marks module function values
        // that resolve to an indexed function.
        .expr_selector {
            lhs_c := c.edge(0)
            w.mark_selector_fn_value_cursor(c, mod_name)
            w.walk_expr_cursor(lhs_c, mod_name)
        }
        // Every expr/type FlatNodeKind has an explicit arm above; aux_*
        // nodes never reach walk_expr_cursor (they are addressed via list_at
        // / edge by their parents). Anything else is a schema mismatch.
        else {}
    }
}

// walk_field_value_list iterates the aux_field_init list at `parent.edge(list_edge)`
// and handles each field's value expr (aux_field_init edge 0). Used by
// stmt_const_decl, whose only walk-relevant per-field datum is the value.
fn (mut w Walker) walk_field_value_list(parent ast.Cursor, list_edge int, mod_name string) {
    fields := parent.list_at(list_edge)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        if !field.is_valid() {
            continue
        }
        w.mark_fn_value_expr_cursor(field.edge(0), mod_name)
        w.walk_expr_cursor_edge(field, 0, mod_name)
    }
}

// walk_field_decl_list iterates the aux_field_decl list at `parent.edge(list_edge)`.
// Each aux_field_decl has edge 0 = typ, edge 1 = value, edge 2 = attrs. When
// `walk_typ` is true the typ edge is also walked (struct/global decls);
// otherwise only the value edge is walked (enum decls).
fn (mut w Walker) walk_field_decl_list(parent ast.Cursor, list_edge int, mod_name string, walk_typ bool) {
    fields := parent.list_at(list_edge)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        if !field.is_valid() {
            continue
        }
        if walk_typ {
            w.walk_expr_cursor_edge(field, 0, mod_name)
        }
        w.walk_expr_cursor_edge(field, 1, mod_name)
    }
}

fn (mut w Walker) collect_defs() {
    for file in w.files {
        mod_name := normalize_module_name(file.mod)
        w.add_module_name(mod_name)
        w.collect_file_imports(file.name, file.imports)
        for stmt in file.stmts {
            w.collect_def_stmt(stmt, mod_name, file.name, ast.FlatNodeId(-1))
        }
    }
    w.collect_const_fn_value_aliases()
}

// collect_defs_from_flat is the flat-input analogue of collect_defs. It
// walks each file's top-level statements through Cursor and only decodes
// the decls collect_def_stmt actually consumes (struct/enum/interface/
// type/global/fn). Imports are read directly from cursor fields
// (name / extra_str alias) so the []ImportStmt slice is never allocated.
// The shared collect_def_stmt dispatch keeps the flat path bit-identical
// to the legacy path on the same input.
fn (mut w Walker) collect_defs_from_flat(flat &ast.FlatAst) {
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        mod_name := normalize_module_name(fc.mod())
        w.add_module_name(mod_name)
        imports_list := fc.imports()
        for i in 0 .. imports_list.len() {
            imp_cur := imports_list.at(i)
            name := imp_cur.name()
            w.add_module_name(name)
            alias := imp_cur.extra_str()
            import_mod := if imp_cur.flag(ast.flag_is_aliased) {
                name.all_after_last('.')
            } else {
                alias
            }
            for si in 0 .. imp_cur.edge_count() {
                symbol := imp_cur.edge(si)
                if symbol.is_valid() && symbol.kind() == .expr_ident {
                    w.selective_import_fn_targets['${fc.name()}:${symbol.name()}'] = markused_imported_symbol_fn_name(import_mod,
                        symbol.name())
                }
            }
            if alias != '' {
                w.add_module_name(alias)
                // Map alias to real module name for correct symbol resolution.
                // e.g., 'import v2.ssa.optimize as ssa_optimize' → 'ssa_optimize' → 'optimize'
                real_name := if name.contains('.') {
                    name.all_after_last('.')
                } else {
                    name
                }
                w.module_alias_to_real[alias] = real_name
            }
        }
        file_name := fc.name()
        stmts_list := fc.stmts()
        for i in 0 .. stmts_list.len() {
            c := stmts_list.at(i)
            match c.kind() {
                .stmt_fn_decl {
                    fn_decl := c.fn_decl_signature()
                    if fn_decl.name == '' {
                        continue
                    }
                    has_body := c.list_at(3).len() > 0
                    info := FnInfo{
                        key:      decl_key(mod_name, fn_decl, w.env)
                        mod:      mod_name
                        file:     file_name
                        decl:     fn_decl
                        decl_id:  c.id
                        has_body: has_body
                    }
                    w.fns << info
                    idx := w.fns.len - 1
                    w.index_fn(idx, info)
                }
                .stmt_struct_decl, .stmt_enum_decl, .stmt_interface_decl, .stmt_type_decl,
                .stmt_global_decl {
                    w.collect_def_cursor(c, mod_name)
                }
                else {}
            }
        }
    }
    w.collect_const_fn_value_aliases_from_flat(flat)
}

fn const_fn_value_alias_key(mod_name string, name string) string {
    return '${normalize_module_name(mod_name)}:${name}'
}

fn (mut w Walker) collect_const_fn_value_aliases() {
    for file in w.files {
        mod_name := normalize_module_name(file.mod)
        prev_fn_file := w.cur_fn_file
        w.cur_fn_file = file.name
        for stmt in file.stmts {
            if !stmt_ok(stmt) {
                continue
            }
            if stmt is ast.ConstDecl {
                for field in stmt.fields {
                    if field.name == '' {
                        continue
                    }
                    if field.value is ast.Ident
                        && w.ident_resolves_to_fn_value(field.value.name, mod_name) {
                        w.const_fn_value_aliases[const_fn_value_alias_key(mod_name, field.name)] = field.value.name
                    } else if field.value is ast.SelectorExpr {
                        target := w.selector_fn_value_target(field.value)
                        if target != '' {
                            w.const_fn_value_aliases[const_fn_value_alias_key(mod_name, field.name)] = target
                        }
                    }
                }
            }
        }
        w.cur_fn_file = prev_fn_file
    }
}

fn (mut w Walker) collect_const_fn_value_aliases_from_flat(flat &ast.FlatAst) {
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        mod_name := normalize_module_name(fc.mod())
        prev_fn_file := w.cur_fn_file
        w.cur_fn_file = fc.name()
        stmts_list := fc.stmts()
        for i in 0 .. stmts_list.len() {
            c := stmts_list.at(i)
            if c.kind() != .stmt_const_decl {
                continue
            }
            fields := c.list_at(0)
            for j in 0 .. fields.len() {
                field := fields.at(j)
                name := field.name()
                if name == '' {
                    continue
                }
                value_c := field.edge(0)
                if !value_c.is_valid() {
                    continue
                }
                if value_c.kind() == .expr_ident
                    && w.ident_resolves_to_fn_value(value_c.name(), mod_name) {
                    w.const_fn_value_aliases[const_fn_value_alias_key(mod_name, name)] =
                        value_c.name()
                } else if value_c.kind() == .expr_selector {
                    target := w.selector_fn_value_target_cursor(value_c)
                    if target != '' {
                        w.const_fn_value_aliases[const_fn_value_alias_key(mod_name, name)] = target
                    }
                }
            }
        }
        w.cur_fn_file = prev_fn_file
    }
}

fn (mut w Walker) collect_imports(imports []ast.ImportStmt) {
    for imp in imports {
        w.add_module_name(imp.name)
        if imp.alias != '' {
            w.add_module_name(imp.alias)
            // Map alias to real module name for correct symbol resolution.
            // e.g., 'import v2.ssa.optimize as ssa_optimize' → 'ssa_optimize' → 'optimize'
            real_name := if imp.name.contains('.') {
                imp.name.all_after_last('.')
            } else {
                imp.name
            }
            w.module_alias_to_real[imp.alias] = real_name
        }
    }
}

fn markused_imported_symbol_fn_name(module_name string, name string) string {
    if module_name == '' || module_name == 'main' {
        return name
    }
    return '${module_name}__${name}'
}

fn selective_import_fn_key(file_name string, name string) string {
    return '${file_name}:${name}'
}

fn (mut w Walker) collect_file_imports(file_name string, imports []ast.ImportStmt) {
    w.collect_imports(imports)
    for imp in imports {
        if imp.symbols.len == 0 {
            continue
        }
        import_mod := if imp.is_aliased { imp.name.all_after_last('.') } else { imp.alias }
        for symbol in imp.symbols {
            if symbol is ast.Ident {
                w.selective_import_fn_targets[selective_import_fn_key(file_name, symbol.name)] = markused_imported_symbol_fn_name(import_mod,
                    symbol.name)
            }
        }
    }
}

fn (mut w Walker) collect_def_stmt(stmt ast.Stmt, mod_name string, file_name string, decl_id ast.FlatNodeId) {
    if !stmt_ok(stmt) {
        return
    }
    match stmt {
        ast.StructDecl {
            w.add_type_name(mod_name, stmt.name)
            w.add_struct_field_receivers(mod_name, stmt)
            w.add_struct_embedded_receivers(mod_name, stmt)
            w.add_struct_fn_fields(mod_name, stmt)
        }
        ast.EnumDecl {
            w.add_type_name(mod_name, stmt.name)
        }
        ast.InterfaceDecl {
            w.add_type_name(mod_name, stmt.name)
            w.add_interface_decl(mod_name, stmt)
        }
        ast.TypeDecl {
            w.add_type_name(mod_name, stmt.name)
        }
        ast.GlobalDecl {
            w.add_global_interface_names(mod_name, stmt)
        }
        ast.FnDecl {
            if stmt.name == '' {
                return
            }
            info := FnInfo{
                key:      decl_key(mod_name, stmt, w.env)
                mod:      mod_name
                file:     file_name
                decl:     stmt
                decl_id:  decl_id
                has_body: stmt.stmts.len > 0
            }
            w.fns << info
            idx := w.fns.len - 1
            w.index_fn(idx, info)
        }
        else {}
    }
}

fn (mut w Walker) collect_def_cursor(c ast.Cursor, mod_name string) {
    if !c.is_valid() {
        return
    }
    match c.kind() {
        .stmt_struct_decl {
            w.add_type_name(mod_name, c.name())
            w.add_struct_field_receivers_cursor(mod_name, c)
            w.add_struct_embedded_receivers_cursor(mod_name, c)
            w.add_struct_fn_fields_cursor(mod_name, c)
        }
        .stmt_enum_decl, .stmt_type_decl {
            w.add_type_name(mod_name, c.name())
        }
        .stmt_interface_decl {
            w.add_interface_decl_cursor(mod_name, c)
        }
        .stmt_global_decl {
            w.add_global_interface_names_cursor(mod_name, c)
        }
        else {}
    }
}

fn (mut w Walker) seed_roots() bool {
    mut has_root := false
    for i, info in w.fns {
        if is_main_root(info) {
            w.mark_fn(i)
            has_root = true
        }
    }
    if has_root {
        if w.opts.minimal_runtime_roots {
            w.seed_minimal_runtime_roots()
        } else {
            w.seed_generic_specialization_roots()
            w.seed_codegen_required_roots()
            // Also seed module init() functions (called from synthesized main)
            for i, info in w.fns {
                if is_module_init(info) {
                    w.mark_fn(i)
                }
            }
            w.seed_top_level_initializer_roots()
            w.seed_drop_method_roots()
        }
        return true
    }
    for i, info in w.fns {
        if is_test_root(info) || is_module_init(info) {
            w.mark_fn(i)
            has_root = true
        }
    }
    if has_root {
        if w.opts.minimal_runtime_roots {
            w.seed_minimal_runtime_roots()
        } else {
            w.seed_generic_specialization_roots()
            w.seed_codegen_required_roots()
            w.seed_top_level_initializer_roots()
            w.seed_drop_method_roots()
        }
    }
    return has_root
}

fn (mut w Walker) seed_minimal_runtime_roots() {
}

fn (mut w Walker) seed_roots_from_flat(flat &ast.FlatAst) bool {
    mut has_root := false
    for i, info in w.fns {
        if is_main_root(info) {
            w.mark_fn(i)
            has_root = true
        }
    }
    if has_root {
        if !w.opts.minimal_runtime_roots {
            w.seed_generic_specialization_roots()
            w.seed_codegen_required_roots()
            // Also seed module init() functions (called from synthesized main)
            for i, info in w.fns {
                if is_module_init(info) {
                    w.mark_fn(i)
                }
            }
            w.seed_top_level_initializer_roots_from_flat(flat)
            w.seed_drop_method_roots()
        }
        return true
    }
    for i, info in w.fns {
        if is_test_root(info) || is_module_init(info) {
            w.mark_fn(i)
            has_root = true
        }
    }
    if has_root {
        if !w.opts.minimal_runtime_roots {
            w.seed_generic_specialization_roots()
            w.seed_codegen_required_roots()
            w.seed_top_level_initializer_roots_from_flat(flat)
            w.seed_drop_method_roots()
        }
    }
    return has_root
}

fn (mut w Walker) seed_codegen_required_roots() {
    for i, info in w.fns {
        if w.is_codegen_required_root(info) {
            w.mark_fn(i)
        }
    }
}

// seed_drop_method_roots marks every `Type.drop` method as live for the
// types that the ownership checker recorded in `env.drop_at_fn_exit`. The
// cleanc backend will emit synthetic `Type__drop(&var)` calls at fn-exit
// for those bindings; without seeding the methods here, dead-code elim
// would strip the bodies and leave the linker with unresolved symbols.
fn (mut w Walker) seed_drop_method_roots() {
    if w.env == unsafe { nil } {
        return
    }
    mut seen := map[string]bool{}
    for _, entries in w.env.drop_at_fn_exit {
        for entry in entries {
            if entry.type_name.len == 0 || entry.type_name in seen {
                continue
            }
            seen[entry.type_name] = true
            w.mark_method_name('drop', [entry.type_name])
        }
    }
}

fn (w &Walker) is_codegen_required_root(info FnInfo) bool {
    decl := info.decl
    if !w.opts.minimal_runtime_roots && should_always_emit_for_markused(info.file) {
        return true
    }
    if !w.opts.minimal_runtime_roots && info.mod == 'builtin' && decl.name == 'print_backtrace' {
        return true
    }
    if info.mod == 'json2' && decl.name == 'enum_uses_json_as_number' {
        return true
    }
    if info.mod == 'time' && decl.is_method && decl.receiver.typ is ast.Ident
        && decl.receiver.typ.name == 'Duration' {
        return true
    }
    if info.mod == 'sync' {
        if decl.name in ['try_pop_priv', 'try_push_priv', 'new_channel_st', 'new_spin_lock'] {
            return true
        }
        if decl.is_method && decl.name == 'try_wait' {
            return true
        }
    }
    if is_builtin_map_file(info.file) && should_keep_builtin_map_decl(decl) {
        return true
    }
    if is_builtin_string_file(info.file) && should_keep_builtin_string_decl(decl) {
        return true
    }
    if is_builtin_array_file(info.file) && should_keep_builtin_array_decl(decl) {
        return true
    }
    if decl.name == 'str' || decl.name.ends_with('__str') {
        return true
    }
    if decl.name.starts_with('__sort_cmp_') {
        return true
    }
    if decl.is_method {
        if decl.name in ['+', '-', '*', '/', '%', '==', '!=', '<', '>', '<=', '>='] {
            return true
        }
        if decl.receiver.typ is ast.Type && decl.receiver.typ is ast.ArrayType {
            return true
        }
    }
    return false
}

pub fn should_always_emit_for_markused(path string) bool {
    if path.ends_with('.vh') {
        return true
    }
    return is_builtin_runtime_keep_file(path)
}

pub fn is_builtin_runtime_keep_file(path string) bool {
    normalized := path.replace('\\', '/')
    return normalized.ends_with('vlib/builtin/map.c.v')
        || normalized.ends_with('vlib/builtin/builtin.c.v')
        || normalized.ends_with('vlib/builtin/builtin.v')
        || normalized.ends_with('vlib/builtin/cfns_wrapper.c.v')
        || normalized.ends_with('vlib/builtin/allocation.c.v')
        || normalized.ends_with('vlib/builtin/prealloc.c.v')
        || normalized.ends_with('vlib/builtin/panicing.c.v')
        || normalized.ends_with('vlib/builtin/chan_option_result.v')
        || normalized.ends_with('vlib/builtin/int.v') || normalized.ends_with('vlib/builtin/rune.v')
        || normalized.ends_with('vlib/builtin/float.c.v')
        || normalized.ends_with('vlib/builtin/utf8.v')
        || normalized.ends_with('vlib/builtin/utf8.c.v')
        || normalized.ends_with('vlib/strings/builder.c.v')
        || normalized.ends_with('vlib/strconv/utilities.v')
        || normalized.ends_with('vlib/strconv/utilities.c.v')
        || normalized.ends_with('vlib/strconv/ftoa.c.v')
        || normalized.ends_with('vlib/strconv/f32_str.c.v')
        || normalized.ends_with('vlib/strconv/f64_str.c.v')
        || normalized.ends_with('vlib/math/bits/bits.v')
        || normalized.ends_with('vlib/math/bits/bits.c.v')
        || normalized.ends_with('vlib/sokol/memory/memory.c.v')
}

pub fn is_builtin_map_file(path string) bool {
    normalized := path.replace('\\', '/')
    return normalized.ends_with('vlib/builtin/map.v')
}

pub fn should_keep_builtin_map_decl(decl ast.FnDecl) bool {
    base_keep := decl.name in ['new_map', 'move', 'clear', 'key_to_index', 'meta_less',
        'meta_greater', 'ensure_extra_metas', 'ensure_extra_metas_grow', 'set', 'expand', 'rehash',
        'reserve', 'cached_rehash', 'get_and_set', 'get', 'get_check', 'exists', 'delete', 'keys',
        'values', 'clone', 'free', 'key', 'value', 'has_index', 'zeros_to_end', 'new_dense_array']
    return base_keep || decl.name.starts_with('map_eq_') || decl.name.starts_with('map_clone_')
        || decl.name.starts_with('map_free_')
}

pub fn is_builtin_string_file(path string) bool {
    normalized := path.replace('\\', '/')
    return normalized.ends_with('vlib/builtin/string.v')
}

pub fn should_keep_builtin_string_decl(decl ast.FnDecl) bool {
    return decl.name in ['eq', 'plus', 'plus_two', 'substr', 'substr_unsafe', 'repeat', 'free',
        'vstring', 'vstring_with_len', 'vstring_literal', 'vstring_literal_with_len', 'runes',
        'join', 'compare_strings', 'compare_strings_by_len', 'compare_lower_strings']
}

pub fn is_builtin_array_file(path string) bool {
    normalized := path.replace('\\', '/')
    return normalized.ends_with('vlib/builtin/array.v')
}

pub fn should_keep_builtin_array_decl(decl ast.FnDecl) bool {
    return decl.name in [
        '__new_array',
        '__new_array_with_default',
        '__new_array_with_multi_default',
        '__new_array_with_array_default',
        '__new_array_with_map_default',
        'new_array_from_c_array',
        'new_array_from_c_array_no_alloc',
        'new_array_from_array_and_c_array',
        'ensure_cap',
        'repeat',
        'repeat_to_depth',
        'insert',
        'insert_many',
        'prepend',
        'prepend_many',
        'delete',
        'delete_many',
        'clear',
        'reset',
        'trim',
        'drop',
        'get_unsafe',
        'get',
        'get_with_check',
        'first',
        'last',
        'pop_left',
        'pop',
        'delete_last',
        'slice',
        'slice_ni',
        'contains',
        'clone_static_to_depth',
        'clone',
        'clone_to_depth',
        'set_unsafe',
        'set',
        'push',
        'push_many',
        'reverse_in_place',
        'reverse',
        'free',
        'sort',
        'sort_with_compare',
        'sorted_with_compare',
        'copy',
        'write_u8',
        'write_rune',
        'write_string',
        'write_ptr',
        'grow_cap',
        'grow_len',
        'pointers',
        'panic_on_negative_len',
        'panic_on_negative_cap',
    ]
}

fn (mut w Walker) seed_top_level_initializer_roots() {
    for file in w.files {
        mod_name := normalize_module_name(file.mod)
        for stmt in file.stmts {
            if !stmt_ok(stmt) {
                continue
            }
            match stmt {
                ast.ConstDecl, ast.GlobalDecl {
                    w.walk_stmt(stmt, mod_name)
                }
                else {}
            }
        }
    }
}

fn (mut w Walker) seed_top_level_initializer_roots_from_flat(flat &ast.FlatAst) {
    for i in 0 .. flat.files.len {
        fc := flat.file_cursor(i)
        mod_name := normalize_module_name(fc.mod())
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            stmt_c := stmts.at(j)
            match stmt_c.kind() {
                .stmt_const_decl, .stmt_global_decl {
                    w.walk_stmt_cursor(stmt_c, mod_name)
                }
                else {}
            }
        }
    }
}

fn generic_base_name_from_key(key string) string {
    mut name := key
    bracket_idx := name.index_u8(`[`)
    if bracket_idx > 0 {
        name = name[..bracket_idx]
    }
    dot_idx := name.last_index_u8(`.`)
    if dot_idx > 0 && dot_idx < name.len - 1 {
        name = name[dot_idx + 1..]
    }
    return strip_generic_specialization_suffix(name)
}

fn (mut w Walker) seed_generic_specialization_roots() {
    if w.env == unsafe { nil } {
        return
    }
    for key, _ in w.env.generic_types {
        base_name := generic_base_name_from_key(key)
        if base_name == '' {
            continue
        }
        w.mark_lookup('fn:${base_name}')
        w.mark_lookup('mname:${base_name}')
    }
}

fn is_main_root(info FnInfo) bool {
    return !is_method_decl(info.decl) && info.mod == 'main' && info.decl.name == 'main'
}

fn is_test_root(info FnInfo) bool {
    return !is_method_decl(info.decl) && info.decl.name.starts_with('test_')
        && info.decl.typ.params.len == 0
}

fn is_method_decl(decl ast.FnDecl) bool {
    return decl.is_method || decl.is_static
}

fn is_module_init(info FnInfo) bool {
    return !is_method_decl(info.decl) && (info.decl.name == 'init'
        || info.decl.name == 'deinit'
        || info.decl.name.starts_with('__v_init_consts_'))
}

fn normalize_module_name(module_name string) string {
    if module_name == '' {
        return 'main'
    }
    return module_name
}

fn sanitize_receiver_name(name string) string {
    if !string_ok(name) {
        return ''
    }
    mut out := name.trim_space()
    for out.len > 0 && (out[0] == `&` || out[0] == `?` || out[0] == `!`) {
        out = out[1..]
    }
    return out
}

fn maybe_trim_module_prefix(mod_name string, name string) string {
    if mod_name == '' || mod_name == 'main' {
        return name
    }
    prefix := '${mod_name}__'
    if name.starts_with(prefix) {
        return name[prefix.len..]
    }
    return name
}

fn add_unique_string(mut out []string, value string) {
    if value == '' {
        return
    }
    for existing in out {
        if existing == value {
            return
        }
    }
    out << value
}

fn add_unique_int(mut out []int, value int) {
    for existing in out {
        if existing == value {
            return
        }
    }
    out << value
}

fn add_unique_fn_name(mut out []string, value string) {
    if value == '' {
        return
    }
    for existing in out {
        if existing == value {
            return
        }
    }
    out << value
}

fn type_name_candidates_from_type(mod_name string, typ types.Type) []string {
    mut out := []string{}
    names := [typ.name(), typ.base_type().name()]
    for raw_name in names {
        name := sanitize_receiver_name(raw_name)
        add_unique_string(mut out, name)
        add_unique_string(mut out, maybe_trim_module_prefix(mod_name, name))
        if name.contains('__') {
            add_unique_string(mut out, name.all_after_last('__'))
        } else if mod_name != '' && mod_name != 'main' {
            add_unique_string(mut out, '${mod_name}__${name}')
        }
        // For array types like []Attribute, also add Array_Attribute form.
        if name.starts_with('[]') {
            elem := name[2..]
            add_unique_string(mut out, 'Array_${elem}')
            add_unique_string(mut out, maybe_trim_module_prefix(mod_name, 'Array_${elem}'))
            if mod_name != '' && mod_name != 'main' {
                add_unique_string(mut out, 'Array_${mod_name}__${elem}')
            }
        }
    }
    return out
}

fn type_is_fn_value(typ types.Type) bool {
    return type_is_fn_value_with_depth(typ, 0)
}

fn type_is_fn_value_with_depth(typ types.Type, depth int) bool {
    if depth > 16 || !type_ok(typ) {
        return false
    }
    match typ {
        types.FnType {
            return true
        }
        types.Alias {
            return type_is_fn_value_with_depth(typ.base_type, depth + 1)
        }
        else {
            return false
        }
    }
}

fn (w &Walker) type_name_is_fn_value(name string, mod_name string) bool {
    if w.env == unsafe { nil } || name == '' || !string_ok(name) {
        return false
    }
    mut type_names := []string{}
    add_unique_string(mut type_names, name)
    add_unique_string(mut type_names, maybe_trim_module_prefix(mod_name, name))
    if name.contains('__') {
        add_unique_string(mut type_names, name.all_after_last('__'))
    } else if mod_name != '' && mod_name != 'main' {
        add_unique_string(mut type_names, '${mod_name}__${name}')
    }
    mut scope_names := []string{}
    add_unique_string(mut scope_names, mod_name)
    if name.contains('__') {
        add_unique_string(mut scope_names, name.all_before('__'))
    }
    add_unique_string(mut scope_names, 'builtin')
    for scope_name in scope_names {
        if scope_name == '' {
            continue
        }
        if scope := w.env.get_scope(scope_name) {
            for type_name in type_names {
                if typ := scope.lookup_type_parent(type_name, 0) {
                    if type_is_fn_value(typ) {
                        return true
                    }
                }
            }
        }
    }
    return false
}

fn (w &Walker) type_expr_is_fn_value(expr ast.Expr, mod_name string) bool {
    match expr {
        ast.Ident {
            return w.type_name_is_fn_value(expr.name, mod_name)
        }
        ast.SelectorExpr {
            if expr.lhs is ast.Ident {
                lhs_name := expr.lhs.name
                real_mod := w.module_alias_to_real[lhs_name] or { lhs_name }
                return w.type_name_is_fn_value(expr.rhs.name, real_mod)
                    || w.type_name_is_fn_value('${real_mod}__${expr.rhs.name}', real_mod)
            }
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return w.type_expr_is_fn_value(expr.expr, mod_name)
            }
        }
        ast.ModifierExpr {
            return w.type_expr_is_fn_value(expr.expr, mod_name)
        }
        ast.GenericArgs {
            return w.type_expr_is_fn_value(expr.lhs, mod_name)
        }
        ast.GenericArgOrIndexExpr {
            return w.type_expr_is_fn_value(expr.lhs, mod_name)
        }
        ast.Type {
            match expr {
                ast.FnType {
                    return true
                }
                ast.PointerType {
                    return w.type_expr_is_fn_value(expr.base_type, mod_name)
                }
                ast.GenericType {
                    return w.type_expr_is_fn_value(expr.name, mod_name)
                }
                else {}
            }
        }
        else {}
    }

    return false
}

fn (w &Walker) expr_has_fn_value_type(expr ast.Expr) bool {
    if w.env == unsafe { nil } || !expr_ok(expr) {
        return false
    }
    pos := expr.pos()
    if !pos.is_valid() {
        return false
    }
    if typ := w.env.get_expr_type(pos.id) {
        return type_is_fn_value(typ)
    }
    return false
}

fn (w &Walker) cursor_has_fn_value_type(c ast.Cursor) bool {
    if w.env == unsafe { nil } || !c.is_valid() {
        return false
    }
    pos := c.pos()
    if !pos.is_valid() {
        return false
    }
    if typ := w.env.get_expr_type(pos.id) {
        return type_is_fn_value(typ)
    }
    return false
}

fn (w &Walker) type_expr_is_fn_value_cursor(c ast.Cursor, mod_name string) bool {
    if !c.is_valid() {
        return false
    }
    if w.cursor_has_fn_value_type(c) {
        return true
    }
    match c.kind() {
        .expr_ident {
            return w.type_name_is_fn_value(c.name(), mod_name)
        }
        .expr_selector {
            lhs_c := c.edge(0)
            rhs_c := c.edge(1)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_ident && rhs_c.is_valid() {
                real_mod := w.module_alias_to_real[lhs_c.name()] or { lhs_c.name() }
                return w.type_name_is_fn_value(rhs_c.name(), real_mod)
                    || w.type_name_is_fn_value('${real_mod}__${rhs_c.name()}', real_mod)
            }
        }
        .expr_prefix, .expr_modifier, .typ_pointer, .typ_generic {
            return w.type_expr_is_fn_value_cursor(c.edge(0), mod_name)
        }
        .typ_fn {
            return true
        }
        else {}
    }

    return false
}

fn add_receiver_name_candidates(mut out []string, mod_name string, raw_name string) {
    name := sanitize_receiver_name(raw_name)
    if name == '' {
        return
    }
    add_unique_string(mut out, name)
    add_unique_string(mut out, maybe_trim_module_prefix(mod_name, name))
    if name.contains('__') {
        add_unique_string(mut out, name.all_after_last('__'))
    } else if mod_name != '' && mod_name != 'main' {
        add_unique_string(mut out, '${mod_name}__${name}')
    }
}

fn receiver_type_expr_name(expr ast.Expr) string {
    match expr {
        ast.Ident {
            return expr.name
        }
        ast.SelectorExpr {
            return expr.rhs.name
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return receiver_type_expr_name(expr.expr)
            }
        }
        ast.ModifierExpr {
            return receiver_type_expr_name(expr.expr)
        }
        ast.GenericArgs {
            return receiver_type_expr_name(expr.lhs)
        }
        ast.GenericArgOrIndexExpr {
            return receiver_type_expr_name(expr.lhs)
        }
        ast.Type {
            match expr {
                ast.PointerType {
                    return receiver_type_expr_name(expr.base_type)
                }
                ast.ArrayType {
                    elem_name := receiver_type_expr_name(expr.elem_type)
                    if elem_name != '' {
                        return 'Array_${elem_name}'
                    }
                }
                ast.ArrayFixedType {
                    elem_name := receiver_type_expr_name(expr.elem_type)
                    len_name := receiver_fixed_array_len_name(expr.len)
                    if elem_name != '' && len_name != '' {
                        return 'Array_fixed_${elem_name}_${len_name}'
                    }
                }
                ast.GenericType {
                    return receiver_type_expr_name(expr.name)
                }
                else {}
            }
        }
        else {}
    }

    return ''
}

fn receiver_fixed_array_len_name(expr ast.Expr) string {
    match expr {
        ast.BasicLiteral {
            return expr.value
        }
        ast.Ident {
            return expr.name
        }
        else {
            return expr.name()
        }
    }
}

fn type_expr_receiver_candidates(mod_name string, expr ast.Expr) []string {
    mut out := []string{}
    match expr {
        ast.SelectorExpr {
            if expr.lhs is ast.Ident {
                add_receiver_name_candidates(mut out, mod_name, expr.rhs.name)
                add_unique_string(mut out, '${expr.lhs.name}__${expr.rhs.name}')
            }
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return type_expr_receiver_candidates(mod_name, expr.expr)
            }
        }
        ast.ModifierExpr {
            return type_expr_receiver_candidates(mod_name, expr.expr)
        }
        ast.GenericArgs {
            return type_expr_receiver_candidates(mod_name, expr.lhs)
        }
        ast.GenericArgOrIndexExpr {
            return type_expr_receiver_candidates(mod_name, expr.lhs)
        }
        ast.Type {
            match expr {
                ast.PointerType {
                    return type_expr_receiver_candidates(mod_name, expr.base_type)
                }
                ast.GenericType {
                    return type_expr_receiver_candidates(mod_name, expr.name)
                }
                else {}
            }
        }
        else {}
    }

    name := receiver_type_expr_name(expr)
    if name != '' {
        add_receiver_name_candidates(mut out, mod_name, name)
    }
    return out
}

fn type_expr_receiver_candidates_cursor(c ast.Cursor, mod_name string) []string {
    mut out := []string{}
    if !c.is_valid() {
        return out
    }
    match c.kind() {
        .expr_selector {
            lhs_c := c.edge(0)
            rhs_c := c.edge(1)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_ident && rhs_c.is_valid() {
                add_receiver_name_candidates(mut out, mod_name, rhs_c.name())
                add_unique_string(mut out, '${lhs_c.name()}__${rhs_c.name()}')
            }
        }
        .expr_prefix, .expr_modifier, .expr_generic_args, .expr_generic_arg_or_index, .typ_pointer,
        .typ_generic {
            return type_expr_receiver_candidates_cursor(c.edge(0), mod_name)
        }
        .expr_ident {
            add_receiver_name_candidates(mut out, mod_name, c.name())
        }
        else {}
    }

    name := receiver_type_expr_name_cursor(c)
    if name != '' {
        add_receiver_name_candidates(mut out, mod_name, name)
    }
    return out
}

fn receiver_type_expr_name_cursor(c ast.Cursor) string {
    if !c.is_valid() {
        return ''
    }
    match c.kind() {
        .expr_ident {
            return c.name()
        }
        .expr_selector {
            rhs := c.edge(1)
            if rhs.is_valid() {
                return rhs.name()
            }
        }
        .expr_prefix, .expr_modifier, .expr_generic_args, .expr_generic_arg_or_index, .typ_pointer,
        .typ_generic {
            return receiver_type_expr_name_cursor(c.edge(0))
        }
        .typ_array {
            elem_name := receiver_type_expr_name_cursor(c.edge(0))
            if elem_name != '' {
                return 'Array_${elem_name}'
            }
        }
        .typ_array_fixed {
            elem_name := receiver_type_expr_name_cursor(c.edge(1))
            len_name := receiver_fixed_array_len_name_cursor(c.edge(0))
            if elem_name != '' && len_name != '' {
                return 'Array_fixed_${elem_name}_${len_name}'
            }
        }
        else {}
    }

    return ''
}

fn receiver_fixed_array_len_name_cursor(c ast.Cursor) string {
    if !c.is_valid() {
        return ''
    }
    if c.kind() == .expr_basic_literal || c.kind() == .expr_ident {
        return c.name()
    }
    return c.name()
}

fn receiver_names_from_decl(mod_name string, decl ast.FnDecl, env &types.Environment) []string {
    mut out := []string{}
    add_receiver_name_candidates(mut out, mod_name, receiver_type_expr_name(decl.receiver.typ))
    match decl.receiver.typ {
        ast.Ident {
            name := sanitize_receiver_name(decl.receiver.typ.name)
            add_unique_string(mut out, name)
            add_unique_string(mut out, maybe_trim_module_prefix(mod_name, name))
            if mod_name != '' && mod_name != 'main' {
                add_unique_string(mut out, '${mod_name}__${name}')
            }
        }
        ast.PrefixExpr {
            if decl.receiver.typ.expr is ast.Ident {
                name := sanitize_receiver_name(decl.receiver.typ.expr.name)
                add_unique_string(mut out, name)
                add_unique_string(mut out, maybe_trim_module_prefix(mod_name, name))
                if mod_name != '' && mod_name != 'main' {
                    add_unique_string(mut out, '${mod_name}__${name}')
                }
            }
        }
        else {}
    }

    // Method on []ElemType — receiver name is Array_ElemType.
    // Use the string name which includes [] prefix for array types.
    recv_name := decl.receiver.typ.name()
    if recv_name.starts_with('[]') {
        elem_name := recv_name[2..]
        if elem_name.len > 0 {
            arr_name := 'Array_${elem_name}'
            add_unique_string(mut out, arr_name)
            add_unique_string(mut out, maybe_trim_module_prefix(mod_name, arr_name))
            if mod_name != '' && mod_name != 'main' {
                add_unique_string(mut out, 'Array_${mod_name}__${elem_name}')
            }
        }
    }
    pos := decl.receiver.typ.pos()
    if env != unsafe { nil } && pos.is_valid() {
        if receiver_type := env.get_expr_type(pos.id) {
            for name in type_name_candidates_from_type(mod_name, receiver_type) {
                add_unique_string(mut out, name)
            }
        }
    }
    return out
}

fn receiver_primary_name(mod_name string, decl ast.FnDecl, env &types.Environment) string {
    names := receiver_names_from_decl(mod_name, decl, env)
    if names.len > 0 {
        return names[0]
    }
    return 'unknown'
}

fn normalize_method_name(name string) string {
    if !string_ok(name) {
        return ''
    }
    return match name {
        '+' { 'plus' }
        '-' { 'minus' }
        '*' { 'mul' }
        '/' { 'div' }
        '%' { 'mod' }
        '==' { 'eq' }
        '!=' { 'ne' }
        '<' { 'lt' }
        '>' { 'gt' }
        '<=' { 'le' }
        '>=' { 'ge' }
        else { name }
    }
}

fn (w &Walker) lookup_fn_scope(info FnInfo) &types.Scope {
    if w.env == unsafe { nil } {
        return unsafe { nil }
    }
    decl := info.decl
    mod_name := info.mod
    if !is_method_decl(decl) {
        if scope := w.env.get_fn_scope(mod_name, decl.name) {
            return scope
        }
        return unsafe { nil }
    }
    receivers := receiver_names_from_decl(mod_name, decl, w.env)
    for recv in receivers {
        if scope := w.env.get_fn_scope(mod_name, '${recv}__${decl.name}') {
            return scope
        }
    }
    return unsafe { nil }
}

fn (mut w Walker) add_lookup(key string, idx int) {
    if key == '' {
        return
    }
    if key !in w.lookup {
        w.lookup[key] = [idx]
        return
    }
    mut values := w.lookup[key]
    add_unique_int(mut values, idx)
    w.lookup[key] = values
}

fn (mut w Walker) index_fn(idx int, info FnInfo) {
    decl := info.decl
    mod_name := info.mod
    if is_method_decl(decl) {
        mut method_names := []string{}
        add_unique_string(mut method_names, decl.name)
        add_unique_string(mut method_names, normalize_method_name(decl.name))
        receivers := receiver_names_from_decl(mod_name, decl, w.env)
        for method_name in method_names {
            w.add_lookup('mname:${method_name}', idx)
            for receiver_name in receivers {
                w.add_method_receiver(receiver_name, idx)
                if receiver_name.contains('__') {
                    w.add_method_receiver(receiver_name.all_after_last('__'), idx)
                }
                w.add_lookup('meth:${receiver_name}:${method_name}', idx)
                w.add_lookup('fn:${receiver_name}__${method_name}', idx)
                w.add_lookup('mod:${mod_name}:${receiver_name}__${method_name}', idx)
            }
        }
        return
    }
    w.add_lookup('fn:${decl.name}', idx)
    w.add_lookup('mod:${mod_name}:${decl.name}', idx)
    if mod_name != '' && mod_name != 'main' && mod_name != 'builtin' {
        w.add_lookup('fn:${mod_name}__${decl.name}', idx)
    }
}

fn (mut w Walker) add_module_name(name string) {
    if name == '' {
        return
    }
    w.module_names[name] = true
    if name.contains('.') {
        w.module_names[name.all_after_last('.')] = true
    }
}

fn (mut w Walker) add_type_name(mod_name string, name string) {
    if name == '' {
        return
    }
    w.type_names[name] = true
    trimmed := maybe_trim_module_prefix(mod_name, name)
    w.type_names[trimmed] = true
    if mod_name != '' && mod_name != 'main' {
        w.type_names['${mod_name}__${trimmed}'] = true
    }
}

fn (mut w Walker) add_interface_name(mod_name string, name string) {
    if name == '' {
        return
    }
    w.interface_type_names[name] = true
    trimmed := maybe_trim_module_prefix(mod_name, name)
    w.interface_type_names[trimmed] = true
    if mod_name != '' && mod_name != 'main' {
        w.interface_type_names['${mod_name}__${trimmed}'] = true
    }
}

fn (mut w Walker) add_interface_decl(mod_name string, decl ast.InterfaceDecl) {
    w.add_interface_name(mod_name, decl.name)
    mut method_names := []string{}
    for field in decl.fields {
        if field.is_interface_method && field.typ is ast.Type && field.typ is ast.FnType {
            add_unique_fn_name(mut method_names, field.name)
            add_unique_fn_name(mut method_names, normalize_method_name(field.name))
        }
    }
    mut embedded_names := []string{}
    for embedded in decl.embedded {
        for embedded_name in type_expr_receiver_candidates(mod_name, embedded) {
            add_unique_string(mut embedded_names, embedded_name)
        }
    }
    mut iface_names := []string{}
    add_unique_string(mut iface_names, decl.name)
    add_unique_string(mut iface_names, maybe_trim_module_prefix(mod_name, decl.name))
    if mod_name != '' && mod_name != 'main' {
        trimmed := maybe_trim_module_prefix(mod_name, decl.name)
        add_unique_string(mut iface_names, '${mod_name}__${trimmed}')
    }
    for iface_name in iface_names {
        if method_names.len > 0 {
            if iface_name in w.interface_method_names {
                mut existing := w.interface_method_names[iface_name]
                for method_name in method_names {
                    add_unique_fn_name(mut existing, method_name)
                }
                w.interface_method_names[iface_name] = existing
            } else {
                w.interface_method_names[iface_name] = method_names.clone()
            }
        }
        if embedded_names.len > 0 {
            mut existing := w.interface_embedded_names[iface_name] or { []string{} }
            for embedded_name in embedded_names {
                add_unique_string(mut existing, embedded_name)
            }
            w.interface_embedded_names[iface_name] = existing
        }
    }
}

fn (mut w Walker) add_interface_decl_cursor(mod_name string, decl ast.Cursor) {
    w.add_interface_name(mod_name, decl.name())
    mut method_names := []string{}
    fields := decl.list_at(3)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        typ := field.edge(0)
        if field.flag(ast.flag_field_is_interface_method) && typ.is_valid() && typ.kind() == .typ_fn {
            add_unique_fn_name(mut method_names, field.name())
            add_unique_fn_name(mut method_names, normalize_method_name(field.name()))
        }
    }
    mut embedded_names := []string{}
    embedded := decl.list_at(2)
    for i in 0 .. embedded.len() {
        for embedded_name in type_expr_receiver_candidates_cursor(embedded.at(i), mod_name) {
            add_unique_string(mut embedded_names, embedded_name)
        }
    }
    mut iface_names := []string{}
    add_unique_string(mut iface_names, decl.name())
    add_unique_string(mut iface_names, maybe_trim_module_prefix(mod_name, decl.name()))
    if mod_name != '' && mod_name != 'main' {
        trimmed := maybe_trim_module_prefix(mod_name, decl.name())
        add_unique_string(mut iface_names, '${mod_name}__${trimmed}')
    }
    for iface_name in iface_names {
        if method_names.len > 0 {
            if iface_name in w.interface_method_names {
                mut existing := w.interface_method_names[iface_name]
                for method_name in method_names {
                    add_unique_fn_name(mut existing, method_name)
                }
                w.interface_method_names[iface_name] = existing
            } else {
                w.interface_method_names[iface_name] = method_names.clone()
            }
        }
        if embedded_names.len > 0 {
            mut existing := w.interface_embedded_names[iface_name] or { []string{} }
            for embedded_name in embedded_names {
                add_unique_string(mut existing, embedded_name)
            }
            w.interface_embedded_names[iface_name] = existing
        }
    }
}

fn (mut w Walker) add_struct_field_receivers(mod_name string, decl ast.StructDecl) {
    mut struct_names := []string{}
    add_receiver_name_candidates(mut struct_names, mod_name, decl.name)
    for field in decl.fields {
        field_receivers := type_expr_receiver_candidates(mod_name, field.typ)
        if field_receivers.len == 0 {
            continue
        }
        for struct_name in struct_names {
            key := '${struct_name}:${field.name}'
            mut existing := w.struct_field_receivers[key] or { []string{} }
            for receiver in field_receivers {
                add_unique_string(mut existing, receiver)
            }
            w.struct_field_receivers[key] = existing
        }
    }
}

fn (mut w Walker) add_struct_field_receivers_cursor(mod_name string, decl ast.Cursor) {
    mut struct_names := []string{}
    add_receiver_name_candidates(mut struct_names, mod_name, decl.name())
    fields := decl.list_at(4)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        field_receivers := type_expr_receiver_candidates_cursor(field.edge(0), mod_name)
        if field_receivers.len == 0 {
            continue
        }
        for struct_name in struct_names {
            key := '${struct_name}:${field.name()}'
            mut existing := w.struct_field_receivers[key] or { []string{} }
            for receiver in field_receivers {
                add_unique_string(mut existing, receiver)
            }
            w.struct_field_receivers[key] = existing
        }
    }
}

fn (mut w Walker) add_struct_embedded_receivers(mod_name string, decl ast.StructDecl) {
    if decl.embedded.len == 0 {
        return
    }
    mut struct_names := []string{}
    add_receiver_name_candidates(mut struct_names, mod_name, decl.name)
    for embedded in decl.embedded {
        embedded_receivers := type_expr_receiver_candidates(mod_name, embedded)
        if embedded_receivers.len == 0 {
            continue
        }
        for struct_name in struct_names {
            mut existing := w.struct_embedded_receivers[struct_name] or { []string{} }
            for receiver in embedded_receivers {
                add_unique_string(mut existing, receiver)
            }
            w.struct_embedded_receivers[struct_name] = existing
        }
    }
}

fn (mut w Walker) add_struct_embedded_receivers_cursor(mod_name string, decl ast.Cursor) {
    embedded := decl.list_at(2)
    if embedded.len() == 0 {
        return
    }
    mut struct_names := []string{}
    add_receiver_name_candidates(mut struct_names, mod_name, decl.name())
    for i in 0 .. embedded.len() {
        embedded_receivers := type_expr_receiver_candidates_cursor(embedded.at(i), mod_name)
        if embedded_receivers.len == 0 {
            continue
        }
        for struct_name in struct_names {
            mut existing := w.struct_embedded_receivers[struct_name] or { []string{} }
            for receiver in embedded_receivers {
                add_unique_string(mut existing, receiver)
            }
            w.struct_embedded_receivers[struct_name] = existing
        }
    }
}

fn (mut w Walker) add_struct_fn_fields(mod_name string, decl ast.StructDecl) {
    mut struct_names := []string{}
    add_receiver_name_candidates(mut struct_names, mod_name, decl.name)
    for field in decl.fields {
        if !w.type_expr_is_fn_value(field.typ, mod_name) {
            continue
        }
        for struct_name in struct_names {
            w.struct_fn_fields['${struct_name}:${field.name}'] = true
        }
    }
}

fn (mut w Walker) add_struct_fn_fields_cursor(mod_name string, decl ast.Cursor) {
    mut struct_names := []string{}
    add_receiver_name_candidates(mut struct_names, mod_name, decl.name())
    fields := decl.list_at(4)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        if !w.type_expr_is_fn_value_cursor(field.edge(0), mod_name) {
            continue
        }
        for struct_name in struct_names {
            w.struct_fn_fields['${struct_name}:${field.name()}'] = true
        }
    }
}

fn (w &Walker) init_field_is_fn_value(init_typ ast.Expr, field_name string, mod_name string) bool {
    if field_name == '' {
        return false
    }
    for struct_name in type_expr_receiver_candidates(mod_name, init_typ) {
        if w.struct_fn_fields['${struct_name}:${field_name}'] {
            return true
        }
    }
    return false
}

fn (w &Walker) init_field_is_fn_value_cursor(init_typ ast.Cursor, field_name string, mod_name string) bool {
    if field_name == '' {
        return false
    }
    for struct_name in type_expr_receiver_candidates_cursor(init_typ, mod_name) {
        if w.struct_fn_fields['${struct_name}:${field_name}'] {
            return true
        }
    }
    return false
}

fn (mut w Walker) add_global_interface_names(mod_name string, decl ast.GlobalDecl) {
    for field in decl.fields {
        iface_name := w.interface_name_from_type_expr(field.typ, mod_name)
        if iface_name == '' {
            continue
        }
        w.global_interface_names[field.name] = iface_name
        if mod_name != '' && mod_name != 'main' && mod_name != 'builtin' {
            w.global_interface_names['${mod_name}__${field.name}'] = iface_name
        }
    }
}

fn (mut w Walker) add_global_interface_names_cursor(mod_name string, decl ast.Cursor) {
    fields := decl.list_at(1)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        iface_name := w.interface_name_from_cursor(field.edge(0), mod_name)
        if iface_name == '' {
            continue
        }
        w.global_interface_names[field.name()] = iface_name
        if mod_name != '' && mod_name != 'main' && mod_name != 'builtin' {
            w.global_interface_names['${mod_name}__${field.name()}'] = iface_name
        }
    }
}

fn (mut w Walker) add_method_receiver(receiver_name string, idx int) {
    if receiver_name == '' {
        return
    }
    if receiver_name !in w.methods_by_receiver {
        w.methods_by_receiver[receiver_name] = [idx]
        return
    }
    mut values := w.methods_by_receiver[receiver_name]
    add_unique_int(mut values, idx)
    w.methods_by_receiver[receiver_name] = values
}

fn (mut w Walker) mark_fn(idx int) {
    if idx < 0 || idx >= w.fns.len {
        return
    }
    info := w.fns[idx]
    key := info.key
    was_used := key in w.used_keys
    if !was_used {
        w.used_keys[key] = true
        w.mark_generic_binding_receiver_methods(info)
    }
    if idx in w.queued_fn_indices {
        return
    }
    w.queued_fn_indices[idx] = true
    if info.has_body {
        w.queue << idx
    }
}

fn (mut w Walker) mark_generic_binding_receiver_methods(info FnInfo) {
    if w.env == unsafe { nil } || info.decl.typ.generic_params.len == 0 {
        return
    }
    for key, bindings_list in w.env.generic_types {
        if generic_base_name_from_key(key) != info.decl.name {
            continue
        }
        for bindings in bindings_list {
            for _, concrete in bindings {
                receivers := type_name_candidates_from_type(info.mod, concrete)
                w.mark_all_methods_for_receivers(receivers)
            }
        }
    }
}

fn (w &Walker) lookup_count(key string) int {
    if !string_ok(key) {
        return 0
    }
    if values := w.lookup[key] {
        return values.len
    }
    return 0
}

fn (mut w Walker) mark_lookup(key string) {
    if !string_ok(key) {
        return
    }
    if values := w.lookup[key] {
        for idx in values {
            w.mark_fn(idx)
        }
    }
}

fn called_fn_name_candidates(name string) []string {
    mut out := []string{}
    if name == '' || !string_ok(name) {
        return out
    }
    add_unique_string(mut out, name)
    generic_base := strip_generic_specialization_suffix(name)
    if generic_base != name {
        add_unique_string(mut out, generic_base)
    }
    if name == 'builtin__new_array_from_c_array_noscan' {
        add_unique_string(mut out, 'new_array_from_c_array')
        return out
    }
    if name == 'builtin__new_array_from_array_and_c_array' {
        add_unique_string(mut out, 'new_array_from_array_and_c_array')
        return out
    }
    if name == 'builtin__array_push_noscan' || name == 'builtin__array__push_noscan' {
        add_unique_string(mut out, 'array__push_noscan')
        return out
    }
    if name.starts_with('builtin__') {
        base := name['builtin__'.len..]
        add_unique_string(mut out, base)
    }
    if name == 'gen_v__new_gen' {
        add_unique_string(mut out, 'v__new_gen')
    }
    if name.starts_with('strings__Builder__') {
        method_name := name.all_after_last('__')
        add_unique_string(mut out, 'array__${method_name}')
    }
    return out
}

fn (mut w Walker) cached_called_fn_name_candidates(name string) []string {
    if candidates := w.called_fn_name_candidate_cache[name] {
        return candidates
    }
    candidates := called_fn_name_candidates(name)
    w.called_fn_name_candidate_cache[name] = candidates
    return candidates
}

fn strip_generic_specialization_suffix(name string) string {
    if idx := name.index('_T_') {
        if idx > 0 {
            return name[..idx]
        }
    }
    return name
}

fn should_mark_ident_as_fn(name string) bool {
    if name == '' || !string_ok(name) {
        return false
    }
    return name.starts_with('map_') || name.starts_with('map__') || name.starts_with('new_map')
        || name.starts_with('array__') || name.starts_with('IError_') || name.starts_with('Error__')
        || name.starts_with('MessageError__') || name.starts_with('_option_')
        || name.starts_with('_result_')
}

fn (mut w Walker) ident_resolves_to_fn_value(name string, mod_name string) bool {
    if name == '' || !string_ok(name) || name == 'C' || name in w.module_names
        || w.is_cast_type_name(name) {
        return false
    }
    if w.cur_fn_scope != unsafe { nil } {
        if obj := w.cur_fn_scope.lookup_parent(name, 0) {
            return obj is types.Fn
        }
    }
    candidates := w.cached_called_fn_name_candidates(name)
    if _ := w.exact_mangled_fn_lookup_key(name) {
        return true
    }
    for candidate in candidates {
        if _ := w.current_module_fn_lookup_key(candidate, mod_name) {
            return true
        }
    }
    for candidate in candidates {
        if _ := w.selective_import_fn_lookup_key(candidate) {
            return true
        }
    }
    for candidate in candidates {
        if w.lookup_count('mod:${mod_name}:${candidate}') > 0
            || w.lookup_count('fn:${candidate}') > 0 {
            return true
        }
        if !candidate.contains('__') && mod_name != '' && mod_name != 'main'
            && mod_name != 'builtin' && w.lookup_count('fn:${mod_name}__${candidate}') > 0 {
            return true
        }
    }
    return false
}

fn (w &Walker) current_module_fn_lookup_key(name string, mod_name string) ?string {
    key := 'mod:${mod_name}:${name}'
    if w.lookup_count(key) > 0 {
        return key
    }
    return none
}

fn (w &Walker) exact_mangled_fn_lookup_key(name string) ?string {
    if !name.contains('__') {
        return none
    }
    key := 'fn:${name}'
    if w.lookup_count(key) > 0 {
        return key
    }
    return none
}

fn (w &Walker) selective_import_fn_lookup_key(name string) ?string {
    if w.cur_fn_file == '' {
        return none
    }
    if target := w.selective_import_fn_targets[selective_import_fn_key(w.cur_fn_file, name)] {
        key := 'fn:${target}'
        if w.lookup_count(key) > 0 {
            return key
        }
    }
    return none
}

fn (mut w Walker) mark_fn_name(name string, mod_name string) {
    if name == '' || !string_ok(name) || !string_ok(mod_name) {
        return
    }
    if w.opts.minimal_runtime_roots && name in ['array__eq', 'builtin__array__eq'] {
        w.mark_fn_name('map_map_eq', 'builtin')
    }
    candidates := w.cached_called_fn_name_candidates(name)
    if key := w.exact_mangled_fn_lookup_key(name) {
        w.mark_lookup(key)
        return
    }
    for candidate in candidates {
        if key := w.current_module_fn_lookup_key(candidate, mod_name) {
            w.mark_lookup(key)
            return
        }
    }
    for candidate in candidates {
        if key := w.selective_import_fn_lookup_key(candidate) {
            w.mark_lookup(key)
            return
        }
    }
    for candidate in candidates {
        w.mark_lookup('mod:${mod_name}:${candidate}')
        w.mark_lookup('fn:${candidate}')
        if !candidate.contains('__') && mod_name != '' && mod_name != 'main'
            && mod_name != 'builtin' {
            w.mark_lookup('fn:${mod_name}__${candidate}')
        }
    }
}

fn (mut w Walker) mark_method_name(name string, receivers []string) {
    if name == '' || !string_ok(name) {
        return
    }
    normalized := normalize_method_name(name)
    for receiver in receivers {
        if !string_ok(receiver) {
            continue
        }
        w.mark_method_receiver_candidate(receiver, name, normalized)
    }
}

fn (w &Walker) method_lookup_count(name string, receivers []string) int {
    if name == '' || !string_ok(name) {
        return 0
    }
    normalized := normalize_method_name(name)
    mut count := 0
    for receiver in receivers {
        if !string_ok(receiver) {
            continue
        }
        count += w.method_receiver_candidate_count(receiver, name, normalized)
    }
    return count
}

fn (mut w Walker) mark_method_lookup_candidate(candidate string, name string, normalized string) {
    w.mark_lookup('meth:${candidate}:${name}')
    if normalized != name {
        w.mark_lookup('meth:${candidate}:${normalized}')
    }
}

fn (mut w Walker) mark_method_receiver_candidate(receiver string, name string, normalized string) {
    w.mark_method_lookup_candidate(receiver, name, normalized)
    mut short_name := ''
    if receiver.contains('__') {
        short_name = receiver.all_after_last('__')
        if short_name != '' && short_name != receiver {
            w.mark_method_lookup_candidate(short_name, name, normalized)
        }
    }
    if receiver.starts_with('Array_') || receiver.starts_with('Array_fixed_') {
        if receiver != 'array' && short_name != 'array' {
            w.mark_method_lookup_candidate('array', name, normalized)
        }
    }
    if receiver.starts_with('Map_') {
        if receiver != 'map' && short_name != 'map' {
            w.mark_method_lookup_candidate('map', name, normalized)
        }
    }
    if receiver.starts_with('_option_') {
        if receiver != '_option' && short_name != '_option' {
            w.mark_method_lookup_candidate('_option', name, normalized)
        }
    }
    if receiver.starts_with('_result_') {
        if receiver != '_result' && short_name != '_result' {
            w.mark_method_lookup_candidate('_result', name, normalized)
        }
    }
}

fn (w &Walker) method_lookup_candidate_count(candidate string, name string, normalized string) int {
    mut count := w.lookup_count('meth:${candidate}:${name}')
    if normalized != name {
        count += w.lookup_count('meth:${candidate}:${normalized}')
    }
    return count
}

fn (w &Walker) method_receiver_candidate_count(receiver string, name string, normalized string) int {
    mut count := w.method_lookup_candidate_count(receiver, name, normalized)
    mut short_name := ''
    if receiver.contains('__') {
        short_name = receiver.all_after_last('__')
        if short_name != '' && short_name != receiver {
            count += w.method_lookup_candidate_count(short_name, name, normalized)
        }
    }
    if receiver.starts_with('Array_') || receiver.starts_with('Array_fixed_') {
        if receiver != 'array' && short_name != 'array' {
            count += w.method_lookup_candidate_count('array', name, normalized)
        }
    }
    if receiver.starts_with('Map_') {
        if receiver != 'map' && short_name != 'map' {
            count += w.method_lookup_candidate_count('map', name, normalized)
        }
    }
    if receiver.starts_with('_option_') {
        if receiver != '_option' && short_name != '_option' {
            count += w.method_lookup_candidate_count('_option', name, normalized)
        }
    }
    if receiver.starts_with('_result_') {
        if receiver != '_result' && short_name != '_result' {
            count += w.method_lookup_candidate_count('_result', name, normalized)
        }
    }
    return count
}

fn (mut w Walker) mark_method_name_fallback(name string) {
    if name == '' || !string_ok(name) {
        return
    }
    normalized := normalize_method_name(name)
    // Check count first to avoid pulling in everything for common names.
    count := w.lookup_count('mname:${name}') +
        if normalized != name { w.lookup_count('mname:${normalized}') } else { 0 }
    if count == 0 || count > 64 {
        return
    }
    w.mark_lookup('mname:${name}')
    if normalized != name {
        w.mark_lookup('mname:${normalized}')
    }
}

fn infix_operator_may_use_method(op token.Token) bool {
    return op in [.plus, .minus, .mul, .div, .mod, .eq, .ne, .lt, .gt, .le, .ge, .pipe, .xor]
}

fn (mut w Walker) mark_infix_operator_method(expr ast.InfixExpr, mod_name string) {
    if !infix_operator_may_use_method(expr.op) {
        return
    }
    method_name := expr.op.str()
    receivers := w.receiver_candidates_for_expr(expr.lhs, mod_name)
    if receivers.len > 0 {
        w.mark_method_name(method_name, receivers)
        return
    }
    w.mark_method_name_fallback(method_name)
}

fn (mut w Walker) mark_all_methods_for_receivers(receivers []string) {
    for receiver in receivers {
        if receiver in w.methods_by_receiver {
            for idx in w.methods_by_receiver[receiver] {
                w.mark_fn(idx)
            }
        }
        if receiver.contains('__') {
            short_name := receiver.all_after_last('__')
            if short_name in w.methods_by_receiver {
                for idx in w.methods_by_receiver[short_name] {
                    w.mark_fn(idx)
                }
            }
        }
    }
}

fn (mut w Walker) mark_comptime_method_loop_receivers(stmt ast.Stmt, mod_name string) {
    if stmt !is ast.ForStmt {
        return
    }
    if stmt.init !is ast.ForInStmt {
        return
    }
    for_in := stmt.init as ast.ForInStmt
    if for_in.expr !is ast.SelectorExpr {
        return
    }
    sel := for_in.expr as ast.SelectorExpr
    if sel.rhs.name != 'methods' {
        return
    }
    mut receivers := []string{}
    for receiver in type_expr_receiver_candidates(mod_name, sel.lhs) {
        add_unique_string(mut receivers, receiver)
    }
    for receiver in w.receiver_candidates_for_expr(sel.lhs, mod_name) {
        add_unique_string(mut receivers, receiver)
    }
    w.mark_all_methods_for_receivers(receivers)
}

fn (mut w Walker) mark_comptime_method_loop_receivers_cursor(stmt ast.Cursor, mod_name string) {
    if !stmt.is_valid() || stmt.kind() != .stmt_for {
        return
    }
    init := stmt.edge(0)
    if !init.is_valid() || init.kind() != .stmt_for_in {
        return
    }
    expr := init.edge(2)
    if !expr.is_valid() || expr.kind() != .expr_selector {
        return
    }
    rhs := expr.edge(1)
    if !rhs.is_valid() || rhs.name() != 'methods' {
        return
    }
    lhs := expr.edge(0)
    mut receivers := []string{}
    for receiver in type_expr_receiver_candidates_cursor(lhs, mod_name) {
        add_unique_string(mut receivers, receiver)
    }
    for receiver in w.receiver_candidates_for_cursor(lhs, mod_name) {
        add_unique_string(mut receivers, receiver)
    }
    w.mark_all_methods_for_receivers(receivers)
}

fn (w &Walker) embedded_receivers_for(receivers []string) []string {
    mut out := []string{}
    mut seen := map[string]bool{}
    mut stack := []string{}
    for receiver in receivers {
        if receiver == '' || receiver in seen {
            continue
        }
        seen[receiver] = true
        stack << receiver
    }
    for stack.len > 0 {
        receiver := stack[stack.len - 1]
        stack.delete(stack.len - 1)
        embedded := w.struct_embedded_receivers[receiver] or { continue }
        for embedded_receiver in embedded {
            add_unique_string(mut out, embedded_receiver)
            if embedded_receiver !in seen {
                seen[embedded_receiver] = true
                stack << embedded_receiver
            }
        }
    }
    return out
}

fn ierror_wrapper_base_from_ident(name string) string {
    if !name.starts_with('IError_') {
        return ''
    }
    prefix_len := 'IError_'.len
    if name.ends_with('_type_name_wrapper') {
        return name[prefix_len..name.len - '_type_name_wrapper'.len]
    }
    if name.ends_with('_msg_wrapper') {
        return name[prefix_len..name.len - '_msg_wrapper'.len]
    }
    if name.ends_with('_code_wrapper') {
        return name[prefix_len..name.len - '_code_wrapper'.len]
    }
    return ''
}

fn (mut w Walker) mark_ierror_wrapper_dependencies(name string, mod_name string) {
    base := ierror_wrapper_base_from_ident(name)
    if base == '' {
        return
    }
    w.mark_fn_name('${base}__msg', mod_name)
    w.mark_fn_name('${base}__code', mod_name)
    w.mark_fn_name('Error__code', mod_name)
}

fn (w &Walker) interface_name_from_expr(expr ast.Expr, mod_name string) string {
    match expr {
        ast.Ident {
            name := sanitize_receiver_name(expr.name)
            if name in w.interface_type_names {
                return name
            }
            if mod_name != '' && mod_name != 'main' {
                qualified := '${mod_name}__${name}'
                if qualified in w.interface_type_names {
                    return qualified
                }
            }
        }
        ast.SelectorExpr {
            if expr.lhs is ast.Ident {
                mut candidates := []string{}
                add_unique_string(mut candidates, expr.rhs.name)
                add_unique_string(mut candidates, '${expr.lhs.name}__${expr.rhs.name}')
                if mod_name != '' && mod_name != 'main' {
                    add_unique_string(mut candidates, '${mod_name}__${expr.rhs.name}')
                }
                for candidate in candidates {
                    if candidate in w.interface_type_names {
                        return candidate
                    }
                }
            }
        }
        else {}
    }

    return ''
}

// interface_name_from_cursor mirrors interface_name_from_expr but reads its
// inputs from a Cursor instead of a decoded ast.Expr. interface_name_from_expr
// only ever inspects Ident and SelectorExpr variants, so the cursor version
// only needs to dispatch on .expr_ident / .expr_selector.
fn (w &Walker) interface_name_from_cursor(c ast.Cursor, mod_name string) string {
    if !c.is_valid() {
        return ''
    }
    match c.kind() {
        .expr_ident {
            name := sanitize_receiver_name(c.name())
            if name in w.interface_type_names {
                return name
            }
            if mod_name != '' && mod_name != 'main' {
                qualified := '${mod_name}__${name}'
                if qualified in w.interface_type_names {
                    return qualified
                }
            }
        }
        .expr_selector {
            lhs_c := c.edge(0)
            rhs_c := c.edge(1)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_ident && rhs_c.is_valid() {
                lhs_name := lhs_c.name()
                rhs_name := rhs_c.name()
                mut candidates := []string{}
                add_unique_string(mut candidates, rhs_name)
                add_unique_string(mut candidates, '${lhs_name}__${rhs_name}')
                if mod_name != '' && mod_name != 'main' {
                    add_unique_string(mut candidates, '${mod_name}__${rhs_name}')
                }
                for candidate in candidates {
                    if candidate in w.interface_type_names {
                        return candidate
                    }
                }
            }
        }
        else {}
    }

    return ''
}

fn (mut w Walker) mark_interface_conversion_methods(target_expr ast.Expr, value_expr ast.Expr, mod_name string) {
    iface_name := w.interface_name_from_expr(target_expr, mod_name)
    if iface_name == '' {
        return
    }
    w.mark_interface_conversion_methods_for_name(iface_name, value_expr, mod_name)
}

fn (w &Walker) interface_name_from_type_expr(expr ast.Expr, mod_name string) string {
    match expr {
        ast.Ident, ast.SelectorExpr {
            return w.interface_name_from_expr(expr, mod_name)
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return w.interface_name_from_type_expr(expr.expr, mod_name)
            }
        }
        ast.ModifierExpr {
            return w.interface_name_from_type_expr(expr.expr, mod_name)
        }
        ast.Type {
            match expr {
                ast.PointerType {
                    return w.interface_name_from_type_expr(expr.base_type, mod_name)
                }
                ast.GenericType {
                    return w.interface_name_from_type_expr(expr.name, mod_name)
                }
                else {}
            }
        }
        else {}
    }

    return ''
}

fn (w &Walker) interface_name_from_type(typ types.Type) string {
    if !type_ok(typ) {
        return ''
    }
    match typ {
        types.Interface {
            return typ.name
        }
        types.Pointer {
            if !type_ok(typ.base_type) {
                return ''
            }
            return w.interface_name_from_type(typ.base_type)
        }
        types.Alias {
            if !type_ok(typ.base_type) {
                return ''
            }
            return w.interface_name_from_type(typ.base_type)
        }
        else {}
    }

    return ''
}

fn (w &Walker) interface_name_from_expr_type(expr ast.Expr, mod_name string) string {
    if expr is ast.Ident {
        if iface_name := w.global_interface_names[expr.name] {
            return iface_name
        }
        if mod_name != '' && mod_name != 'main' && mod_name != 'builtin' {
            qualified := '${mod_name}__${expr.name}'
            if iface_name := w.global_interface_names[qualified] {
                return iface_name
            }
        }
    }
    if w.env != unsafe { nil } {
        pos := expr.pos()
        if pos.is_valid() {
            if typ := w.env.get_expr_type(pos.id) {
                return w.interface_name_from_type(typ)
            }
        }
    }
    return ''
}

fn (w &Walker) interface_method_names_for(iface_name string) []string {
    mut out := []string{}
    mut seen := map[string]bool{}
    mut stack := []string{}
    add_unique_string(mut stack, iface_name)
    for stack.len > 0 {
        current := stack[stack.len - 1]
        stack.delete(stack.len - 1)
        if current == '' || current in seen {
            continue
        }
        seen[current] = true
        method_names := w.interface_method_names[current] or { []string{} }
        for method_name in method_names {
            add_unique_fn_name(mut out, method_name)
        }
        embedded_names := w.interface_embedded_names[current] or { []string{} }
        for embedded_name in embedded_names {
            if embedded_name !in seen {
                add_unique_string(mut stack, embedded_name)
            }
        }
    }
    return out
}

fn (mut w Walker) mark_assignment_interface_conversion(lhs ast.Expr, rhs ast.Expr, mod_name string) {
    iface_name := w.interface_name_from_expr_type(lhs, mod_name)
    if iface_name == '' {
        return
    }
    w.mark_interface_conversion_methods_for_name(iface_name, rhs, mod_name)
}

// interface_name_from_expr_type_cursor mirrors interface_name_from_expr_type
// but reads from a Cursor without decoding the underlying Expr. Most lhs
// nodes are Idents, so the global_interface_names lookup short-circuits
// before any env call.
fn (w &Walker) interface_name_from_expr_type_cursor(c ast.Cursor, mod_name string) string {
    if !c.is_valid() {
        return ''
    }
    if c.kind() == .expr_ident {
        name := c.name()
        if iface_name := w.global_interface_names[name] {
            return iface_name
        }
        if mod_name != '' && mod_name != 'main' && mod_name != 'builtin' {
            qualified := '${mod_name}__${name}'
            if iface_name := w.global_interface_names[qualified] {
                return iface_name
            }
        }
    }
    if w.env != unsafe { nil } {
        pos := c.pos()
        if pos.is_valid() {
            if typ := w.env.get_expr_type(pos.id) {
                return w.interface_name_from_type(typ)
            }
        }
    }
    return ''
}

// mark_assignment_interface_conversion_cursor is the cursor analogue of
// mark_assignment_interface_conversion. The lhs cursor is inspected for
// the interface-type fast path; only when iface_name is non-empty does
// the rhs cursor get handed to the by-cursor receiver lookup.
fn (mut w Walker) mark_assignment_interface_conversion_cursor(lhs_c ast.Cursor, rhs_c ast.Cursor, mod_name string) {
    iface_name := w.interface_name_from_expr_type_cursor(lhs_c, mod_name)
    if iface_name == '' {
        return
    }
    w.mark_interface_conversion_methods_for_name_cursor(iface_name, rhs_c, mod_name)
}

// mark_interface_conversion_methods_cursor mirrors mark_interface_conversion_methods
// but accepts the value as a Cursor. target_expr stays a legacy Expr because
// callers (e.g. stmt_return) already hold one — cur_fn_decl.typ.return_type.
fn (mut w Walker) mark_interface_conversion_methods_cursor(target_expr ast.Expr, value_c ast.Cursor, mod_name string) {
    iface_name := w.interface_name_from_expr(target_expr, mod_name)
    if iface_name == '' {
        return
    }
    w.mark_interface_conversion_methods_for_name_cursor(iface_name, value_c, mod_name)
}

// mark_result_error_return_methods_cursor is the cursor analogue of
// mark_result_error_return_methods. Only fires when the function's return
// type is ResultType — in that case the receiver candidates for the
// returned value are pulled from the cursor, and 'msg' / 'code' are marked
// on each.
fn (mut w Walker) mark_result_error_return_methods_cursor(return_type ast.Expr, value_c ast.Cursor, mod_name string) {
    if return_type is ast.Type && return_type is ast.ResultType {
        receivers := w.receiver_candidates_for_cursor(value_c, mod_name)
        if receivers.len == 0 {
            return
        }
        w.mark_method_name('msg', receivers)
        w.mark_method_name('code', receivers)
    }
}

fn (mut w Walker) mark_interface_conversion_methods_for_name(iface_name string, value_expr ast.Expr, mod_name string) {
    receivers := w.receiver_candidates_for_expr(value_expr, mod_name)
    if receivers.len == 0 {
        return
    }
    method_names := w.interface_method_names_for(iface_name)
    if method_names.len > 0 {
        embedded_receivers := w.embedded_receivers_for(receivers)
        for method_name in method_names {
            w.mark_method_name(method_name, receivers)
            w.mark_method_name(method_name, embedded_receivers)
        }
    }
}

fn (mut w Walker) mark_call_arg_interface_conversions(expr ast.CallExpr, mod_name string) {
    mut marked := false
    if w.env == unsafe { nil } {
        w.mark_call_arg_interface_conversions_from_decls(expr.lhs, expr.args, mod_name)
        return
    }
    if lhs_type := w.call_lhs_fn_type(expr.lhs, mod_name) {
        param_types := lhs_type.get_param_types()
        param_offset := if expr.lhs is ast.SelectorExpr { 1 } else { 0 }
        for i, arg in expr.args {
            param_idx := i + param_offset
            if param_idx >= param_types.len {
                break
            }
            param_type := param_types[param_idx]
            if param_type is types.Interface {
                w.mark_interface_conversion_methods_for_name((param_type as types.Interface).name,
                    arg, mod_name)
                marked = true
            }
        }
    }
    if !marked {
        w.mark_call_arg_interface_conversions_from_decls(expr.lhs, expr.args, mod_name)
    }
}

fn (mut w Walker) mark_call_or_cast_arg_interface_conversion(expr ast.CallOrCastExpr, mod_name string) {
    mut marked := false
    if w.env == unsafe { nil } {
        w.mark_call_arg_interface_conversions_from_decls(expr.lhs, [expr.expr], mod_name)
        return
    }
    if lhs_type := w.call_lhs_fn_type(expr.lhs, mod_name) {
        param_types := lhs_type.get_param_types()
        param_offset := if expr.lhs is ast.SelectorExpr { 1 } else { 0 }
        if param_offset < param_types.len {
            param_type := param_types[param_offset]
            if param_type is types.Interface {
                w.mark_interface_conversion_methods_for_name((param_type as types.Interface).name,
                    expr.expr, mod_name)
                marked = true
            }
        }
    }
    if !marked {
        w.mark_call_arg_interface_conversions_from_decls(expr.lhs, [expr.expr], mod_name)
    }
}

fn (w &Walker) add_lookup_indices(key string, mut out []int) {
    if !string_ok(key) {
        return
    }
    if values := w.lookup[key] {
        for idx in values {
            add_unique_int(mut out, idx)
        }
    }
}

fn (mut w Walker) add_fn_name_indices(name string, mod_name string, mut out []int) {
    if name == '' || !string_ok(name) || !string_ok(mod_name) {
        return
    }
    candidates := w.cached_called_fn_name_candidates(name)
    if key := w.exact_mangled_fn_lookup_key(name) {
        w.add_lookup_indices(key, mut out)
        return
    }
    for candidate in candidates {
        if key := w.current_module_fn_lookup_key(candidate, mod_name) {
            w.add_lookup_indices(key, mut out)
            return
        }
    }
    for candidate in candidates {
        if key := w.selective_import_fn_lookup_key(candidate) {
            w.add_lookup_indices(key, mut out)
            return
        }
    }
    for candidate in candidates {
        w.add_lookup_indices('mod:${mod_name}:${candidate}', mut out)
        w.add_lookup_indices('fn:${candidate}', mut out)
        if !candidate.contains('__') && mod_name != '' && mod_name != 'main'
            && mod_name != 'builtin' {
            w.add_lookup_indices('fn:${mod_name}__${candidate}', mut out)
        }
    }
}

fn (w &Walker) add_method_name_indices(name string, receivers []string, mut out []int) {
    if name == '' || !string_ok(name) {
        return
    }
    normalized := normalize_method_name(name)
    for receiver in receivers {
        if !string_ok(receiver) {
            continue
        }
        w.add_method_receiver_candidate_indices(receiver, name, normalized, mut out)
    }
}

fn (w &Walker) add_method_candidate_indices(candidate string, name string, normalized string, mut out []int) {
    w.add_lookup_indices('meth:${candidate}:${name}', mut out)
    if normalized != name {
        w.add_lookup_indices('meth:${candidate}:${normalized}', mut out)
    }
}

fn (w &Walker) add_method_receiver_candidate_indices(receiver string, name string, normalized string, mut out []int) {
    w.add_method_candidate_indices(receiver, name, normalized, mut out)
    mut short_name := ''
    if receiver.contains('__') {
        short_name = receiver.all_after_last('__')
        if short_name != '' && short_name != receiver {
            w.add_method_candidate_indices(short_name, name, normalized, mut out)
        }
    }
    if receiver.starts_with('Array_') || receiver.starts_with('Array_fixed_') {
        if receiver != 'array' && short_name != 'array' {
            w.add_method_candidate_indices('array', name, normalized, mut out)
        }
    }
    if receiver.starts_with('Map_') {
        if receiver != 'map' && short_name != 'map' {
            w.add_method_candidate_indices('map', name, normalized, mut out)
        }
    }
    if receiver.starts_with('_option_') {
        if receiver != '_option' && short_name != '_option' {
            w.add_method_candidate_indices('_option', name, normalized, mut out)
        }
    }
    if receiver.starts_with('_result_') {
        if receiver != '_result' && short_name != '_result' {
            w.add_method_candidate_indices('_result', name, normalized, mut out)
        }
    }
}

fn (mut w Walker) call_lhs_decl_indices(lhs ast.Expr, mod_name string) []int {
    mut out := []int{}
    if !expr_ok(lhs) {
        return out
    }
    match lhs {
        ast.Ident {
            w.add_fn_name_indices(lhs.name, mod_name, mut out)
        }
        ast.GenericArgs {
            return w.call_lhs_decl_indices(lhs.lhs, mod_name)
        }
        ast.GenericArgOrIndexExpr {
            return w.call_lhs_decl_indices(lhs.lhs, mod_name)
        }
        ast.SelectorExpr {
            method_name := lhs.rhs.name
            if !string_ok(method_name) {
                return out
            }
            if lhs.lhs is ast.Ident {
                left_name := lhs.lhs.name
                if !string_ok(left_name) {
                    return out
                }
                if left_name == 'C' {
                    w.add_fn_name_indices(method_name, mod_name, mut out)
                    return out
                }
                if left_name in w.module_names {
                    real_mod := w.module_alias_to_real[left_name] or { left_name }
                    w.add_fn_name_indices('${real_mod}__${method_name}', mod_name, mut out)
                    return out
                }
                if left_name in w.type_names {
                    w.add_method_name_indices(method_name,
                        [left_name, '${mod_name}__${left_name}'], mut out)
                    return out
                }
            }
            if lhs.lhs is ast.SelectorExpr {
                type_sel := lhs.lhs as ast.SelectorExpr
                if type_sel.lhs is ast.Ident {
                    mod_ident := type_sel.lhs.name
                    type_name := type_sel.rhs.name
                    if !string_ok(mod_ident) || !string_ok(type_name) {
                        return out
                    }
                    if mod_ident in w.module_names || mod_ident in w.type_names {
                        mut candidates := []string{cap: 3}
                        candidates << type_name
                        candidates << '${mod_name}__${type_name}'
                        candidates << '${mod_ident}__${type_name}'
                        w.add_method_name_indices(method_name, candidates, mut out)
                        return out
                    }
                }
            }
            receivers := w.receiver_candidates_for_expr(lhs.lhs, mod_name)
            if receivers.len > 0 {
                w.add_method_name_indices(method_name, receivers, mut out)
                if out.len > 0 {
                    return out
                }
            }
            normalized := normalize_method_name(method_name)
            w.add_lookup_indices('mname:${method_name}', mut out)
            if normalized != method_name {
                w.add_lookup_indices('mname:${normalized}', mut out)
            }
        }
        else {}
    }

    return out
}

fn (mut w Walker) mark_call_arg_interface_conversions_from_decls(lhs ast.Expr, args []ast.Expr, mod_name string) {
    decl_indices := w.call_lhs_decl_indices(lhs, mod_name)
    if decl_indices.len == 0 {
        return
    }
    for idx in decl_indices {
        if idx < 0 || idx >= w.fns.len {
            continue
        }
        info := w.fns[idx]
        params := info.decl.typ.params
        arg_offset := if lhs is ast.Ident && info.decl.is_method && !info.decl.is_static {
            1
        } else {
            0
        }
        for i, param in params {
            arg_idx := i + arg_offset
            if arg_idx >= args.len {
                break
            }
            iface_name := w.interface_name_from_expr(param.typ, info.mod)
            if iface_name == '' {
                continue
            }
            w.mark_interface_conversion_methods_for_name(iface_name, args[arg_idx], mod_name)
        }
    }
}

fn (mut w Walker) mark_string_interpolation_str_dependency(expr ast.Expr, mod_name string) {
    receivers := w.receiver_candidates_for_expr(expr, mod_name)
    if receivers.len == 0 {
        return
    }
    w.mark_method_name('str', receivers)
    for receiver in receivers {
        w.mark_fn_name('${receiver}__str', mod_name)
    }
}

fn (mut w Walker) mark_result_error_return_methods(return_type ast.Expr, expr ast.Expr, mod_name string) {
    if return_type is ast.Type && return_type is ast.ResultType {
        receivers := w.receiver_candidates_for_expr(expr, mod_name)
        if receivers.len == 0 {
            return
        }
        w.mark_method_name('msg', receivers)
        w.mark_method_name('code', receivers)
    }
}

// call_lhs_fn_type_cursor mirrors call_lhs_fn_type but reads from a Cursor.
// receiver_candidates_for_expr still needs a decoded Expr for the
// SelectorExpr branch — only that subtree is decoded, and only when env
// lookup falls through to it.
fn (w &Walker) call_lhs_fn_type_cursor(c ast.Cursor, mod_name string) ?types.FnType {
    if !c.is_valid() {
        return none
    }
    if w.env != unsafe { nil } {
        if lhs_type := w.env.get_expr_type(c.pos().id) {
            if lhs_type is types.FnType {
                return lhs_type as types.FnType
            }
        }
        match c.kind() {
            .expr_ident {
                if fn_type := w.env.lookup_fn(mod_name, c.name()) {
                    return fn_type
                }
            }
            .expr_selector {
                inner_lhs := c.edge(0)
                rhs_c := c.edge(1)
                if inner_lhs.is_valid() && rhs_c.is_valid() {
                    receivers := w.receiver_candidates_for_cursor(inner_lhs, mod_name)
                    for receiver in receivers {
                        if fn_type := w.env.lookup_method(receiver, rhs_c.name()) {
                            return fn_type
                        }
                    }
                }
            }
            else {}
        }
    }
    if c.kind() == .expr_ident && w.cur_fn_scope != unsafe { nil } {
        if obj := w.cur_fn_scope.lookup_parent(c.name(), 0) {
            typ := obj.typ()
            if typ is types.FnType {
                return typ as types.FnType
            }
        }
    }
    return none
}

// call_lhs_decl_indices_cursor mirrors call_lhs_decl_indices with cursor
// input. Same shape: Ident / GenericArgs / GenericArgOrIndexExpr / Selector
// — the only ast-decoded subtree is lhs.lhs for SelectorExpr's
// receiver_candidates_for_expr fallback.
fn (mut w Walker) call_lhs_decl_indices_cursor(c ast.Cursor, mod_name string) []int {
    mut out := []int{}
    if !c.is_valid() {
        return out
    }
    match c.kind() {
        .expr_ident {
            w.add_fn_name_indices(c.name(), mod_name, mut out)
        }
        .expr_generic_args {
            return w.call_lhs_decl_indices_cursor(c.edge(0), mod_name)
        }
        .expr_generic_arg_or_index {
            return w.call_lhs_decl_indices_cursor(c.edge(0), mod_name)
        }
        .expr_selector {
            rhs_c := c.edge(1)
            if !rhs_c.is_valid() {
                return out
            }
            method_name := rhs_c.name()
            if !string_ok(method_name) {
                return out
            }
            lhs_c := c.edge(0)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_ident {
                left_name := lhs_c.name()
                if !string_ok(left_name) {
                    return out
                }
                if left_name == 'C' {
                    w.add_fn_name_indices(method_name, mod_name, mut out)
                    return out
                }
                if left_name in w.module_names {
                    real_mod := w.module_alias_to_real[left_name] or { left_name }
                    w.add_fn_name_indices('${real_mod}__${method_name}', mod_name, mut out)
                    return out
                }
                if left_name in w.type_names {
                    w.add_method_name_indices(method_name,
                        [left_name, '${mod_name}__${left_name}'], mut out)
                    return out
                }
            }
            if lhs_c.is_valid() && lhs_c.kind() == .expr_selector {
                inner_lhs := lhs_c.edge(0)
                inner_rhs := lhs_c.edge(1)
                if inner_lhs.is_valid() && inner_lhs.kind() == .expr_ident && inner_rhs.is_valid() {
                    mod_ident := inner_lhs.name()
                    type_name := inner_rhs.name()
                    if !string_ok(mod_ident) || !string_ok(type_name) {
                        return out
                    }
                    if mod_ident in w.module_names || mod_ident in w.type_names {
                        mut candidates := []string{cap: 3}
                        candidates << type_name
                        candidates << '${mod_name}__${type_name}'
                        candidates << '${mod_ident}__${type_name}'
                        w.add_method_name_indices(method_name, candidates, mut out)
                        return out
                    }
                }
            }
            receivers := w.receiver_candidates_for_cursor(lhs_c, mod_name)
            if receivers.len > 0 {
                w.add_method_name_indices(method_name, receivers, mut out)
                if out.len > 0 {
                    return out
                }
            }
            normalized := normalize_method_name(method_name)
            w.add_lookup_indices('mname:${method_name}', mut out)
            if normalized != method_name {
                w.add_lookup_indices('mname:${normalized}', mut out)
            }
        }
        else {}
    }

    return out
}

// mark_call_arg_interface_conversions_cursor / _from_decls_cursor are the
// cursor analogues of mark_call_arg_interface_conversions /
// mark_call_arg_interface_conversions_from_decls. Args are only decoded on
// demand (when the param type is an interface), so non-interface params do
// not pay any decode cost.
fn (mut w Walker) mark_call_arg_interface_conversions_cursor(call_c ast.Cursor, mod_name string) {
    lhs_c := call_c.edge(0)
    ec := call_c.edge_count()
    args_len := ec - 1
    mut marked := false
    if w.env != unsafe { nil } {
        if lhs_type := w.call_lhs_fn_type_cursor(lhs_c, mod_name) {
            param_types := lhs_type.get_param_types()
            param_offset := if lhs_c.is_valid() && lhs_c.kind() == .expr_selector {
                1
            } else {
                0
            }
            for i in 0 .. args_len {
                param_idx := i + param_offset
                if param_idx >= param_types.len {
                    break
                }
                param_type := param_types[param_idx]
                if param_type is types.Interface {
                    arg_c := call_c.edge(1 + i)
                    w.mark_interface_conversion_methods_for_name_cursor((param_type as types.Interface).name,
                        arg_c, mod_name)
                    marked = true
                }
            }
        }
    } else {
        w.mark_call_arg_interface_conversions_from_decls_cursor(call_c, mod_name)
        return
    }
    if !marked {
        w.mark_call_arg_interface_conversions_from_decls_cursor(call_c, mod_name)
    }
}

fn (mut w Walker) mark_call_arg_interface_conversions_from_decls_cursor(call_c ast.Cursor, mod_name string) {
    lhs_c := call_c.edge(0)
    decl_indices := w.call_lhs_decl_indices_cursor(lhs_c, mod_name)
    if decl_indices.len == 0 {
        return
    }
    args_len := call_c.edge_count() - 1
    lhs_is_ident := lhs_c.is_valid() && lhs_c.kind() == .expr_ident
    for idx in decl_indices {
        if idx < 0 || idx >= w.fns.len {
            continue
        }
        info := w.fns[idx]
        params := info.decl.typ.params
        arg_offset := if lhs_is_ident && info.decl.is_method && !info.decl.is_static {
            1
        } else {
            0
        }
        for i, param in params {
            arg_idx := i + arg_offset
            if arg_idx >= args_len {
                break
            }
            iface_name := w.interface_name_from_expr(param.typ, info.mod)
            if iface_name == '' {
                continue
            }
            arg_c := call_c.edge(1 + arg_idx)
            w.mark_interface_conversion_methods_for_name_cursor(iface_name, arg_c, mod_name)
        }
    }
}

// mark_call_or_cast_arg_interface_conversion_cursor is the cursor analogue
// of mark_call_or_cast_arg_interface_conversion. The "expr" edge (call_c.edge(1))
// is treated as a single-arg list; it is decoded only when the param type
// is an interface.
fn (mut w Walker) mark_call_or_cast_arg_interface_conversion_cursor(call_c ast.Cursor, mod_name string) {
    lhs_c := call_c.edge(0)
    expr_c := call_c.edge(1)
    mut marked := false
    if w.env != unsafe { nil } {
        if lhs_type := w.call_lhs_fn_type_cursor(lhs_c, mod_name) {
            param_types := lhs_type.get_param_types()
            param_offset := if lhs_c.is_valid() && lhs_c.kind() == .expr_selector {
                1
            } else {
                0
            }
            if param_offset < param_types.len {
                param_type := param_types[param_offset]
                if param_type is types.Interface {
                    w.mark_interface_conversion_methods_for_name_cursor((param_type as types.Interface).name,
                        expr_c, mod_name)
                    marked = true
                }
            }
        }
    } else {
        decl_indices := w.call_lhs_decl_indices_cursor(lhs_c, mod_name)
        w.mark_call_or_cast_arg_interface_from_decl_indices_cursor(decl_indices, lhs_c, expr_c,
            mod_name)
        return
    }
    if !marked {
        decl_indices := w.call_lhs_decl_indices_cursor(lhs_c, mod_name)
        w.mark_call_or_cast_arg_interface_from_decl_indices_cursor(decl_indices, lhs_c, expr_c,
            mod_name)
    }
}

fn (mut w Walker) mark_call_or_cast_arg_interface_from_decl_indices_cursor(decl_indices []int, lhs_c ast.Cursor, expr_c ast.Cursor, mod_name string) {
    if decl_indices.len == 0 || !expr_c.is_valid() {
        return
    }
    lhs_is_ident := lhs_c.is_valid() && lhs_c.kind() == .expr_ident
    for idx in decl_indices {
        if idx < 0 || idx >= w.fns.len {
            continue
        }
        info := w.fns[idx]
        params := info.decl.typ.params
        arg_offset := if lhs_is_ident && info.decl.is_method && !info.decl.is_static {
            1
        } else {
            0
        }
        if arg_offset >= params.len {
            continue
        }
        param := params[arg_offset]
        iface_name := w.interface_name_from_expr(param.typ, info.mod)
        if iface_name == '' {
            continue
        }
        w.mark_interface_conversion_methods_for_name_cursor(iface_name, expr_c, mod_name)
    }
}

fn (w &Walker) call_lhs_fn_type(lhs ast.Expr, mod_name string) ?types.FnType {
    if !expr_ok(lhs) {
        return none
    }
    if w.env != unsafe { nil } {
        if lhs_type := w.env.get_expr_type(lhs.pos().id) {
            if lhs_type is types.FnType {
                return lhs_type as types.FnType
            }
        }
        if lhs is ast.Ident {
            if fn_type := w.env.lookup_fn(mod_name, lhs.name) {
                return fn_type
            }
        }
        if lhs is ast.SelectorExpr {
            receivers := w.receiver_candidates_for_expr(lhs.lhs, mod_name)
            for receiver in receivers {
                if fn_type := w.env.lookup_method(receiver, lhs.rhs.name) {
                    return fn_type
                }
            }
        }
    }
    if lhs is ast.Ident && w.cur_fn_scope != unsafe { nil } {
        if obj := w.cur_fn_scope.lookup_parent(lhs.name, 0) {
            typ := obj.typ()
            if typ is types.FnType {
                return typ as types.FnType
            }
        }
    }
    return none
}

fn (w &Walker) current_param_receiver_candidates(name string, mod_name string) []string {
    mut out := []string{}
    if name == '' || w.cur_fn_decl.name == '' {
        return out
    }
    for param in w.cur_fn_decl.typ.params {
        if param.name != name {
            continue
        }
        for receiver in type_expr_receiver_candidates(mod_name, param.typ) {
            add_unique_string(mut out, receiver)
        }
        generic_name := receiver_type_expr_name(param.typ)
        if generic_name == '' || w.env == unsafe { nil } {
            continue
        }
        for bindings in w.current_fn_generic_bindings() {
            if concrete := bindings[generic_name] {
                for receiver in type_name_candidates_from_type(mod_name, concrete) {
                    add_unique_string(mut out, receiver)
                }
            }
        }
    }
    return out
}

fn (w &Walker) current_receiver_candidates(name string, mod_name string) []string {
    mut out := []string{}
    if name == '' || w.cur_fn_decl.name == '' || !is_method_decl(w.cur_fn_decl)
        || w.cur_fn_decl.receiver.name != name {
        return out
    }
    for receiver in type_expr_receiver_candidates(mod_name, w.cur_fn_decl.receiver.typ) {
        add_unique_string(mut out, receiver)
    }
    generic_name := receiver_type_expr_name(w.cur_fn_decl.receiver.typ)
    if generic_name == '' || w.env == unsafe { nil } {
        return out
    }
    for bindings in w.current_fn_generic_bindings() {
        if concrete := bindings[generic_name] {
            for receiver in type_name_candidates_from_type(mod_name, concrete) {
                add_unique_string(mut out, receiver)
            }
        }
    }
    return out
}

fn (w &Walker) current_fn_generic_bindings() []map[string]types.Type {
    if w.env == unsafe { nil } || w.cur_fn_decl.name == '' {
        return []map[string]types.Type{}
    }
    mut out := []map[string]types.Type{}
    for key, bindings_list in w.env.generic_types {
        if generic_base_name_from_key(key) != w.cur_fn_decl.name {
            continue
        }
        for bindings in bindings_list {
            out << bindings
        }
    }
    return out
}

// receiver_candidates_for_cursor mirrors receiver_candidates_for_expr but
// reads inputs from a Cursor instead of a decoded ast.Expr. Same shape:
// env-type lookup by pos.id first, then a structural match on cursor kind.
// PrefixExpr / ParenExpr / ModifierExpr / SelectorExpr recurse through
// edge(0); InitExpr through its typ at edge(0); CallExpr / CallOrCastExpr
// look at edge(0)'s selector.lhs without recursion.
fn (w &Walker) receiver_candidates_for_cursor(c ast.Cursor, mod_name string) []string {
    mut out := []string{}
    if !c.is_valid() {
        return out
    }
    pos := c.pos()
    if w.env != unsafe { nil } && pos.is_valid() {
        if receiver_type := w.env.get_expr_type(pos.id) {
            for name in type_name_candidates_from_type(mod_name, receiver_type) {
                add_unique_string(mut out, name)
            }
        }
    }
    match c.kind() {
        .expr_ident {
            ident_name := c.name()
            if w.env != unsafe { nil } && w.cur_fn_scope != unsafe { nil } {
                if local_type := w.env.lookup_local_var(w.cur_fn_scope, ident_name) {
                    for type_name in type_name_candidates_from_type(mod_name, local_type) {
                        add_unique_string(mut out, type_name)
                    }
                }
            }
            name := sanitize_receiver_name(ident_name)
            for type_name in w.current_receiver_candidates(ident_name, mod_name) {
                add_unique_string(mut out, type_name)
            }
            for type_name in w.current_param_receiver_candidates(ident_name, mod_name) {
                add_unique_string(mut out, type_name)
            }
            add_unique_string(mut out, name)
            if mod_name != '' && mod_name != 'main' {
                add_unique_string(mut out, '${mod_name}__${name}')
            }
        }
        .expr_prefix, .expr_paren, .expr_modifier {
            for name in w.receiver_candidates_for_cursor(c.edge(0), mod_name) {
                add_unique_string(mut out, name)
            }
        }
        .expr_init {
            for name in w.receiver_candidates_for_cursor(c.edge(0), mod_name) {
                add_unique_string(mut out, name)
            }
        }
        .expr_call, .expr_call_or_cast {
            lhs_c := c.edge(0)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_selector {
                inner_lhs := lhs_c.edge(0)
                if inner_lhs.is_valid() && inner_lhs.kind() == .expr_ident {
                    type_name := inner_lhs.name()
                    if type_name in w.type_names {
                        add_receiver_name_candidates(mut out, mod_name, type_name)
                    }
                }
            }
        }
        .expr_selector {
            lhs_c := c.edge(0)
            rhs_c := c.edge(1)
            if rhs_c.is_valid() {
                rhs_name := rhs_c.name()
                lhs_receivers := w.receiver_candidates_for_cursor(lhs_c, mod_name)
                for lhs_receiver in lhs_receivers {
                    key := '${lhs_receiver}:${rhs_name}'
                    if field_receivers := w.struct_field_receivers[key] {
                        for field_receiver in field_receivers {
                            add_unique_string(mut out, field_receiver)
                        }
                    }
                }
            }
        }
        else {}
    }

    return out
}

// mark_interface_conversion_methods_for_name_cursor is the cursor analogue
// of mark_interface_conversion_methods_for_name. The value_expr is replaced
// by a value cursor, so receiver_candidates_for_cursor avoids decoding.
fn (mut w Walker) mark_interface_conversion_methods_for_name_cursor(iface_name string, value_c ast.Cursor, mod_name string) {
    receivers := w.receiver_candidates_for_cursor(value_c, mod_name)
    if receivers.len == 0 {
        return
    }
    if iface_name in w.interface_method_names {
        embedded_receivers := w.embedded_receivers_for(receivers)
        for method_name in w.interface_method_names[iface_name] {
            w.mark_method_name(method_name, receivers)
            w.mark_method_name(method_name, embedded_receivers)
        }
    }
    w.mark_all_methods_for_receivers(receivers)
}

// mark_string_interpolation_str_dependency_cursor is the cursor analogue of
// mark_string_interpolation_str_dependency.
fn (mut w Walker) mark_string_interpolation_str_dependency_cursor(value_c ast.Cursor, mod_name string) {
    receivers := w.receiver_candidates_for_cursor(value_c, mod_name)
    if receivers.len == 0 {
        return
    }
    w.mark_method_name('str', receivers)
    for receiver in receivers {
        w.mark_fn_name('${receiver}__str', mod_name)
    }
}

fn (w &Walker) receiver_candidates_for_expr(expr ast.Expr, mod_name string) []string {
    mut out := []string{}
    if !expr_ok(expr) {
        return out
    }
    pos := expr.pos()
    if w.env != unsafe { nil } && pos.is_valid() {
        if receiver_type := w.env.get_expr_type(pos.id) {
            for name in type_name_candidates_from_type(mod_name, receiver_type) {
                add_unique_string(mut out, name)
            }
        }
    }
    match expr {
        ast.Ident {
            if w.env != unsafe { nil } && w.cur_fn_scope != unsafe { nil } {
                if local_type := w.env.lookup_local_var(w.cur_fn_scope, expr.name) {
                    for type_name in type_name_candidates_from_type(mod_name, local_type) {
                        add_unique_string(mut out, type_name)
                    }
                }
            }
            name := sanitize_receiver_name(expr.name)
            for type_name in w.current_receiver_candidates(expr.name, mod_name) {
                add_unique_string(mut out, type_name)
            }
            for type_name in w.current_param_receiver_candidates(expr.name, mod_name) {
                add_unique_string(mut out, type_name)
            }
            add_unique_string(mut out, name)
            if mod_name != '' && mod_name != 'main' {
                add_unique_string(mut out, '${mod_name}__${name}')
            }
        }
        ast.PrefixExpr {
            for name in w.receiver_candidates_for_expr(expr.expr, mod_name) {
                add_unique_string(mut out, name)
            }
        }
        ast.ParenExpr {
            for name in w.receiver_candidates_for_expr(expr.expr, mod_name) {
                add_unique_string(mut out, name)
            }
        }
        ast.ModifierExpr {
            for name in w.receiver_candidates_for_expr(expr.expr, mod_name) {
                add_unique_string(mut out, name)
            }
        }
        ast.InitExpr {
            // InitExpr has a .typ that names the struct being constructed.
            for name in w.receiver_candidates_for_expr(expr.typ, mod_name) {
                add_unique_string(mut out, name)
            }
        }
        ast.CallExpr {
            if expr.lhs is ast.SelectorExpr {
                selector := expr.lhs as ast.SelectorExpr
                if selector.lhs is ast.Ident {
                    type_name := selector.lhs.name
                    if type_name in w.type_names {
                        add_receiver_name_candidates(mut out, mod_name, type_name)
                    }
                }
            }
        }
        ast.CallOrCastExpr {
            if expr.lhs is ast.SelectorExpr {
                selector := expr.lhs as ast.SelectorExpr
                if selector.lhs is ast.Ident {
                    type_name := selector.lhs.name
                    if type_name in w.type_names {
                        add_receiver_name_candidates(mut out, mod_name, type_name)
                    }
                }
            }
        }
        ast.SelectorExpr {
            lhs_receivers := w.receiver_candidates_for_expr(expr.lhs, mod_name)
            for lhs_receiver in lhs_receivers {
                key := '${lhs_receiver}:${expr.rhs.name}'
                if field_receivers := w.struct_field_receivers[key] {
                    for field_receiver in field_receivers {
                        add_unique_string(mut out, field_receiver)
                    }
                }
            }
        }
        else {}
    }

    return out
}

fn (w &Walker) is_cast_type_name(name string) bool {
    if !string_ok(name) {
        return false
    }
    if name in builtin_cast_type_names {
        return true
    }
    return name in w.type_names
}

fn (mut w Walker) mark_call_lhs(lhs ast.Expr, mod_name string) {
    if !expr_ok(lhs) {
        return
    }
    match lhs {
        ast.Ident {
            w.mark_fn_name(lhs.name, mod_name)
            w.mark_const_fn_value_alias(lhs.name, mod_name)
        }
        ast.GenericArgs {
            w.mark_call_lhs(lhs.lhs, mod_name)
        }
        ast.GenericArgOrIndexExpr {
            w.mark_call_lhs(lhs.lhs, mod_name)
        }
        ast.SelectorExpr {
            method_name := lhs.rhs.name
            if !string_ok(method_name) {
                return
            }
            if lhs.lhs is ast.Ident {
                left_name := lhs.lhs.name
                if !string_ok(left_name) {
                    return
                }
                if left_name == 'C' {
                    w.mark_fn_name(method_name, mod_name)
                    return
                }
                if left_name in w.module_names {
                    // Resolve import aliases (e.g., 'ssa_optimize' → 'optimize')
                    // so lookup finds 'optimize__func' not 'ssa_optimize__func'.
                    real_mod := w.module_alias_to_real[left_name] or { left_name }
                    w.mark_fn_name('${real_mod}__${method_name}', mod_name)
                    return
                }
                if left_name in w.type_names {
                    w.mark_method_name(method_name, [left_name, '${mod_name}__${left_name}'])
                    return
                }
            }
            if lhs.lhs is ast.SelectorExpr {
                type_sel := lhs.lhs as ast.SelectorExpr
                if type_sel.lhs is ast.Ident {
                    mod_ident := type_sel.lhs.name
                    type_name := type_sel.rhs.name
                    if !string_ok(mod_ident) || !string_ok(type_name) {
                        return
                    }
                    if mod_ident in w.module_names || mod_ident in w.type_names {
                        candidates := [
                            type_name,
                            '${mod_name}__${type_name}',
                            '${mod_ident}__${type_name}',
                        ]
                        w.mark_method_name(method_name, candidates)
                        return
                    }
                }
            }
            receivers := w.receiver_candidates_for_expr(lhs.lhs, mod_name)
            if receivers.len > 0 {
                prev_queue_len := w.queue.len
                w.mark_method_name(method_name, receivers)
                if w.queue.len > prev_queue_len {
                    return
                }
            }
            w.mark_method_name_fallback(method_name)
        }
        else {}
    }
}

fn (w &Walker) const_fn_value_alias_is_shadowed(name string) bool {
    if w.cur_fn_scope == unsafe { nil } {
        return false
    }
    if obj := w.cur_fn_scope.lookup_parent(name, 0) {
        return obj !is types.Const
    }
    return false
}

fn (mut w Walker) mark_const_fn_value_alias(name string, mod_name string) bool {
    if name == '' || !string_ok(name) || !string_ok(mod_name)
        || w.const_fn_value_alias_is_shadowed(name) {
        return false
    }
    if target := w.const_fn_value_aliases[const_fn_value_alias_key(mod_name, name)] {
        w.mark_fn_name(target, mod_name)
        return true
    }
    return false
}

// mark_call_lhs_cursor is the cursor-input analogue of mark_call_lhs. It
// handles every case structurally via cursor accesses, and only falls back
// to decoding `lhs.lhs` for the SelectorExpr receiver_candidates_for_expr
// branch — which is itself only reached when the early-return cases (C.fn,
// module.fn, Type.method, mod.Type.method) all fail.
fn (mut w Walker) mark_call_lhs_cursor(c ast.Cursor, mod_name string) {
    if !c.is_valid() {
        return
    }
    match c.kind() {
        .expr_ident {
            w.mark_fn_name(c.name(), mod_name)
            w.mark_const_fn_value_alias(c.name(), mod_name)
        }
        .expr_generic_args {
            w.mark_call_lhs_cursor(c.edge(0), mod_name)
        }
        .expr_generic_arg_or_index {
            w.mark_call_lhs_cursor(c.edge(0), mod_name)
        }
        .expr_selector {
            rhs_c := c.edge(1)
            if !rhs_c.is_valid() {
                return
            }
            method_name := rhs_c.name()
            if !string_ok(method_name) {
                return
            }
            lhs_c := c.edge(0)
            if lhs_c.is_valid() && lhs_c.kind() == .expr_ident {
                left_name := lhs_c.name()
                if !string_ok(left_name) {
                    return
                }
                if left_name == 'C' {
                    w.mark_fn_name(method_name, mod_name)
                    return
                }
                if left_name in w.module_names {
                    real_mod := w.module_alias_to_real[left_name] or { left_name }
                    w.mark_fn_name('${real_mod}__${method_name}', mod_name)
                    return
                }
                if left_name in w.type_names {
                    w.mark_method_name(method_name, [left_name, '${mod_name}__${left_name}'])
                    return
                }
            }
            if lhs_c.is_valid() && lhs_c.kind() == .expr_selector {
                inner_lhs := lhs_c.edge(0)
                inner_rhs := lhs_c.edge(1)
                if inner_lhs.is_valid() && inner_lhs.kind() == .expr_ident && inner_rhs.is_valid() {
                    mod_ident := inner_lhs.name()
                    type_name := inner_rhs.name()
                    if !string_ok(mod_ident) || !string_ok(type_name) {
                        return
                    }
                    if mod_ident in w.module_names || mod_ident in w.type_names {
                        candidates := [
                            type_name,
                            '${mod_name}__${type_name}',
                            '${mod_ident}__${type_name}',
                        ]
                        w.mark_method_name(method_name, candidates)
                        return
                    }
                }
            }
            // Fallback: cursor-native receiver candidates — no decode.
            receivers := w.receiver_candidates_for_cursor(lhs_c, mod_name)
            if receivers.len > 0 {
                prev_queue_len := w.queue.len
                w.mark_method_name(method_name, receivers)
                if w.queue.len > prev_queue_len {
                    return
                }
            }
            w.mark_method_name_fallback(method_name)
        }
        else {}
    }
}

fn (mut w Walker) mark_selector_fn_value(expr ast.SelectorExpr, mod_name string) {
    w.mark_selector_fn_value_with_fallback(expr, mod_name, false)
}

fn (mut w Walker) mark_selector_fn_value_with_fallback(expr ast.SelectorExpr, mod_name string, force_fallback bool) {
    target := w.selector_fn_value_target(expr)
    if target != '' {
        w.mark_fn_name(target, mod_name)
        return
    }
    if expr.rhs.name == '' {
        return
    }
    receivers := w.receiver_candidates_for_expr(expr.lhs, mod_name)
    if receivers.len > 0 {
        matched := w.method_lookup_count(expr.rhs.name, receivers) > 0
        w.mark_method_name(expr.rhs.name, receivers)
        if matched {
            return
        }
    }
    if force_fallback || w.expr_has_fn_value_type(ast.Expr(expr)) {
        w.mark_method_name_fallback(expr.rhs.name)
    }
}

fn (mut w Walker) mark_selector_fn_value_cursor(c ast.Cursor, mod_name string) {
    w.mark_selector_fn_value_cursor_with_fallback(c, mod_name, false)
}

fn (mut w Walker) mark_selector_fn_value_cursor_with_fallback(c ast.Cursor, mod_name string, force_fallback bool) {
    target := w.selector_fn_value_target_cursor(c)
    if target != '' {
        w.mark_fn_name(target, mod_name)
        return
    }
    rhs_c := c.edge(1)
    if !rhs_c.is_valid() {
        return
    }
    method_name := rhs_c.name()
    if method_name == '' {
        return
    }
    receivers := w.receiver_candidates_for_cursor(c.edge(0), mod_name)
    if receivers.len > 0 {
        matched := w.method_lookup_count(method_name, receivers) > 0
        w.mark_method_name(method_name, receivers)
        if matched {
            return
        }
    }
    if force_fallback || w.cursor_has_fn_value_type(c) {
        w.mark_method_name_fallback(method_name)
    }
}

fn (w &Walker) selector_fn_value_target(expr ast.SelectorExpr) string {
    if expr.lhs !is ast.Ident {
        return ''
    }
    left := expr.lhs as ast.Ident
    left_name := left.name
    if left_name == 'C' || left_name !in w.module_names {
        return ''
    }
    real_mod := w.module_alias_to_real[left_name] or { left_name }
    target := '${real_mod}__${expr.rhs.name}'
    if w.lookup_count('fn:${target}') > 0 {
        return target
    }
    return ''
}

fn (w &Walker) selector_fn_value_target_cursor(c ast.Cursor) string {
    if !c.is_valid() || c.kind() != .expr_selector {
        return ''
    }
    lhs_c := c.edge(0)
    rhs_c := c.edge(1)
    if !lhs_c.is_valid() || lhs_c.kind() != .expr_ident || !rhs_c.is_valid() {
        return ''
    }
    left_name := lhs_c.name()
    if left_name == 'C' || left_name !in w.module_names {
        return ''
    }
    real_mod := w.module_alias_to_real[left_name] or { left_name }
    target := '${real_mod}__${rhs_c.name()}'
    if w.lookup_count('fn:${target}') > 0 {
        return target
    }
    return ''
}

fn (mut w Walker) mark_fn_value_expr(expr ast.Expr, mod_name string) {
    if !w.opts.minimal_runtime_roots || !expr_ok(expr) {
        return
    }
    match expr {
        ast.Ident {
            if w.mark_const_fn_value_alias(expr.name, mod_name) {
                return
            }
            if w.ident_resolves_to_fn_value(expr.name, mod_name) {
                w.mark_fn_name(expr.name, mod_name)
            }
        }
        ast.SelectorExpr {
            w.mark_selector_fn_value(expr, mod_name)
        }
        ast.GenericArgs {
            w.mark_fn_value_expr(expr.lhs, mod_name)
        }
        ast.GenericArgOrIndexExpr {
            w.mark_fn_value_expr(expr.lhs, mod_name)
        }
        ast.ModifierExpr {
            w.mark_fn_value_expr(expr.expr, mod_name)
        }
        ast.ParenExpr {
            w.mark_fn_value_expr(expr.expr, mod_name)
        }
        else {}
    }
}

fn (mut w Walker) mark_fn_value_expr_cursor(c ast.Cursor, mod_name string) {
    if !w.opts.minimal_runtime_roots || !c.is_valid() {
        return
    }
    match c.kind() {
        .expr_ident {
            name := c.name()
            if w.mark_const_fn_value_alias(name, mod_name) {
                return
            }
            if w.ident_resolves_to_fn_value(name, mod_name) {
                w.mark_fn_name(name, mod_name)
            }
        }
        .expr_selector {
            w.mark_selector_fn_value_cursor(c, mod_name)
        }
        .expr_generic_args {
            w.mark_fn_value_expr_cursor(c.edge(0), mod_name)
        }
        .expr_generic_arg_or_index {
            w.mark_fn_value_expr_cursor(c.edge(0), mod_name)
        }
        .expr_modifier {
            w.mark_fn_value_expr_cursor(c.edge(0), mod_name)
        }
        .expr_paren {
            w.mark_fn_value_expr_cursor(c.edge(0), mod_name)
        }
        else {}
    }
}

fn (mut w Walker) walk_stmts(stmts []ast.Stmt, mod_name string) {
    for stmt in stmts {
        w.walk_stmt(stmt, mod_name)
    }
}

fn (mut w Walker) walk_stmt(stmt ast.Stmt, mod_name string) {
    if !stmt_ok(stmt) {
        return
    }
    match stmt {
        ast.AssertStmt {
            w.walk_expr(stmt.expr, mod_name)
            w.walk_expr(stmt.extra, mod_name)
        }
        ast.AssignStmt {
            for i, rhs in stmt.rhs {
                if i < stmt.lhs.len {
                    w.mark_assignment_interface_conversion(stmt.lhs[i], rhs, mod_name)
                }
            }
            for expr in stmt.lhs {
                w.walk_expr(expr, mod_name)
            }
            for expr in stmt.rhs {
                w.mark_fn_value_expr(expr, mod_name)
                w.walk_expr(expr, mod_name)
            }
        }
        ast.BlockStmt {
            w.walk_stmts(stmt.stmts, mod_name)
        }
        ast.ComptimeStmt {
            w.mark_comptime_method_loop_receivers(stmt.stmt, mod_name)
            w.walk_stmt(stmt.stmt, mod_name)
        }
        ast.ConstDecl {
            for field in stmt.fields {
                w.mark_fn_value_expr(field.value, mod_name)
                w.walk_expr(field.value, mod_name)
            }
        }
        ast.DeferStmt {
            w.walk_stmts(stmt.stmts, mod_name)
        }
        ast.EnumDecl {
            for field in stmt.fields {
                w.walk_expr(field.value, mod_name)
            }
        }
        ast.ExprStmt {
            w.walk_expr(stmt.expr, mod_name)
        }
        ast.ForInStmt {
            w.walk_expr(stmt.key, mod_name)
            w.walk_expr(stmt.value, mod_name)
            w.walk_expr(stmt.expr, mod_name)
        }
        ast.ForStmt {
            w.walk_stmt(stmt.init, mod_name)
            w.walk_expr(stmt.cond, mod_name)
            w.walk_stmt(stmt.post, mod_name)
            w.walk_stmts(stmt.stmts, mod_name)
        }
        ast.GlobalDecl {
            for field in stmt.fields {
                w.walk_expr(field.typ, mod_name)
                w.walk_expr(field.value, mod_name)
            }
        }
        ast.LabelStmt {
            w.walk_stmt(stmt.stmt, mod_name)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                w.mark_fn_value_expr(expr, mod_name)
                w.walk_expr(expr, mod_name)
                // If the function returns an interface type and the return expr
                // is a concrete struct InitExpr, mark the concrete type's
                // interface methods so the vtable wrapper can call them.
                w.mark_interface_conversion_methods(w.cur_fn_decl.typ.return_type, expr, mod_name)
                w.mark_result_error_return_methods(w.cur_fn_decl.typ.return_type, expr, mod_name)
            }
        }
        ast.StructDecl {
            for field in stmt.fields {
                w.walk_expr(field.typ, mod_name)
                w.walk_expr(field.value, mod_name)
            }
        }
        ast.TypeDecl {
            w.walk_expr(stmt.base_type, mod_name)
            for variant in stmt.variants {
                w.walk_expr(variant, mod_name)
            }
        }
        []ast.Attribute {
            attrs := stmt as []ast.Attribute
            for attr in attrs {
                w.walk_expr(attr.value, mod_name)
                w.walk_expr(attr.comptime_cond, mod_name)
            }
        }
        else {}
    }
}

fn (mut w Walker) walk_expr(expr ast.Expr, mod_name string) {
    if !expr_ok(expr) {
        return
    }
    match expr {
        ast.ArrayInitExpr {
            w.walk_expr(expr.typ, mod_name)
            for item in expr.exprs {
                w.mark_fn_value_expr(item, mod_name)
                w.walk_expr(item, mod_name)
            }
            w.mark_fn_value_expr(expr.init, mod_name)
            w.walk_expr(expr.init, mod_name)
            w.walk_expr(expr.cap, mod_name)
            w.walk_expr(expr.len, mod_name)
            w.walk_expr(expr.update_expr, mod_name)
        }
        ast.AsCastExpr {
            w.walk_expr(expr.expr, mod_name)
            w.walk_expr(expr.typ, mod_name)
        }
        ast.AssocExpr {
            w.walk_expr(expr.typ, mod_name)
            w.walk_expr(expr.expr, mod_name)
            for field in expr.fields {
                w.mark_fn_value_expr(field.value, mod_name)
                w.walk_expr(field.value, mod_name)
            }
        }
        ast.CallExpr {
            w.mark_call_lhs(expr.lhs, mod_name)
            w.mark_call_arg_interface_conversions(expr, mod_name)
            w.walk_expr(expr.lhs, mod_name)
            for arg in expr.args {
                w.mark_fn_value_expr(arg, mod_name)
                w.walk_expr(arg, mod_name)
            }
        }
        ast.CallOrCastExpr {
            if expr.lhs is ast.Ident && w.is_cast_type_name(expr.lhs.name) {
                w.mark_interface_conversion_methods(expr.lhs, expr.expr, mod_name)
                w.walk_expr(expr.expr, mod_name)
                return
            }
            w.mark_call_lhs(expr.lhs, mod_name)
            w.mark_call_or_cast_arg_interface_conversion(expr, mod_name)
            w.walk_expr(expr.lhs, mod_name)
            w.mark_fn_value_expr(expr.expr, mod_name)
            w.walk_expr(expr.expr, mod_name)
        }
        ast.CastExpr {
            w.mark_interface_conversion_methods(expr.typ, expr.expr, mod_name)
            w.walk_expr(expr.typ, mod_name)
            w.walk_expr(expr.expr, mod_name)
        }
        ast.ComptimeExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.FnLiteral {
            w.walk_stmts(expr.stmts, mod_name)
        }
        ast.GenericArgs {
            w.walk_expr(expr.lhs, mod_name)
            for arg in expr.args {
                w.walk_expr(arg, mod_name)
            }
        }
        ast.GenericArgOrIndexExpr {
            w.walk_expr(expr.lhs, mod_name)
            w.walk_expr(expr.expr, mod_name)
        }
        ast.Ident {
            w.mark_ierror_wrapper_dependencies(expr.name, mod_name)
            if (!w.opts.minimal_runtime_roots || should_mark_ident_as_fn(expr.name))
                && !w.is_cast_type_name(expr.name) {
                w.mark_fn_name(expr.name, mod_name)
            }
        }
        ast.FieldInit {
            if expr.value is ast.SelectorExpr && expr.value.lhs !is ast.EmptyExpr {
                w.mark_selector_fn_value_with_fallback(expr.value, mod_name, true)
            }
            w.mark_fn_value_expr(expr.value, mod_name)
            w.walk_expr(expr.value, mod_name)
        }
        ast.IfExpr {
            w.walk_expr(expr.cond, mod_name)
            w.walk_stmts(expr.stmts, mod_name)
            w.walk_expr(expr.else_expr, mod_name)
        }
        ast.IfGuardExpr {
            w.walk_stmt(ast.Stmt(expr.stmt), mod_name)
        }
        ast.IndexExpr {
            w.walk_expr(expr.lhs, mod_name)
            w.walk_expr(expr.expr, mod_name)
        }
        ast.InfixExpr {
            w.mark_infix_operator_method(expr, mod_name)
            w.walk_expr(expr.lhs, mod_name)
            w.walk_expr(expr.rhs, mod_name)
        }
        ast.InitExpr {
            w.mark_interface_conversion_methods(expr.typ, expr, mod_name)
            w.walk_expr(expr.typ, mod_name)
            for field in expr.fields {
                if field.value is ast.SelectorExpr
                    && w.init_field_is_fn_value(expr.typ, field.name, mod_name) {
                    w.mark_selector_fn_value_with_fallback(field.value, mod_name, true)
                }
                w.mark_fn_value_expr(field.value, mod_name)
                w.walk_expr(field.value, mod_name)
            }
        }
        ast.KeywordOperator {
            for value in expr.exprs {
                w.walk_expr(value, mod_name)
            }
        }
        ast.LambdaExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.LockExpr {
            for lock_expr in expr.lock_exprs {
                w.walk_expr(lock_expr, mod_name)
            }
            for lock_expr in expr.rlock_exprs {
                w.walk_expr(lock_expr, mod_name)
            }
            w.walk_stmts(expr.stmts, mod_name)
        }
        ast.MapInitExpr {
            w.walk_expr(expr.typ, mod_name)
            for key in expr.keys {
                w.mark_fn_value_expr(key, mod_name)
                w.walk_expr(key, mod_name)
            }
            for value in expr.vals {
                w.mark_fn_value_expr(value, mod_name)
                w.walk_expr(value, mod_name)
            }
        }
        ast.MatchExpr {
            w.walk_expr(expr.expr, mod_name)
            for branch in expr.branches {
                for cond in branch.cond {
                    w.walk_expr(cond, mod_name)
                }
                w.walk_stmts(branch.stmts, mod_name)
            }
        }
        ast.ModifierExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.OrExpr {
            w.walk_expr(expr.expr, mod_name)
            w.walk_stmts(expr.stmts, mod_name)
        }
        ast.ParenExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.PostfixExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.PrefixExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.RangeExpr {
            w.walk_expr(expr.start, mod_name)
            w.walk_expr(expr.end, mod_name)
        }
        ast.SelectExpr {
            w.walk_stmt(expr.stmt, mod_name)
            w.walk_stmts(expr.stmts, mod_name)
            w.walk_expr(expr.next, mod_name)
        }
        ast.SelectorExpr {
            w.mark_selector_fn_value(expr, mod_name)
            w.walk_expr(expr.lhs, mod_name)
        }
        ast.SqlExpr {
            w.walk_expr(expr.expr, mod_name)
        }
        ast.StringInterLiteral {
            for inter in expr.inters {
                w.mark_string_interpolation_str_dependency(inter.expr, mod_name)
                w.walk_expr(inter.expr, mod_name)
                w.walk_expr(inter.format_expr, mod_name)
            }
        }
        ast.Tuple {
            for value in expr.exprs {
                w.mark_fn_value_expr(value, mod_name)
                w.walk_expr(value, mod_name)
            }
        }
        ast.UnsafeExpr {
            w.walk_stmts(expr.stmts, mod_name)
        }
        ast.Type {
            match expr {
                ast.ArrayFixedType {
                    w.walk_expr(expr.len, mod_name)
                    w.walk_expr(expr.elem_type, mod_name)
                }
                ast.ArrayType {
                    w.walk_expr(expr.elem_type, mod_name)
                }
                ast.ChannelType {
                    w.walk_expr(expr.cap, mod_name)
                    w.walk_expr(expr.elem_type, mod_name)
                }
                ast.FnType {
                    for param in expr.params {
                        w.walk_expr(param.typ, mod_name)
                    }
                    w.walk_expr(expr.return_type, mod_name)
                }
                ast.GenericType {
                    w.walk_expr(expr.name, mod_name)
                    for param in expr.params {
                        w.walk_expr(param, mod_name)
                    }
                }
                ast.MapType {
                    w.walk_expr(expr.key_type, mod_name)
                    w.walk_expr(expr.value_type, mod_name)
                }
                ast.OptionType {
                    w.walk_expr(expr.base_type, mod_name)
                }
                ast.PointerType {
                    w.walk_expr(expr.base_type, mod_name)
                }
                ast.ResultType {
                    w.walk_expr(expr.base_type, mod_name)
                }
                ast.ThreadType {
                    w.walk_expr(expr.elem_type, mod_name)
                }
                ast.TupleType {
                    for typ in expr.types {
                        w.walk_expr(typ, mod_name)
                    }
                }
                ast.AnonStructType {
                    for embedded in expr.embedded {
                        w.walk_expr(embedded, mod_name)
                    }
                    for field in expr.fields {
                        w.walk_expr(field.typ, mod_name)
                        w.walk_expr(field.value, mod_name)
                    }
                }
                else {}
            }
        }
        else {}
    }
}