// 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 cleanc

import runtime
import strings
import time
import v2.ast
import v2.token
import v2.types

const max_generic_struct_scan_jobs = 4

$if !windows {
    struct GenericStructScanChunkArgs {
        worker           voidptr // &Gen - pre-cloned worker
        file_indices_ptr voidptr // &[]int - worker-owned full-file indexes
    }

    @[typedef]
    struct C.pthread_t {}

    fn C.pthread_create(thread &C.pthread_t, attr voidptr, start_routine fn (voidptr) voidptr, arg voidptr) int
    fn C.pthread_join(thread C.pthread_t, retval voidptr) int
    fn C.pthread_attr_init(attr voidptr) int
    fn C.pthread_attr_setstacksize(attr voidptr, stacksize usize) int
    fn C.pthread_attr_destroy(attr voidptr) int

    fn generic_struct_scan_chunk_thread(arg voidptr) voidptr {
        a := unsafe { &GenericStructScanChunkArgs(arg) }
        mut w := unsafe { &Gen(a.worker) }
        indices := unsafe { &[]int(a.file_indices_ptr) }
        w.collect_generic_struct_bindings_file_indices(*indices)
        return unsafe { nil }
    }
}

fn (mut g Gen) has_explicit_str_method_for_c_type(c_type_name string) bool {
    old_file := g.cur_file_name
    old_module := g.cur_module
    old_import_modules := g.cur_import_modules.clone()
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            g.set_file_cursor_module(fc)
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() == .stmt_fn_decl && stmt.name() == 'str' {
                    decl := stmt.fn_decl_signature()
                    if decl.is_method
                        && g.method_decl_c_name_for_module(g.cur_module, decl) == '${c_type_name}__str' {
                        g.cur_file_name = old_file
                        g.cur_module = old_module
                        g.cur_import_modules = old_import_modules.clone()
                        return true
                    }
                }
            }
        }
    } else {
        for file in g.files {
            g.set_file_module(file)
            for stmt in file.stmts {
                if stmt is ast.FnDecl {
                    if stmt.is_method && stmt.name == 'str'
                        && g.method_decl_c_name_for_module(g.cur_module, stmt) == '${c_type_name}__str' {
                        g.cur_file_name = old_file
                        g.cur_module = old_module
                        g.cur_import_modules = old_import_modules.clone()
                        return true
                    }
                }
            }
        }
    }
    g.cur_file_name = old_file
    g.cur_module = old_module
    g.cur_import_modules = old_import_modules.clone()
    return false
}

// collect_generic_struct_bindings scans all struct fields for GenericType
// instantiations (e.g. LinkedList[ValueInfo]) and records the concrete type
// bindings so that methods on generic structs can resolve their generic params.
fn (mut g Gen) collect_generic_struct_bindings() {
    stats_enabled := g.cgen_stats_enabled()
    stats_scope := g.cgen_stats_scope_label()
    mut stats_sw := time.new_stopwatch()
    mut stage_start := stats_sw.elapsed()
    prev_active_generic_types := g.active_generic_types.clone()
    prev_runtime_local_types := g.runtime_local_types.clone()
    prev_runtime_decl_types := g.runtime_decl_types.clone()
    prev_not_local_var_cache := g.not_local_var_cache.clone()
    prev_is_module_ident_cache := g.is_module_ident_cache.clone()
    prev_resolved_module_names := g.resolved_module_names.clone()
    prev_cur_fn_generic_params := g.cur_fn_generic_params.clone()
    prev_fn_name := g.cur_fn_name
    prev_fn_c_name := g.cur_fn_c_name
    g.active_generic_types = map[string]types.Type{}
    g.runtime_local_types = map[string]string{}
    g.runtime_decl_types = map[string]string{}
    g.not_local_var_cache = map[string]bool{}
    g.is_module_ident_cache = map[string]bool{}
    g.resolved_module_names = map[string]string{}
    g.cur_fn_generic_params = map[string]string{}
    g.cur_fn_name = ''
    g.cur_fn_c_name = ''
    defer {
        g.active_generic_types = prev_active_generic_types.clone()
        g.runtime_local_types = prev_runtime_local_types.clone()
        g.runtime_decl_types = prev_runtime_decl_types.clone()
        g.not_local_var_cache = prev_not_local_var_cache.clone()
        g.is_module_ident_cache = prev_is_module_ident_cache.clone()
        g.resolved_module_names = prev_resolved_module_names.clone()
        g.cur_fn_generic_params = prev_cur_fn_generic_params.clone()
        g.cur_fn_name = prev_fn_name
        g.cur_fn_c_name = prev_fn_c_name
    }
    if g.has_flat() {
        g.collect_generic_struct_bindings_flat()
    } else if !g.collect_generic_struct_bindings_file_scan_parallel() {
        g.collect_generic_struct_bindings_file_scan(g.files)
    }
    stage_start = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
        'setup.generic_struct_bindings.file_scan')
    if g.has_flat() {
        g.propagate_generic_struct_bindings_flat()
    } else {
        g.propagate_generic_struct_bindings_for_files(g.files)
    }
    stage_start = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
        'setup.generic_struct_bindings.propagate')
    if g.has_flat() {
        g.scan_receiver_generic_struct_bindings_flat()
    } else {
        g.scan_receiver_generic_struct_bindings_for_files(g.files)
    }
    _ = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
        'setup.generic_struct_bindings.receiver_scan')
}

fn (mut g Gen) collect_generic_struct_bindings_flat() {
    for i in 0 .. g.flat.files.len {
        fc := g.flat.file_cursor(i)
        g.set_file_cursor_module(fc)
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            stmt := stmts.at(j)
            match stmt.kind() {
                .stmt_struct_decl {
                    decl := stmt.struct_decl()
                    for field in decl.fields {
                        g.scan_expr_for_generic_types(field.typ)
                    }
                }
                .stmt_fn_decl {
                    decl := stmt.fn_decl_signature()
                    if decl.receiver.typ !is ast.EmptyExpr {
                        g.scan_expr_for_generic_types(decl.receiver.typ)
                    }
                    for param in decl.typ.params {
                        g.scan_expr_for_generic_types(param.typ)
                    }
                    if decl.typ.return_type !is ast.EmptyExpr {
                        g.scan_expr_for_generic_types(decl.typ.return_type)
                    }
                    if stmt.list_at(3).len() > 0 {
                        g.scan_fn_body_cursor_for_generic_types_with_clean_locals(stmt, decl, '')
                    }
                }
                else {}
            }
        }
    }
}

fn (mut g Gen) collect_generic_struct_bindings_file_scan(files []ast.File) {
    for file in files {
        g.collect_generic_struct_bindings_file(file)
    }
}

fn (mut g Gen) collect_generic_struct_bindings_file_indices(file_indices []int) {
    for file_idx in file_indices {
        if file_idx < 0 || file_idx >= g.files.len {
            continue
        }
        g.collect_generic_struct_bindings_file(g.files[file_idx])
    }
}

fn (mut g Gen) collect_generic_struct_bindings_file(file ast.File) {
    g.set_file_module(file)
    for stmt in file.stmts {
        if stmt is ast.StructDecl {
            for field in stmt.fields {
                g.scan_expr_for_generic_types(field.typ)
            }
        }
        // Also scan function bodies for generic type references
        // (e.g. LinkedList[StructFieldInfo]{} in decode_value)
        if stmt is ast.FnDecl {
            if stmt.receiver.typ !is ast.EmptyExpr {
                g.scan_expr_for_generic_types(stmt.receiver.typ)
            }
            for param in stmt.typ.params {
                g.scan_expr_for_generic_types(param.typ)
            }
            if stmt.typ.return_type !is ast.EmptyExpr {
                g.scan_expr_for_generic_types(stmt.typ.return_type)
            }
            g.scan_fn_body_for_generic_types_with_clean_locals(stmt, '')
        }
    }
}

fn (mut g Gen) propagate_generic_struct_bindings_for_files(files []ast.File) {
    // Propagation pass: for each generic struct with recorded bindings,
    // look for nested generic type references (e.g. Node[T] inside
    // LinkedList[T]) and record concrete bindings by substituting the
    // parent struct's known bindings for placeholder params.
    for file in files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if stmt is ast.StructDecl {
                if stmt.generic_params.len == 0 {
                    continue
                }
                struct_c_name := g.get_struct_name(stmt)
                if struct_c_name !in g.generic_struct_bindings {
                    continue
                }
                // Propagate for ALL instances (not just the primary binding)
                instances := g.generic_struct_instances[struct_c_name]
                for inst in instances {
                    for field in stmt.fields {
                        g.propagate_generic_bindings(field.typ, inst.bindings)
                    }
                }
            }
        }
    }
}

fn (mut g Gen) propagate_generic_struct_bindings_flat() {
    for i in 0 .. g.flat.files.len {
        fc := g.flat.file_cursor(i)
        g.set_file_cursor_module(fc)
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            stmt := stmts.at(j)
            if stmt.kind() != .stmt_struct_decl {
                continue
            }
            decl := stmt.struct_decl()
            if decl.generic_params.len == 0 {
                continue
            }
            struct_c_name := g.get_struct_name(decl)
            if struct_c_name !in g.generic_struct_bindings {
                continue
            }
            instances := g.generic_struct_instances[struct_c_name]
            for inst in instances {
                for field in decl.fields {
                    g.propagate_generic_bindings(field.typ, inst.bindings)
                }
            }
        }
    }
}

fn (mut g Gen) scan_receiver_generic_struct_bindings_for_files(files []ast.File) {
    // Generic receiver methods can contain explicit calls like
    // `helper[T](...)` even when the receiver itself is emitted with v2's
    // fallback placeholder type. Rescan those bodies with concrete receiver
    // bindings. Uninstantiated receiver-generic methods should not invent
    // concrete helper calls from unrelated generic bindings.
    for file in files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                recv_params := receiver_generic_param_names(stmt)
                if recv_params.len == 0 {
                    continue
                }
                mut binding_sets := []map[string]types.Type{}
                all_bindings := g.get_all_receiver_generic_bindings(stmt)
                if all_bindings.len > 0 {
                    binding_sets << all_bindings
                } else if bindings := g.get_receiver_generic_bindings(stmt) {
                    binding_sets << bindings
                }
                if binding_sets.len == 0 {
                    continue
                }
                prev_generic_types := g.active_generic_types.clone()
                for bindings in binding_sets {
                    g.active_generic_types = bindings.clone()
                    g.scan_fn_body_for_generic_types_with_clean_locals(stmt, '')
                }
                g.active_generic_types = prev_generic_types.clone()
            }
        }
    }
}

fn (mut g Gen) scan_receiver_generic_struct_bindings_flat() {
    for i in 0 .. g.flat.files.len {
        fc := g.flat.file_cursor(i)
        g.set_file_cursor_module(fc)
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            stmt := stmts.at(j)
            if stmt.kind() != .stmt_fn_decl {
                continue
            }
            decl := stmt.fn_decl_signature()
            recv_params := receiver_generic_param_names(decl)
            if recv_params.len == 0 {
                continue
            }
            mut binding_sets := []map[string]types.Type{}
            all_bindings := g.get_all_receiver_generic_bindings(decl)
            if all_bindings.len > 0 {
                binding_sets << all_bindings
            } else if bindings := g.get_receiver_generic_bindings(decl) {
                binding_sets << bindings
            }
            if binding_sets.len == 0 {
                continue
            }
            prev_generic_types := g.active_generic_types.clone()
            for bindings in binding_sets {
                g.active_generic_types = bindings.clone()
                g.scan_fn_body_cursor_for_generic_types_with_clean_locals(stmt, decl, '')
            }
            g.active_generic_types = prev_generic_types.clone()
        }
    }
}

fn (mut g Gen) collect_generic_struct_bindings_file_scan_parallel() bool {
    if g.pref == unsafe { nil } || g.pref.no_parallel || g.files.len < 2 {
        return false
    }
    $if windows {
        return false
    } $else {
        stats_enabled := g.cgen_stats_enabled()
        stats_scope := g.cgen_stats_scope_label()
        mut stats_sw := time.new_stopwatch()
        mut stage_start := stats_sw.elapsed()
        n_files := g.files.len
        n_runtime_jobs := runtime.nr_jobs()
        n_jobs := generic_struct_scan_job_count(n_runtime_jobs, n_files)
        if n_jobs <= 1 {
            return false
        }

        mut thread_ids := []C.pthread_t{len: n_jobs}
        mut args := []GenericStructScanChunkArgs{cap: n_jobs}
        mut workers := []voidptr{cap: n_jobs}
        mut chunk_indices := [][]int{cap: n_jobs}
        for ci := 0; ci < n_jobs; ci++ {
            start := ci * n_files / n_jobs
            end := (ci + 1) * n_files / n_jobs
            mut indices := []int{cap: end - start}
            for file_idx := start; file_idx < end; file_idx++ {
                indices << file_idx
            }
            chunk_indices << indices
            w := g.new_generic_struct_scan_worker(ci)
            workers << voidptr(w)
        }
        stage_start = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
            'setup.generic_struct_bindings.worker_setup')
        for ci := 0; ci < n_jobs; ci++ {
            args << GenericStructScanChunkArgs{
                worker:           workers[ci]
                file_indices_ptr: unsafe { voidptr(&chunk_indices[ci]) }
            }
        }

        attr_buf := [64]u8{}
        attr := unsafe { voidptr(&attr_buf[0]) }
        C.pthread_attr_init(attr)
        C.pthread_attr_setstacksize(attr, 64 * 1024 * 1024)
        for ci := 0; ci < n_jobs; ci++ {
            C.pthread_create(unsafe { &thread_ids[ci] }, attr, generic_struct_scan_chunk_thread,
                unsafe { voidptr(&args[ci]) })
        }
        C.pthread_attr_destroy(attr)
        for ci := 0; ci < n_jobs; ci++ {
            C.pthread_join(thread_ids[ci], unsafe { nil })
        }
        stage_start = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
            'setup.generic_struct_bindings.worker_run')
        for ci := 0; ci < n_jobs; ci++ {
            w := unsafe { &Gen(workers[ci]) }
            g.merge_generic_struct_scan_worker(w)
        }
        _ = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
            'setup.generic_struct_bindings.worker_merge')
        return true
    }
}

fn generic_struct_scan_job_count(n_runtime_jobs int, n_files int) int {
    if n_runtime_jobs <= 0 || n_files <= 0 {
        return 0
    }
    mut n_jobs := n_runtime_jobs
    if n_jobs > max_generic_struct_scan_jobs {
        n_jobs = max_generic_struct_scan_jobs
    }
    if n_jobs > n_files {
        n_jobs = n_files
    }
    // Worker Gen clones are sizeable; avoid spending more time cloning than scanning
    // when the current bundle is already small because .vh caches did most work.
    if n_files < n_jobs * 4 {
        n_jobs = if n_files >= 4 { n_files / 4 } else { 1 }
    }
    return n_jobs
}

fn (g &Gen) new_generic_struct_scan_worker(worker_id int) &Gen {
    mut w := g.new_pass5_worker([], worker_id)
    w.generic_body_scan_cache = g.generic_body_scan_cache.clone()
    w.generic_spec_index = clone_generic_spec_index(g.generic_spec_index)
    w.late_generic_specs = clone_late_generic_specs(g.late_generic_specs)
    w.generic_struct_bindings = clone_generic_struct_bindings(g.generic_struct_bindings)
    w.generic_struct_instances = clone_generic_struct_instances(g.generic_struct_instances)
    w.active_generic_types = map[string]types.Type{}
    w.runtime_local_types = map[string]string{}
    w.runtime_decl_types = map[string]string{}
    w.not_local_var_cache = map[string]bool{}
    w.is_module_ident_cache = map[string]bool{}
    w.resolved_module_names = map[string]string{}
    w.cur_fn_generic_params = map[string]string{}
    w.cur_fn_name = ''
    w.cur_fn_c_name = ''
    return w
}

fn (mut g Gen) merge_generic_struct_scan_worker(w &Gen) {
    for struct_c_name, instances in w.generic_struct_instances {
        for inst in instances {
            g.merge_generic_struct_scan_instance(struct_c_name, inst)
        }
    }
    for key, bindings in w.generic_struct_bindings {
        if key !in g.generic_struct_bindings && key !in g.generic_struct_instances {
            g.generic_struct_bindings[key] = bindings.clone()
        }
    }
    for key, specs in w.late_generic_specs {
        for bindings in specs {
            g.record_late_generic_call_spec_unchecked(key, bindings)
        }
    }
    for key, scanned in w.generic_body_scan_cache {
        if scanned {
            g.generic_body_scan_cache[key] = true
        }
    }
    g.merge_generic_setup_alias_maps(w)
}

fn (mut g Gen) merge_generic_struct_scan_instance(struct_c_name string, inst GenericStructInstance) {
    mut instances := g.generic_struct_instances[struct_c_name]
    struct_base := if struct_c_name.contains('__') {
        struct_c_name.all_after_last('__')
    } else {
        struct_c_name
    }
    param_names := g.generic_struct_runtime_param_names(struct_base, struct_c_name)
    bindings_key := g.generic_struct_bindings_key(param_names, inst.bindings)
    for existing in instances {
        if g.generic_struct_instance_matches(existing, inst.params_key, bindings_key, param_names) {
            return
        }
    }
    mut c_name := inst.c_name
    if instances.len > 0 && c_name == struct_c_name {
        c_name = '${struct_c_name}_T_${inst.params_key}'
    }
    merged := GenericStructInstance{
        params_key: inst.params_key
        bindings:   inst.bindings.clone()
        c_name:     c_name
    }
    instances << merged
    g.generic_struct_instances[struct_c_name] = instances
    if struct_c_name !in g.generic_struct_bindings {
        g.generic_struct_bindings[struct_c_name] = merged.bindings.clone()
    }
}

fn (mut g Gen) merge_generic_setup_alias_maps(w &Gen) {
    for key, values in w.tuple_aliases {
        if key !in g.tuple_aliases {
            g.tuple_aliases[key] = values.clone()
        }
    }
    for key, value in w.array_aliases {
        if value {
            g.array_aliases[key] = true
        }
    }
    for key, value in w.map_aliases {
        if value {
            g.map_aliases[key] = true
        }
    }
    for key, value in w.result_aliases {
        if value {
            g.result_aliases[key] = true
        }
    }
    for key, value in w.option_aliases {
        if value {
            g.option_aliases[key] = true
        }
    }
    for key, value in w.collected_fixed_array_types {
        if key !in g.collected_fixed_array_types {
            g.collected_fixed_array_types[key] = value
        }
    }
    for key, value in w.collected_map_types {
        if key !in g.collected_map_types {
            g.collected_map_types[key] = value
        }
    }
}

fn (mut g Gen) scan_fn_body_for_generic_types_with_clean_locals(node ast.FnDecl, spec_name string) {
    prev_runtime_local_types := g.runtime_local_types.clone()
    prev_runtime_decl_types := g.runtime_decl_types.clone()
    prev_not_local_var_cache := g.not_local_var_cache.clone()
    prev_is_module_ident_cache := g.is_module_ident_cache.clone()
    prev_resolved_module_names := g.resolved_module_names.clone()
    prev_cur_fn_generic_params := g.cur_fn_generic_params.clone()
    prev_fn_name := g.cur_fn_name
    prev_fn_c_name := g.cur_fn_c_name
    g.runtime_local_types = map[string]string{}
    g.runtime_decl_types = map[string]string{}
    g.not_local_var_cache = map[string]bool{}
    g.is_module_ident_cache = map[string]bool{}
    g.resolved_module_names = map[string]string{}
    g.cur_fn_generic_params = map[string]string{}
    g.cur_fn_name = ''
    g.cur_fn_c_name = ''
    g.scan_fn_body_for_generic_types(node, spec_name)
    g.runtime_local_types = prev_runtime_local_types.clone()
    g.runtime_decl_types = prev_runtime_decl_types.clone()
    g.not_local_var_cache = prev_not_local_var_cache.clone()
    g.is_module_ident_cache = prev_is_module_ident_cache.clone()
    g.resolved_module_names = prev_resolved_module_names.clone()
    g.cur_fn_generic_params = prev_cur_fn_generic_params.clone()
    g.cur_fn_name = prev_fn_name
    g.cur_fn_c_name = prev_fn_c_name
}

fn (mut g Gen) scan_fn_body_cursor_for_generic_types_with_clean_locals(stmt ast.Cursor, decl ast.FnDecl, spec_name string) {
    prev_runtime_local_types := g.runtime_local_types.clone()
    prev_runtime_decl_types := g.runtime_decl_types.clone()
    prev_not_local_var_cache := g.not_local_var_cache.clone()
    prev_is_module_ident_cache := g.is_module_ident_cache.clone()
    prev_resolved_module_names := g.resolved_module_names.clone()
    prev_cur_fn_generic_params := g.cur_fn_generic_params.clone()
    prev_fn_name := g.cur_fn_name
    prev_fn_c_name := g.cur_fn_c_name
    g.runtime_local_types = map[string]string{}
    g.runtime_decl_types = map[string]string{}
    g.not_local_var_cache = map[string]bool{}
    g.is_module_ident_cache = map[string]bool{}
    g.resolved_module_names = map[string]string{}
    g.cur_fn_generic_params = map[string]string{}
    g.cur_fn_name = ''
    g.cur_fn_c_name = ''
    g.scan_fn_body_cursor_for_generic_types(stmt, decl, spec_name)
    g.runtime_local_types = prev_runtime_local_types.clone()
    g.runtime_decl_types = prev_runtime_decl_types.clone()
    g.not_local_var_cache = prev_not_local_var_cache.clone()
    g.is_module_ident_cache = prev_is_module_ident_cache.clone()
    g.resolved_module_names = prev_resolved_module_names.clone()
    g.cur_fn_generic_params = prev_cur_fn_generic_params.clone()
    g.cur_fn_name = prev_fn_name
    g.cur_fn_c_name = prev_fn_c_name
}

fn clone_tuple_aliases(src map[string][]string) map[string][]string {
    mut out := map[string][]string{}
    for key, values in src {
        out[key] = values.clone()
    }
    return out
}

fn clone_generic_spec_index(src map[string][]string) map[string][]string {
    mut out := map[string][]string{}
    for key, values in src {
        out[key] = values.clone()
    }
    return out
}

fn clone_late_generic_specs(src map[string][]map[string]types.Type) map[string][]map[string]types.Type {
    mut out := map[string][]map[string]types.Type{}
    for key, specs in src {
        mut cloned_specs := []map[string]types.Type{cap: specs.len}
        for spec in specs {
            cloned_specs << spec.clone()
        }
        out[key] = cloned_specs
    }
    return out
}

fn clone_generic_struct_bindings(src map[string]map[string]types.Type) map[string]map[string]types.Type {
    mut out := map[string]map[string]types.Type{}
    for key, bindings in src {
        out[key] = bindings.clone()
    }
    return out
}

fn clone_generic_struct_instances(src map[string][]GenericStructInstance) map[string][]GenericStructInstance {
    mut out := map[string][]GenericStructInstance{}
    for key, instances in src {
        mut cloned_instances := []GenericStructInstance{cap: instances.len}
        for inst in instances {
            cloned_instances << GenericStructInstance{
                params_key: inst.params_key
                bindings:   inst.bindings.clone()
                c_name:     inst.c_name
            }
        }
        out[key] = cloned_instances
    }
    return out
}

fn (s &GenericSetupSnapshot) clone() GenericSetupSnapshot {
    return GenericSetupSnapshot{
        ready:                       s.ready
        tuple_aliases:               clone_tuple_aliases(s.tuple_aliases)
        array_aliases:               s.array_aliases.clone()
        map_aliases:                 s.map_aliases.clone()
        result_aliases:              s.result_aliases.clone()
        option_aliases:              s.option_aliases.clone()
        collected_fixed_array_types: s.collected_fixed_array_types.clone()
        collected_map_types:         s.collected_map_types.clone()
        generic_body_scan_cache:     s.generic_body_scan_cache.clone()
        generic_spec_index:          clone_generic_spec_index(s.generic_spec_index)
        late_generic_specs:          clone_late_generic_specs(s.late_generic_specs)
        generic_struct_bindings:     clone_generic_struct_bindings(s.generic_struct_bindings)
        generic_struct_instances:    clone_generic_struct_instances(s.generic_struct_instances)
    }
}

pub fn (mut g Gen) use_generic_setup_snapshot(snapshot GenericSetupSnapshot) {
    g.generic_setup_snapshot = snapshot.clone()
    g.has_generic_setup_snapshot = snapshot.ready
}

pub fn (g &Gen) generic_setup_snapshot() GenericSetupSnapshot {
    return GenericSetupSnapshot{
        ready:                       true
        tuple_aliases:               clone_tuple_aliases(g.tuple_aliases)
        array_aliases:               g.array_aliases.clone()
        map_aliases:                 g.map_aliases.clone()
        result_aliases:              g.result_aliases.clone()
        option_aliases:              g.option_aliases.clone()
        collected_fixed_array_types: g.collected_fixed_array_types.clone()
        collected_map_types:         g.collected_map_types.clone()
        generic_body_scan_cache:     g.generic_body_scan_cache.clone()
        generic_spec_index:          clone_generic_spec_index(g.generic_spec_index)
        late_generic_specs:          clone_late_generic_specs(g.late_generic_specs)
        generic_struct_bindings:     clone_generic_struct_bindings(g.generic_struct_bindings)
        generic_struct_instances:    clone_generic_struct_instances(g.generic_struct_instances)
    }
}

fn (mut g Gen) apply_generic_setup_snapshot() {
    snapshot := g.generic_setup_snapshot
    g.tuple_aliases = clone_tuple_aliases(snapshot.tuple_aliases)
    g.array_aliases = snapshot.array_aliases.clone()
    g.map_aliases = snapshot.map_aliases.clone()
    g.result_aliases = snapshot.result_aliases.clone()
    g.option_aliases = snapshot.option_aliases.clone()
    g.collected_fixed_array_types = snapshot.collected_fixed_array_types.clone()
    g.collected_map_types = snapshot.collected_map_types.clone()
    g.generic_body_scan_cache = snapshot.generic_body_scan_cache.clone()
    g.generic_spec_index = clone_generic_spec_index(snapshot.generic_spec_index)
    g.late_generic_specs = clone_late_generic_specs(snapshot.late_generic_specs)
    g.generic_struct_bindings = clone_generic_struct_bindings(snapshot.generic_struct_bindings)
    g.generic_struct_instances = clone_generic_struct_instances(snapshot.generic_struct_instances)
}

// propagate_generic_bindings finds nested generic type references and records
// concrete bindings by substituting placeholder params from parent bindings.
fn (mut g Gen) propagate_generic_bindings(e ast.Expr, parent_bindings map[string]types.Type) {
    match e {
        ast.Type {
            if e is ast.GenericType {
                gt := e as ast.GenericType
                base_name := g.expr_type_to_c(gt.name)
                if gt.params.len > 0 {
                    // Check if any param is a placeholder that can be resolved
                    // via parent_bindings.
                    mut all_concrete := true
                    for param in gt.params {
                        pname := param.name()
                        if is_generic_placeholder_type_name(pname) && pname !in parent_bindings {
                            all_concrete = false
                            break
                        }
                    }
                    if all_concrete && !g.generic_call_spec_scan_only {
                        struct_base := if base_name.contains('__') {
                            base_name.all_after_last('__')
                        } else {
                            base_name
                        }
                        g.record_generic_struct_bindings_with_parent(struct_base, base_name,
                            gt.params, parent_bindings)
                    }
                }
                // Recurse into params
                for param in gt.params {
                    g.propagate_generic_bindings(param, parent_bindings)
                }
            }
            if e is ast.PointerType {
                g.propagate_generic_bindings(e.base_type, parent_bindings)
            }
        }
        ast.ModifierExpr {
            g.propagate_generic_bindings(e.expr, parent_bindings)
        }
        ast.PrefixExpr {
            g.propagate_generic_bindings(e.expr, parent_bindings)
        }
        ast.GenericArgOrIndexExpr {
            base_name := g.expr_type_to_c(e.lhs)
            arg_name := e.expr.name()
            if !g.generic_call_spec_scan_only {
                if is_generic_placeholder_type_name(arg_name) && arg_name in parent_bindings {
                    struct_base := if base_name.contains('__') {
                        base_name.all_after_last('__')
                    } else {
                        base_name
                    }
                    g.record_generic_struct_bindings_with_parent(struct_base, base_name, [
                        e.expr,
                    ], parent_bindings)
                } else if !is_generic_placeholder_type_name(arg_name) {
                    struct_base := if base_name.contains('__') {
                        base_name.all_after_last('__')
                    } else {
                        base_name
                    }
                    g.record_generic_struct_bindings(struct_base, base_name, [e.expr])
                }
            }
        }
        ast.GenericArgs {
            base_name := g.expr_type_to_c(e.lhs)
            if e.args.len > 0 && !g.generic_call_spec_scan_only {
                struct_base := if base_name.contains('__') {
                    base_name.all_after_last('__')
                } else {
                    base_name
                }
                g.record_generic_struct_bindings_with_parent(struct_base, base_name, e.args,
                    parent_bindings)
            }
        }
        else {}
    }
}

fn (mut g Gen) scan_expr_for_generic_types(e ast.Expr) {
    match e {
        ast.Ident {
            if e.name.contains('_T_') || e.name.ends_with('_T') {
                g.scan_generic_fn_value_for_specs(e)
                g.record_generic_struct_bindings_from_specialized_name(e.name)
            }
        }
        ast.Type {
            if e is ast.GenericType {
                gt := e as ast.GenericType
                base_name := g.expr_type_to_c(gt.name)
                if gt.params.len > 0 && !g.generic_call_spec_scan_only {
                    struct_base := if base_name.contains('__') {
                        base_name.all_after_last('__')
                    } else {
                        base_name
                    }
                    g.record_generic_struct_bindings(struct_base, base_name, gt.params)
                }
                // Also scan params recursively (e.g. Node[T] inside LinkedList[ValueInfo])
                for param in gt.params {
                    g.scan_expr_for_generic_types(param)
                }
            }
            if e is ast.ArrayType {
                g.scan_expr_for_generic_types(e.elem_type)
            }
            if e is ast.MapType {
                g.scan_expr_for_generic_types(e.key_type)
                g.scan_expr_for_generic_types(e.value_type)
            }
            if e is ast.OptionType {
                g.scan_expr_for_generic_types(e.base_type)
            }
            if e is ast.ResultType {
                g.scan_expr_for_generic_types(e.base_type)
            }
            if e is ast.PointerType {
                g.scan_expr_for_generic_types(e.base_type)
            }
        }
        ast.ModifierExpr {
            g.scan_expr_for_generic_types(e.expr)
        }
        ast.PrefixExpr {
            g.scan_expr_for_generic_types(e.expr)
        }
        ast.GenericArgOrIndexExpr {
            // e.g. &Node[ValueInfo] → PrefixExpr { GenericArgOrIndexExpr { Ident("Node"), Ident("ValueInfo") } }
            g.scan_generic_fn_value_for_specs(e)
            base_name := g.expr_type_to_c(e.lhs)
            arg_name := e.expr.name()
            if !g.generic_call_spec_scan_only {
                struct_base := if base_name.contains('__') {
                    base_name.all_after_last('__')
                } else {
                    base_name
                }
                if is_generic_placeholder_type_name(arg_name) {
                    if concrete := g.active_generic_types[arg_name] {
                        g.record_generic_struct_bindings(struct_base, base_name, [
                            ast.Expr(ast.Ident{
                                name: g.types_type_to_c(concrete)
                            }),
                        ])
                    }
                } else {
                    g.record_generic_struct_bindings(struct_base, base_name, [e.expr])
                }
            }
        }
        ast.GenericArgs {
            g.scan_generic_fn_value_for_specs(e)
            base_name := g.expr_type_to_c(e.lhs)
            if e.args.len > 0 && !g.generic_call_spec_scan_only {
                struct_base := if base_name.contains('__') {
                    base_name.all_after_last('__')
                } else {
                    base_name
                }
                mut concrete_args := []ast.Expr{cap: e.args.len}
                mut all_concrete := true
                for arg in e.args {
                    arg_name := arg.name()
                    if is_generic_placeholder_type_name(arg_name) {
                        if concrete := g.active_generic_types[arg_name] {
                            concrete_args << ast.Expr(ast.Ident{
                                name: g.types_type_to_c(concrete)
                            })
                        } else {
                            all_concrete = false
                            break
                        }
                    } else {
                        concrete_args << arg
                    }
                }
                if all_concrete {
                    g.record_generic_struct_bindings(struct_base, base_name, concrete_args)
                }
            }
        }
        ast.CallOrCastExpr {
            // LinkedList[StructFieldInfo]{} is parsed as CallOrCastExpr with
            // lhs = GenericArgOrIndexExpr or GenericArgs
            g.scan_expr_for_generic_types(e.lhs)
            g.scan_expr_for_generic_types(e.expr)
        }
        ast.CallExpr {
            g.scan_expr_for_generic_types(e.lhs)
            for arg in e.args {
                g.scan_expr_for_generic_types(arg)
                g.scan_expr_stmts_for_generic_types(arg)
            }
            g.scan_call_for_generic_fn_specs(e)
        }
        ast.InfixExpr {
            g.scan_expr_for_generic_types(e.lhs)
            g.scan_expr_for_generic_types(e.rhs)
            if e.op == .left_shift {
                g.remember_array_append_lhs_type_for_generic_scan(e.lhs, e.rhs)
            }
        }
        ast.OrExpr {
            g.scan_expr_for_generic_types(e.expr)
        }
        ast.ComptimeExpr {
            if e.expr is ast.IfExpr {
                g.scan_comptime_if_for_generic_types(e.expr)
                return
            }
            g.scan_expr_for_generic_types(e.expr)
        }
        ast.IfExpr {
            g.scan_expr_for_generic_types(e.cond)
        }
        ast.MatchExpr {
            g.scan_expr_for_generic_types(e.expr)
            for branch in e.branches {
                for cond in branch.cond {
                    g.scan_expr_for_generic_types(cond)
                }
            }
        }
        ast.Tuple {
            mut elem_types := []string{cap: e.exprs.len}
            for expr in e.exprs {
                g.scan_expr_for_generic_types(expr)
                g.scan_expr_stmts_for_generic_types(expr)
                mut elem_type := g.get_expr_type(expr)
                if elem_type == '' || elem_type == 'int' {
                    if raw := g.get_raw_type(expr) {
                        elem_type = g.types_type_to_c(raw)
                    }
                }
                if elem_type == '' {
                    elem_type = 'int'
                }
                elem_types << elem_type
            }
            g.register_tuple_alias(elem_types)
        }
        ast.InitExpr {
            // e.g. LinkedList[StructFieldInfo]{} has .typ = GenericArgs
            g.scan_expr_for_generic_types(e.typ)
            for field in e.fields {
                g.scan_expr_for_generic_types(field.value)
            }
        }
        else {}
    }
}

fn (mut g Gen) record_generic_struct_bindings_from_specialized_name(raw_name string) {
    if !raw_name.contains('_T_') {
        return
    }
    struct_c_name := raw_name.all_before('_T_')
    if struct_c_name == '' {
        return
    }
    runtime_param_names := g.generic_struct_runtime_param_names(struct_c_name, struct_c_name)
    if runtime_param_names.len == 0 {
        return
    }
    arg_tokens := generic_call_embedded_type_arg_names_from_name(raw_name, runtime_param_names.len)
    if arg_tokens.len != runtime_param_names.len {
        return
    }
    mut bindings := map[string]types.Type{}
    mut param_c_names := []string{cap: arg_tokens.len}
    for i, param_name in runtime_param_names {
        concrete_c_name := generic_token_to_c_type(arg_tokens[i])
        if concrete_c_name == '' {
            return
        }
        concrete_type := g.concrete_type_from_call_arg_c_name(concrete_c_name) or { return }
        if type_contains_generic_placeholder(concrete_type)
            || !g.generic_concrete_type_is_runtime_specializable(concrete_type) {
            return
        }
        bindings[param_name] = concrete_type
        param_c_names << mangle_alias_component(concrete_c_name)
    }
    if bindings.len != runtime_param_names.len
        || !g.generic_specialization_belongs_to_emit_modules(bindings) {
        return
    }
    params_key := param_c_names.join('_')
    bindings_key := g.generic_struct_bindings_key(runtime_param_names, bindings)
    mut instances := g.generic_struct_instances[struct_c_name]
    for inst in instances {
        if inst.c_name == raw_name
            || g.generic_struct_instance_matches(inst, params_key, bindings_key, runtime_param_names)
            || g.generic_struct_instance_bindings_match(inst, bindings, runtime_param_names) {
            return
        }
    }
    instances << GenericStructInstance{
        params_key: params_key
        bindings:   bindings.clone()
        c_name:     raw_name
    }
    g.generic_struct_instances[struct_c_name] = instances
    if struct_c_name !in g.generic_struct_bindings {
        g.generic_struct_bindings[struct_c_name] = bindings.clone()
    }
}

fn (mut g Gen) generic_call_decl_from_lhs(lhs ast.Expr) ?ast.FnDecl {
    mut call_name := match lhs {
        ast.Ident {
            lhs.name
        }
        ast.SelectorExpr {
            lhs.rhs.name
        }
        ast.GenericArgOrIndexExpr {
            return g.generic_call_decl_from_lhs(lhs.lhs)
        }
        ast.GenericArgs {
            return g.generic_call_decl_from_lhs(lhs.lhs)
        }
        else {
            ''
        }
    }

    if call_name.contains('_T_') {
        call_name = call_name.all_before('_T_')
    } else if call_name.ends_with('_T') {
        call_name = call_name[..call_name.len - 2]
    }

    if call_name == '' {
        return none
    }
    for candidate in generic_call_decl_candidates(call_name) {
        if info := g.generic_fn_decl_index[candidate] {
            if g.has_flat() {
                if info.file_idx < 0 || info.file_idx >= g.flat.files.len {
                    continue
                }
                stmts := g.flat.file_cursor(info.file_idx).stmts()
                if info.stmt_idx < 0 || info.stmt_idx >= stmts.len() {
                    continue
                }
                stmt := stmts.at(info.stmt_idx)
                if stmt.kind() == .stmt_fn_decl {
                    return stmt.fn_decl_signature()
                }
            } else if info.file_idx >= 0 && info.file_idx < g.files.len {
                file := g.files[info.file_idx]
                if info.stmt_idx >= 0 && info.stmt_idx < file.stmts.len {
                    stmt := file.stmts[info.stmt_idx]
                    if stmt is ast.FnDecl {
                        return stmt
                    }
                }
            }
        }
    }
    if g.generic_fn_decl_index.len > 0 {
        return none
    }
    prev_module := g.cur_module
    prev_file_name := g.cur_file_name
    prev_active_generic_types := g.active_generic_types.clone()
    g.active_generic_types = map[string]types.Type{}
    defer {
        g.cur_module = prev_module
        g.cur_file_name = prev_file_name
        g.active_generic_types = prev_active_generic_types.clone()
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            g.set_file_cursor_module(fc)
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() != .stmt_fn_decl || stmt.name() != call_name {
                    continue
                }
                decl := stmt.fn_decl_signature()
                if g.generic_fn_param_names(decl).len > 0 {
                    return decl
                }
            }
        }
        return none
    }
    for file in g.files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == call_name
                && g.generic_fn_param_names(stmt).len > 0 {
                return stmt
            }
        }
    }
    return none
}

fn (mut g Gen) generic_call_decl_from_lhs_cursor(lhs ast.Cursor) ?ast.FnDecl {
    mut call_name := generic_call_short_name_cursor(lhs)
    if call_name == '' {
        return none
    }
    for candidate in generic_call_decl_candidates(call_name) {
        if info := g.generic_fn_decl_index[candidate] {
            if g.has_flat() {
                if info.file_idx < 0 || info.file_idx >= g.flat.files.len {
                    continue
                }
                stmts := g.flat.file_cursor(info.file_idx).stmts()
                if info.stmt_idx < 0 || info.stmt_idx >= stmts.len() {
                    continue
                }
                stmt := stmts.at(info.stmt_idx)
                if stmt.kind() == .stmt_fn_decl {
                    return stmt.fn_decl_signature()
                }
            } else if info.file_idx >= 0 && info.file_idx < g.files.len {
                file := g.files[info.file_idx]
                if info.stmt_idx >= 0 && info.stmt_idx < file.stmts.len {
                    stmt := file.stmts[info.stmt_idx]
                    if stmt is ast.FnDecl {
                        return stmt
                    }
                }
            }
        }
    }
    if g.generic_fn_decl_index.len > 0 {
        return none
    }
    prev_module := g.cur_module
    prev_file_name := g.cur_file_name
    prev_active_generic_types := g.active_generic_types.clone()
    g.active_generic_types = map[string]types.Type{}
    defer {
        g.cur_module = prev_module
        g.cur_file_name = prev_file_name
        g.active_generic_types = prev_active_generic_types.clone()
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            g.set_file_cursor_module(fc)
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() != .stmt_fn_decl || stmt.name() != call_name {
                    continue
                }
                decl := stmt.fn_decl_signature()
                if g.generic_fn_param_names(decl).len > 0 {
                    return decl
                }
            }
        }
        return none
    }
    for file in g.files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == call_name
                && g.generic_fn_param_names(stmt).len > 0 {
                return stmt
            }
        }
    }
    return none
}

fn generic_call_decl_candidates(call_name string) []string {
    mut candidates := []string{cap: 3}
    if call_name != '' {
        candidates << call_name
    }
    sanitized := sanitize_fn_ident(call_name)
    if sanitized != '' && sanitized !in candidates {
        candidates << sanitized
    }
    if call_name.contains('__') {
        short_name := call_name.all_after_last('__')
        if short_name != '' && short_name !in candidates {
            candidates << short_name
        }
    }
    return candidates
}

fn generic_call_short_name(lhs ast.Expr) string {
    mut name := match lhs {
        ast.Ident {
            lhs.name
        }
        ast.SelectorExpr {
            lhs.rhs.name
        }
        ast.GenericArgOrIndexExpr {
            generic_call_short_name(lhs.lhs)
        }
        ast.GenericArgs {
            generic_call_short_name(lhs.lhs)
        }
        else {
            ''
        }
    }

    if name.contains('_T_') {
        name = name.all_before('_T_')
    } else if name.ends_with('_T') {
        name = name[..name.len - 2]
    }
    return name
}

fn generic_call_short_name_cursor(lhs ast.Cursor) string {
    mut name := match lhs.kind() {
        .expr_ident {
            lhs.name()
        }
        .expr_selector {
            lhs.edge(1).name()
        }
        .expr_generic_arg_or_index, .expr_generic_args {
            generic_call_short_name_cursor(lhs.edge(0))
        }
        else {
            ''
        }
    }

    if name.contains('_T_') {
        name = name.all_before('_T_')
    } else if name.ends_with('_T') {
        name = name[..name.len - 2]
    }
    return name
}

fn generic_call_raw_name(lhs ast.Expr) string {
    return match lhs {
        ast.Ident {
            lhs.name
        }
        ast.SelectorExpr {
            lhs.rhs.name
        }
        ast.GenericArgOrIndexExpr {
            generic_call_raw_name(lhs.lhs)
        }
        ast.GenericArgs {
            generic_call_raw_name(lhs.lhs)
        }
        else {
            ''
        }
    }
}

fn generic_call_raw_name_cursor(lhs ast.Cursor) string {
    return match lhs.kind() {
        .expr_ident {
            lhs.name()
        }
        .expr_selector {
            lhs.edge(1).name()
        }
        .expr_generic_arg_or_index, .expr_generic_args {
            generic_call_raw_name_cursor(lhs.edge(0))
        }
        else {
            ''
        }
    }
}

fn generic_call_type_args(lhs ast.Expr) []ast.Expr {
    return match lhs {
        ast.GenericArgOrIndexExpr {
            if lhs.expr is ast.LifetimeExpr {
                []ast.Expr{}
            } else {
                [lhs.expr]
            }
        }
        ast.GenericArgs {
            runtime_generic_args(lhs.args)
        }
        else {
            []ast.Expr{}
        }
    }
}

fn generic_call_type_args_cursor(lhs ast.Cursor) []ast.Expr {
    match lhs.kind() {
        .expr_generic_arg_or_index {
            arg := lhs.edge(1)
            if arg.kind() == .expr_lifetime {
                return []ast.Expr{}
            }
            return [arg.type_expr()]
        }
        .expr_generic_args {
            mut args := []ast.Expr{cap: lhs.edge_count() - 1}
            for i in 1 .. lhs.edge_count() {
                arg := lhs.edge(i)
                if arg.kind() == .expr_lifetime {
                    continue
                }
                args << arg.type_expr()
            }
            return args
        }
        else {
            return []ast.Expr{}
        }
    }
}

fn generic_call_embedded_type_arg_names_from_name(raw_name string, expected_count int) []string {
    if expected_count <= 0 {
        return []string{}
    }
    if !raw_name.contains('_T_') {
        return []string{}
    }
    suffix := raw_name.all_after('_T_')
    if suffix == '' {
        return []string{}
    }
    if expected_count == 1 {
        return [suffix]
    }
    parts := suffix.split('_')
    if parts.len != expected_count {
        return []string{}
    }
    return parts
}

fn generic_call_embedded_type_arg_names(lhs ast.Expr, expected_count int) []string {
    raw_name := match lhs {
        ast.Ident {
            lhs.name
        }
        ast.SelectorExpr {
            lhs.rhs.name
        }
        ast.GenericArgOrIndexExpr {
            return generic_call_embedded_type_arg_names(lhs.lhs, expected_count)
        }
        ast.GenericArgs {
            return generic_call_embedded_type_arg_names(lhs.lhs, expected_count)
        }
        else {
            ''
        }
    }

    return generic_call_embedded_type_arg_names_from_name(raw_name, expected_count)
}

fn generic_call_embedded_type_arg_names_cursor(lhs ast.Cursor, expected_count int) []string {
    raw_name := generic_call_raw_name_cursor(lhs)
    return generic_call_embedded_type_arg_names_from_name(raw_name, expected_count)
}

fn (g &Gen) active_generic_bindings_matching_embedded_args(embedded_args []string, generic_params []string) ?map[string]types.Type {
    if embedded_args.len != generic_params.len || g.active_generic_types.len == 0 {
        return none
    }
    mut bindings := map[string]types.Type{}
    for i, param_name in generic_params {
        arg_name := embedded_args[i]
        concrete := if is_generic_placeholder_type_name(arg_name) {
            g.active_generic_types[arg_name] or { return none }
        } else {
            active := g.active_generic_types[param_name] or { return none }
            spec_token := g.generic_specialization_token_from_type(active)
            if !generic_token_matches_short_name(spec_token, arg_name) {
                return none
            }
            active
        }
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return none
        }
        bindings[param_name] = concrete
    }
    return bindings
}

fn (g &Gen) generic_concrete_type_is_runtime_specializable(typ types.Type) bool {
    if !generic_concrete_type_is_runtime_specializable(typ) {
        return false
    }
    concrete := normalize_generic_concrete_type(typ)
    c_name := g.types_type_to_c(concrete)
    if c_name != '' && g.generic_struct_primary_instance_is_concrete(c_name) {
        return true
    }
    if c_name != '' {
        if struct_typ := g.lookup_type_by_c_name_const(c_name) {
            if struct_typ is types.Struct
                && type_contains_generic_placeholder(types.Type(struct_typ)) {
                return false
            }
        }
    }
    if c_name != '' && c_name in g.generic_struct_instances && c_name !in g.generic_struct_bindings {
        return false
    }
    return true
}

fn (g &Gen) active_generic_bindings_matching_embedded_suffix(lhs ast.Expr, generic_params []string) ?map[string]types.Type {
    embedded_args := generic_call_embedded_type_arg_names(lhs, generic_params.len)
    return g.active_generic_bindings_matching_embedded_args(embedded_args, generic_params)
}

fn (g &Gen) active_generic_bindings_matching_embedded_suffix_cursor(lhs ast.Cursor, generic_params []string) ?map[string]types.Type {
    embedded_args := generic_call_embedded_type_arg_names_cursor(lhs, generic_params.len)
    return g.active_generic_bindings_matching_embedded_args(embedded_args, generic_params)
}

fn (g &Gen) active_generic_bindings_matching_name_suffix(name string, generic_params []string) ?map[string]types.Type {
    embedded_args := generic_call_embedded_type_arg_names_from_name(name, generic_params.len)
    return g.active_generic_bindings_matching_embedded_args(embedded_args, generic_params)
}

fn (mut g Gen) bind_embedded_generic_type_args(lhs ast.Expr, generic_params []string, mut bindings map[string]types.Type) bool {
    embedded_args := generic_call_embedded_type_arg_names(lhs, generic_params.len)
    if embedded_args.len == 0 {
        return true
    }
    if embedded_args.len != generic_params.len {
        return bindings.len == generic_params.len
    }
    for i, param_name in generic_params {
        if param_name in bindings {
            continue
        }
        arg_name := embedded_args[i]
        if is_generic_placeholder_type_name(arg_name) {
            concrete := g.active_generic_types[arg_name] or { return false }
            bindings[param_name] = concrete
            continue
        }
        concrete := g.concrete_type_from_c_name(arg_name) or { return false }
        bindings[param_name] = concrete
    }
    return true
}

fn (mut g Gen) bind_embedded_generic_type_args_cursor(lhs ast.Cursor, generic_params []string, mut bindings map[string]types.Type) bool {
    embedded_args := generic_call_embedded_type_arg_names_cursor(lhs, generic_params.len)
    if embedded_args.len == 0 {
        return true
    }
    if embedded_args.len != generic_params.len {
        return bindings.len == generic_params.len
    }
    for i, param_name in generic_params {
        if param_name in bindings {
            continue
        }
        arg_name := embedded_args[i]
        if is_generic_placeholder_type_name(arg_name) {
            concrete := g.active_generic_types[arg_name] or { return false }
            bindings[param_name] = concrete
            continue
        }
        concrete := g.concrete_type_from_c_name(arg_name) or { return false }
        bindings[param_name] = concrete
    }
    return true
}

fn (mut g Gen) generic_type_arg_concrete_type(arg ast.Expr) ?types.Type {
    arg_name := arg.name()
    if is_generic_placeholder_type_name(arg_name) {
        if concrete := g.active_generic_types[arg_name] {
            resolved_concrete := g.concrete_type_with_active_generics(concrete)
            if !generic_concrete_type_is_runtime_specializable(resolved_concrete) {
                return none
            }
            return resolved_concrete
        }
        return none
    }
    c_name := g.expr_type_to_c(arg).trim_space().trim_right('*')
    concrete := g.concrete_type_from_c_name(c_name) or { return none }
    if !g.generic_concrete_type_is_runtime_specializable(concrete) {
        return none
    }
    return concrete
}

fn (mut g Gen) concrete_type_from_generic_call_arg(arg ast.Expr) ?types.Type {
    base_arg := if arg is ast.ModifierExpr { arg.expr } else { arg }
    if is_comptime_field_metadata_expr(base_arg, g.comptime_field_var) {
        return none
    }
    if base_arg is ast.SelectorExpr && is_comptime_selector_rhs_name(base_arg.rhs.name)
        && type_has_valid_data(g.comptime_field_raw_type) {
        return g.comptime_field_raw_type
    }
    if active_concrete := g.active_generic_concrete_from_arg(base_arg) {
        return active_concrete
    }
    if base_arg is ast.Ident {
        if placeholder := g.cur_fn_generic_params[base_arg.name] {
            if placeholder !in g.active_generic_types {
                return none
            }
        }
    }
    mut c_name := ''
    if base_arg is ast.InitExpr {
        c_name = g.expr_type_to_c(base_arg.typ).trim_space()
    }
    if c_name == '' && base_arg is ast.CastExpr {
        c_name = g.expr_type_to_c(base_arg.typ).trim_space()
    }
    if (c_name == '' || c_name == 'int' || c_name == 'array' || c_name == 'map')
        && base_arg is ast.SelectorExpr {
        c_name = g.selector_field_type(base_arg).trim_space()
        if c_name == '' || c_name == 'int' || c_name == 'array' || c_name == 'map' {
            c_name = g.selector_declared_field_type(base_arg).trim_space()
        }
    }
    mut found_local_arg_type := false
    if c_name == '' || c_name == 'int' {
        if base_arg is ast.Ident {
            c_name = (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space()
            found_local_arg_type = c_name != ''
        }
    }
    if !found_local_arg_type && (c_name == '' || c_name == 'int') {
        c_name = g.get_expr_type(base_arg).trim_space()
    }
    if c_name == '' || c_name == 'int' {
        if raw := g.get_raw_type(base_arg) {
            return raw
        }
    }
    if c_name == '' || c_name == 'int' {
        return none
    }
    if concrete := g.active_generic_types[c_name] {
        return concrete
    }
    return g.concrete_type_from_call_arg_c_name(c_name)
}

fn (mut g Gen) concrete_type_from_generic_call_arg_cursor(arg ast.Cursor) ?types.Type {
    base_arg := generic_call_base_arg_cursor(arg)
    if is_comptime_field_metadata_expr_cursor(base_arg, g.comptime_field_var) {
        return none
    }
    if base_arg.kind() == .expr_selector && is_comptime_selector_rhs_name(base_arg.edge(1).name())
        && type_has_valid_data(g.comptime_field_raw_type) {
        return g.comptime_field_raw_type
    }
    if active_concrete := g.active_generic_concrete_from_arg_cursor(base_arg) {
        return active_concrete
    }
    if base_arg.kind() == .expr_ident {
        if placeholder := g.cur_fn_generic_params[base_arg.name()] {
            if placeholder !in g.active_generic_types {
                return none
            }
        }
    }
    mut c_name := ''
    match base_arg.kind() {
        .expr_init {
            c_name = g.expr_type_to_c(base_arg.edge(0).type_expr()).trim_space()
        }
        .expr_cast {
            c_name = g.expr_type_to_c(base_arg.edge(0).type_expr()).trim_space()
        }
        .expr_as_cast {
            c_name = g.expr_type_to_c(base_arg.edge(1).type_expr()).trim_space()
        }
        else {}
    }

    if (c_name == '' || c_name == 'int' || c_name == 'array' || c_name == 'map')
        && base_arg.kind() == .expr_selector {
        c_name = g.selector_declared_field_type_cursor_for_generic_scan(base_arg).trim_space()
    }

    mut found_local_arg_type := false
    if c_name == '' || c_name == 'int' {
        if base_arg.kind() == .expr_ident {
            c_name = (g.get_local_var_c_type(base_arg.name()) or { '' }).trim_space()
            found_local_arg_type = c_name != ''
        }
    }
    if !found_local_arg_type && (c_name == '' || c_name == 'int') {
        c_name = g.generic_scan_expr_cursor_c_type(base_arg).trim_space()
    }
    if !found_local_arg_type && (c_name == '' || c_name == 'int') {
        if raw := g.raw_type_from_generic_call_arg_cursor(base_arg) {
            return raw
        }
    }
    if c_name == '' || c_name == 'int' {
        return none
    }
    if concrete := g.active_generic_types[c_name] {
        return concrete
    }
    return g.concrete_type_from_call_arg_c_name(c_name)
}

fn generic_call_base_arg_cursor(arg ast.Cursor) ast.Cursor {
    if arg.kind() == .expr_modifier {
        return arg.edge(0)
    }
    return arg
}

fn (mut g Gen) active_generic_concrete_from_arg_cursor(arg ast.Cursor) ?types.Type {
    if g.active_generic_types.len == 0 {
        return none
    }
    if arg.kind() == .expr_prefix && unsafe { token.Token(int(arg.aux())) } == .amp {
        if concrete := g.active_generic_concrete_from_arg_cursor(arg.edge(0)) {
            return types.Type(types.Pointer{
                base_type: concrete
            })
        }
    }
    if arg.kind() == .expr_ident {
        if param_name := g.cur_fn_generic_params[arg.name()] {
            if concrete := g.active_generic_types[param_name] {
                return normalize_generic_concrete_type(concrete)
            }
        }
    }
    raw := g.raw_type_from_generic_call_arg_cursor(arg) or { return none }
    concrete := g.concrete_type_with_active_generics(raw)
    if type_contains_generic_placeholder(concrete) || concrete.name() == raw.name() {
        return none
    }
    return normalize_generic_concrete_type(concrete)
}

fn (mut g Gen) raw_type_from_generic_call_arg_cursor(arg ast.Cursor) ?types.Type {
    if g.env == unsafe { nil } || !arg.is_valid() {
        return none
    }
    if arg.kind() == .expr_ident {
        if cached := g.is_module_ident_cache[arg.name()] {
            if cached {
                return none
            }
        }
        if local_type := g.runtime_local_types[arg.name()] {
            if resolved := g.resolve_c_type_to_raw(local_type) {
                return resolved
            }
        }
        if mut fn_scope := g.ensure_cur_fn_scope() {
            if obj := fn_scope.lookup_parent(arg.name(), 0) {
                if obj is types.Module {
                    return none
                }
                return obj.typ()
            }
        }
    }
    pos := arg.pos()
    if pos.is_valid() {
        if typ := g.env.get_expr_type(pos.id) {
            if type_has_valid_data(typ) {
                return typ
            }
        }
    }
    return none
}

fn is_comptime_field_metadata_expr(expr ast.Expr, field_var string) bool {
    if field_var == '' {
        return false
    }
    base_expr := if expr is ast.ModifierExpr { expr.expr } else { expr }
    if base_expr is ast.SelectorExpr && base_expr.lhs is ast.Ident
        && (base_expr.lhs as ast.Ident).name == field_var
        && !is_comptime_selector_rhs_name(base_expr.rhs.name) {
        return true
    }
    return false
}

fn is_comptime_field_metadata_expr_cursor(expr ast.Cursor, field_var string) bool {
    if field_var == '' {
        return false
    }
    base_expr := generic_call_base_arg_cursor(expr)
    if base_expr.kind() != .expr_selector {
        return false
    }
    lhs := base_expr.edge(0)
    rhs := base_expr.edge(1)
    return lhs.kind() == .expr_ident && lhs.name() == field_var
        && !is_comptime_selector_rhs_name(rhs.name())
}

fn (mut g Gen) record_late_generic_call_spec_for_key(key string, bindings map[string]types.Type) {
    if key == '' || bindings.len == 0 {
        return
    }
    for _, concrete in bindings {
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return
        }
    }
    for existing in g.late_generic_specs[key] {
        if existing == bindings {
            return
        }
    }
    g.late_generic_specs[key] << bindings.clone()
    g.index_late_generic_spec_key(key)
}

fn (mut g Gen) record_late_generic_call_spec_unchecked(key string, bindings map[string]types.Type) {
    if key == '' || bindings.len == 0 {
        return
    }
    for existing in g.late_generic_specs[key] {
        if existing == bindings {
            return
        }
    }
    g.late_generic_specs[key] << bindings.clone()
    g.index_late_generic_spec_key(key)
}

fn (mut g Gen) record_late_generic_call_spec(key string, bindings map[string]types.Type) {
    g.record_late_generic_call_spec_for_key(key, bindings)
    dot_pos := key.last_index_u8(`.`)
    if dot_pos > 0 && dot_pos < key.len - 1 {
        short_key := key[dot_pos + 1..]
        if short_key != key {
            g.record_late_generic_call_spec_for_key(short_key, bindings)
        }
    }
}

fn (mut g Gen) record_generic_scan_call_name(lhs ast.Expr, arg_count int, generic_params []string, bindings map[string]types.Type) {
    base_name := g.resolve_call_name(lhs, arg_count)
    g.record_generic_scan_call_base_name(base_name, generic_params, bindings)
}

fn (mut g Gen) record_generic_scan_call_name_cursor(lhs ast.Cursor, arg_count int, generic_params []string, bindings map[string]types.Type) {
    base_name := g.resolve_call_name_cursor_for_generic_scan(lhs, arg_count)
    g.record_generic_scan_call_base_name(base_name, generic_params, bindings)
}

fn (mut g Gen) record_generic_scan_call_base_name(name string, generic_params []string, bindings map[string]types.Type) {
    if !g.collect_generic_scan_calls {
        return
    }
    if generic_params.len == 0 || bindings.len != generic_params.len {
        return
    }
    mut base_name := name
    if base_name == '' {
        return
    }
    if base_name.contains('_T_') {
        base_name = base_name.all_before('_T_')
    } else if base_name.ends_with('_T') {
        base_name = base_name[..base_name.len - 2]
    }
    base_name = normalize_duplicate_qualified_method_prefix(base_name)
    mut suffixes := []string{cap: generic_params.len}
    for param_name in generic_params {
        concrete := bindings[param_name] or { return }
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return
        }
        suffixes << g.generic_specialization_token_from_type(concrete)
    }
    if suffixes.len == generic_params.len {
        specialized_name := '${base_name}_T_${suffixes.join('_')}'
        g.generic_scan_called_names[specialized_name] = true
        if !base_name.contains('__') && g.cur_module != '' && g.cur_module != 'main'
            && g.cur_module != 'builtin' {
            g.generic_scan_called_names['${g.cur_module}__${specialized_name}'] = true
        }
    }
}

fn (mut g Gen) resolve_call_name_cursor_for_generic_scan(lhs ast.Cursor, arg_count int) string {
    mut name := ''
    match lhs.kind() {
        .expr_generic_arg_or_index, .expr_generic_args {
            return g.resolve_call_name_cursor_for_generic_scan(lhs.edge(0), arg_count)
        }
        .expr_ident {
            name = sanitize_fn_ident(lhs.name())
        }
        .expr_selector {
            lhs_expr := lhs.edge(0)
            method_name := sanitize_fn_ident(lhs.edge(1).name())
            if lhs_expr.kind() == .expr_ident && lhs_expr.name() == 'C' {
                return method_name
            }
            if lhs_expr.kind() == .expr_ident && (g.is_type_name(lhs_expr.name())
                || g.selector_lhs_is_static_type_ident(lhs_expr.name())) {
                return '${g.get_qualified_name(lhs_expr.name())}__${method_name}'
            }
            if mod_call_name := g.resolve_selector_module_call_name_cursor(lhs) {
                name = mod_call_name
            } else if qualified_method_name := g.resolved_qualified_selector_method_name(method_name) {
                name = qualified_method_name
            } else {
                mut base_type := g.method_receiver_base_type_cursor_for_generic_scan(lhs_expr)
                if base_type == '' {
                    base_type =
                        g.generic_scan_expr_cursor_c_type(lhs_expr).trim_space().trim_right('*')
                }
                name = '${base_type}__${method_name}'
                if receiver_type := g.get_receiver_expr_type_for_method_cursor(lhs_expr) {
                    if concrete_method := g.resolve_method_on_concrete_type(receiver_type,
                        method_name)
                    {
                        name = concrete_method
                    }
                }
                if name !in g.fn_return_types && name !in g.fn_param_is_ptr {
                    if raw_type := g.raw_type_from_generic_call_arg_cursor(lhs_expr) {
                        raw_c_type := strip_pointer_type_name(g.types_type_to_c(raw_type))
                        if raw_c_type != '' && raw_c_type != base_type {
                            if raw_method := g.resolve_method_on_concrete_type(raw_c_type,
                                method_name)
                            {
                                name = raw_method
                            }
                        }
                    }
                    if name !in g.fn_return_types && name !in g.fn_param_is_ptr {
                        if alias_base := g.alias_base_c_type(base_type) {
                            alias_name := '${alias_base}__${method_name}'
                            if alias_name in g.fn_return_types || alias_name in g.fn_param_is_ptr {
                                name = alias_name
                            }
                        }
                    }
                    if name !in g.fn_return_types && name !in g.fn_param_is_ptr {
                        if map_method := g.map_runtime_method_name_cursor(lhs_expr, method_name) {
                            name = map_method
                        }
                    }
                }
            }
        }
        else {}
    }

    if name == 'builtin__new_array_from_c_array_noscan' {
        name = 'new_array_from_c_array'
    }
    if name == 'builtin__array_push_noscan' {
        name = 'array__push'
    }
    if name == 'panic' {
        name = 'v_panic'
    }
    if name == 'voidptr__vbytes' {
        name = 'void__vbytes'
    }
    if name == 'int__bytestr' {
        name = 'Array_u8__bytestr'
    }
    if name.ends_with('__bytes') && name !in g.fn_return_types && name !in g.fn_param_is_ptr {
        if 'string__bytes' in g.fn_return_types || 'string__bytes' in g.fn_param_is_ptr {
            name = 'string__bytes'
        }
    }
    if is_c_runtime_function(name) {
        return name
    }
    if name != '' && g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
        && !name.contains('__') {
        qualified := '${g.cur_module}__${name}'
        if qualified in g.fn_return_types || qualified in g.fn_param_is_ptr {
            return qualified
        }
        if name in g.fn_return_types || name in g.fn_param_is_ptr {
            return name
        }
        return qualified
    }
    return name
}

fn (mut g Gen) resolve_selector_module_call_name_cursor(lhs ast.Cursor) ?string {
    if lhs.kind() != .expr_selector {
        return none
    }
    lhs_ident := lhs.edge(0)
    if lhs_ident.kind() != .expr_ident || lhs_ident.name() == 'C' {
        return none
    }
    if _ := g.get_local_var_c_type(lhs_ident.name()) {
        return none
    }
    mod_name := g.resolve_module_name(lhs_ident.name())
    name := '${mod_name}__${sanitize_fn_ident(lhs.edge(1).name())}'
    if g.is_module_ident(lhs_ident.name()) || name in g.fn_return_types || name in g.fn_param_is_ptr
        || g.is_module_local_fn(name) || g.has_specialized_fn_base(name)
        || g.has_generic_fn_decl_by_base_name(name) {
        return name
    }
    return none
}

fn (mut g Gen) direct_known_c_type_for_expr_cursor(expr ast.Cursor) string {
    if !expr.is_valid() {
        return ''
    }
    match expr.kind() {
        .expr_paren, .expr_modifier {
            return g.direct_known_c_type_for_expr_cursor(expr.edge(0))
        }
        .expr_prefix {
            if unsafe { token.Token(int(expr.aux())) } == .mul {
                ptr_type := g.direct_known_c_type_for_expr_cursor(expr.edge(0))
                if ptr_type != '' {
                    return strip_one_pointer_type_name(ptr_type)
                }
            }
        }
        .expr_cast {
            return g.expr_type_to_c(expr.edge(0).type_expr())
        }
        .expr_as_cast {
            return g.expr_type_to_c(expr.edge(1).type_expr())
        }
        .expr_ident {
            name := expr.name()
            if local_type := g.get_local_var_c_type(name) {
                return local_type
            }
            if const_type := g.const_types[name] {
                return const_type
            }
            if global_type := g.global_var_types[name] {
                return global_type
            }
            if g.cur_module != '' {
                qualified := '${g.cur_module}__${name}'
                if const_type := g.const_types[qualified] {
                    return const_type
                }
                if global_type := g.global_var_types[qualified] {
                    return global_type
                }
            }
        }
        else {}
    }

    return ''
}

fn (mut g Gen) selector_struct_name_cursor_for_generic_scan(expr ast.Cursor) string {
    direct_type := g.direct_known_c_type_for_expr_cursor(expr)
    if direct_type != '' {
        base := strip_pointer_type_name(direct_type)
        if base != '' && base != 'int' && base !in ['void', 'void*', 'voidptr'] {
            return base
        }
    }
    if expr.kind() == .expr_ident {
        if local_type := g.get_local_var_c_type(expr.name()) {
            base := strip_pointer_type_name(local_type)
            if base != '' && base != 'int' && base !in ['void', 'void*', 'voidptr'] {
                return base
            }
        }
    }
    if raw_type := g.raw_type_from_generic_call_arg_cursor(expr) {
        if !type_has_valid_data(raw_type) {
            return g.generic_scan_expr_cursor_c_type(expr).trim_right('*')
        }
        match raw_type {
            types.Pointer {
                if raw_type.base_type is types.Struct {
                    return raw_type.base_type.name
                }
                if raw_type.base_type is types.Alias {
                    return raw_type.base_type.name
                }
            }
            types.Struct {
                return raw_type.name
            }
            types.Alias {
                return raw_type.name
            }
            else {}
        }
    }
    return g.generic_scan_expr_cursor_c_type(expr).trim_right('*')
}

fn (mut g Gen) selector_declared_field_type_cursor_for_generic_scan(sel ast.Cursor) string {
    if sel.kind() != .expr_selector {
        return ''
    }
    rhs := sel.edge(1).name()
    if rhs == '' {
        return ''
    }
    lhs_expr := sel.edge(0)
    lhs_struct_name := g.selector_struct_name_cursor_for_generic_scan(lhs_expr)
    if lhs_struct_name != '' {
        if g.active_generic_types.len > 0 || lhs_struct_name in g.generic_struct_bindings
            || lhs_struct_name in g.generic_struct_instances || lhs_struct_name.contains('_T_') {
            if field_type := g.lookup_struct_field_type_by_name(lhs_struct_name, rhs) {
                return field_type
            }
        }
        if field_type := g.lookup_struct_decl_field_type_by_name(lhs_struct_name, rhs) {
            return field_type
        }
        if field_type := g.lookup_struct_field_type_by_name(lhs_struct_name, rhs) {
            return field_type
        }
    }
    lhs_expr_type := g.generic_scan_expr_cursor_c_type(lhs_expr)
    if lhs_expr_type != '' && lhs_expr_type != 'int' {
        if field_type := g.lookup_struct_field_type_by_name(lhs_expr_type, rhs) {
            return field_type
        }
    }
    mut raw_resolved := ''
    if lhs_raw := g.raw_type_from_generic_call_arg_cursor(lhs_expr) {
        if field_type := selector_struct_field_type_from_type(lhs_raw, rhs) {
            resolved := g.types_type_to_c(field_type)
            if resolved != '' && resolved !in ['int', 'array'] {
                return resolved
            }
            raw_resolved = resolved
        }
    }
    return raw_resolved
}

fn (mut g Gen) method_receiver_base_type_cursor_for_generic_scan(expr ast.Cursor) string {
    mut base_expr := expr
    for base_expr.is_valid() && base_expr.kind() in [.expr_paren, .expr_modifier] {
        base_expr = base_expr.edge(0)
    }
    if !base_expr.is_valid() {
        return ''
    }
    if base_expr.kind() == .expr_prefix
        && unsafe { token.Token(int(base_expr.aux())) } in [.amp, .mul] {
        return g.method_receiver_base_type_cursor_for_generic_scan(base_expr.edge(0))
    }
    direct_type := g.direct_known_c_type_for_expr_cursor(base_expr)
    if direct_type != '' && direct_type != 'int' {
        base := strip_pointer_type_name(direct_type)
        if base != '' && base != 'int' && base !in ['void', 'void*', 'voidptr'] {
            return base
        }
    }
    if base_expr.kind() == .expr_init {
        init_type := g.expr_type_to_c(base_expr.edge(0).type_expr())
        if init_type != '' && init_type != 'int' {
            return init_type
        }
    }
    if base_expr.kind() == .expr_ident {
        if local_type := g.get_local_var_c_type(base_expr.name()) {
            base := strip_pointer_type_name(local_type)
            if base != '' && base != 'int' {
                return base
            }
        }
    }
    if base_expr.kind() == .expr_selector {
        lhs_struct_name := g.selector_struct_name_cursor_for_generic_scan(base_expr.edge(0))
        if lhs_struct_name != '' {
            if declared_field_type := g.lookup_struct_field_type_by_name(lhs_struct_name,
                base_expr.edge(1).name())
            {
                base := strip_pointer_type_name(declared_field_type)
                if base != '' && base != 'int' && base !in ['void', 'void*', 'voidptr'] {
                    return base
                }
            }
        }
        field_type := g.selector_declared_field_type_cursor_for_generic_scan(base_expr)
        if field_type != '' && field_type != 'int' {
            base := strip_pointer_type_name(field_type)
            if base in ['voidptr', 'void*'] {
                return 'void'
            }
            return base
        }
    }
    if raw_type := g.raw_type_from_generic_call_arg_cursor(base_expr) {
        match raw_type {
            types.Pointer {
                return g.types_type_to_c(raw_type.base_type)
            }
            else {
                raw_c_type := g.types_type_to_c(raw_type)
                if raw_c_type != 'void' {
                    return raw_c_type
                }
            }
        }
    }
    mut receiver_type := g.generic_scan_expr_cursor_c_type(base_expr)
    if receiver_type.ends_with('*') {
        receiver_type = receiver_type[..receiver_type.len - 1]
    }
    if receiver_type in ['voidptr', 'void*'] {
        return 'void'
    }
    return receiver_type
}

fn (mut g Gen) get_receiver_expr_type_for_method_cursor(expr ast.Cursor) ?string {
    mut base_expr := expr
    for base_expr.is_valid() && base_expr.kind() in [.expr_paren, .expr_modifier] {
        base_expr = base_expr.edge(0)
    }
    if !base_expr.is_valid() {
        return none
    }
    if base_expr.kind() == .expr_prefix
        && unsafe { token.Token(int(base_expr.aux())) } in [.amp, .mul] {
        if receiver_type := g.get_receiver_expr_type_for_method_cursor(base_expr.edge(0)) {
            return receiver_type
        }
    }
    if active_concrete := g.active_generic_concrete_from_arg_cursor(base_expr) {
        active_type := g.types_type_to_c(active_concrete).trim_space()
        if active_type != '' && active_type != 'int' && active_type != 'void' {
            return active_type.trim_right('*')
        }
    }
    if base_expr.kind() == .expr_ident {
        local_type := (g.get_local_var_c_type(base_expr.name()) or { '' }).trim_space()
        if local_type != '' && local_type != 'int' && local_type != 'void' {
            return local_type.trim_right('*')
        }
    }
    mut receiver_type := g.generic_scan_expr_cursor_c_type(base_expr).trim_space()
    if base_expr.kind() == .expr_selector {
        declared_type :=
            g.selector_declared_field_type_cursor_for_generic_scan(base_expr).trim_space()
        declared_base := strip_pointer_type_name(declared_type)
        receiver_base := strip_pointer_type_name(receiver_type)
        if declared_type != '' && declared_type != 'int' && declared_type != 'void'
            && (receiver_type == '' || receiver_type == 'int'
            || (declared_type.contains('_T_') && (!receiver_type.contains('_T_')
            || declared_base != receiver_base))) {
            receiver_type = declared_type
        }
    }
    if (receiver_type == '' || receiver_type == 'int') && base_expr.kind() == .expr_ident {
        receiver_type = (g.get_local_var_c_type(base_expr.name()) or { '' }).trim_space()
    }
    if receiver_type == '' || receiver_type == 'int' {
        if raw := g.raw_type_from_generic_call_arg_cursor(base_expr) {
            receiver_type = g.types_type_to_c(raw).trim_space()
        }
    }
    if receiver_type.ends_with('*') {
        receiver_type = receiver_type[..receiver_type.len - 1]
    }
    if receiver_type == '' || receiver_type == 'int' {
        return none
    }
    return receiver_type
}

fn (mut g Gen) selector_receiver_is_map_cursor(receiver ast.Cursor) bool {
    if raw_type := g.raw_type_from_generic_call_arg_cursor(receiver) {
        match raw_type {
            types.Map {
                return true
            }
            types.Pointer {
                match raw_type.base_type {
                    types.Map {
                        return true
                    }
                    types.Alias {
                        return raw_type.base_type.base_type is types.Map
                    }
                    else {}
                }
            }
            types.Alias {
                return raw_type.base_type is types.Map
            }
            else {}
        }
    }
    base_type := g.method_receiver_base_type_cursor_for_generic_scan(receiver)
    if c_type_is_map_value(base_type) {
        return true
    }
    expr_type := g.generic_scan_expr_cursor_c_type(receiver)
    return c_type_is_map_value(expr_type)
}

fn (mut g Gen) map_runtime_method_name_cursor(receiver ast.Cursor, method_name string) ?string {
    if method_name !in ['clone', 'keys', 'values'] || !g.selector_receiver_is_map_cursor(receiver) {
        return none
    }
    return 'map__${method_name}'
}

fn normalize_duplicate_qualified_method_prefix(name string) string {
    parts := name.split('__')
    if parts.len < 5 {
        return name
    }
    max_prefix_parts := parts.len / 2
    for prefix_parts := max_prefix_parts; prefix_parts >= 2; prefix_parts-- {
        mut matches := true
        for i := 0; i < prefix_parts; i++ {
            if parts[i] != parts[prefix_parts + i] {
                matches = false
                break
            }
        }
        if matches {
            return parts[prefix_parts..].join('__')
        }
    }
    return name
}

fn (mut g Gen) index_late_generic_spec_key(key string) {
    // Some generic function values are first discovered while emitting an earlier
    // function body. Keep the specialization index in sync immediately so a later
    // declaration in the same generation pass can emit the concrete body.
    mut fn_name := key
    bracket_idx := key.index_u8(`[`)
    if bracket_idx > 0 {
        fn_name = key[..bracket_idx]
    }
    dot_idx := fn_name.last_index_u8(`.`)
    if dot_idx > 0 && dot_idx < fn_name.len - 1 {
        short_name := fn_name[dot_idx + 1..]
        if short_name.len > 0 && key !in g.generic_spec_index[short_name] {
            g.generic_spec_index[short_name] << key
        }
    }
    double_underscore_idx := fn_name.last_index('__') or { -1 }
    if double_underscore_idx > 0 && double_underscore_idx < fn_name.len - 2 {
        short_name := fn_name[double_underscore_idx + 2..]
        if short_name.len > 0 && key !in g.generic_spec_index[short_name] {
            g.generic_spec_index[short_name] << key
        }
    }
    if fn_name.len > 0 && key !in g.generic_spec_index[fn_name] {
        g.generic_spec_index[fn_name] << key
    }
}

fn (mut g Gen) scan_call_for_generic_fn_specs(call ast.CallExpr) {
    decl := g.generic_call_decl_from_lhs(call.lhs) or { return }
    generic_params := g.generic_fn_param_names(decl)
    if generic_params.len == 0 {
        return
    }
    mut bindings := map[string]types.Type{}
    mut metadata_params := map[string]bool{}
    type_args := generic_call_type_args(call.lhs)
    mut has_unresolved_explicit_type_arg := false
    for i, param_name in generic_params {
        if i >= type_args.len {
            break
        }
        concrete := g.generic_type_arg_concrete_type(type_args[i]) or {
            has_unresolved_explicit_type_arg = true
            continue
        }
        bindings[param_name] = concrete
    }
    if has_unresolved_explicit_type_arg {
        return
    }
    if type_args.len == 0 {
        if active_bindings := g.active_generic_bindings_matching_embedded_suffix(call.lhs,
            generic_params)
        {
            for param_name, concrete in active_bindings {
                bindings[param_name] = concrete
            }
        }
    }
    if type_args.len == 0 && g.active_generic_types.len == 0
        && !g.bind_embedded_generic_type_args(call.lhs, generic_params, mut bindings) {
        return
    }
    arg_offset := if decl.is_method && call.args.len == decl.typ.params.len + 1 { 1 } else { 0 }
    for i, param in decl.typ.params {
        arg_idx := i + arg_offset
        if arg_idx >= call.args.len || !expr_has_generic_placeholder(param.typ) {
            continue
        }
        arg := call.args[arg_idx]
        if is_comptime_field_metadata_expr(arg, g.comptime_field_var) {
            mut seen := map[string]bool{}
            mut names := []string{}
            collect_generic_placeholder_names_from_expr(param.typ, mut seen, mut names)
            for name in names {
                metadata_params[name] = true
            }
            continue
        }
        concrete := g.concrete_type_from_generic_call_arg(arg) or { continue }
        g.infer_generic_type_bindings_from_param(param.typ, g.concrete_type_for_generic_param(param,
            concrete), generic_params, mut bindings)
    }
    for param_name in generic_params {
        if param_name in bindings {
            continue
        }
        if param_name in metadata_params {
            continue
        }
        if concrete := g.active_generic_types[param_name] {
            bindings[param_name] = concrete
        }
    }
    if type_args.len == 0 && bindings.len != generic_params.len
        && !g.bind_embedded_generic_type_args(call.lhs, generic_params, mut bindings) {
        raw_name := generic_call_raw_name(call.lhs)
        if !g.generic_call_name_has_placeholder_suffix(raw_name) {
            if specialized_name := g.try_specialize_generic_call_name(raw_name, call.args) {
                g.record_called_specialized_generic_name(specialized_name)
            }
            return
        }
        return_bindings := g.infer_generic_bindings_from_current_return(decl, generic_params) or {
            return
        }
        for param_name, concrete in return_bindings {
            if param_name !in bindings {
                bindings[param_name] = concrete
            }
        }
    }
    if bindings.len != generic_params.len {
        return
    }
    for _, concrete in bindings {
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return
        }
    }
    short_name := generic_call_short_name(call.lhs)
    keys := if short_name == '' {
        []string{}
    } else {
        [short_name]
    }

    for key in keys {
        g.record_late_generic_call_spec(key, bindings)
    }
    g.record_generic_scan_call_name(call.lhs, call.args.len, generic_params, bindings)
}

fn generic_fn_value_base_cursor(expr ast.Cursor) ast.Cursor {
    if expr.kind() in [.expr_generic_args, .expr_generic_arg_or_index] {
        return expr.edge(0)
    }
    return ast.Cursor{}
}

fn (mut g Gen) scan_generic_struct_bindings_cursor(expr ast.Cursor) {
    if g.generic_call_spec_scan_only {
        return
    }
    match expr.kind() {
        .expr_generic_arg_or_index {
            base_name := g.expr_type_to_c(expr.edge(0).type_expr())
            arg := expr.edge(1)
            arg_name := arg.name()
            struct_base := if base_name.contains('__') {
                base_name.all_after_last('__')
            } else {
                base_name
            }
            if is_generic_placeholder_type_name(arg_name) {
                if concrete := g.active_generic_types[arg_name] {
                    g.record_generic_struct_bindings(struct_base, base_name, [
                        ast.Expr(ast.Ident{
                            name: g.types_type_to_c(concrete)
                        }),
                    ])
                }
            } else {
                g.record_generic_struct_bindings(struct_base, base_name, [
                    arg.type_expr(),
                ])
            }
        }
        .expr_generic_args {
            args := generic_call_type_args_cursor(expr)
            if args.len == 0 {
                return
            }
            base_name := g.expr_type_to_c(expr.edge(0).type_expr())
            struct_base := if base_name.contains('__') {
                base_name.all_after_last('__')
            } else {
                base_name
            }
            mut concrete_args := []ast.Expr{cap: args.len}
            mut all_concrete := true
            for arg in args {
                arg_name := arg.name()
                if is_generic_placeholder_type_name(arg_name) {
                    if concrete := g.active_generic_types[arg_name] {
                        concrete_args << ast.Expr(ast.Ident{
                            name: g.types_type_to_c(concrete)
                        })
                    } else {
                        all_concrete = false
                        break
                    }
                } else {
                    concrete_args << arg
                }
            }
            if all_concrete {
                g.record_generic_struct_bindings(struct_base, base_name, concrete_args)
            }
        }
        else {}
    }
}

fn (mut g Gen) scan_generic_fn_value_cursor_for_specs(expr ast.Cursor) {
    decl := g.generic_call_decl_from_lhs_cursor(expr) or { return }
    generic_params := g.generic_fn_param_names(decl)
    if generic_params.len == 0 {
        return
    }
    mut bindings := map[string]types.Type{}
    type_args := generic_call_type_args_cursor(expr)
    mut has_unresolved_explicit_type_arg := false
    for i, param_name in generic_params {
        if i >= type_args.len {
            break
        }
        concrete := g.generic_type_arg_concrete_type(type_args[i]) or {
            has_unresolved_explicit_type_arg = true
            continue
        }
        bindings[param_name] = concrete
    }
    if has_unresolved_explicit_type_arg {
        return
    }
    for param_name in generic_params {
        if param_name in bindings {
            continue
        }
        if concrete := g.active_generic_types[param_name] {
            bindings[param_name] = concrete
        }
    }
    if type_args.len == 0 && bindings.len != generic_params.len
        && !g.bind_embedded_generic_type_args_cursor(expr, generic_params, mut bindings) {
        return
    }
    if bindings.len != generic_params.len {
        return
    }
    for _, concrete in bindings {
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return
        }
    }
    short_name := generic_call_short_name_cursor(expr)
    if short_name == '' {
        return
    }
    g.record_late_generic_call_spec(short_name, bindings)
    g.record_generic_scan_call_name_cursor(generic_fn_value_base_cursor(expr), 0, generic_params,
        bindings)
}

fn (mut g Gen) scan_generic_fn_value_for_specs(expr ast.Expr) {
    decl := g.generic_call_decl_from_lhs(expr) or { return }
    generic_params := g.generic_fn_param_names(decl)
    if generic_params.len == 0 {
        return
    }
    mut bindings := map[string]types.Type{}
    type_args := generic_call_type_args(expr)
    mut has_unresolved_explicit_type_arg := false
    for i, param_name in generic_params {
        if i >= type_args.len {
            break
        }
        concrete := g.generic_type_arg_concrete_type(type_args[i]) or {
            has_unresolved_explicit_type_arg = true
            continue
        }
        bindings[param_name] = concrete
    }
    if has_unresolved_explicit_type_arg {
        return
    }
    // Generic function values inside generic functions do not have call
    // arguments to infer from. Substitute the surrounding function's concrete
    // bindings so a value like handler[A, X] emits handler_T_App_Context.
    for param_name in generic_params {
        if param_name in bindings {
            continue
        }
        if concrete := g.active_generic_types[param_name] {
            bindings[param_name] = concrete
        }
    }
    if type_args.len == 0 && bindings.len != generic_params.len
        && !g.bind_embedded_generic_type_args(expr, generic_params, mut bindings) {
        return
    }
    if bindings.len != generic_params.len {
        return
    }
    for _, concrete in bindings {
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return
        }
    }
    short_name := generic_call_short_name(expr)
    if short_name == '' {
        return
    }
    g.record_late_generic_call_spec(short_name, bindings)
    g.record_generic_scan_call_name(generic_fn_value_base_expr(expr), 0, generic_params, bindings)
}

fn (mut g Gen) scan_comptime_for_for_generic_types(node ast.ForStmt) bool {
    if node.init !is ast.ForInStmt {
        return false
    }
    for_in := node.init as ast.ForInStmt
    if for_in.expr !is ast.SelectorExpr {
        return false
    }
    sel := for_in.expr as ast.SelectorExpr
    if sel.rhs.name != 'fields' {
        return false
    }
    type_name := sel.lhs.name()
    concrete := g.active_generic_types[type_name] or { return false }
    if concrete !is types.Struct {
        return false
    }
    struct_type := g.comptime_for_struct_type(concrete, concrete as types.Struct)
    prev_field_var := g.comptime_field_var
    prev_field_name := g.comptime_field_name
    prev_field_type := g.comptime_field_type
    prev_field_raw_type := g.comptime_field_raw_type
    prev_field_attrs := g.comptime_field_attrs
    prev_field_idx := g.comptime_field_idx
    defer {
        g.comptime_field_var = prev_field_var
        g.comptime_field_name = prev_field_name
        g.comptime_field_type = prev_field_type
        g.comptime_field_raw_type = prev_field_raw_type
        g.comptime_field_attrs = prev_field_attrs
        g.comptime_field_idx = prev_field_idx
    }
    g.comptime_field_var = for_in.value.name()
    for i, field in struct_type.fields {
        g.comptime_field_name = field.name
        g.comptime_field_type = g.types_type_to_c(field.typ)
        g.comptime_field_raw_type = field.typ
        g.comptime_field_attrs = g.comptime_field_attribute_strings(struct_type.name, field)
        g.comptime_field_idx = i
        g.scan_stmts_for_generic_types(node.stmts)
    }
    return true
}

// scan_stmts_for_generic_types walks statements to find generic
// type instantiations (e.g. LinkedList[StructFieldInfo]{} in function bodies).
fn generic_body_scan_bindings_key(bindings map[string]types.Type) string {
    if bindings.len == 0 {
        return ''
    }
    mut keys := bindings.keys()
    keys.sort()
    mut parts := []string{cap: keys.len}
    for key in keys {
        concrete := bindings[key] or { continue }
        parts << '${key}=${concrete.name()}'
    }
    return parts.join(',')
}

fn (mut g Gen) scan_fn_body_for_generic_types(node ast.FnDecl, spec_name string) {
    prev_cur_fn_ret_type := g.cur_fn_ret_type
    if ret_type := g.scan_fn_return_c_type(node, spec_name) {
        g.cur_fn_ret_type = ret_type
    }
    defer {
        g.cur_fn_ret_type = prev_cur_fn_ret_type
    }
    if node.pos.id <= 0 {
        if !g.stmts_may_need_generic_scan(node.stmts) {
            return
        }
        g.scan_stmts_for_generic_types(node.stmts)
        return
    }
    fn_key := node.pos.id.str()
    bindings_key := if spec_name.len > 0 {
        spec_name
    } else {
        generic_body_scan_bindings_key(g.active_generic_types)
    }
    mode_key := if g.generic_call_spec_scan_only { 'calls' } else { 'all' }
    cache_key := '${g.cur_module}:${fn_key}:${bindings_key}:${mode_key}'
    if cache_key in g.generic_body_scan_cache {
        if !g.collect_generic_scan_calls {
            return
        }
    } else {
        g.generic_body_scan_cache[cache_key] = true
    }
    if !g.stmts_may_need_generic_scan(node.stmts) {
        return
    }
    g.scan_stmts_for_generic_types(node.stmts)
}

fn (mut g Gen) scan_fn_body_cursor_for_generic_types(stmt ast.Cursor, decl ast.FnDecl, spec_name string) {
    prev_cur_fn_ret_type := g.cur_fn_ret_type
    if ret_type := g.scan_fn_return_c_type(decl, spec_name) {
        g.cur_fn_ret_type = ret_type
    }
    defer {
        g.cur_fn_ret_type = prev_cur_fn_ret_type
    }
    body := stmt.list_at(3)
    if decl.pos.id <= 0 {
        if !g.cursor_stmts_may_need_generic_scan(body) {
            return
        }
        g.scan_cursor_stmts_for_generic_types(body)
        return
    }
    fn_key := decl.pos.id.str()
    bindings_key := if spec_name.len > 0 {
        spec_name
    } else {
        generic_body_scan_bindings_key(g.active_generic_types)
    }
    mode_key := if g.generic_call_spec_scan_only { 'calls' } else { 'all' }
    cache_key := '${g.cur_module}:${fn_key}:${bindings_key}:${mode_key}'
    if cache_key in g.generic_body_scan_cache {
        if !g.collect_generic_scan_calls {
            return
        }
    } else {
        g.generic_body_scan_cache[cache_key] = true
    }
    if !g.cursor_stmts_may_need_generic_scan(body) {
        return
    }
    g.scan_cursor_stmts_for_generic_types(body)
}

fn (mut g Gen) scan_fn_return_c_type(node ast.FnDecl, spec_name string) ?string {
    if spec_name != '' {
        if ret := g.fn_return_types[spec_name] {
            return normalize_signature_type_name(ret, 'void')
        }
    }
    if node.typ.return_type !is ast.EmptyExpr {
        return normalize_signature_type_name(g.expr_type_to_c(node.typ.return_type), 'void')
    }
    return 'void'
}

fn (g &Gen) stmts_may_need_generic_scan(stmts []ast.Stmt) bool {
    for stmt in stmts {
        match stmt {
            ast.AssignStmt {
                for expr in stmt.lhs {
                    if g.expr_may_need_generic_scan(expr) {
                        return true
                    }
                }
                for expr in stmt.rhs {
                    if g.expr_may_need_generic_scan(expr) {
                        return true
                    }
                }
            }
            ast.ReturnStmt {
                for expr in stmt.exprs {
                    if g.expr_may_need_generic_scan(expr) {
                        return true
                    }
                }
            }
            ast.ExprStmt {
                if g.expr_may_need_generic_scan(stmt.expr) {
                    return true
                }
            }
            ast.ComptimeStmt {
                if g.stmts_may_need_generic_scan([stmt.stmt]) {
                    return true
                }
            }
            ast.ForStmt {
                if g.expr_may_need_generic_scan(stmt.cond)
                    || g.stmts_may_need_generic_scan(stmt.stmts) {
                    return true
                }
            }
            ast.ForInStmt {
                if g.expr_may_need_generic_scan(stmt.key)
                    || g.expr_may_need_generic_scan(stmt.value)
                    || g.expr_may_need_generic_scan(stmt.expr) {
                    return true
                }
            }
            ast.BlockStmt {
                if g.stmts_may_need_generic_scan(stmt.stmts) {
                    return true
                }
            }
            else {}
        }
    }
    return false
}

fn (g &Gen) cursor_stmts_may_need_generic_scan(stmts ast.CursorList) bool {
    for i in 0 .. stmts.len() {
        if g.cursor_stmt_may_need_generic_scan(stmts.at(i)) {
            return true
        }
    }
    return false
}

fn (g &Gen) cursor_stmt_may_need_generic_scan(stmt ast.Cursor) bool {
    if !stmt.is_valid() {
        return false
    }
    match stmt.kind() {
        .stmt_assign {
            lhs_len := stmt.extra_int()
            for i in 0 .. lhs_len {
                if g.cursor_expr_may_need_generic_scan(stmt.edge(i)) {
                    return true
                }
            }
            for i in lhs_len .. stmt.edge_count() {
                if g.cursor_expr_may_need_generic_scan(stmt.edge(i)) {
                    return true
                }
            }
        }
        .stmt_return {
            for i in 0 .. stmt.edge_count() {
                if g.cursor_expr_may_need_generic_scan(stmt.edge(i)) {
                    return true
                }
            }
        }
        .stmt_expr {
            return g.cursor_expr_may_need_generic_scan(stmt.edge(0))
        }
        .stmt_comptime {
            return g.cursor_stmt_may_need_generic_scan(stmt.edge(0))
        }
        .stmt_for {
            init := stmt.edge(0)
            if init.kind() == .stmt_for_in && g.cursor_stmt_may_need_generic_scan(init) {
                return true
            }
            if g.cursor_expr_may_need_generic_scan(stmt.edge(1)) {
                return true
            }
            return g.cursor_stmts_may_need_generic_scan(stmt.for_body_list())
        }
        .stmt_for_in {
            return g.cursor_expr_may_need_generic_scan(stmt.edge(0))
                || g.cursor_expr_may_need_generic_scan(stmt.edge(1))
                || g.cursor_expr_may_need_generic_scan(stmt.edge(2))
        }
        .stmt_block, .stmt_defer {
            for i in 0 .. stmt.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(stmt.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (g &Gen) cursor_call_lhs_may_need_generic_scan(lhs ast.Cursor) bool {
    call_name := generic_call_short_name_cursor(lhs)
    if call_name != '' {
        for candidate in generic_call_decl_candidates(call_name) {
            if candidate in g.generic_fn_decl_index {
                return true
            }
        }
    }
    return g.cursor_expr_may_need_generic_scan(lhs)
}

fn (g &Gen) cursor_expr_may_need_generic_scan(expr ast.Cursor) bool {
    if !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_ident {
            name := expr.name()
            return name.contains('_T_') || name.ends_with('_T')
        }
        .typ_anon_struct, .typ_array_fixed, .typ_array, .typ_channel, .typ_fn, .typ_generic,
        .typ_map, .typ_option, .typ_pointer, .typ_result, .typ_thread, .typ_tuple {
            return g.type_cursor_may_need_generic_scan(expr)
        }
        .expr_generic_arg_or_index, .expr_generic_args, .expr_tuple {
            return true
        }
        .expr_call {
            if g.cursor_call_lhs_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_call_or_cast {
            return g.cursor_call_lhs_may_need_generic_scan(expr.edge(0))
                || g.cursor_expr_may_need_generic_scan(expr.edge(1))
        }
        .expr_infix {
            return g.cursor_expr_may_need_generic_scan(expr.edge(0))
                || g.cursor_expr_may_need_generic_scan(expr.edge(1))
        }
        .expr_postfix, .expr_prefix, .expr_paren, .expr_modifier, .expr_lambda, .expr_comptime {
            return g.cursor_expr_may_need_generic_scan(expr.edge(0))
        }
        .expr_assoc {
            if g.type_cursor_may_need_generic_scan(expr.edge(0))
                || g.cursor_expr_may_need_generic_scan(expr.edge(1)) {
                return true
            }
            for i in 2 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i).edge(0)) {
                    return true
                }
            }
        }
        .expr_if_guard {
            return g.cursor_stmt_may_need_generic_scan(expr.edge(0))
        }
        .expr_or {
            if g.cursor_expr_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_unsafe {
            for i in 0 .. expr.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_lock {
            packed := u32(expr.extra_int())
            lock_len := int(packed & 0xFFFF)
            rlock_len := int((packed >> 16) & 0xFFFF)
            for i in 0 .. (lock_len + rlock_len) {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
            for i in (lock_len + rlock_len) .. expr.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_if {
            if g.cursor_expr_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 2 .. expr.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
            return g.cursor_expr_may_need_generic_scan(expr.edge(1))
        }
        .expr_match {
            if g.cursor_expr_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                branch := expr.edge(i)
                conds := branch.list_at(0)
                for ci in 0 .. conds.len() {
                    if g.cursor_expr_may_need_generic_scan(conds.at(ci)) {
                        return true
                    }
                }
                if g.cursor_stmts_may_need_generic_scan(branch.list_at(1)) {
                    return true
                }
            }
        }
        .expr_select {
            if g.cursor_stmt_may_need_generic_scan(expr.edge(0))
                || g.cursor_expr_may_need_generic_scan(expr.edge(1)) {
                return true
            }
            for i in 2 .. expr.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_string_inter {
            inters := expr.list_at(1)
            for i in 0 .. inters.len() {
                inter := inters.at(i)
                if g.cursor_expr_may_need_generic_scan(inter.edge(0))
                    || g.cursor_expr_may_need_generic_scan(inter.edge(1)) {
                    return true
                }
            }
        }
        .expr_init {
            if g.type_cursor_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i).edge(0)) {
                    return true
                }
            }
        }
        .expr_array_init {
            if g.type_cursor_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_map_init {
            if g.type_cursor_may_need_generic_scan(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_index, .expr_cast, .expr_as_cast, .expr_range {
            for i in 0 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_keyword_operator {
            for i in 0 .. expr.edge_count() {
                if g.cursor_expr_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_fn_literal {
            captured_len := expr.extra_int()
            for i in 0 .. captured_len {
                if g.cursor_expr_may_need_generic_scan(expr.edge(1 + i)) {
                    return true
                }
            }
            for i in (1 + captured_len) .. expr.edge_count() {
                if g.cursor_stmt_may_need_generic_scan(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_sql, .expr_selector {
            return g.cursor_expr_may_need_generic_scan(expr.edge(0))
        }
        else {}
    }

    return false
}

fn (g &Gen) type_cursor_may_need_generic_scan(typ ast.Cursor) bool {
    if !typ.is_valid() {
        return false
    }
    match typ.kind() {
        .typ_generic, .expr_generic_arg_or_index, .expr_generic_args {
            return true
        }
        .expr_ident {
            name := typ.name()
            return name.contains('_T_') || name.ends_with('_T')
        }
        .expr_modifier, .expr_prefix, .expr_paren {
            return g.type_cursor_may_need_generic_scan(typ.edge(0))
        }
        .typ_anon_struct {
            generic_params := typ.list_at(0)
            for i in 0 .. generic_params.len() {
                if g.cursor_expr_may_need_generic_scan(generic_params.at(i)) {
                    return true
                }
            }
            embedded := typ.list_at(1)
            for i in 0 .. embedded.len() {
                if g.cursor_expr_may_need_generic_scan(embedded.at(i)) {
                    return true
                }
            }
            fields := typ.list_at(2)
            for i in 0 .. fields.len() {
                field := fields.at(i)
                if g.cursor_expr_may_need_generic_scan(field.edge(0))
                    || g.cursor_expr_may_need_generic_scan(field.edge(1)) {
                    return true
                }
            }
        }
        .typ_array_fixed {
            return g.type_cursor_may_need_generic_scan(typ.edge(0))
                || g.type_cursor_may_need_generic_scan(typ.edge(1))
        }
        .typ_array, .typ_channel, .typ_option, .typ_pointer, .typ_result, .typ_thread {
            return g.type_cursor_may_need_generic_scan(typ.edge(0))
        }
        .typ_fn {
            generic_params := typ.list_at(0)
            for i in 0 .. generic_params.len() {
                if g.cursor_expr_may_need_generic_scan(generic_params.at(i)) {
                    return true
                }
            }
            params := typ.list_at(1)
            for i in 0 .. params.len() {
                if g.cursor_expr_may_need_generic_scan(params.at(i).edge(0)) {
                    return true
                }
            }
            return g.type_cursor_may_need_generic_scan(typ.edge(2))
        }
        .typ_map {
            return g.type_cursor_may_need_generic_scan(typ.edge(0))
                || g.type_cursor_may_need_generic_scan(typ.edge(1))
        }
        .typ_tuple {
            for i in 0 .. typ.edge_count() {
                if g.type_cursor_may_need_generic_scan(typ.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (g &Gen) call_lhs_may_need_generic_scan(lhs ast.Expr) bool {
    call_name := generic_call_short_name(lhs)
    if call_name != '' {
        for candidate in generic_call_decl_candidates(call_name) {
            if candidate in g.generic_fn_decl_index {
                return true
            }
        }
    }
    return g.expr_may_need_generic_scan(lhs)
}

fn (g &Gen) expr_may_need_generic_scan(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            return expr.name.contains('_T_') || expr.name.ends_with('_T')
        }
        ast.Type {
            return type_expr_may_need_generic_scan(expr)
        }
        ast.GenericArgOrIndexExpr {
            return true
        }
        ast.GenericArgs {
            return true
        }
        ast.CallOrCastExpr {
            return g.expr_may_need_generic_scan(expr.lhs) || g.expr_may_need_generic_scan(expr.expr)
        }
        ast.CallExpr {
            if g.call_lhs_may_need_generic_scan(expr.lhs) {
                return true
            }
            for arg in expr.args {
                if g.expr_may_need_generic_scan(arg) {
                    return true
                }
            }
        }
        ast.InfixExpr {
            return g.expr_may_need_generic_scan(expr.lhs) || g.expr_may_need_generic_scan(expr.rhs)
        }
        ast.PostfixExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        ast.PrefixExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        ast.ParenExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        ast.ModifierExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        ast.AssocExpr {
            if type_expr_may_need_generic_scan(expr.typ) || g.expr_may_need_generic_scan(expr.expr) {
                return true
            }
            for field in expr.fields {
                if g.expr_may_need_generic_scan(field.value) {
                    return true
                }
            }
        }
        ast.IfGuardExpr {
            return g.stmts_may_need_generic_scan([ast.Stmt(expr.stmt)])
        }
        ast.OrExpr {
            return g.expr_may_need_generic_scan(expr.expr)
                || g.stmts_may_need_generic_scan(expr.stmts)
        }
        ast.UnsafeExpr {
            return g.stmts_may_need_generic_scan(expr.stmts)
        }
        ast.LockExpr {
            for lock_expr in expr.lock_exprs {
                if g.expr_may_need_generic_scan(lock_expr) {
                    return true
                }
            }
            for lock_expr in expr.rlock_exprs {
                if g.expr_may_need_generic_scan(lock_expr) {
                    return true
                }
            }
            return g.stmts_may_need_generic_scan(expr.stmts)
        }
        ast.IfExpr {
            if g.expr_may_need_generic_scan(expr.cond) || g.stmts_may_need_generic_scan(expr.stmts) {
                return true
            }
            return expr.else_expr !is ast.EmptyExpr && g.expr_may_need_generic_scan(expr.else_expr)
        }
        ast.MatchExpr {
            if g.expr_may_need_generic_scan(expr.expr) {
                return true
            }
            for branch in expr.branches {
                for cond in branch.cond {
                    if g.expr_may_need_generic_scan(cond) {
                        return true
                    }
                }
                if g.stmts_may_need_generic_scan(branch.stmts) {
                    return true
                }
            }
        }
        ast.ComptimeExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        ast.SelectExpr {
            return g.stmts_may_need_generic_scan([expr.stmt])
                || g.stmts_may_need_generic_scan(expr.stmts)
                || g.expr_may_need_generic_scan(expr.next)
        }
        ast.StringInterLiteral {
            for item in expr.inters {
                if g.expr_may_need_generic_scan(item.expr)
                    || g.expr_may_need_generic_scan(item.format_expr) {
                    return true
                }
            }
        }
        ast.InitExpr {
            if type_expr_may_need_generic_scan(expr.typ) {
                return true
            }
            for field in expr.fields {
                if g.expr_may_need_generic_scan(field.value) {
                    return true
                }
            }
        }
        ast.ArrayInitExpr {
            if type_expr_may_need_generic_scan(expr.typ) || g.expr_may_need_generic_scan(expr.len) {
                return true
            }
            if g.expr_may_need_generic_scan(expr.init) || g.expr_may_need_generic_scan(expr.cap)
                || g.expr_may_need_generic_scan(expr.update_expr) {
                return true
            }
            for item in expr.exprs {
                if g.expr_may_need_generic_scan(item) {
                    return true
                }
            }
        }
        ast.MapInitExpr {
            if type_expr_may_need_generic_scan(expr.typ) {
                return true
            }
            for key in expr.keys {
                if g.expr_may_need_generic_scan(key) {
                    return true
                }
            }
            for value in expr.vals {
                if g.expr_may_need_generic_scan(value) {
                    return true
                }
            }
        }
        ast.IndexExpr {
            return g.expr_may_need_generic_scan(expr.lhs) || g.expr_may_need_generic_scan(expr.expr)
        }
        ast.CastExpr {
            return type_expr_may_need_generic_scan(expr.typ)
                || g.expr_may_need_generic_scan(expr.expr)
        }
        ast.AsCastExpr {
            return type_expr_may_need_generic_scan(expr.typ)
                || g.expr_may_need_generic_scan(expr.expr)
        }
        ast.Tuple {
            return true
        }
        ast.FieldInit {
            return g.expr_may_need_generic_scan(expr.value)
        }
        ast.KeywordOperator {
            for arg in expr.exprs {
                if g.expr_may_need_generic_scan(arg) {
                    return true
                }
            }
        }
        ast.RangeExpr {
            return g.expr_may_need_generic_scan(expr.start)
                || g.expr_may_need_generic_scan(expr.end)
        }
        ast.FnLiteral {
            for captured in expr.captured_vars {
                if g.expr_may_need_generic_scan(captured) {
                    return true
                }
            }
            return g.stmts_may_need_generic_scan(expr.stmts)
        }
        ast.LambdaExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        ast.SqlExpr {
            return g.expr_may_need_generic_scan(expr.expr)
        }
        else {}
    }

    return false
}

fn type_expr_may_need_generic_scan(expr ast.Expr) bool {
    match expr {
        ast.Type {
            if expr is ast.GenericType {
                return true
            }
            if expr is ast.ArrayType {
                return type_expr_may_need_generic_scan(expr.elem_type)
            }
            if expr is ast.ArrayFixedType {
                return type_expr_may_need_generic_scan(expr.elem_type)
                    || type_expr_may_need_generic_scan(expr.len)
            }
            if expr is ast.MapType {
                return type_expr_may_need_generic_scan(expr.key_type)
                    || type_expr_may_need_generic_scan(expr.value_type)
            }
            if expr is ast.OptionType {
                return type_expr_may_need_generic_scan(expr.base_type)
            }
            if expr is ast.ResultType {
                return type_expr_may_need_generic_scan(expr.base_type)
            }
            if expr is ast.PointerType {
                return type_expr_may_need_generic_scan(expr.base_type)
            }
            if expr is ast.FnType {
                for param in expr.params {
                    if type_expr_may_need_generic_scan(param.typ) {
                        return true
                    }
                }
                return type_expr_may_need_generic_scan(expr.return_type)
            }
            return false
        }
        ast.GenericArgOrIndexExpr {
            return true
        }
        ast.GenericArgs {
            return true
        }
        ast.Ident {
            return expr.name.contains('_T_') || expr.name.ends_with('_T')
        }
        ast.ModifierExpr {
            return type_expr_may_need_generic_scan(expr.expr)
        }
        ast.PrefixExpr {
            return type_expr_may_need_generic_scan(expr.expr)
        }
        ast.ParenExpr {
            return type_expr_may_need_generic_scan(expr.expr)
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) scan_stmts_for_generic_types(stmts []ast.Stmt) {
    for stmt in stmts {
        if stmt is ast.AssignStmt {
            for rhs in stmt.rhs {
                g.scan_expr_for_generic_types(rhs)
                g.scan_expr_stmts_for_generic_types(rhs)
            }
            for i, lhs in stmt.lhs {
                if i >= stmt.rhs.len {
                    continue
                }
                lhs_name := generic_wrapped_ident_name(lhs)
                if lhs_name == '' {
                    continue
                }

                mut rhs_type := g.get_expr_type(stmt.rhs[i]).trim_space()
                if generic_scan_type_is_unresolved(rhs_type) {
                    if raw := g.get_raw_type(stmt.rhs[i]) {
                        rhs_type = g.types_type_to_c(raw).trim_space()
                    }
                }
                if generic_scan_type_is_unresolved(rhs_type) {
                    rhs_type = (g.get_local_var_c_type(lhs_name) or { '' }).trim_space()
                }
                if generic_scan_type_is_unresolved(rhs_type) && stmt.rhs[i] is ast.ArrayInitExpr {
                    array_init := stmt.rhs[i] as ast.ArrayInitExpr
                    rhs_type = g.expr_type_to_c(array_init.typ).trim_space()
                }
                if !generic_scan_type_is_unresolved(rhs_type) {
                    g.remember_runtime_local_type(lhs_name, rhs_type)
                } else if stmt.rhs[i] is ast.ArrayInitExpr {
                    g.remember_runtime_current_local_type(lhs_name, 'array')
                }
            }
        } else if stmt is ast.ReturnStmt {
            for expr in stmt.exprs {
                g.scan_expr_for_generic_types(expr)
                g.scan_expr_stmts_for_generic_types(expr)
            }
        } else if stmt is ast.ExprStmt {
            g.scan_expr_for_generic_types(stmt.expr)
            // Recurse into IfExpr/MatchExpr bodies
            g.scan_expr_stmts_for_generic_types(stmt.expr)
        } else if stmt is ast.ComptimeStmt {
            if stmt.stmt is ast.ForStmt && g.scan_comptime_for_for_generic_types(stmt.stmt) {
                continue
            }
            if stmt.stmt is ast.ExprStmt && stmt.stmt.expr is ast.ComptimeExpr
                && (stmt.stmt.expr as ast.ComptimeExpr).expr is ast.IfExpr {
                g.scan_comptime_if_for_generic_types((stmt.stmt.expr as ast.ComptimeExpr).expr as ast.IfExpr)
                continue
            }
            // Recurse into comptime $if/$for bodies (wraps a single stmt)
            g.scan_stmts_for_generic_types([stmt.stmt])
        } else if stmt is ast.ForStmt {
            g.scan_stmts_for_generic_types(stmt.stmts)
        } else if stmt is ast.BlockStmt {
            g.scan_stmts_for_generic_types(stmt.stmts)
        }
    }
}

fn (mut g Gen) scan_cursor_stmts_for_generic_types(stmts ast.CursorList) {
    for i in 0 .. stmts.len() {
        g.scan_cursor_stmt_for_generic_types(stmts.at(i))
    }
}

fn (mut g Gen) scan_cursor_stmt_for_generic_types(stmt ast.Cursor) {
    if !stmt.is_valid() {
        return
    }
    match stmt.kind() {
        .stmt_assign {
            lhs_len := stmt.extra_int()
            for i in lhs_len .. stmt.edge_count() {
                g.scan_expr_cursor_for_generic_types(stmt.edge(i))
            }
            for i in 0 .. lhs_len {
                rhs_idx := lhs_len + i
                if rhs_idx >= stmt.edge_count() {
                    continue
                }
                g.remember_assign_cursor_runtime_local_type(stmt.edge(i), stmt.edge(rhs_idx))
            }
        }
        .stmt_return {
            for i in 0 .. stmt.edge_count() {
                g.scan_expr_cursor_for_generic_types(stmt.edge(i))
            }
        }
        .stmt_expr {
            g.scan_expr_cursor_for_generic_types(stmt.edge(0))
        }
        .stmt_comptime {
            inner := stmt.edge(0)
            if inner.kind() == .stmt_for && g.scan_comptime_for_cursor_for_generic_types(inner) {
                return
            }
            if inner.kind() == .stmt_expr {
                expr := inner.edge(0)
                if expr.kind() == .expr_comptime && expr.edge(0).kind() == .expr_if {
                    g.scan_comptime_if_cursor_for_generic_types(expr.edge(0))
                    return
                }
            }
            g.scan_cursor_stmt_for_generic_types(inner)
        }
        .stmt_for {
            g.scan_cursor_stmts_for_generic_types(stmt.for_body_list())
        }
        .stmt_block, .stmt_defer {
            for i in 0 .. stmt.edge_count() {
                g.scan_cursor_stmt_for_generic_types(stmt.edge(i))
            }
        }
        else {}
    }
}

fn generic_call_cursor_arg_count(call ast.Cursor) int {
    return if call.edge_count() > 1 { call.edge_count() - 1 } else { 0 }
}

fn generic_call_cursor_arg(call ast.Cursor, idx int) ast.Cursor {
    edge_idx := idx + 1
    if idx < 0 || edge_idx >= call.edge_count() {
        return ast.Cursor{}
    }
    return call.edge(edge_idx)
}

fn sum_payload_ident_name_from_cursor(expr ast.Cursor) ?string {
    if !expr.is_valid() {
        return none
    }
    match expr.kind() {
        .expr_ident {
            return expr.name()
        }
        .expr_as_cast, .expr_modifier, .expr_paren {
            return sum_payload_ident_name_from_cursor(expr.edge(0))
        }
        .expr_cast {
            return sum_payload_ident_name_from_cursor(expr.edge(1))
        }
        .expr_prefix {
            if unsafe { token.Token(int(expr.aux())) } == .mul {
                return sum_payload_ident_name_from_cursor(expr.edge(0))
            }
        }
        .expr_selector {
            lhs := expr.edge(0)
            rhs := expr.edge(1)
            if lhs.kind() == .expr_selector && lhs.edge(1).name() == '_data' {
                return sum_payload_ident_name_from_cursor(lhs.edge(0))
            }
            if rhs.name() == '_data' {
                return sum_payload_ident_name_from_cursor(lhs)
            }
        }
        else {}
    }

    return none
}

fn (mut g Gen) resolve_sum_payload_arg_type_name_cursor(arg ast.Cursor, candidate_type string) string {
    mut type_name := candidate_type.trim_space()
    if type_name == '' || type_name == 'int' {
        return type_name
    }
    ident_name := sum_payload_ident_name_from_cursor(arg) or { return type_name }
    decl_type :=
        (g.get_local_var_c_type(ident_name) or { return type_name }).trim_space().trim_right('*')
    if decl_type == '' || type_name == decl_type || type_name == decl_type + '*' {
        return type_name
    }
    mut ptr_suffix := ''
    for type_name.ends_with('*') {
        ptr_suffix += '*'
        type_name = type_name[..type_name.len - 1].trim_space()
    }
    variants := g.get_sum_type_variants_for(decl_type)
    if variants.len == 0 {
        return type_name + ptr_suffix
    }
    mut variant_field := g.sum_type_variant_field_name(decl_type, type_name)
    if variant_field !in variants {
        for variant in variants {
            if sum_type_variant_matches(variant, type_name) {
                variant_field = variant
                break
            }
        }
    }
    if variant_field !in variants {
        return type_name + ptr_suffix
    }
    payload_type := g.sum_type_variant_payload_type(decl_type, type_name, variant_field)
    if payload_type == '' {
        return type_name + ptr_suffix
    }
    return payload_type + ptr_suffix
}

fn (mut g Gen) get_comptime_selector_type_cursor(node ast.Cursor) string {
    if node.kind() != .expr_selector {
        return ''
    }
    lhs := node.edge(0)
    rhs_name := node.edge(1).name()
    if is_comptime_selector_rhs_name(rhs_name) {
        return g.comptime_field_type
    }
    if lhs.kind() == .expr_ident && lhs.name() == g.comptime_field_var {
        match rhs_name {
            'name' {
                return 'string'
            }
            'typ', 'unaliased_typ' {
                return 'int'
            }
            'attrs' {
                return 'Array_string'
            }
            'is_pub', 'is_mut', 'is_embed', 'is_shared', 'is_atomic', 'is_option', 'is_array',
            'is_map', 'is_chan', 'is_enum', 'is_struct', 'is_alias' {
                return 'bool'
            }
            else {}
        }
    }
    if lhs.kind() == .expr_selector && lhs.edge(0).kind() == .expr_ident
        && lhs.edge(0).name() == g.comptime_field_var && lhs.edge(1).name() == 'name' {
        match rhs_name {
            'str' {
                return 'char*'
            }
            'len' {
                return 'int'
            }
            else {}
        }
    }
    return ''
}

fn (mut g Gen) generic_specialization_arg_type_name_cursor(arg ast.Cursor) string {
    mut base_arg := generic_call_base_arg_cursor(arg)
    for base_arg.is_valid() && base_arg.kind() == .expr_paren {
        base_arg = base_arg.edge(0)
    }
    if !base_arg.is_valid() {
        return ''
    }
    if base_arg.kind() == .expr_prefix && unsafe { token.Token(int(base_arg.aux())) } == .amp {
        inner_type_name := g.generic_specialization_arg_type_name_cursor(base_arg.edge(0))
        if inner_type_name != '' && inner_type_name != 'int' {
            return inner_type_name.trim_right('*') + '*'
        }
    }
    mut arg_type_name := ''
    if base_arg.kind() == .expr_selector {
        rhs := base_arg.edge(1)
        if is_comptime_selector_rhs_name(rhs.name()) {
            comptime_type := g.get_comptime_selector_type_cursor(base_arg).trim_space()
            if comptime_type != '' && comptime_type != 'int' {
                return comptime_type
            }
        }
        arg_type_name =
            g.selector_declared_field_type_cursor_for_generic_scan(base_arg).trim_space()
        if arg_type_name == '' || arg_type_name == 'array' {
            arg_type_name = g.generic_scan_expr_cursor_c_type(base_arg).trim_space()
        }
        lhs := base_arg.edge(0)
        if lhs.kind() == .expr_ident {
            if placeholder := g.cur_fn_generic_params[lhs.name()] {
                if concrete := g.active_generic_types[placeholder] {
                    mut struct_type := g.resolve_type_to_struct(concrete)
                    if struct_type.fields.len == 0 {
                        struct_c_name := g.types_type_to_c(concrete).trim_space().trim_right('*')
                        struct_type = g.lookup_struct_type_by_c_name(struct_c_name)
                    }
                    for field in struct_type.fields {
                        if field.name == rhs.name() {
                            arg_type_name = g.types_type_to_c(field.typ)
                            break
                        }
                    }
                }
            }
        }
    }
    if arg_type_name == '' {
        if active_concrete := g.active_generic_concrete_from_arg_cursor(base_arg) {
            arg_type_name = g.generic_specialization_token_from_type(active_concrete)
        }
    }
    if arg_type_name == '' && base_arg.kind() == .expr_init {
        arg_type_name = g.expr_type_to_c(base_arg.edge(0).type_expr()).trim_space()
    }
    if arg_type_name == '' && base_arg.kind() == .expr_cast {
        arg_type_name = g.expr_type_to_c(base_arg.edge(0).type_expr()).trim_space()
    }
    if arg_type_name == '' || arg_type_name == 'int' {
        arg_type_name = g.generic_scan_expr_cursor_c_type(base_arg).trim_space()
    }
    if (arg_type_name == '' || arg_type_name == 'int') && base_arg.kind() == .expr_ident {
        arg_type_name = (g.get_local_var_c_type(base_arg.name()) or { '' }).trim_space()
    }
    if arg_type_name == '' || arg_type_name == 'int' {
        if raw := g.raw_type_from_generic_call_arg_cursor(base_arg) {
            arg_type_name = g.types_type_to_c(raw).trim_space()
        }
    }
    return if arg_type_name.trim_space() == 'void*' {
        'voidptr'
    } else {
        g.resolve_sum_payload_arg_type_name_cursor(base_arg, arg_type_name).trim_space()
    }
}

fn (mut g Gen) generic_call_has_concrete_arg_bindings_cursor(decl ast.FnDecl, call ast.Cursor, generic_params []string) bool {
    if generic_params.len == 0 || g.env == unsafe { nil } {
        return false
    }
    arg_count := generic_call_cursor_arg_count(call)
    mut bindings := map[string]types.Type{}
    if decl.is_method && arg_count > 0 && expr_has_generic_placeholder(decl.receiver.typ) {
        recv_arg := generic_call_base_arg_cursor(generic_call_cursor_arg(call, 0))
        if recv_arg.is_valid() {
            if concrete := g.concrete_type_from_generic_call_arg_cursor(recv_arg) {
                g.infer_generic_type_bindings_from_param(decl.receiver.typ,
                    g.concrete_type_with_active_generics(concrete), generic_params, mut bindings)
            }
        }
    }
    arg_offset := if decl.is_method && arg_count == decl.typ.params.len + 1 { 1 } else { 0 }
    for i, param in decl.typ.params {
        arg_idx := i + arg_offset
        if arg_idx >= arg_count || !expr_has_generic_placeholder(param.typ) {
            continue
        }
        arg := generic_call_base_arg_cursor(generic_call_cursor_arg(call, arg_idx))
        if !arg.is_valid() {
            continue
        }
        concrete := g.concrete_type_from_generic_call_arg_cursor(arg) or { continue }
        g.infer_generic_type_bindings_from_param(param.typ, g.concrete_type_for_generic_param(param,
            concrete), generic_params, mut bindings)
    }
    for param_name in generic_params {
        concrete := bindings[param_name] or { return false }
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return false
        }
    }
    return true
}

fn (mut g Gen) try_specialize_generic_call_name_cursor(name string, call ast.Cursor) ?string {
    if name == '' {
        return none
    }
    if candidate := g.same_receiver_specialized_method_name(name) {
        return candidate
    }
    if name == 'copy' {
        return none
    }
    arg_count := generic_call_cursor_arg_count(call)
    is_struct_field_should_encode :=
        name in ['struct_field_should_encode_T', 'json2__struct_field_should_encode_T', 'struct_field_should_encode', 'json2__struct_field_should_encode']
        || name.starts_with('struct_field_should_encode_T_')
        || name.starts_with('json2__struct_field_should_encode_T_')
    if is_struct_field_should_encode && arg_count > 1 {
        arg_type_name :=
            g.generic_specialization_arg_type_name_cursor(generic_call_cursor_arg(call, 1))
        if arg_type_name != '' {
            g.record_late_single_generic_call_spec_from_c_type('struct_field_should_encode', 'T',
                arg_type_name)
            spec_token := generic_specialization_token_from_c_type_name(arg_type_name)
            for base_name in [g.qualify_local_call_name('struct_field_should_encode'),
                'json2__struct_field_should_encode', 'struct_field_should_encode'] {
                if candidate := g.find_specialized_call_name(base_name, spec_token) {
                    return candidate
                }
                g.ensure_specialized_call_signature('${base_name}_T_${spec_token}')
                if candidate := g.find_specialized_call_name(base_name, spec_token) {
                    return candidate
                }
            }
        }
    }
    is_encode_struct_field_value :=
        name in ['Encoder__encode_struct_field_value_T', 'json2__Encoder__encode_struct_field_value_T', 'Encoder__encode_struct_field_value', 'json2__Encoder__encode_struct_field_value']
        || name.starts_with('Encoder__encode_struct_field_value_T_')
        || name.starts_with('json2__Encoder__encode_struct_field_value_T_')
    if is_encode_struct_field_value && arg_count > 1 {
        arg_type_name :=
            g.generic_specialization_arg_type_name_cursor(generic_call_cursor_arg(call, 1))
        if arg_type_name != '' {
            g.record_late_single_generic_call_spec_from_c_type('encode_struct_field_value', 'T',
                arg_type_name)
            spec_token := generic_specialization_token_from_c_type_name(arg_type_name)
            for base_name in [
                g.qualify_local_call_name('Encoder__encode_struct_field_value'),
                'json2__Encoder__encode_struct_field_value',
                'Encoder__encode_struct_field_value',
            ] {
                if candidate := g.find_specialized_call_name(base_name, spec_token) {
                    return candidate
                }
                g.ensure_specialized_call_signature('${base_name}_T_${spec_token}')
                if candidate := g.find_specialized_call_name(base_name, spec_token) {
                    return candidate
                }
            }
        }
    }
    if name.ends_with('_T') {
        base_name := generic_call_base_name_for_specialization(name)
        if base_name != '' {
            mut has_arg_bindings := false
            if generic_decl := g.find_generic_fn_decl_by_base_name(base_name) {
                has_arg_bindings = g.generic_call_has_concrete_arg_bindings_cursor(generic_decl,
                    call, g.generic_fn_param_names(generic_decl))
            }
            cur_fn_specialized_name := if g.cur_fn_c_name != '' {
                g.cur_fn_c_name
            } else {
                g.cur_fn_name
            }
            if cur_fn_specialized_name.contains('_T_') && !has_arg_bindings {
                suffix := cur_fn_specialized_name.all_after('_T_')
                if suffix != '' {
                    candidate := '${base_name}_T_${suffix}'
                    g.ensure_specialized_call_signature(candidate)
                    if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                        return candidate
                    }
                    if !base_name.contains('__') {
                        qualified := g.qualify_local_call_name(candidate)
                        g.ensure_specialized_call_signature(qualified)
                        if qualified != candidate
                            && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                            return qualified
                        }
                    }
                }
            }
            if g.active_generic_types.len > 0 && !has_arg_bindings {
                if concrete := g.active_generic_types['T'] {
                    spec_token := g.generic_specialization_token_from_type(concrete)
                    candidate := '${base_name}_T_${spec_token}'
                    g.ensure_specialized_call_signature(candidate)
                    if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                        return candidate
                    }
                    if !base_name.contains('__') {
                        qualified := g.qualify_local_call_name(candidate)
                        g.ensure_specialized_call_signature(qualified)
                        if qualified != candidate
                            && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                            return qualified
                        }
                    }
                }
            }
            if g.active_generic_types.len == 0 {
                if candidate := g.find_specialized_call_name(g.qualify_local_call_name(base_name),
                    'f64')
                {
                    return candidate
                }
                if candidate := g.find_specialized_call_name(base_name, 'f64') {
                    return candidate
                }
            }
        }
    }
    if name in ['decode_value_T', 'json2__decode_value_T'] && arg_count > 1 {
        arg_type_name :=
            g.generic_specialization_arg_type_name_cursor(generic_call_cursor_arg(call, 1)).trim_space().trim_right('*')
        if arg_type_name != '' && arg_type_name != 'int' {
            if candidate := g.find_specialized_call_name(g.qualify_local_call_name('decode_value'),
                sanitize_generic_token_part(arg_type_name))
            {
                return candidate
            }
        }
    }
    if name in ['Encoder__encode_value_T', 'json2__Encoder__encode_value_T', 'Encoder__encode_value', 'json2__Encoder__encode_value']
        && arg_count > 1 {
        arg_type_name :=
            g.generic_specialization_arg_type_name_cursor(generic_call_cursor_arg(call, 1)).trim_space().trim_right('*')
        if arg_type_name != '' && arg_type_name != 'int' {
            if candidate := g.find_specialized_call_name('json2__Encoder__encode_value',
                sanitize_generic_token_part(arg_type_name))
            {
                return candidate
            }
        }
    }
    if g.active_generic_types.len > 0 && name.contains('_T_') {
        base_name := name.all_before('_T_')
        mut parts := name.all_after('_T_').split('_')
        mut c_parts := parts.clone()
        mut changed := false
        for i, part in parts {
            if concrete := g.active_generic_types[part] {
                parts[i] = g.generic_specialization_token_from_type(concrete)
                c_type := g.types_type_to_c(concrete).trim_space().trim_right('*')
                c_parts[i] = if c_type == '' {
                    parts[i]
                } else {
                    sanitize_generic_token_part(c_type)
                }
                changed = true
            }
        }
        if changed {
            candidate := '${base_name}_T_${parts.join('_')}'
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            g.ensure_specialized_call_signature(candidate)
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            if !base_name.contains('__') {
                qualified := g.qualify_local_call_name(candidate)
                if qualified != candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
                g.ensure_specialized_call_signature(qualified)
                if qualified != candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
            }
            c_candidate := '${base_name}_T_${c_parts.join('_')}'
            if c_candidate != candidate
                && (c_candidate in g.fn_param_is_ptr || c_candidate in g.fn_return_types) {
                return c_candidate
            }
            if c_candidate != candidate {
                g.ensure_specialized_call_signature(c_candidate)
                if c_candidate in g.fn_param_is_ptr || c_candidate in g.fn_return_types {
                    return c_candidate
                }
            }
            if c_candidate != candidate && !base_name.contains('__') {
                qualified := g.qualify_local_call_name(c_candidate)
                if qualified != c_candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
                g.ensure_specialized_call_signature(qualified)
                if qualified != c_candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
            }
        }
    }
    if g.active_generic_types.len > 0 {
        mut parts := name.split('_')
        mut changed := false
        for i, part in parts {
            if concrete := g.active_generic_types[part] {
                parts[i] = 'T_${g.generic_specialization_token_from_type(concrete)}'
                changed = true
            }
        }
        if changed {
            candidate := parts.join('_')
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
        }
    }
    if !name.contains('__') {
        qualified := g.qualify_local_call_name(name)
        if qualified != name && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types)
            && !g.has_generic_fn_decl_by_base_name(qualified) {
            return none
        }
    }
    mut skip_arg0_specialization := false
    arg0_lookup_name := if name.contains('_T_') {
        name.all_before('_T_')
    } else if name.ends_with('_T') {
        name[..name.len - 2]
    } else {
        name
    }
    if generic_decl := g.find_generic_fn_decl_by_base_name(arg0_lookup_name) {
        skip_arg0_specialization = generic_decl.is_method || generic_decl.typ.params.len == 0
            || !expr_has_generic_placeholder(generic_decl.typ.params[0].typ)
    }
    if arg_count > 0 && !skip_arg0_specialization {
        mut arg_type_name :=
            g.generic_specialization_arg_type_name_cursor(generic_call_cursor_arg(call, 0))
        if arg_type_name != '' && arg_type_name != 'int' && arg_type_name.trim_space() != 'void*' {
            arg_type_name = g.resolve_sum_payload_arg_type_name_cursor(generic_call_cursor_arg(call, 0),
                arg_type_name)
        }
        arg_type_name = if arg_type_name.trim_space() == 'void*' {
            'voidptr'
        } else {
            arg_type_name.trim_right('*')
        }
        if arg_type_name != '' && arg_type_name != 'int' {
            mut candidate_types := [arg_type_name]
            if !arg_type_name.contains('__') && g.cur_module != '' && g.cur_module != 'main'
                && g.cur_module != 'builtin' {
                candidate_types << '${g.cur_module}__${arg_type_name}'
                if arg_type_name.starts_with('Array_') && arg_type_name.len > 'Array_'.len {
                    elem_type_name := arg_type_name['Array_'.len..]
                    if !elem_type_name.contains('__') {
                        candidate_types << 'Array_${g.cur_module}__${elem_type_name}'
                    }
                }
            }
            for concrete_type_name in candidate_types {
                if candidate := g.find_specialized_call_name(name,
                    sanitize_generic_token_part(concrete_type_name))
                {
                    return candidate
                }
            }
        }
    }
    if name in ['decode_value', 'json2__decode_value'] && g.cur_fn_ret_type.starts_with('_result_') {
        result_base := g.cur_fn_ret_type['_result_'.len..]
        if candidate := g.find_specialized_call_name(g.qualify_local_call_name('decode_value'),
            sanitize_generic_token_part(result_base))
        {
            return candidate
        }
    }
    mut generic_base_name := generic_call_base_name_for_specialization(name)
    if qualified_name := g.qualified_generic_fn_base_name(generic_base_name) {
        generic_base_name = qualified_name
    }
    decl := g.find_generic_fn_decl_by_base_name(generic_base_name) or {
        if generic_base_name.contains('__') {
            g.find_generic_fn_decl_by_base_name(generic_base_name.all_after_last('__')) or {
                return none
            }
        } else {
            return none
        }
    }
    generic_params := g.generic_fn_param_names(decl)
    if generic_params.len == 0 || g.env == unsafe { nil } {
        return none
    }
    if name.contains('_T_') {
        if active_bindings := g.active_generic_bindings_matching_name_suffix(name, generic_params) {
            mut suffixes := []string{cap: generic_params.len}
            for param_name in generic_params {
                concrete := active_bindings[param_name] or { return none }
                suffixes << g.generic_specialization_token_from_type(concrete)
            }
            candidate := '${generic_base_name}_T_${suffixes.join('_')}'
            g.ensure_specialized_call_signature(candidate)
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            specialized_candidate := g.specialized_fn_name(decl, active_bindings)
            if specialized_candidate != candidate {
                g.ensure_specialized