// 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 v2.ast
import v2.markused
import v2.types
import strings
import os

fn (mut g Gen) is_error_call_expr(expr ast.Expr) bool {
    match expr {
        ast.CallOrCastExpr {
            if expr.lhs is ast.Ident {
                name := sanitize_fn_ident(expr.lhs.name)
                if name in ['error', 'error_posix', 'error_with_code', 'error_win32'] {
                    return true
                }
            }
        }
        ast.CallExpr {
            if expr.lhs is ast.Ident {
                name := sanitize_fn_ident(expr.lhs.name)
                if name in ['error', 'error_posix', 'error_with_code', 'error_win32'] {
                    return true
                }
            }
            // Check if the call returns IError
            ret := g.get_call_return_type(expr.lhs, expr.args) or { '' }
            if ret == 'IError' {
                return true
            }
        }
        else {}
    }

    // Also check environment type
    expr_type := g.get_expr_type(expr)
    if expr_type == 'IError' {
        return true
    }
    return false
}

pub fn (mut g Gen) set_cached_init_calls(calls []string) {
    g.cached_init_calls = calls.clone()
}

pub fn (mut g Gen) set_used_fn_keys(used map[string]bool) {
    g.used_fn_keys = used.clone()
}

pub fn (mut g Gen) set_force_emit_fn_names(names []string) {
    for name in names {
        if name.len > 0 {
            g.force_emit_fn_names[name] = true
        }
    }
}

pub fn (mut g Gen) add_called_fn_names(names []string) {
    for name in names {
        g.mark_called_fn_name(name)
    }
}

fn (mut g Gen) mark_called_fn_name(name string) {
    if name.len > 0 {
        g.called_fn_names[name] = true
        g.remember_called_specialized_name(name)
    }
}

pub fn (g &Gen) external_called_fn_names() []string {
    mut names := []string{}
    for name, _ in g.called_fn_names {
        if name.len == 0 || 'fn_${name}' in g.emitted_types {
            continue
        }
        names << name
    }
    names.sort()
    return names
}

fn (g &Gen) should_emit_fn_decl(module_name string, decl ast.FnDecl) bool {
    if g.cached_init_calls.len > 0 && !g.should_emit_module(module_name) {
        return true
    }
    if g.used_fn_keys.len == 0 || g.env == unsafe { nil } {
        return true
    }
    if should_always_emit_for_markused(g.cur_file_name) {
        return true
    }
    if module_name == 'builtin' && decl.name == 'print_backtrace' {
        return true
    }
    if module_name == 'json2' && decl.name == 'enum_uses_json_as_number' {
        return true
    }
    if module_name == 'time' && decl.is_method && decl.receiver.typ is ast.Ident
        && decl.receiver.typ.name == 'Duration' {
        return true
    }
    if module_name == 'sync' {
        if decl.name in ['try_pop_priv', 'try_push_priv', 'new_channel_st', 'new_spin_lock'] {
            return true
        }
        if decl.is_method && decl.name == 'try_wait' {
            return true
        }
    }
    if is_builtin_map_file(g.cur_file_name) && should_keep_builtin_map_decl(decl) {
        return true
    }
    if is_builtin_string_file(g.cur_file_name) && should_keep_builtin_string_decl(decl) {
        return true
    }
    if is_builtin_array_file(g.cur_file_name) && should_keep_builtin_array_decl(decl) {
        return true
    }
    if decl.name.starts_with('__v_init_consts_') {
        return true
    }
    // Module init/deinit functions are called from the synthesized test main,
    // which runs after markused, so they won't be in used_fn_keys.
    if !decl.is_method && !decl.is_static && (decl.name == 'init' || decl.name == 'deinit') {
        return true
    }
    if decl.name == 'str' {
        return true
    }
    if decl.name.ends_with('__str') {
        if g.emit_files.len > 0 && g.cache_bundle_name != 'virtuals' {
            return false
        }
        return true
    }
    if decl.name.starts_with('__sort_cmp_') {
        if g.emit_files.len > 0 && g.cache_bundle_name == '' && decl.name !in g.force_emit_fn_names {
            return false
        }
        return true
    }
    // Methods on array types ([]T) and other types with unresolvable receivers
    // may produce 'unknown' receiver in the markused key, causing them to be
    // incorrectly pruned. Always emit methods whose receiver can't be resolved.
    // Also always emit methods on array receivers ([]T), since the markused
    // key for these can differ between the walker and the gen lookup.
    if decl.is_method {
        key2 := markused.decl_key(module_name, decl, g.env)
        if key2.contains('|unknown|') {
            return true
        }
        if decl.name in ['+', '-', '*', '/', '%', '==', '!=', '<', '>', '<=', '>='] {
            return true
        }
        if decl.receiver.typ is ast.Type && decl.receiver.typ is ast.ArrayType {
            return true
        }
    }
    if g.force_emit_fn_names.len > 0 {
        c_name := if decl.is_method {
            g.method_decl_c_name_for_module(module_name, decl)
        } else if module_name.len > 0 && module_name != 'builtin' && module_name != 'main' {
            '${module_name}__${sanitize_fn_ident(decl.name)}'
        } else {
            sanitize_fn_ident(decl.name)
        }
        if c_name in g.force_emit_fn_names {
            return true
        }
    }
    // Check if this function was force-requested by generated code (e.g. map str functions).
    if g.force_emit_fn_names.len > 0 && decl.name == 'str' && decl.is_method {
        c_name := g.method_decl_c_name_for_module(module_name, decl)
        if c_name in g.force_emit_fn_names {
            return true
        }
    }
    key := markused.decl_key(module_name, decl, g.env)
    return key in g.used_fn_keys
}

fn (mut g Gen) should_emit_fn_decl_cached(module_name string, decl ast.FnDecl) bool {
    cache_key := if decl.pos.id > 0 {
        '${module_name}:${decl.pos.id}:${decl.name}'
    } else {
        '${module_name}:${g.cur_file_name}:${decl.name}:${decl.is_method}:${decl.is_static}'
    }
    if cached := g.should_emit_fn_decl_cache[cache_key] {
        return cached
    }
    result := g.transformed_specialization_belongs_to_cache(module_name, decl)
        && g.should_emit_fn_decl(module_name, decl)
    g.should_emit_fn_decl_cache[cache_key] = result
    return result
}

fn (mut g Gen) transformed_specialization_belongs_to_cache(module_name string, decl ast.FnDecl) bool {
    c_name := if decl.is_method {
        g.method_decl_c_name_for_module(module_name, decl)
    } else {
        decl.name
    }
    if g.cache_bundle_name.len == 0 || (!decl.name.contains('_T_') && !c_name.contains('_T_')) {
        return true
    }
    if decl.is_method && !g.transformed_specialization_type_expr_belongs_to_cache(decl.receiver.typ) {
        return false
    }
    for param in decl.typ.params {
        if !g.transformed_specialization_type_expr_belongs_to_cache(param.typ) {
            return false
        }
    }
    if decl.typ.return_type !is ast.EmptyExpr
        && !g.transformed_specialization_type_expr_belongs_to_cache(decl.typ.return_type) {
        return false
    }
    return true
}

fn (mut g Gen) transformed_specialization_type_expr_belongs_to_cache(expr ast.Expr) bool {
    c_name := g.expr_type_to_c(expr).trim_space()
    if c_name == '' {
        return true
    }
    return g.generic_concrete_c_name_belongs_to_emit_modules(c_name)
}

fn (g &Gen) method_decl_c_name_for_module(module_name string, decl ast.FnDecl) string {
    if !decl.is_method {
        return ''
    }
    recv_type_name := g.receiver_type_to_scope_name(decl.receiver.typ)

    if recv_type_name == '' {
        return ''
    }
    qualified_recv := if module_name.len > 0 && module_name != 'builtin' && module_name != 'main'
        && !recv_type_name.contains('__') {
        '${module_name}__${recv_type_name}'
    } else {
        recv_type_name
    }
    return '${qualified_recv}__${sanitize_fn_ident(decl.name)}'
}

fn (mut g Gen) emit_cached_init_call_decls() {
    if g.cached_init_calls.len == 0 {
        return
    }
    for fn_name in g.cached_init_calls {
        key := 'cached_init_decl_${fn_name}'
        if key in g.emitted_types {
            continue
        }
        g.emitted_types[key] = true
        g.sb.writeln('void ${fn_name}(void);')
    }
    g.sb.writeln('')
}

fn (mut g Gen) ensure_tuple_alias_for_fn_return(node ast.FnDecl, ret_type string) {
    tuple_name := tuple_payload_type_name(ret_type)
    if tuple_name == '' || tuple_name in g.tuple_aliases {
        return
    }
    // Resolve tuple element types from the Environment's function type metadata.
    if g.env != unsafe { nil } {
        fn_name := if node.is_method {
            v_type_name := g.receiver_type_to_scope_name(node.receiver.typ)
            if v_type_name != '' {
                '${v_type_name}__${node.name}'
            } else {
                node.name
            }
        } else {
            node.name
        }
        if fields := g.tuple_fields_from_env(fn_name) {
            if fields.len > 0 {
                g.tuple_aliases[tuple_name] = fields.clone()
            }
            return
        }
    }
    mut tuple_types := []ast.Expr{}
    if node.typ.return_type is ast.Type && node.typ.return_type is ast.TupleType {
        tuple_types = (node.typ.return_type as ast.TupleType).types.clone()
    } else if node.typ.return_type is ast.Type && node.typ.return_type is ast.OptionType {
        opt_type := node.typ.return_type as ast.OptionType
        if opt_type.base_type is ast.Type && opt_type.base_type is ast.TupleType {
            tuple_types = (opt_type.base_type as ast.TupleType).types.clone()
        }
    } else if node.typ.return_type is ast.Type && node.typ.return_type is ast.ResultType {
        res_type := node.typ.return_type as ast.ResultType
        if res_type.base_type is ast.Type && res_type.base_type is ast.TupleType {
            tuple_types = (res_type.base_type as ast.TupleType).types.clone()
        }
    }
    if tuple_types.len == 0 {
        return
    }
    mut fields := []string{cap: tuple_types.len}
    for tuple_type in tuple_types {
        c_type := g.expr_type_to_c(tuple_type)
        if c_type == '' {
            return
        }
        fields << c_type
    }
    if fields.len > 0 {
        g.tuple_aliases[tuple_name] = fields.clone()
    }
}

// tuple_fields_from_env looks up a function in the module scope and extracts
// tuple element types from its return type.
fn (mut g Gen) tuple_fields_from_env(fn_name string) ?[]string {
    if g.env == unsafe { nil } {
        return none
    }
    // Look up the function object in the module scope.
    if mut mod_scope := g.env_scope(g.cur_module) {
        if obj := mod_scope.lookup_parent(fn_name, 0) {
            if obj is types.Fn {
                fn_obj := obj as types.Fn
                fn_typ := fn_obj.get_typ()
                if fn_typ is types.FnType {
                    return g.extract_tuple_fields_from_return_type(fn_typ)
                }
            }
        }
    }
    // Also check builtin scope for builtin functions.
    if g.cur_module != 'builtin' {
        if mut builtin_scope := g.env_scope('builtin') {
            if obj := builtin_scope.lookup_parent(fn_name, 0) {
                if obj is types.Fn {
                    fn_obj := obj as types.Fn
                    fn_typ := fn_obj.get_typ()
                    if fn_typ is types.FnType {
                        return g.extract_tuple_fields_from_return_type(fn_typ)
                    }
                }
            }
        }
    }
    return none
}

fn (mut g Gen) extract_tuple_fields_from_return_type(fn_typ types.FnType) ?[]string {
    ret_type := fn_typ.get_return_type() or { return none }
    // Unwrap Option/Result wrappers to get the payload type.
    inner := match ret_type {
        types.OptionType { ret_type.base_type }
        types.ResultType { ret_type.base_type }
        else { ret_type }
    }

    if inner is types.Tuple {
        tuple_types := inner.get_types()
        mut fields := []string{cap: tuple_types.len}
        for elem_type in tuple_types {
            c := g.types_type_to_c(elem_type)
            if c == '' {
                return none
            }
            fields << c
        }
        return fields
    }
    return none
}

fn fixed_array_return_wrapper_name(ret_type string) string {
    return '_v_${ret_type}'
}

fn (g &Gen) c_fn_return_type_from_v(ret_type string) string {
    if ret_type.starts_with('Array_fixed_') {
        return g.fixed_array_ret_wrappers[ret_type] or { fixed_array_return_wrapper_name(ret_type) }
    }
    return ret_type
}

fn (mut g Gen) c_callback_return_type_from_v(ret_type string) string {
    if ret_type.starts_with('Array_fixed_') {
        g.fixed_array_ret_wrappers[ret_type] = fixed_array_return_wrapper_name(ret_type)
    }
    return g.c_fn_return_type_from_v(ret_type)
}

fn (mut g Gen) infer_vector_return_type_from_stmts(stmts []ast.Stmt) string {
    for stmt in stmts {
        match stmt {
            ast.ReturnStmt {
                if stmt.exprs.len == 0 {
                    continue
                }
                ret_expr := stmt.exprs[0]
                if ret_expr is ast.InitExpr {
                    init_type := g.expr_type_to_c(ret_expr.typ)
                    if vector_elem_type_for_name(init_type) != '' {
                        return init_type
                    }
                }
                mut expr_type := g.get_expr_type(ret_expr)
                if expr_type == '' || expr_type == 'int' {
                    if raw := g.get_raw_type(ret_expr) {
                        expr_type = g.types_type_to_c(raw)
                    }
                }
                expr_type = expr_type.trim_right('*')
                if vector_elem_type_for_name(expr_type) != '' {
                    return expr_type
                }
            }
            ast.BlockStmt {
                inferred := g.infer_vector_return_type_from_stmts(stmt.stmts)
                if inferred != '' {
                    return inferred
                }
            }
            ast.ForStmt {
                inferred := g.infer_vector_return_type_from_stmts(stmt.stmts)
                if inferred != '' {
                    return inferred
                }
            }
            ast.ExprStmt {
                if stmt.expr is ast.IfExpr {
                    inferred := g.infer_vector_return_type_from_stmts(stmt.expr.stmts)
                    if inferred != '' {
                        return inferred
                    }
                    if stmt.expr.else_expr is ast.IfExpr {
                        else_inferred :=
                            g.infer_vector_return_type_from_stmts(stmt.expr.else_expr.stmts)
                        if else_inferred != '' {
                            return else_inferred
                        }
                    }
                }
            }
            else {}
        }
    }
    return ''
}

fn (mut g Gen) collect_fn_signatures() {
    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 {
                    continue
                }
                g.collect_fn_signature_from_cursor(stmt)
            }
        }
        return
    }
    for file in g.files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if !stmt_has_valid_data(stmt) {
                continue
            }
            match stmt {
                ast.FnDecl {
                    g.collect_fn_signature_from_decl(stmt, stmt.stmts.len)
                }
                else {}
            }
        }
    }
}

fn (mut g Gen) collect_fn_signature_from_cursor(stmt ast.Cursor) {
    decl := stmt.fn_decl_signature()
    body_len := stmt.list_at(3).len()
    if body_len > 0 && g.fn_signature_collection_needs_body(decl) {
        g.collect_fn_signature_from_body_source(decl, body_len, stmt, true)
        return
    }
    g.collect_fn_signature_from_decl(decl, body_len)
}

fn (mut g Gen) fn_signature_collection_needs_body(decl ast.FnDecl) bool {
    if !g.should_emit_fn_decl_cached(g.cur_module, decl) {
        return false
    }
    if decl.language == .js || g.should_skip_backend_generic_fn(decl) {
        return false
    }
    if g.generic_fn_param_names(decl).len > 0 || receiver_generic_param_names(decl).len > 0 {
        return true
    }
    return decl.typ.return_type !is ast.EmptyExpr
        && expr_has_generic_placeholder(decl.typ.return_type)
}

fn (mut g Gen) collect_fn_signature_from_decl(decl ast.FnDecl, body_len int) {
    g.collect_fn_signature_from_body_source(decl, body_len, ast.Cursor{}, false)
}

fn (mut g Gen) scan_fn_body_for_generic_types_from_source(decl ast.FnDecl, body_cursor ast.Cursor, use_cursor bool, spec_name string) {
    if use_cursor {
        g.scan_fn_body_cursor_for_generic_types(body_cursor, decl, spec_name)
    } else {
        g.scan_fn_body_for_generic_types(decl, spec_name)
    }
}

fn (mut g Gen) collect_fn_signature_from_body_source(decl ast.FnDecl, body_len int, body_cursor ast.Cursor, use_cursor bool) {
    if !g.should_emit_fn_decl_cached(g.cur_module, decl) {
        return
    }
    if decl.language == .js {
        return
    }
    if g.should_skip_backend_generic_fn(decl) {
        return
    }
    if g.generic_fn_param_names(decl).len > 0 {
        prev_generic_types := g.active_generic_types.clone()
        prev_fn_name := g.cur_fn_name
        prev_fn_c_name := g.cur_fn_c_name
        prev_fn_scope := g.cur_fn_scope
        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_cur_fn_generic_params := g.cur_fn_generic_params.clone()
        for spec in g.generic_fn_specializations_for_emit_scope_with_receiver_bindings(decl) {
            g.active_generic_types = spec.generic_types.clone()
            g.cur_fn_name = decl.name
            g.cur_fn_c_name = spec.name
            g.cur_fn_scope = unsafe { nil }
            g.runtime_local_types = map[string]string{}
            g.runtime_decl_types = map[string]string{}
            g.not_local_var_cache = map[string]bool{}
            g.cur_fn_generic_params = map[string]string{}
            scope_fn_name := if decl.is_method {
                v_type_name := g.receiver_type_to_scope_name(decl.receiver.typ)
                if v_type_name != '' {
                    '${v_type_name}__${decl.name}'
                } else {
                    decl.name
                }
            } else {
                decl.name
            }
            if g.env != unsafe { nil } {
                if fn_scope := g.env.get_fn_scope(g.cur_module, scope_fn_name) {
                    g.cur_fn_scope = fn_scope
                }
            }
            // Function-pointer fields can reference another generic function value before that
            // function's signature is collected (veb.run_new assigns parallel_request_handler[A, X]).
            g.seed_fn_scan_runtime_types(decl, spec.name)
            g.scan_fn_body_for_generic_types_from_source(decl, body_cursor, use_cursor, spec.name)
            g.register_fn_signature(decl, spec.name)
        }
        g.active_generic_types = prev_generic_types.clone()
        g.cur_fn_name = prev_fn_name
        g.cur_fn_c_name = prev_fn_c_name
        g.cur_fn_scope = prev_fn_scope
        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.cur_fn_generic_params = prev_cur_fn_generic_params.clone()
        return
    }
    recv_gp := receiver_generic_param_names(decl)
    if recv_gp.len > 0 {
        all_bindings := g.get_all_receiver_generic_bindings(decl)
        if all_bindings.len > 0 {
            prev_gt := g.active_generic_types.clone()
            prev_fn_name := g.cur_fn_name
            prev_fn_c_name := g.cur_fn_c_name
            prev_fn_scope := g.cur_fn_scope
            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_cur_fn_generic_params := g.cur_fn_generic_params.clone()
            prev_generic_call_spec_scan_only := g.generic_call_spec_scan_only
            for bi in all_bindings {
                g.active_generic_types = bi.clone()
                gfn := g.get_fn_name(decl)
                if gfn != '' {
                    g.cur_fn_name = decl.name
                    g.cur_fn_c_name = gfn
                    g.cur_fn_scope = unsafe { nil }
                    g.runtime_local_types = map[string]string{}
                    g.runtime_decl_types = map[string]string{}
                    g.not_local_var_cache = map[string]bool{}
                    g.cur_fn_generic_params = map[string]string{}
                    scope_fn_name := if decl.is_method {
                        v_type_name := g.receiver_type_to_scope_name(decl.receiver.typ)
                        if v_type_name != '' {
                            '${v_type_name}__${decl.name}'
                        } else {
                            decl.name
                        }
                    } else {
                        decl.name
                    }
                    if g.env != unsafe { nil } {
                        if fn_scope := g.env.get_fn_scope(g.cur_module, scope_fn_name) {
                            g.cur_fn_scope = fn_scope
                        }
                    }
                    g.seed_fn_scan_runtime_types(decl, gfn)
                    g.generic_call_spec_scan_only = true
                    g.scan_fn_body_for_generic_types_from_source(decl, body_cursor, use_cursor, gfn)
                    g.generic_call_spec_scan_only = prev_generic_call_spec_scan_only
                    g.register_fn_signature(decl, gfn)
                }
            }
            g.active_generic_types = prev_gt.clone()
            g.cur_fn_name = prev_fn_name
            g.cur_fn_c_name = prev_fn_c_name
            g.cur_fn_scope = prev_fn_scope
            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.cur_fn_generic_params = prev_cur_fn_generic_params.clone()
            g.generic_call_spec_scan_only = prev_generic_call_spec_scan_only
            return
        } else if bindings := g.get_receiver_generic_bindings(decl) {
            prev_gt := g.active_generic_types.clone()
            prev_fn_name := g.cur_fn_name
            prev_fn_c_name := g.cur_fn_c_name
            prev_fn_scope := g.cur_fn_scope
            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_cur_fn_generic_params := g.cur_fn_generic_params.clone()
            prev_generic_call_spec_scan_only := g.generic_call_spec_scan_only
            g.active_generic_types = bindings.clone()
            gfn := g.get_fn_name(decl)
            if gfn != '' {
                g.cur_fn_name = decl.name
                g.cur_fn_c_name = gfn
                g.cur_fn_scope = unsafe { nil }
                g.runtime_local_types = map[string]string{}
                g.runtime_decl_types = map[string]string{}
                g.not_local_var_cache = map[string]bool{}
                g.cur_fn_generic_params = map[string]string{}
                scope_fn_name := if decl.is_method {
                    v_type_name := g.receiver_type_to_scope_name(decl.receiver.typ)
                    if v_type_name != '' {
                        '${v_type_name}__${decl.name}'
                    } else {
                        decl.name
                    }
                } else {
                    decl.name
                }
                if g.env != unsafe { nil } {
                    if fn_scope := g.env.get_fn_scope(g.cur_module, scope_fn_name) {
                        g.cur_fn_scope = fn_scope
                    }
                }
                g.seed_fn_scan_runtime_types(decl, gfn)
                g.generic_call_spec_scan_only = true
                g.scan_fn_body_for_generic_types_from_source(decl, body_cursor, use_cursor, gfn)
                g.generic_call_spec_scan_only = prev_generic_call_spec_scan_only
                g.register_fn_signature(decl, gfn)
            }
            g.active_generic_types = prev_gt.clone()
            g.cur_fn_name = prev_fn_name
            g.cur_fn_c_name = prev_fn_c_name
            g.cur_fn_scope = prev_fn_scope
            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.cur_fn_generic_params = prev_cur_fn_generic_params.clone()
            g.generic_call_spec_scan_only = prev_generic_call_spec_scan_only
            return
        }
        return
    }
    mut fn_name := ''
    if body_len == 0 && decl.language == .c {
        // Keep raw symbol names for C / system declaration-only functions.
        fn_name = sanitize_fn_ident(decl.name)
    } else {
        fn_name = g.get_fn_name(decl)
    }
    g.register_fn_signature(decl, fn_name)
}

fn (mut g Gen) collect_fn_signatures_to_fixed_point() {
    for _ in 0 .. 8 {
        before_late_specs := g.late_generic_spec_count()
        before_signatures := g.fn_return_types.len + g.fn_param_is_ptr.len + g.fn_param_types.len
        before_options := g.option_aliases.len
        before_results := g.result_aliases.len
        g.build_generic_spec_index()
        g.collect_fn_signatures()
        if g.late_generic_spec_count() == before_late_specs
            && g.fn_return_types.len + g.fn_param_is_ptr.len + g.fn_param_types.len == before_signatures
            && g.option_aliases.len == before_options && g.result_aliases.len == before_results {
            break
        }
    }
    g.build_generic_spec_index()
}

fn (mut g Gen) register_fn_signature(node ast.FnDecl, fn_name string) {
    if fn_name == '' {
        return
    }
    saved_cur_module := g.cur_module
    saved_fn_scope := g.cur_fn_scope
    defer {
        g.cur_module = saved_cur_module
        g.cur_fn_scope = saved_fn_scope
    }
    sig_module := module_prefix_from_fn_name(fn_name)
    if sig_module.len > 0 && sig_module[0] >= `a` && sig_module[0] <= `z` {
        g.cur_module = sig_module
    }
    g.cur_fn_scope = unsafe { nil }
    if g.env != unsafe { nil } {
        scope_fn_name := if node.is_method {
            v_type_name := g.receiver_type_to_scope_name(node.receiver.typ)
            if v_type_name != '' {
                '${v_type_name}__${node.name}'
            } else {
                fn_name
            }
        } else {
            node.name
        }
        if fn_scope := g.env.get_fn_scope(g.cur_module, scope_fn_name) {
            g.cur_fn_scope = fn_scope
        }
    }
    // If this function has an @[export] attribute, map the V-qualified
    // name to the export name so call sites resolve correctly.
    for attr in node.attributes {
        if attr.name == 'export' {
            if attr.value is ast.StringLiteral {
                export_name := attr.value.value.trim('\'"')
                if export_name.len > 0 {
                    v_name := sanitize_fn_ident(node.name)
                    v_qualified := if g.cur_module != '' && g.cur_module != 'main'
                        && g.cur_module != 'builtin' {
                        '${g.cur_module}__${v_name}'
                    } else {
                        v_name
                    }
                    if v_qualified != export_name {
                        g.export_fn_names[v_qualified] = export_name
                    }
                }
            }
        }
    }
    is_program_main := g.is_program_main_fn(&node)
    mut ret_type := if is_program_main {
        'int'
    } else if node.typ.return_type !is ast.EmptyExpr {
        g.signature_expr_type_to_c(node.typ.return_type)
    } else {
        'void'
    }
    ret_type = normalize_signature_type_name(ret_type, 'void')
    if ret_type == 'int' && node.typ.return_type !is ast.EmptyExpr
        && expr_has_generic_placeholder(node.typ.return_type) {
        inferred := g.infer_vector_return_type_from_stmts(node.stmts)
        if inferred != '' {
            ret_type = inferred
        }
    }
    if ret_type.starts_with('_option_') || ret_type.starts_with('_result_') {
        g.register_alias_type(ret_type)
    }
    if ret_type.starts_with('Array_fixed_') {
        g.fixed_array_ret_wrappers[ret_type] = fixed_array_return_wrapper_name(ret_type)
    }
    g.ensure_tuple_alias_for_fn_return(node, ret_type)
    mut params := []bool{}
    mut param_types := []string{}
    if node.is_method && !node.is_static && node.receiver.name != '' {
        recv_base_type := if concrete_receiver := g.receiver_generic_instance_c_name_for_active_bindings(node) {
            if param_type_is_pointer_expr(node.receiver.typ) && !concrete_receiver.ends_with('*') {
                concrete_receiver + '*'
            } else {
                concrete_receiver
            }
        } else {
            g.signature_expr_type_to_c(node.receiver.typ)
        }
        recv_type := normalize_signature_type_name(recv_base_type, 'void*')
        params << (node.receiver.is_mut || recv_type.ends_with('*'))
        param_types << if node.receiver.is_mut && !recv_type.ends_with('*') {
            recv_type + '*'
        } else {
            recv_type
        }
    }
    if g.needs_implicit_veb_ctx_param(&node, fn_name) {
        params << true
        param_types << g.implicit_veb_ctx_c_type()
    }
    for param in node.typ.params {
        param_type := normalize_signature_type_name(g.fn_param_signature_c_type(param), 'int')
        params << (param.is_mut || param_type.ends_with('*'))
        param_types << if param.is_mut && !param_type.ends_with('*') {
            param_type + '*'
        } else {
            param_type
        }
    }
    g.fn_param_is_ptr[fn_name] = params
    g.fn_param_types[fn_name] = param_types
    g.fn_return_types[fn_name] = ret_type
    if node.language == .v {
        g.v_fn_return_types[fn_name] = ret_type
    }
    if node.is_method && g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
        && !fn_name.starts_with(g.cur_module + '__') {
        recv_type := g.expr_type_to_c(node.receiver.typ).trim_right('*')
        if recv_type != '' && !recv_type.contains('__') && g.is_module_local_type(recv_type) {
            qualified_name := '${g.cur_module}__${fn_name}'
            g.fn_param_is_ptr[qualified_name] = params.clone()
            g.fn_param_types[qualified_name] = param_types.clone()
            g.fn_return_types[qualified_name] = ret_type
            if node.language == .v {
                g.v_fn_return_types[qualified_name] = ret_type
            }
        }
    }
    g.remember_specialized_fn_base(fn_name)
}

fn (mut g Gen) remember_specialized_fn_base(fn_name string) {
    if !fn_name.contains('_T_') {
        return
    }
    base_name := fn_name.all_before('_T_')
    if base_name != '' {
        g.specialized_fn_bases[base_name] = true
    }
    g.remember_specialized_receiver_method(fn_name, base_name)
}

fn (mut g Gen) remember_specialized_receiver_method(fn_name string, receiver_base string) {
    if receiver_base == '' {
        return
    }
    generic_tail := fn_name.all_after('_T_')
    if !generic_tail.contains('__') {
        return
    }
    method_name := fn_name.all_after_last('__')
    if method_name == '' {
        return
    }
    key := specialized_receiver_method_key(receiver_base, method_name)
    g.specialized_receiver_method_miss.delete(key)
    if key in g.specialized_receiver_method_ambiguous {
        return
    }
    if existing := g.specialized_receiver_methods[key] {
        if existing != fn_name {
            g.specialized_receiver_methods.delete(key)
            g.specialized_receiver_method_ambiguous[key] = true
        }
        return
    }
    g.specialized_receiver_methods[key] = fn_name
}

fn specialized_receiver_method_key(receiver_type string, method_name string) string {
    return '${receiver_type}|${method_name}'
}

fn (mut g Gen) ensure_specialized_receiver_method_index() {
    if g.specialized_receiver_method_indexed {
        return
    }
    for fn_name, _ in g.fn_return_types {
        g.remember_specialized_fn_base(fn_name)
    }
    for fn_name, _ in g.fn_param_is_ptr {
        g.remember_specialized_fn_base(fn_name)
    }
    g.specialized_receiver_method_indexed = true
}

fn (mut g Gen) needs_implicit_veb_ctx_param(node &ast.FnDecl, fn_name string) bool {
    if node.receiver.name == 'ctx' {
        return false
    }
    for param in node.typ.params {
        if param.name == 'ctx' {
            return false
        }
    }
    mut ret_type := if fn_ret := g.fn_return_types[fn_name] {
        fn_ret
    } else if node.typ.return_type !is ast.EmptyExpr {
        g.expr_type_to_c(node.typ.return_type)
    } else {
        'void'
    }
    ret_type = normalize_signature_type_name(ret_type, 'void')
    if ret_type !in ['veb__Result', 'veb.Result', 'Result'] {
        return false
    }
    if g.cur_fn_scope != unsafe { nil } {
        if _ := g.cur_fn_scope.lookup_parent('ctx', 0) {
            return true
        }
    }
    return false
}

fn (mut g Gen) implicit_veb_ctx_c_type() string {
    if g.cur_fn_scope != unsafe { nil } {
        if ctx_type := g.cur_fn_scope.lookup_var_type('ctx') {
            c_type := normalize_signature_type_name(g.types_type_to_c(ctx_type), 'Context*')
            if c_type != '' {
                return c_type
            }
        }
    }
    return 'Context*'
}

fn collect_generic_placeholder_names_from_expr(expr ast.Expr, mut seen map[string]bool, mut out []string) {
    match expr {
        ast.Ident {
            if is_generic_placeholder_type_name(expr.name) && expr.name !in seen {
                seen[expr.name] = true
                out << expr.name
            }
        }
        ast.PrefixExpr {
            collect_generic_placeholder_names_from_expr(expr.expr, mut seen, mut out)
        }
        ast.ModifierExpr {
            collect_generic_placeholder_names_from_expr(expr.expr, mut seen, mut out)
        }
        ast.ParenExpr {
            collect_generic_placeholder_names_from_expr(expr.expr, mut seen, mut out)
        }
        ast.SelectorExpr {
            collect_generic_placeholder_names_from_expr(expr.lhs, mut seen, mut out)
        }
        ast.GenericArgOrIndexExpr {
            collect_generic_placeholder_names_from_expr(expr.lhs, mut seen, mut out)
            collect_generic_placeholder_names_from_expr(expr.expr, mut seen, mut out)
        }
        ast.GenericArgs {
            collect_generic_placeholder_names_from_expr(expr.lhs, mut seen, mut out)
            for arg in expr.args {
                collect_generic_placeholder_names_from_expr(arg, mut seen, mut out)
            }
        }
        ast.Type {
            match expr {
                ast.ArrayType {
                    collect_generic_placeholder_names_from_expr(expr.elem_type, mut seen, mut out)
                }
                ast.ArrayFixedType {
                    collect_generic_placeholder_names_from_expr(expr.elem_type, mut seen, mut out)
                    collect_generic_placeholder_names_from_expr(expr.len, mut seen, mut out)
                }
                ast.MapType {
                    collect_generic_placeholder_names_from_expr(expr.key_type, mut seen, mut out)
                    collect_generic_placeholder_names_from_expr(expr.value_type, mut seen, mut out)
                }
                ast.PointerType {
                    collect_generic_placeholder_names_from_expr(expr.base_type, mut seen, mut out)
                }
                ast.OptionType {
                    collect_generic_placeholder_names_from_expr(expr.base_type, mut seen, mut out)
                }
                ast.ResultType {
                    collect_generic_placeholder_names_from_expr(expr.base_type, mut seen, mut out)
                }
                ast.TupleType {
                    for typ in expr.types {
                        collect_generic_placeholder_names_from_expr(typ, mut seen, mut out)
                    }
                }
                ast.FnType {
                    for param in expr.params {
                        collect_generic_placeholder_names_from_expr(param.typ, mut seen, mut out)
                    }
                    if expr.return_type !is ast.EmptyExpr {
                        collect_generic_placeholder_names_from_expr(expr.return_type, mut seen, mut
                            out)
                    }
                }
                ast.GenericType {
                    // Recurse into params (e.g. LinkedList[T] → extract T)
                    for param in expr.params {
                        collect_generic_placeholder_names_from_expr(param, mut seen, mut out)
                    }
                }
                else {}
            }
        }
        else {}
    }
}

fn (g &Gen) generic_fn_param_names(node ast.FnDecl) []string {
    mut names := []string{}
    for gp in node.typ.generic_params {
        if gp is ast.Ident && gp.name != '' {
            names << gp.name
        }
    }
    return names
}

fn (g &Gen) should_skip_backend_generic_fn(node ast.FnDecl) bool {
    return g.generic_fn_param_names(node).len > 0 || receiver_generic_param_names(node).len > 0
}

// receiver_generic_param_names collects generic placeholder names from a
// method's receiver type (e.g. LinkedList[T] → ['T']). These params are
// inherited from the struct definition, not the function's own generic_params.
fn receiver_generic_param_names(node ast.FnDecl) []string {
    if !node.is_method {
        return []string{}
    }
    mut seen := map[string]bool{}
    mut names := []string{}
    if node.receiver.typ !is ast.EmptyExpr {
        collect_generic_placeholder_names_from_expr(node.receiver.typ, mut seen, mut names)
    }
    return names
}

// get_receiver_generic_bindings returns the concrete type bindings for a method
// on a generic struct by looking up the struct's recorded bindings from
// GenericType instantiations (e.g. LinkedList[ValueInfo] → {T: ValueInfo}).
fn (mut g Gen) get_receiver_generic_bindings(node ast.FnDecl) ?map[string]types.Type {
    if !node.is_method {
        return none
    }
    // Use the receiver's generic base name directly. Calling expr_type_to_c on
    // LinkedList[T] without active bindings can resolve T through the fallback
    // placeholder type and point method emission at a stray specialization.
    recv_c_name := g.receiver_generic_base_c_name(node)
    if recv_c_name == '' {
        return none
    }
    if instances := g.generic_struct_instances[recv_c_name] {
        if instances.len > 0 {
            return instances[0].bindings
        }
    }
    if bindings := g.generic_struct_bindings[recv_c_name] {
        return bindings
    }
    // Also try with current module prefix
    if !recv_c_name.contains('__') && g.cur_module != '' && g.cur_module != 'main'
        && g.cur_module != 'builtin' {
        qualified := '${g.cur_module}__${recv_c_name}'
        if instances := g.generic_struct_instances[qualified] {
            if instances.len > 0 {
                return instances[0].bindings
            }
        }
        if bindings := g.generic_struct_bindings[qualified] {
            return bindings
        }
    }
    return none
}

// get_all_receiver_generic_bindings returns ALL concrete type binding sets for a method
// on a generic struct (for multi-instantiation, e.g. LinkedList[ValueInfo] AND LinkedList[StructFieldInfo]).
fn (mut g Gen) get_all_receiver_generic_bindings(node ast.FnDecl) []map[string]types.Type {
    instances := g.get_all_receiver_generic_instances(node)
    if instances.len == 0 {
        return []
    }
    mut all_bindings := []map[string]types.Type{cap: instances.len}
    for inst in instances {
        all_bindings << inst.bindings
    }
    return all_bindings
}

fn (mut g Gen) get_all_receiver_generic_instances(node ast.FnDecl) []GenericStructInstance {
    if !node.is_method {
        return []
    }
    recv_c_name := g.receiver_generic_base_c_name(node)
    if recv_c_name == '' {
        return []
    }
    mut struct_name := recv_c_name
    if !struct_name.contains('__') && g.cur_module != '' && g.cur_module != 'main'
        && g.cur_module != 'builtin' {
        struct_name = '${g.cur_module}__${recv_c_name}'
    }
    if instances := g.generic_struct_instances[struct_name] {
        if instances.len > 0 {
            return instances
        }
    }
    if struct_name != recv_c_name {
        if instances := g.generic_struct_instances[recv_c_name] {
            if instances.len > 0 {
                return instances
            }
        }
    }
    return []
}

fn (mut g Gen) receiver_generic_base_c_name(node ast.FnDecl) string {
    if !node.is_method || node.receiver.typ is ast.EmptyExpr {
        return ''
    }
    return g.receiver_generic_base_c_name_from_expr(node.receiver.typ).trim_right('*')
}

fn (mut g Gen) receiver_generic_base_c_name_from_expr(expr ast.Expr) string {
    match expr {
        ast.GenericArgOrIndexExpr {
            return g.expr_type_to_c(expr.lhs)
        }
        ast.GenericArgs {
            return g.expr_type_to_c(expr.lhs)
        }
        ast.PrefixExpr {
            if expr.op in [.amp, .mul] {
                return g.receiver_generic_base_c_name_from_expr(expr.expr)
            }
        }
        ast.ModifierExpr {
            return g.receiver_generic_base_c_name_from_expr(expr.expr)
        }
        ast.Type {
            match expr {
                ast.PointerType {
                    return g.receiver_generic_base_c_name_from_expr(expr.base_type)
                }
                ast.GenericType {
                    return g.expr_type_to_c(expr.name)
                }
                else {}
            }
        }
        else {}
    }

    mut name := g.expr_type_to_c(expr)
    if name.contains('_T_') {
        name = name.all_before('_T_')
    }
    return name
}

fn (mut g Gen) receiver_generic_instance_c_name_for_active_bindings(node ast.FnDecl) ?string {
    recv_params := receiver_generic_param_names(node)
    if recv_params.len == 0 || g.active_generic_types.len == 0 {
        return none
    }
    base_name := g.receiver_generic_base_c_name(node)
    if base_name == '' {
        return none
    }
    mut instances := g.generic_struct_instances[base_name]
    if instances.len == 0 && !base_name.contains('__') && g.cur_module != ''
        && g.cur_module != 'main' && g.cur_module != 'builtin' {
        instances = g.generic_struct_instances['${g.cur_module}__${base_name}']
    }
    for inst in instances {
        mut matches := true
        for param_name in recv_params {
            active_type := g.active_generic_types[param_name] or {
                matches = false
                break
            }
            inst_type := inst.bindings[param_name] or {
                matches = false
                break
            }
            active_token := g.generic_specialization_token_from_type(active_type)
            inst_token := g.generic_specialization_token_from_type(inst_type)
            if active_token != inst_token {
                matches = false
                break
            }
        }
        if matches {
            return inst.c_name
        }
    }
    return none
}

fn (mut g Gen) specialized_fn_name(node ast.FnDecl, generic_types map[string]types.Type) string {
    generic_params := g.generic_fn_param_names(node)
    if generic_params.len == 0 {
        return ''
    }
    prev_generic_types := g.active_generic_types.clone()
    g.active_generic_types = generic_types.clone()
    base_name := g.get_fn_name(node)
    g.active_generic_types = prev_generic_types.clone()
    if base_name == '' {
        return ''
    }
    mut suffixes := []string{}
    for param_name in generic_params {
        if concrete := generic_types[param_name] {
            suffixes << g.generic_specialization_token_from_type(concrete)
        }
    }
    if suffixes.len == 0 {
        return base_name
    }
    return '${base_name}_T_${suffixes.join('_')}'
}

fn (g &Gen) generic_key_matches_decl(node ast.FnDecl, key string) bool {
    return key == node.name || key.starts_with('${node.name}[') || key.ends_with('.${node.name}')
        || key.contains('.${node.name}[') || key.ends_with('__${node.name}')
        || key.contains('__${node.name}[')
}

fn (mut g Gen) build_generic_fn_decl_index() {
    g.generic_fn_decl_index = map[string]GenericFnDeclInfo{}
    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 file_idx in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(file_idx)
            g.set_file_cursor_module(fc)
            stmts := fc.stmts()
            for stmt_idx in 0 .. stmts.len() {
                stmt := stmts.at(stmt_idx)
                if stmt.kind() != .stmt_fn_decl {
                    continue
                }
                decl := stmt.fn_decl_signature()
                if g.generic_fn_param_names(decl).len == 0
                    && receiver_generic_param_names(decl).len == 0 {
                    continue
                }
                info := GenericFnDeclInfo{
                    file_idx: file_idx
                    stmt_idx: stmt_idx
                }
                qualified := g.get_fn_name(decl)
                if qualified != '' && qualified !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[qualified] = info
                }
                if !decl.is_method && decl.name != '' && decl.name !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[decl.name] = info
                }
                if decl.is_method && decl.name != '' && decl.name !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[decl.name] = info
                }
                sanitized := sanitize_fn_ident(decl.name)
                if !decl.is_method && sanitized != '' && sanitized !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[sanitized] = info
                }
            }
        }
        return
    }
    for file_idx, file in g.files {
        g.set_file_module(file)
        for stmt_idx, stmt in file.stmts {
            if !stmt_has_valid_data(stmt) {
                continue
            }
            if stmt is ast.FnDecl {
                if g.generic_fn_param_names(stmt).len == 0
                    && receiver_generic_param_names(stmt).len == 0 {
                    continue
                }
                info := GenericFnDeclInfo{
                    file_idx: file_idx
                    stmt_idx: stmt_idx
                }
                qualified := g.get_fn_name(stmt)
                if qualified != '' && qualified !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[qualified] = info
                }
                if !stmt.is_method && stmt.name != '' && stmt.name !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[stmt.name] = info
                }
                if stmt.is_method && stmt.name != '' && stmt.name !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[stmt.name] = info
                }
                sanitized := sanitize_fn_ident(stmt.name)
                if !stmt.is_method && sanitized != '' && sanitized !in g.generic_fn_decl_index {
                    g.generic_fn_decl_index[sanitized] = info
                }
            }
        }
    }
}

// discover_comptime_generic_specs pre-scans generic functions that use comptime
// `$for field in T.fields` with recursive generic calls (e.g., decode_value, encode_value).
// For each existing specialization T=SomeStruct, it discovers the struct's field types
// and registers additional specializations (e.g., T=string) so function bodies get emitted.
fn (mut g Gen) discover_comptime_generic_specs() {
    if g.env == unsafe { nil } {
        return
    }
    // For each generic function specialization where T is a struct,
    // discover field types and register additional specializations
    // so that comptime $for field in T.fields { decode_value(field) }
    // can call decode_value_T_<field_type>. Newly discovered struct specs
    // can expose more field types, so iterate to a small fixed point.
    for _ in 0 .. 8 {
        before := g.late_generic_spec_count()
        mut all_keys := map[string]bool{}
        for key, _ in g.env.generic_types {
            all_keys[key] = true
        }
        for key, _ in g.late_generic_specs {
            all_keys[key] = true
        }
        for key, _ in all_keys {
            decl := g.find_generic_fn_decl_by_spec_key(key) or { continue }
            if !fn_has_comptime_stmt(decl) {
                continue
            }
            mut spec_list := []map[string]types.Type{}
            for spec in g.env.generic_types[key] {
                spec_list << spec.clone()
            }
            for spec in g.late_generic_specs[key] {
                spec_list << spec.clone()
            }
            for spec in spec_list {
                for param_name, concrete_type in spec {
                    if concrete_type is types.Struct {
                        mut struct_type := concrete_type as types.Struct
                        if struct_type.fields.len == 0 {
                            struct_c_name :=
                                g.types_type_to_c(concrete_type).trim_space().trim_right('*')
                            full_struct_type := g.lookup_struct_type_by_c_name(struct_c_name)
                            if full_struct_type.fields.len > 0 {
                                struct_type = full_struct_type
                            }
                        }
                        if struct_type.fields.len == 0 {
                            continue
                        }
                        mut seen_types := map[string]bool{}
                        // Mark existing specs as seen to avoid duplicates
                        for existing_spec in spec_list {
                            if existing_t := existing_spec[param_name] {
                                seen_types[existing_t.name()] = true
                            }
                        }
                        for field in struct_type.fields {
                            field_type_name := field.typ.name()
                            if field_type_name in seen_types {
                                continue
                            }
                            seen_types[field_type_name] = true
                            g.record_late_generic_call_spec(key, {
                                param_name: field.typ
                            })
                        }
                    }
                }
            }
        }
        if g.late_generic_spec_count() == before {
            break
        }
    }
}

fn fn_has_comptime_stmt(decl ast.FnDecl) bool {
    for stmt in decl.stmts {
        if stmt_has_comptime_stmt(stmt) {
            return true
        }
    }
    return false
}

fn stmt_has_comptime_stmt(stmt ast.Stmt) bool {
    match stmt {
        ast.ComptimeStmt {
            return true
        }
        ast.BlockStmt {
            for sub in stmt.stmts {
                if stmt_has_comptime_stmt(sub) {
                    return true
                }
            }
        }
        ast.DeferStmt {
            for sub in stmt.stmts {
                if stmt_has_comptime_stmt(sub) {
                    return true
                }
            }
        }
        ast.ForStmt {
            for sub in stmt.stmts {
                if stmt_has_comptime_stmt(sub) {
                    return true
                }
            }
        }
        ast.ExprStmt {
            return expr_has_comptime_stmt(stmt.expr)
        }
        ast.AssignStmt {
            for rhs in stmt.rhs {
                if expr_has_comptime_stmt(rhs) {
                    return true
                }
            }
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                if expr_has_comptime_stmt(expr) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn expr_has_comptime_stmt(expr ast.Expr) bool {
    match expr {
        ast.ComptimeExpr {
            return true
        }
        ast.IfExpr {
            if expr_has_comptime_stmt(expr.cond) {
                return true
            }
            for stmt in expr.stmts {
                if stmt_has_comptime_stmt(stmt) {
                    return true
                }
            }
            return expr.else_expr !is ast.EmptyExpr && expr_has_comptime_stmt(expr.else_expr)
        }
        ast.MatchExpr {
            if expr_has_comptime_stmt(expr.expr) {
                return true
            }
            for branch in expr.branches {
                for cond in branch.cond {
                    if expr_has_comptime_stmt(cond) {
                        return true
                    }
                }
                for stmt in branch.stmts {
                    if stmt_has_comptime_stmt(stmt) {
                        return true
                    }
                }
            }
        }
        ast.OrExpr {
            if expr_has_comptime_stmt(expr.expr) {
                return true
            }
            for stmt in expr.stmts {
                if stmt_has_comptime_stmt(stmt) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn fn_cursor_has_comptime_stmt(decl ast.Cursor) bool {
    return stmt_cursor_list_has_comptime_stmt(decl.list_at(3))
}

fn stmt_cursor_list_has_comptime_stmt(stmts ast.CursorList) bool {
    for i in 0 .. stmts.len() {
        if stmt_cursor_has_comptime_stmt(stmts.at(i)) {
            return true
        }
    }
    return false
}

fn stmt_cursor_has_comptime_stmt(stmt ast.Cursor) bool {
    if !stmt.is_valid() {
        return false
    }
    match stmt.kind() {
        .stmt_comptime {
            return true
        }
        .stmt_block, .stmt_defer {
            for i in 0 .. stmt.edge_count() {
                if stmt_cursor_has_comptime_stmt(stmt.edge(i)) {
                    return true
                }
            }
        }
        .stmt_for {
            return stmt_cursor_list_has_comptime_stmt(stmt.for_body_list())
        }
        .stmt_expr {
            return expr_cursor_has_comptime_stmt(stmt.edge(0))
        }
        .stmt_assign {
            lhs_len := stmt.extra_int()
            for i in lhs_len .. stmt.edge_count() {
                if expr_cursor_has_comptime_stmt(stmt.edge(i)) {
                    return true
                }
            }
        }
        .stmt_return {
            for i in 0 .. stmt.edge_count() {
                if expr_cursor_has_comptime_stmt(stmt.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn expr_cursor_has_comptime_stmt(expr ast.Cursor) bool {
    if !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_comptime {
            return true
        }
        .expr_if {
            if expr_cursor_has_comptime_stmt(expr.edge(0)) {
                return true
            }
            for i in 2 .. expr.edge_count() {
                if stmt_cursor_has_comptime_stmt(expr.edge(i)) {
                    return true
                }
            }
            return expr_cursor_has_comptime_stmt(expr.edge(1))
        }
        .expr_match {
            if expr_cursor_has_comptime_stmt(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 expr_cursor_has_comptime_stmt(conds.at(ci)) {
                        return true
                    }
                }
                if stmt_cursor_list_has_comptime_stmt(branch.list_at(1)) {
                    return true
                }
            }
        }
        .expr_or {
            if expr_cursor_has_comptime_stmt(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if stmt_cursor_has_comptime_stmt(expr.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut g Gen) fn_body_has_generic_call(decl ast.FnDecl) bool {
    for stmt in decl.stmts {
        if g.stmt_has_generic_call(stmt) {
            return true
        }
    }
    return false
}

fn (mut g Gen) stmt_has_generic_call(stmt ast.Stmt) bool {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.lhs {
                if g.expr_has_generic_call(expr) {
                    return true
                }
            }
            for expr in stmt.rhs {
                if g.expr_has_generic_call(expr) {
                    return true
                }
            }
        }
        ast.BlockStmt {
            for sub in stmt.stmts {
                if g.stmt_has_generic_call(sub) {
                    return true
                }
            }
        }
        ast.ComptimeStmt {
            return g.stmt_has_generic_call(stmt.stmt)
        }
        ast.DeferStmt {
            for sub in stmt.stmts {
                if g.stmt_has_generic_call(sub) {
                    return true
                }
            }
        }
        ast.ExprStmt {
            return g.expr_has_generic_call(stmt.expr)
        }
        ast.ForStmt {
            if stmt.init !is ast.EmptyStmt && g.stmt_has_generic_call(stmt.init) {
                return true
            }
            if g.expr_has_generic_call(stmt.cond) {
                return true
            }
            if stmt.post !is ast.EmptyStmt && g.stmt_has_generic_call(stmt.post) {
                return true
            }
            for sub in stmt.stmts {
                if g.stmt_has_generic_call(sub) {
                    return true
                }
            }
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                if g.expr_has_generic_call(expr) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut g Gen) expr_has_generic_call(expr ast.Expr) bool {
    match expr {
        ast.CallExpr {
            if _ := g.generic_call_decl_from_lhs(expr.lhs) {
                return true
            }
            if g.expr_has_generic_call(expr.lhs) {
                return true
            }
            for arg in expr.args {
                if g.expr_has_generic_call(arg) {
                    return true
                }
            }
        }
        ast.CallOrCastExpr {
            return g.expr_has_generic_call(expr.lhs) || g.expr_has_generic_call(expr.expr)
        }
        ast.ComptimeExpr {
            return g.expr_has_generic_call(expr.expr)
        }
        ast.GenericArgOrIndexExpr {
            return g.expr_has_generic_call(expr.lhs) || g.expr_has_generic_call(expr.expr)
        }
        ast.GenericArgs {
            if g.expr_has_generic_call(expr.lhs) {
                return true
            }
            for arg in expr.args {
                if g.expr_has_generic_call(arg) {
                    return true
                }
            }
        }
        ast.IfExpr {
            if g.expr_has_generic_call(expr.cond) {
                return true
            }
            for sub in expr.stmts {
                if g.stmt_has_generic_call(sub) {
                    return true
                }
            }
            return expr.else_expr !is ast.EmptyExpr && g.expr_has_generic_call(expr.else_expr)
        }
        ast.IndexExpr {
            return g.expr_has_generic_call(expr.lhs) || g.expr_has_generic_call(expr.expr)
        }
        ast.InfixExpr {
            return g.expr_has_generic_call(expr.lhs) || g.expr_has_generic_call(expr.rhs)
        }
        ast.MatchExpr {
            if g.expr_has_generic_call(expr.expr) {
                return true
            }
            for branch in expr.branches {
                for cond in branch.cond {
                    if g.expr_has_generic_call(cond) {
                        return true
                    }
                }
                for sub in branch.stmts {
                    if g.stmt_has_generic_call(sub) {
                        return true
                    }
                }
            }
        }
        ast.ModifierExpr {
            return g.expr_has_generic_call(expr.expr)
        }
        ast.OrExpr {
            if g.expr_has_generic_call(expr.expr) {
                return true
            }
            for sub in expr.stmts {
                if g.stmt_has_generic_call(sub) {
                    return true
                }
            }
        }
        ast.ParenExpr {
            return g.expr_has_generic_call(expr.expr)
        }
        ast.PrefixExpr {
            return g.expr_has_generic_call(expr.expr)
        }
        ast.SelectorExpr {
            return g.expr_has_generic_call(expr.lhs)
        }
        ast.Tuple {
            for item in expr.exprs {
                if g.expr_has_generic_call(item) {
                    return true
                }
            }
        }
        ast.UnsafeExpr {
            for sub in expr.stmts {
                if g.stmt_has_generic_call(sub) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut g Gen) fn_cursor_body_has_generic_call(decl ast.Cursor) bool {
    body := decl.list_at(3)
    for i in 0 .. body.len() {
        if g.stmt_cursor_has_generic_call(body.at(i)) {
            return true
        }
    }
    return false
}

fn (mut g Gen) stmt_cursor_has_generic_call(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.expr_cursor_has_generic_call(stmt.edge(i)) {
                    return true
                }
            }
            for i in lhs_len .. stmt.edge_count() {
                if g.expr_cursor_has_generic_call(stmt.edge(i)) {
                    return true
                }
            }
        }
        .stmt_block, .stmt_defer {
            for i in 0 .. stmt.edge_count() {
                if g.stmt_cursor_has_generic_call(stmt.edge(i)) {
                    return true
                }
            }
        }
        .stmt_comptime {
            return g.stmt_cursor_has_generic_call(stmt.edge(0))
        }
        .stmt_expr {
            return g.expr_cursor_has_generic_call(stmt.edge(0))
        }
        .stmt_for {
            if g.stmt_cursor_has_generic_call(stmt.edge(0)) {
                return true
            }
            if g.expr_cursor_has_generic_call(stmt.edge(1)) {
                return true
            }
            if g.stmt_cursor_has_generic_call(stmt.edge(2)) {
                return true
            }
            body := stmt.for_body_list()
            for i in 0 .. body.len() {
                if g.stmt_cursor_has_generic_call(body.at(i)) {
                    return true
                }
            }
        }
        .stmt_return {
            for i in 0 .. stmt.edge_count() {
                if g.expr_cursor_has_generic_call(stmt.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut g Gen) call_cursor_lhs_is_generic_call(lhs ast.Cursor) bool {
    call_name := generic_call_short_name_cursor(lhs)
    if call_name == '' {
        return false
    }
    if g.generic_fn_decl_index.len == 0 {
        if _ := g.generic_call_decl_from_lhs_cursor(lhs) {
            return true
        }
        return false
    }
    for candidate in generic_call_decl_candidates(call_name) {
        if candidate in g.generic_fn_decl_index {
            return true
        }
    }
    return false
}

fn (mut g Gen) expr_cursor_has_generic_call(expr ast.Cursor) bool {
    if !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_call {
            if g.call_cursor_lhs_is_generic_call(expr.edge(0)) {
                return true
            }
            if g.expr_cursor_has_generic_call(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.expr_cursor_has_generic_call(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_call_or_cast, .expr_generic_arg_or_index, .expr_index, .expr_infix {
            return g.expr_cursor_has_generic_call(expr.edge(0))
                || g.expr_cursor_has_generic_call(expr.edge(1))
        }
        .expr_comptime, .expr_modifier, .expr_paren, .expr_prefix, .expr_selector {
            return g.expr_cursor_has_generic_call(expr.edge(0))
        }
        .expr_generic_args, .expr_tuple {
            for i in 0 .. expr.edge_count() {
                if g.expr_cursor_has_generic_call(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_if {
            if g.expr_cursor_has_generic_call(expr.edge(0)) {
                return true
            }
            for i in 2 .. expr.edge_count() {
                if g.stmt_cursor_has_generic_call(expr.edge(i)) {
                    return true
                }
            }
            return g.expr_cursor_has_generic_call(expr.edge(1))
        }
        .expr_match {
            if g.expr_cursor_has_generic_call(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.expr_cursor_has_generic_call(conds.at(ci)) {
                        return true
                    }
                }
                stmts := branch.list_at(1)
                for si in 0 .. stmts.len() {
                    if g.stmt_cursor_has_generic_call(stmts.at(si)) {
                        return true
                    }
                }
            }
        }
        .expr_or {
            if g.expr_cursor_has_generic_call(expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if g.stmt_cursor_has_generic_call(expr.edge(i)) {
                    return true
                }
            }
        }
        .expr_unsafe {
            for i in 0 .. expr.edge_count() {
                if g.stmt_cursor_has_generic_call(expr.edge(i)) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (mut g Gen) accepts_broad_generic_fallback_type(node ast.FnDecl, concrete types.Type) bool {
    if concrete.name() == 'void' {
        return false
    }
    if g.cur_module != 'json2' && g.broad_generic_fallback_type_is_generic_instance(concrete) {
        return false
    }
    if g.cur_module == 'json2'
        && node.name in ['decode', 'decode_value', 'decode_struct_key', 'check_required_struct_fields', 'cached_struct_field_infos']
        && is_json2_runtime_internal_type(concrete) {
        return false
    }
    if g.cur_module == 'stdatomic' && node.name == 'new_atomic' {
        return concrete.name() in ['bool', 'voidptr', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16',
            'u32', 'u64', 'byte', 'isize', 'usize']
    }
    return g.generic_fallback_type_satisfies_body_requirements(node, concrete)
}

fn (g &Gen) broad_generic_fallback_type_is_generic_instance(concrete types.Type) bool {
    c_name := g.types_type_to_c(normalize_generic_concrete_type(concrete))
    return c_name.contains('_T_')
}

fn (mut g Gen) generic_fallback_type_satisfies_body_requirements(node ast.FnDecl, concrete types.Type) bool {
    generic_params := g.generic_fn_param_names(node)
    if generic_params.len != 1 || node.stmts.len == 0 {
        return true
    }
    return g.generic_fallback_type_satisfies_body_requirements_for_param(node, generic_params[0],
        concrete, 0)
}

fn (mut g Gen) generic_fallback_type_satisfies_body_requirements_for_param(node ast.FnDecl, param_name string, concrete types.Type, depth int) bool {
    if param_name == '' || node.stmts.len == 0 {
        return true
    }
    if generic_param_is_scalar_numeric_param(node, param_name)
        && !generic_fallback_type_supports_numeric(concrete) {
        return false
    }
    if generic_fn_has_unconditional_comptime_fields_loop(node.stmts, param_name) {
        if _ := g.generic_fallback_struct_type(concrete) {
        } else {
            return false
        }
    }
    mut value_names, container_names := generic_param_value_and_container_names(node, param_name)
    if value_names.len == 0 && container_names.len == 0 {
        return true
    }
    mut required_fields := map[string]bool{}
    mut required_methods := map[string]bool{}
    collect_generic_param_member_requirements_from_stmts(node.stmts, value_names, mut
        required_fields, mut required_methods)
    mut required_ops := map[string]bool{}
    mut op_value_names := value_names.clone()
    collect_generic_param_operator_requirements_from_stmts(node.stmts, mut op_value_names,
        container_names, mut required_ops)
    if required_ops['ordered'] && !generic_fallback_type_supports_ordered(concrete) {
        return false
    }
    if required_ops['add'] && !generic_fallback_type_supports_add(concrete) {
        return false
    }
    if required_ops['numeric'] && !generic_fallback_type_supports_numeric(concrete) {
        return false
    }
    for field_name, _ in required_fields {
        if !g.generic_fallback_type_has_field(concrete, field_name) {
            return false
        }
    }
    for method_name, _ in required_methods {
        if !g.generic_fallback_type_has_method(concrete, method_name) {
            return false
        }
    }
    if !g.generic_param_call_requirements_satisfied_from_stmts(node.stmts, param_name, value_names,
        container_names, concrete, depth) {
        return false
    }
    return true
}

fn generic_param_is_scalar_numeric_param(node ast.FnDecl, param_name string) bool {
    if !node.name.contains('scalar') {
        return false
    }
    for param in node.typ.params {
        if param.name == 'scalar' && generic_type_expr_is_direct_placeholder(param.typ, param_name) {
            return true
        }
    }
    return false
}

fn (mut g Gen) generic_param_call_requirements_satisfied_from_stmts(stmts []ast.Stmt, param_name string, value_names map[string]bool, container_names map[string]bool, concrete types.Type, depth int) bool {
    for stmt in stmts {
        match stmt {
            ast.AssignStmt {
                for expr in stmt.lhs {
                    if !g.generic_param_call_requirements_satisfied_from_expr(expr, param_name,
                        value_names, container_names, concrete, depth) {
                        return false
                    }
                }
                for expr in stmt.rhs {
                    if !g.generic_param_call_requirements_satisfied_from_expr(expr, param_name,
                        value_names, container_names, concrete, depth) {
                        return false
                    }
                }
            }
            ast.BlockStmt, ast.DeferStmt {
                if !g.generic_param_call_requirements_satisfied_from_stmts(stmt.stmts, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
            ast.ComptimeStmt {
                if stmt.stmt is ast.ExprStmt && stmt.stmt.expr is ast.ComptimeExpr
                    && (stmt.stmt.expr as ast.ComptimeExpr).expr is ast.IfExpr {
                    continue
                }
                if !g.generic_param_call_requirements_satisfied_from_stmts([stmt.stmt], param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
            ast.ExprStmt {
                if !g.generic_param_call_requirements_satisfied_from_expr(stmt.expr, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
            ast.ForStmt {
                if stmt.init !is ast.EmptyStmt
                    && !g.generic_param_call_requirements_satisfied_from_stmts([stmt.init], param_name, value_names, container_names, concrete, depth) {
                    return false
                }
                if !g.generic_param_call_requirements_satisfied_from_expr(stmt.cond, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
                if stmt.post !is ast.EmptyStmt
                    && !g.generic_param_call_requirements_satisfied_from_stmts([stmt.post], param_name, value_names, container_names, concrete, depth) {
                    return false
                }
                if !g.generic_param_call_requirements_satisfied_from_stmts(stmt.stmts, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
            ast.ReturnStmt {
                for expr in stmt.exprs {
                    if !g.generic_param_call_requirements_satisfied_from_expr(expr, param_name,
                        value_names, container_names, concrete, depth) {
                        return false
                    }
                }
            }
            else {}
        }
    }
    return true
}

fn (mut g Gen) generic_param_call_requirements_satisfied_from_expr(expr ast.Expr, param_name string, value_names map[string]bool, container_names map[string]bool, concrete types.Type, depth int) bool {
    match expr {
        ast.ArrayInitExpr {
            for item in expr.exprs {
                if !g.generic_param_call_requirements_satisfied_from_expr(item, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
        }
        ast.CallExpr {
            if !g.generic_param_call_requirements_satisfied_for_call(expr, value_names,
                container_names, concrete, depth) {
                return false
            }
            if !g.generic_param_call_requirements_satisfied_from_expr(expr.lhs, param_name,
                value_names, container_names, concrete, depth) {
                return false
            }
            for arg in expr.args {
                if !g.generic_param_call_requirements_satisfied_from_expr(arg, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
        }
        ast.CallOrCastExpr {
            return
                g.generic_param_call_requirements_satisfied_from_expr(expr.lhs, param_name, value_names, container_names, concrete, depth)
                && g.generic_param_call_requirements_satisfied_from_expr(expr.expr, param_name, value_names, container_names, concrete, depth)
        }
        ast.ComptimeExpr {
            if expr.expr is ast.IfExpr {
                return true
            }
            return g.generic_param_call_requirements_satisfied_from_expr(expr.expr, param_name,
                value_names, container_names, concrete, depth)
        }
        ast.IfExpr {
            if !g.generic_param_call_requirements_satisfied_from_expr(expr.cond, param_name,
                value_names, container_names, concrete, depth) {
                return false
            }
            if !g.generic_param_call_requirements_satisfied_from_stmts(expr.stmts, param_name,
                value_names, container_names, concrete, depth) {
                return false
            }
            if expr.else_expr !is ast.EmptyExpr {
                return g.generic_param_call_requirements_satisfied_from_expr(expr.else_expr,
                    param_name, value_names, container_names, concrete, depth)
            }
        }
        ast.IndexExpr {
            return
                g.generic_param_call_requirements_satisfied_from_expr(expr.lhs, param_name, value_names, container_names, concrete, depth)
                && g.generic_param_call_requirements_satisfied_from_expr(expr.expr, param_name, value_names, container_names, concrete, depth)
        }
        ast.InfixExpr {
            return
                g.generic_param_call_requirements_satisfied_from_expr(expr.lhs, param_name, value_names, container_names, concrete, depth)
                && g.generic_param_call_requirements_satisfied_from_expr(expr.rhs, param_name, value_names, container_names, concrete, depth)
        }
        ast.MatchExpr {
            if !g.generic_param_call_requirements_satisfied_from_expr(expr.expr, param_name,
                value_names, container_names, concrete, depth) {
                return false
            }
            for branch in expr.branches {
                for cond in branch.cond {
                    if !g.generic_param_call_requirements_satisfied_from_expr(cond, param_name,
                        value_names, container_names, concrete, depth) {
                        return false
                    }
                }
                if !g.generic_param_call_requirements_satisfied_from_stmts(branch.stmts,
                    param_name, value_names, container_names, concrete, depth) {
                    return false
                }
            }
        }
        ast.ModifierExpr, ast.ParenExpr, ast.PostfixExpr, ast.PrefixExpr {
            return g.generic_param_call_requirements_satisfied_from_expr(expr.expr, param_name,
                value_names, container_names, concrete, depth)
        }
        ast.OrExpr {
            return
                g.generic_param_call_requirements_satisfied_from_expr(expr.expr, param_name, value_names, container_names, concrete, depth)
                && g.generic_param_call_requirements_satisfied_from_stmts(expr.stmts, param_name, value_names, container_names, concrete, depth)
        }
        ast.SelectorExpr {
            return g.generic_param_call_requirements_satisfied_from_expr(expr.lhs, param_name,
                value_names, container_names, concrete, depth)
        }
        ast.Tuple {
            for item in expr.exprs {
                if !g.generic_param_call_requirements_satisfied_from_expr(item, param_name,
                    value_names, container_names, concrete, depth) {
                    return false
                }
            }
        }
        ast.UnsafeExpr {
            return g.generic_param_call_requirements_satisfied_from_stmts(expr.stmts, param_name,
                value_names, container_names, concrete, depth)
        }
        else {}
    }

    return true
}

fn (mut g Gen) generic_param_call_requirements_satisfied_for_call(call ast.CallExpr, value_names map[string]bool, container_names map[string]bool, concrete types.Type, depth int) bool {
    mut call_args := []ast.Expr{cap: call.args.len + 1}
    if call.lhs is ast.SelectorExpr {
        sel := call.lhs as ast.SelectorExpr
        mut is_static_or_module_call := false
        if sel.lhs is ast.Ident {
            lhs_name := (sel.lhs as ast.Ident).name
            is_static_or_module_call = g.is_type_name(lhs_name) || g.is_module_ident(lhs_name)
        }
        if !is_static_or_module_call {
            call_args << sel.lhs
        }
    }
    call_args << call.args
    mut call_name := g.resolve_call_name(call.lhs, call.args.len)
    if call_name == '' {
        return true
    }
    if call_name.contains('_T_') {
        call_name = call_name.all_before('_T_')
    }
    if call_args.len > 0 && call_name.contains('__')
        && generic_expr_is_generic_value(call_args[0], value_names, container_names) {
        owner := call_name.all_before_last('__')
        method_name := call_name.all_after_last('__')
        if g.generic_requirement_owner_is_type(owner) {
            if declared_method := g.resolve_method_on_concrete_type(owner, method_name) {
                if declared_method == call_name
                    && !g.generic_fallback_type_has_method(concrete, method_name) {
                    return false
                }
            }
        }
    }
    if !g.generic_call_interface_args_satisfy_requirements(call_name, call_args, value_names,
        container_names, concrete) {
        return false
    }
    if depth >= 8 {
        return true
    }
    nested_decl := g.find_generic_fn_decl_for_requirements(call_name) or { return true }
    nested_generic_params := g.generic_fn_param_names(nested_decl)
    if nested_generic_params.len == 0 {
        return true
    }
    arg_offset := if nested_decl.is_method && call_args.len == nested_decl.typ.params.len + 1 {
        1
    } else {
        0
    }
    for arg_idx, arg in call_args {
        if !generic_expr_is_generic_value(arg, value_names, container_names) {
            continue
        }
        param_idx := arg_idx - arg_offset
        if param_idx < 0 || param_idx >= nested_decl.typ.params.len {
            continue
        }
        formal := nested_decl.typ.params[param_idx]
        for nested_param_name in nested_generic_params {
            if !generic_type_expr_is_direct_placeholder(formal.typ, nested_param_name) {
                continue
            }
            if !g.generic_fallback_type_satisfies_body_requirements_for_param(nested_decl,
                nested_param_name, concrete, depth + 1) {
                return false
            }
        }
    }
    return true
}

fn (mut g Gen) generic_requirement_owner_is_type(owner string) bool {
    if owner == '' {
        return false
    }
    clean_owner := strip_pointer_type_name(unmangle_c_ptr_type(owner))
    if clean_owner == '' || clean_owner in primitive_types {
        return false
    }
    if clean_owner in g.c_struct_types || clean_owner in g.typedef_c_types
        || clean_owner in g.enum_type_fields {
        return true
    }
    if _ := g.lookup_type_by_c_name(clean_owner) {
        return true
    }
    if !clean_owner.contains('__') && g.unqualified_type_name_declared_in_files(clean_owner) {
        return true
    }
    return false
}

fn (mut g Gen) find_generic_fn_decl_for_requirements(call_name string) ?ast.FnDecl {
    if decl := g.find_generic_fn_decl_by_base_name(call_name) {
        return decl
    }
    mut short_name := call_name
    if short_name.contains('_T_') {
        short_name = short_name.all_before('_T_')
    }
    if short_name.contains('__') {
        short_name = short_name.all_after_last('__')
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            stmts := g.flat.file_cursor(i).stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() != .stmt_fn_decl || stmt.name() != short_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 {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == short_name
                && g.generic_fn_param_names(stmt).len > 0 {
                return stmt
            }
        }
    }
    return none
}

fn (mut g Gen) generic_call_interface_args_satisfy_requirements(call_name string, call_args []ast.Expr, value_names map[string]bool, container_names map[string]bool, concrete types.Type) bool {
    param_types := g.generic_call_param_types_for_requirements(call_name)
    if param_types.len == 0 {
        return true
    }
    for i, arg in call_args {
        if i >= param_types.len || !generic_expr_is_generic_value(arg, value_names, container_names) {
            continue
        }
        param_base := strip_pointer_type_name(unmangle_c_ptr_type(param_types[i].trim_space()))
        if param_base == '' || !g.is_interface_type(param_base) {
            continue
        }
        if !g.generic_fallback_type_satisfies_interface(concrete, param_base) {
            return false
        }
    }
    return true
}

fn (g &Gen) generic_call_param_types_for_requirements(call_name string) []string {
    mut candidates := []string{}
    if call_name != '' {
        candidates << call_name
        if call_name.contains('_T_') {
            candidates << call_name.all_before('_T_')
        }
        qualified := g.qualify_local_call_name(call_name)
        if qualified != call_name {
            candidates << qualified
        }
        if !call_name.contains('__') {
            if known := g.find_known_qualified_fn_name(call_name) {
                candidates << known
            }
        }
    }
    for candidate in candidates {
        if param_types := g.fn_param_types[candidate] {
            return param_types
        }
    }
    return []string{}
}

fn (mut g Gen) generic_fallback_type_satisfies_interface(concrete types.Type, iface_name string) bool {
    methods := g.interface_methods_for_requirements(iface_name)
    if methods.len == 0 {
        return true
    }
    for method in methods {
        if !g.generic_fallback_type_has_method(concrete, method.name) {
            return false
        }
    }
    return true
}

fn (g &Gen) interface_methods_for_requirements(iface_name string) []InterfaceMethodInfo {
    mut candidates := []string{}
    if iface_name != '' {
        candidates << iface_name
        short_name := iface_name.all_after_last('__')
        if short_name != iface_name {
            candidates << short_name
        }
        if g.cur_module != '' && g.cur_module != 'main' {
            candidates << '${g.cur_module}__${short_name}'
        }
        candidates << 'builtin__${short_name}'
    }
    for candidate in candidates {
        if methods := g.interface_methods[candidate] {
            return methods
        }
    }
    return []InterfaceMethodInfo{}
}

fn generic_param_value_and_container_names(node ast.FnDecl, param_name string) (map[string]bool, map[string]bool) {
    mut value_names := map[string]bool{}
    mut container_names := map[string]bool{}
    for param in node.typ.params {
        if generic_type_expr_is_direct_placeholder(param.typ, param_name) {
            value_names[param.name] = true
        } else if direct_generic_placeholder_name(param.typ) == param_name {
            container_names[param.name] = true
        }
    }
    return value_names, container_names
}

fn generic_type_expr_is_direct_placeholder(expr ast.Expr, param_name string) bool {
    match expr {
        ast.Ident {
            return expr.name == param_name
        }
        ast.ModifierExpr {
            return generic_type_expr_is_direct_placeholder(expr.expr, param_name)
        }
        ast.PrefixExpr {
            return generic_type_expr_is_direct_placeholder(expr.expr, param_name)
        }
        else {}
    }

    return false
}

fn generic_fn_has_unconditional_comptime_fields_loop(stmts []ast.Stmt, param_name string) bool {
    for stmt in stmts {
        match stmt {
            ast.BlockStmt {
                if generic_fn_has_unconditional_comptime_fields_loop(stmt.stmts, param_name) {
                    return true
                }
            }
            ast.ComptimeStmt {
                if comptime_stmt_is_generic_fields_loop(stmt.stmt, param_name) {
                    return true
                }
            }
            ast.ExprStmt {
                if stmt.expr is ast.UnsafeExpr {
                    if generic_fn_has_unconditional_comptime_fields_loop(stmt.expr.stmts,
                        param_name)
                    {
                        return true
                    }
                }
            }
            else {}
        }
    }
    return false
}

fn comptime_stmt_is_generic_fields_loop(stmt ast.Stmt, param_name string) bool {
    if stmt !is ast.ForStmt {
        return false
    }
    if stmt.init !is ast.ForInStmt {
        return false
    }
    for_in := stmt.init as ast.ForInStmt
    if for_in.expr !is ast.SelectorExpr {
        return false
    }
    sel := for_in.expr as ast.SelectorExpr
    return sel.rhs.name == 'fields' && sel.lhs is ast.Ident
        && (sel.lhs as ast.Ident).name == param_name
}

fn collect_generic_param_member_requirements_from_stmts(stmts []ast.Stmt, value_names map[string]bool, mut required_fields map[string]bool, mut required_methods map[string]bool) {
    for stmt in stmts {
        match stmt {
            ast.AssignStmt {
                for expr in stmt.lhs {
                    collect_generic_param_member_requirements_from_expr(expr, value_names, mut
                        required_fields, mut required_methods)
                }
                for expr in stmt.rhs {
                    collect_generic_param_member_requirements_from_expr(expr, value_names, mut
                        required_fields, mut required_methods)
                }
            }
            ast.BlockStmt {
                collect_generic_param_member_requirements_from_stmts(stmt.stmts, value_names, mut
                    required_fields, mut required_methods)
            }
            ast.ComptimeStmt {
                if stmt.stmt is ast.ExprStmt && stmt.stmt.expr is ast.ComptimeExpr
                    && (stmt.stmt.expr as ast.ComptimeExpr).expr is ast.IfExpr {
                    continue
                }
                collect_generic_param_member_requirements_from_stmts([stmt.stmt], value_names, mut
                    required_fields, mut required_methods)
            }
            ast.DeferStmt {
                collect_generic_param_member_requirements_from_stmts(stmt.stmts, value_names, mut
                    required_fields, mut required_methods)
            }
            ast.ExprStmt {
                collect_generic_param_member_requirements_from_expr(stmt.expr, value_names, mut
                    required_fields, mut required_methods)
            }
            ast.ForStmt {
                if stmt.init !is ast.EmptyStmt {
                    collect_generic_param_member_requirements_from_stmts([stmt.init], value_names, mut
                        required_fields, mut required_methods)
                }
                collect_generic_param_member_requirements_from_expr(stmt.cond, value_names, mut
                    required_fields, mut required_methods)
                if stmt.post !is ast.EmptyStmt {
                    collect_generic_param_member_requirements_from_stmts([stmt.post], value_names, mut
                        required_fields, mut required_methods)
                }
                collect_generic_param_member_requirements_from_stmts(stmt.stmts, value_names, mut
                    required_fields, mut required_methods)
            }
            ast.ReturnStmt {
                for expr in stmt.exprs {
                    collect_generic_param_member_requirements_from_expr(expr, value_names, mut
                        required_fields, mut required_methods)
                }
            }
            else {}
        }
    }
}

fn collect_generic_param_member_requirements_from_expr(expr ast.Expr, value_names map[string]bool, mut required_fields map[string]bool, mut required_methods map[string]bool) {
    match expr {
        ast.ArrayInitExpr {
            for item in expr.exprs {
                collect_generic_param_member_requirements_from_expr(item, value_names, mut
                    required_fields, mut required_methods)
            }
        }
        ast.CallExpr {
            if expr.lhs is ast.SelectorExpr {
                sel := expr.lhs as ast.SelectorExpr
                if is_comptime_selector_rhs_name(sel.rhs.name) {
                    collect_generic_param_member_requirements_from_expr(sel.lhs, value_names, mut
                        required_fields, mut required_methods)
                } else if sel.lhs is ast.Ident && (sel.lhs as ast.Ident).name in value_names {
                    required_methods[sel.rhs.name] = true
                } else {
                    collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                        required_fields, mut required_methods)
                }
            } else {
                collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                    required_fields, mut required_methods)
            }
            for arg in expr.args {
                collect_generic_param_member_requirements_from_expr(arg, value_names, mut
                    required_fields, mut required_methods)
            }
        }
        ast.CallOrCastExpr {
            collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                required_fields, mut required_methods)
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.ComptimeExpr {
            if expr.expr is ast.IfExpr {
                return
            }
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.IfExpr {
            collect_generic_param_member_requirements_from_expr(expr.cond, value_names, mut
                required_fields, mut required_methods)
            collect_generic_param_member_requirements_from_stmts(expr.stmts, value_names, mut
                required_fields, mut required_methods)
            if expr.else_expr !is ast.EmptyExpr {
                collect_generic_param_member_requirements_from_expr(expr.else_expr, value_names, mut
                    required_fields, mut required_methods)
            }
        }
        ast.IndexExpr {
            collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                required_fields, mut required_methods)
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.InfixExpr {
            collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                required_fields, mut required_methods)
            collect_generic_param_member_requirements_from_expr(expr.rhs, value_names, mut
                required_fields, mut required_methods)
        }
        ast.MatchExpr {
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
            for branch in expr.branches {
                for cond in branch.cond {
                    collect_generic_param_member_requirements_from_expr(cond, value_names, mut
                        required_fields, mut required_methods)
                }
                collect_generic_param_member_requirements_from_stmts(branch.stmts, value_names, mut
                    required_fields, mut required_methods)
            }
        }
        ast.ModifierExpr {
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.OrExpr {
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
            collect_generic_param_member_requirements_from_stmts(expr.stmts, value_names, mut
                required_fields, mut required_methods)
        }
        ast.ParenExpr {
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.PostfixExpr {
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.PrefixExpr {
            collect_generic_param_member_requirements_from_expr(expr.expr, value_names, mut
                required_fields, mut required_methods)
        }
        ast.SelectorExpr {
            if is_comptime_selector_rhs_name(expr.rhs.name) {
                collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                    required_fields, mut required_methods)
                return
            }
            if expr.lhs is ast.Ident && (expr.lhs as ast.Ident).name in value_names {
                required_fields[expr.rhs.name] = true
            }
            collect_generic_param_member_requirements_from_expr(expr.lhs, value_names, mut
                required_fields, mut required_methods)
        }
        ast.Tuple {
            for item in expr.exprs {
                collect_generic_param_member_requirements_from_expr(item, value_names, mut
                    required_fields, mut required_methods)
            }
        }
        ast.UnsafeExpr {
            collect_generic_param_member_requirements_from_stmts(expr.stmts, value_names, mut
                required_fields, mut required_methods)
        }
        else {}
    }
}

fn collect_generic_param_operator_requirements_from_stmts(stmts []ast.Stmt, mut value_names map[string]bool, container_names map[string]bool, mut required_ops map[string]bool) {
    for stmt in stmts {
        match stmt {
            ast.AssignStmt {
                for expr in stmt.rhs {
                    collect_generic_param_operator_requirements_from_expr(expr, value_names,
                        container_names, mut required_ops)
                }
                if stmt.op == .plus_assign {
                    for expr in stmt.lhs {
                        if generic_expr_is_generic_value(expr, value_names, container_names) {
                            required_ops['add'] = true
                        }
                    }
                    for expr in stmt.rhs {
                        if generic_expr_is_generic_value(expr, value_names, container_names) {
                            required_ops['add'] = true
                        }
                    }
                }
                for i, lhs in stmt.lhs {
                    lhs_name := generic_wrapped_ident_name(lhs)
                    if lhs_name != '' && i < stmt.rhs.len
                        && generic_expr_is_generic_value(stmt.rhs[i], value_names, container_names) {
                        value_names[lhs_name] = true
                    }
                }
                for expr in stmt.lhs {
                    collect_generic_param_operator_requirements_from_expr(expr, value_names,
                        container_names, mut required_ops)
                }
            }
            ast.BlockStmt {
                collect_generic_param_operator_requirements_from_stmts(stmt.stmts, mut value_names,
                    container_names, mut required_ops)
            }
            ast.ComptimeStmt {
                if stmt.stmt is ast.ExprStmt && stmt.stmt.expr is ast.ComptimeExpr
                    && (stmt.stmt.expr as ast.ComptimeExpr).expr is ast.IfExpr {
                    continue
                }
                collect_generic_param_operator_requirements_from_stmts([stmt.stmt], mut
                    value_names, container_names, mut required_ops)
            }
            ast.DeferStmt {
                collect_generic_param_operator_requirements_from_stmts(stmt.stmts, mut value_names,
                    container_names, mut required_ops)
            }
            ast.ExprStmt {
                collect_generic_param_operator_requirements_from_expr(stmt.expr, value_names,
                    container_names, mut required_ops)
            }
            ast.ForStmt {
                if stmt.init is ast.ForInStmt {
                    for_in := stmt.init as ast.ForInStmt
                    if generic_expr_is_generic_container(for_in.expr, container_names) {
                        if for_in.value is ast.Ident {
                            value_names[(for_in.value as ast.Ident).name] = true
                        } else if for_in.value is ast.ModifierExpr {
                            mod_value := for_in.value as ast.ModifierExpr
                            if mod_value.expr is ast.Ident {
                                value_names[(mod_value.expr as ast.Ident).name] = true
                            }
                        }
                    }
                } else if stmt.init !is ast.EmptyStmt {
                    collect_generic_param_operator_requirements_from_stmts([stmt.init], mut
                        value_names, container_names, mut required_ops)
                }
                collect_generic_param_operator_requirements_from_expr(stmt.cond, value_names,
                    container_names, mut required_ops)
                if stmt.post !is ast.EmptyStmt {
                    collect_generic_param_operator_requirements_from_stmts([stmt.post], mut
                        value_names, container_names, mut required_ops)
                }
                collect_generic_param_operator_requirements_from_stmts(stmt.stmts, mut value_names,
                    container_names, mut required_ops)
            }
            ast.ReturnStmt {
                for expr in stmt.exprs {
                    collect_generic_param_operator_requirements_from_expr(expr, value_names,
                        container_names, mut required_ops)
                }
            }
            else {}
        }
    }
}

fn collect_generic_param_operator_requirements_from_expr(expr ast.Expr, value_names map[string]bool, container_names map[string]bool, mut required_ops map[string]bool) {
    match expr {
        ast.ArrayInitExpr {
            for item in expr.exprs {
                collect_generic_param_operator_requirements_from_expr(item, value_names,
                    container_names, mut required_ops)
            }
        }
        ast.CallExpr {
            collect_generic_param_operator_requirements_from_expr(expr.lhs, value_names,
                container_names, mut required_ops)
            for arg in expr.args {
                collect_generic_param_operator_requirements_from_expr(arg, value_names,
                    container_names, mut required_ops)
            }
        }
        ast.CallOrCastExpr {
            collect_generic_param_operator_requirements_from_expr(expr.lhs, value_names,
                container_names, mut required_ops)
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.ComptimeExpr {
            if expr.expr is ast.IfExpr {
                return
            }
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.IfExpr {
            collect_generic_param_operator_requirements_from_expr(expr.cond, value_names,
                container_names, mut required_ops)
            mut branch_value_names := value_names.clone()
            collect_generic_param_operator_requirements_from_stmts(expr.stmts, mut
                branch_value_names, container_names, mut required_ops)
            if expr.else_expr !is ast.EmptyExpr {
                collect_generic_param_operator_requirements_from_expr(expr.else_expr, value_names,
                    container_names, mut required_ops)
            }
        }
        ast.IndexExpr {
            collect_generic_param_operator_requirements_from_expr(expr.lhs, value_names,
                container_names, mut required_ops)
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.InfixExpr {
            if expr.op in [.lt, .le, .gt, .ge]
                && (generic_expr_is_generic_value(expr.lhs, value_names, container_names)
                || generic_expr_is_generic_value(expr.rhs, value_names, container_names)) {
                required_ops['ordered'] = true
            }
            if expr.op == .plus
                && (generic_expr_is_generic_value(expr.lhs, value_names, container_names)
                || generic_expr_is_generic_value(expr.rhs, value_names, container_names)) {
                required_ops['add'] = true
            }
            if expr.op in [.minus, .mul, .div, .mod]
                && (generic_expr_is_generic_value(expr.lhs, value_names, container_names)
                || generic_expr_is_generic_value(expr.rhs, value_names, container_names)) {
                required_ops['numeric'] = true
            }
            collect_generic_param_operator_requirements_from_expr(expr.lhs, value_names,
                container_names, mut required_ops)
            collect_generic_param_operator_requirements_from_expr(expr.rhs, value_names,
                container_names, mut required_ops)
        }
        ast.MatchExpr {
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
            for branch in expr.branches {
                for cond in branch.cond {
                    collect_generic_param_operator_requirements_from_expr(cond, value_names,
                        container_names, mut required_ops)
                }
                mut branch_value_names := value_names.clone()
                collect_generic_param_operator_requirements_from_stmts(branch.stmts, mut
                    branch_value_names, container_names, mut required_ops)
            }
        }
        ast.ModifierExpr {
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.OrExpr {
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
            mut or_value_names := value_names.clone()
            collect_generic_param_operator_requirements_from_stmts(expr.stmts, mut or_value_names,
                container_names, mut required_ops)
        }
        ast.ParenExpr {
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.PostfixExpr {
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.PrefixExpr {
            collect_generic_param_operator_requirements_from_expr(expr.expr, value_names,
                container_names, mut required_ops)
        }
        ast.SelectorExpr {
            collect_generic_param_operator_requirements_from_expr(expr.lhs, value_names,
                container_names, mut required_ops)
        }
        ast.Tuple {
            for item in expr.exprs {
                collect_generic_param_operator_requirements_from_expr(item, value_names,
                    container_names, mut required_ops)
            }
        }
        ast.UnsafeExpr {
            mut unsafe_value_names := value_names.clone()
            collect_generic_param_operator_requirements_from_stmts(expr.stmts, mut
                unsafe_value_names, container_names, mut required_ops)
        }
        else {}
    }
}

fn generic_expr_is_generic_container(expr ast.Expr, container_names map[string]bool) bool {
    if expr is ast.Ident {
        return expr.name in container_names
    }
    if expr is ast.IndexExpr {
        return generic_expr_is_generic_container(expr.lhs, container_names)
    }
    if expr is ast.ParenExpr {
        return generic_expr_is_generic_container(expr.expr, container_names)
    }
    return false
}

fn generic_wrapped_ident_name(expr ast.Expr) string {
    match expr {
        ast.Ident {
            return expr.name
        }
        ast.ModifierExpr {
            return generic_wrapped_ident_name(expr.expr)
        }
        ast.ParenExpr {
            return generic_wrapped_ident_name(expr.expr)
        }
        else {}
    }

    return ''
}

fn generic_wrapped_ident_name_cursor(expr ast.Cursor) string {
    if !expr.is_valid() {
        return ''
    }
    match expr.kind() {
        .expr_ident {
            return expr.name()
        }
        .expr_modifier, .expr_paren {
            return generic_wrapped_ident_name_cursor(expr.edge(0))
        }
        else {}
    }

    return ''
}

fn generic_expr_is_generic_value(expr ast.Expr, value_names map[string]bool, container_names map[string]bool) bool {
    match expr {
        ast.Ident {
            return expr.name in value_names
        }
        ast.IndexExpr {
            if generic_expr_is_generic_container(expr.lhs, container_names) {
                return true
            }
            return generic_expr_is_generic_value(expr.lhs, value_names, container_names)
        }
        ast.CallExpr {
            for arg in expr.args {
                if generic_expr_is_generic_value(arg, value_names, container_names) {
                    return true
                }
            }
        }
        ast.CallOrCastExpr {
            return generic_expr_is_generic_value(expr.expr, value_names, container_names)
        }
        ast.CastExpr {
            return generic_expr_is_generic_value(expr.expr, value_names, container_names)
        }
        ast.ModifierExpr {
            return generic_expr_is_generic_value(expr.expr, value_names, container_names)
        }
        ast.ParenExpr {
            return generic_expr_is_generic_value(expr.expr, value_names, container_names)
        }
        ast.PrefixExpr {
            return generic_expr_is_generic_value(expr.expr, value_names, container_names)
        }
        else {}
    }

    return false
}

fn generic_fallback_type_supports_ordered(concrete types.Type) bool {
    match concrete {
        types.Alias {
            return generic_fallback_type_supports_ordered(concrete.base_type)
        }
        types.Primitive {
            return concrete.props.has(.integer) || concrete.props.has(.float)
        }
        types.Char, types.Enum, types.ISize, types.Rune, types.String, types.USize {
            return true
        }
        else {}
    }

    return false
}

fn generic_fallback_type_supports_add(concrete types.Type) bool {
    match concrete {
        types.Alias {
            return generic_fallback_type_supports_add(concrete.base_type)
        }
        types.Primitive {
            return concrete.props.has(.integer) || concrete.props.has(.float)
        }
        types.Char, types.ISize, types.Rune, types.String, types.USize {
            return true
        }
        else {}
    }

    return false
}

fn generic_fallback_type_supports_numeric(concrete types.Type) bool {
    match concrete {
        types.Alias {
            return generic_fallback_type_supports_numeric(concrete.base_type)
        }
        types.Primitive {
            return concrete.props.has(.integer) || concrete.props.has(.float)
        }
        types.Char, types.ISize, types.Rune, types.USize {
            return true
        }
        else {}
    }

    return false
}

fn (mut g Gen) generic_fallback_struct_type(concrete types.Type) ?types.Struct {
    match concrete {
        types.Struct {
            c_name := g.types_type_to_c(concrete).trim_space().trim_right('*')
            full_struct_type := g.lookup_struct_type_by_c_name(c_name)
            if full_struct_type.fields.len > 0 || full_struct_type.embedded.len > 0 {
                return full_struct_type
            }
            return concrete
        }
        types.Alias {
            return g.generic_fallback_struct_type(concrete.base_type)
        }
        types.Pointer {
            return g.generic_fallback_struct_type(concrete.base_type)
        }
        else {}
    }

    return none
}

fn (mut g Gen) generic_fallback_type_has_field(concrete types.Type, field_name string) bool {
    struct_type := g.generic_fallback_struct_type(concrete) or { return false }
    for field in struct_type.fields {
        if field.name == field_name {
            return true
        }
    }
    for embedded in struct_type.embedded {
        if g.generic_fallback_type_has_field(types.Type(embedded), field_name) {
            return true
        }
    }
    return false
}

fn (mut g Gen) generic_fallback_type_has_method(concrete types.Type, method_name string) bool {
    if g.env == unsafe { nil } {
        concrete_c_name := g.types_type_to_c(concrete).trim_space().trim_right('*')
        if _ := g.resolve_method_on_concrete_type(concrete_c_name, method_name) {
            return true
        }
        return false
    }
    struct_type := g.generic_fallback_struct_type(concrete) or { return false }
    mut names := []string{}
    if struct_type.name != '' {
        names << struct_type.name
        if struct_type.name.contains('__') {
            names << struct_type.name.all_after_last('__')
        }
    }
    for type_name in names {
        if _ := g.env.lookup_method(type_name, method_name) {
            return true
        }
        if _ := g.resolve_method_on_concrete_type(type_name, method_name) {
            return true
        }
    }
    concrete_c_name := g.types_type_to_c(concrete).trim_space().trim_right('*')
    if _ := g.resolve_method_on_concrete_type(concrete_c_name, method_name) {
        return true
    }
    for embedded in struct_type.embedded {
        if g.generic_fallback_type_has_method(types.Type(embedded), method_name) {
            return true
        }
    }
    return false
}

fn generic_params_are_single_t(generic_params []string) bool {
    return generic_params.len == 1 && generic_params[0] == 'T'
}

fn (g &Gen) is_stdatomic_atomic_val_method(node ast.FnDecl, generic_params []string) bool {
    // AtomicVal[T] is emitted as one fallback struct in V2 for now. Restrict its
    // receiver methods to the same integer binding used by the struct body, so
    // calls like AtomicVal[int].add() do not fall through to the f64 `$else`
    // branch and panic as unreachable.
    return g.cur_module == 'stdatomic' && node.is_method
        && generic_params_are_single_t(generic_params)
        && node.name in ['load', 'store', 'add', 'sub', 'swap', 'compare_and_swap']
}

fn is_json2_runtime_internal_type(concrete types.Type) bool {
    match concrete {
        types.Struct {
            return concrete.name in ['array', 'map', 'DenseArray']
        }
        types.Alias {
            if concrete.name in ['MapHashFn', 'MapEqFn', 'MapCloneFn', 'MapFreeFn'] {
                return true
            }
            return is_json2_runtime_internal_type(concrete.base_type)
        }
        types.FnType {
            return true
        }
        else {}
    }

    return false
}

// build_generic_spec_index precomputes a reverse index from function names
// to matching keys in env.generic_types. This avoids O(n*m) iteration
// in generic_fn_specializations (called per generic fn per file).
fn (mut g Gen) build_generic_spec_index() {
    g.generic_spec_index = map[string][]string{}
    if g.env == unsafe { nil } {
        return
    }
    // Index both env.generic_types and late_generic_specs keys
    mut all_keys := map[string]bool{}
    for key, _ in g.env.generic_types {
        all_keys[key] = true
    }
    for key, _ in g.late_generic_specs {
        all_keys[key] = true
    }
    for key, _ in all_keys {
        // Extract the base function name from the key.
        // Keys can be: "fn_name", "fn_name[T]", "module.fn_name[T]"
        mut fn_name := key
        bracket_idx := key.index_u8(`[`)
        if bracket_idx > 0 {
            fn_name = key[..bracket_idx]
        }
        // If qualified (contains '.'), also index by the short name
        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 {
                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 {
                g.generic_spec_index[short_name] << key
            }
        }
        g.generic_spec_index[fn_name] << key
    }
}

fn (g &Gen) late_generic_spec_count() int {
    mut count := 0
    for _, specs in g.late_generic_specs {
        count += specs.len
    }
    return count
}

fn (mut g Gen) discover_nested_generic_specs() {
    if g.env == unsafe { nil } {
        return
    }
    mut scanned_specs := map[string]bool{}
    for _ in 0 .. 8 {
        g.build_generic_spec_index()
        before := g.late_generic_spec_count()
        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 {
                        g.discover_nested_generic_specs_for_cursor(stmt, mut scanned_specs)
                    }
                }
            }
        } else {
            for file in g.files {
                g.set_file_module(file)
                for stmt in file.stmts {
                    if stmt is ast.FnDecl {
                        g.discover_nested_generic_specs_for_decl(stmt, mut scanned_specs)
                    }
                }
            }
        }
        if g.late_generic_spec_count() == before {
            break
        }
    }
    g.build_generic_spec_index()
}

fn (mut g Gen) discover_nested_generic_specs_for_cursor(stmt ast.Cursor, mut scanned_specs map[string]bool) {
    decl := stmt.fn_decl_signature()
    if !g.should_emit_fn_decl_cached(g.cur_module, decl) {
        return
    }
    if g.generic_fn_param_names(decl).len == 0 {
        return
    }
    if stmt.list_at(3).len() == 0 {
        return
    }
    specs := if fn_cursor_has_comptime_stmt(stmt) || g.fn_cursor_body_has_generic_call(stmt) {
        g.generic_fn_specializations(decl)
    } else {
        g.direct_generic_fn_specializations(decl)
    }
    g.discover_nested_generic_specs_from_body_source(decl, stmt, true, specs, mut scanned_specs)
}

fn (mut g Gen) discover_nested_generic_specs_for_decl(decl ast.FnDecl, mut scanned_specs map[string]bool) {
    if !g.should_emit_fn_decl_cached(g.cur_module, decl) {
        return
    }
    if g.generic_fn_param_names(decl).len == 0 {
        return
    }
    specs := if fn_has_comptime_stmt(decl) || g.fn_body_has_generic_call(decl) {
        g.generic_fn_specializations(decl)
    } else {
        g.direct_generic_fn_specializations(decl)
    }
    g.discover_nested_generic_specs_from_body_source(decl, ast.Cursor{}, false, specs, mut
        scanned_specs)
}

fn (mut g Gen) discover_nested_generic_specs_from_body_source(decl ast.FnDecl, body_cursor ast.Cursor, use_cursor bool, specs []GenericFnSpecialization, mut scanned_specs map[string]bool) {
    if specs.len == 0 {
        return
    }
    prev_fn_name := g.cur_fn_name
    prev_fn_c_name := g.cur_fn_c_name
    prev_fn_scope := g.cur_fn_scope
    mut prev_active_generic_types := g.active_generic_types.clone()
    mut prev_runtime_local_types := g.runtime_local_types.clone()
    mut prev_runtime_decl_types := g.runtime_decl_types.clone()
    mut prev_not_local_var_cache := g.not_local_var_cache.clone()
    mut prev_is_module_ident_cache := g.is_module_ident_cache.clone()
    mut prev_resolved_module_names := g.resolved_module_names.clone()
    mut prev_cur_fn_generic_params := g.cur_fn_generic_params.clone()
    scope_fn_name := if decl.is_method {
        v_type_name := g.receiver_type_to_scope_name(decl.receiver.typ)
        if v_type_name != '' {
            '${v_type_name}__${decl.name}'
        } else {
            decl.name
        }
    } else {
        decl.name
    }
    for spec in specs {
        scan_key := '${g.cur_module}.${scope_fn_name}:${spec.name}'
        if scan_key in scanned_specs {
            continue
        }
        scanned_specs[scan_key] = true
        g.cur_fn_name = decl.name
        g.cur_fn_c_name = spec.name
        g.cur_fn_scope = unsafe { nil }
        if fn_scope := g.env.get_fn_scope(g.cur_module, scope_fn_name) {
            g.cur_fn_scope = fn_scope
        }
        g.active_generic_types = spec.generic_types.clone()
        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.seed_fn_scan_runtime_types(decl, spec.name)
        g.scan_fn_body_for_generic_types_from_source(decl, body_cursor, use_cursor, spec.name)
    }
    g.cur_fn_name = prev_fn_name
    g.cur_fn_c_name = prev_fn_c_name
    g.cur_fn_scope = prev_fn_scope
    g.active_generic_types = prev_active_generic_types.move()
    g.runtime_local_types = prev_runtime_local_types.move()
    g.runtime_decl_types = prev_runtime_decl_types.move()
    g.not_local_var_cache = prev_not_local_var_cache.move()
    g.is_module_ident_cache = prev_is_module_ident_cache.move()
    g.resolved_module_names = prev_resolved_module_names.move()
    g.cur_fn_generic_params = prev_cur_fn_generic_params.move()
}

fn (mut g Gen) discover_direct_generic_call_specs() {
    if g.env == unsafe { nil } {
        return
    }
    g.build_generic_spec_index()
    before := g.late_generic_spec_count()
    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 {
                    g.discover_direct_generic_call_specs_for_cursor(stmt)
                }
            }
        }
    } else {
        for file in g.files {
            g.set_file_module(file)
            for stmt in file.stmts {
                if stmt is ast.FnDecl {
                    g.discover_direct_generic_call_specs_for_decl(stmt)
                }
            }
        }
    }
    if g.late_generic_spec_count() != before {
        g.build_generic_spec_index()
    }
}

fn (mut g Gen) discover_direct_generic_call_specs_for_cursor(stmt ast.Cursor) {
    decl := stmt.fn_decl_signature()
    if !g.should_emit_fn_decl_cached(g.cur_module, decl) {
        return
    }
    if g.generic_fn_param_names(decl).len != 0 {
        return
    }
    if stmt.list_at(3).len() == 0 {
        return
    }
    g.discover_direct_generic_call_specs_from_body_source(decl, stmt, true)
}

fn (mut g Gen) discover_direct_generic_call_specs_for_decl(decl ast.FnDecl) {
    if !g.should_emit_fn_decl_cached(g.cur_module, decl) {
        return
    }
    if g.generic_fn_param_names(decl).len != 0 {
        return
    }
    g.discover_direct_generic_call_specs_from_body_source(decl, ast.Cursor{}, false)
}

fn (mut g Gen) discover_direct_generic_call_specs_from_body_source(decl ast.FnDecl, body_cursor ast.Cursor, use_cursor bool) {
    prev_fn_name := g.cur_fn_name
    prev_fn_c_name := g.cur_fn_c_name
    prev_fn_scope := g.cur_fn_scope
    mut prev_active_generic_types := g.active_generic_types.clone()
    mut prev_runtime_local_types := g.runtime_local_types.clone()
    mut prev_runtime_decl_types := g.runtime_decl_types.clone()
    mut prev_not_local_var_cache := g.not_local_var_cache.clone()
    mut prev_is_module_ident_cache := g.is_module_ident_cache.clone()
    mut prev_resolved_module_names := g.resolved_module_names.clone()
    mut prev_cur_fn_generic_params := g.cur_fn_generic_params.clone()
    scope_fn_name := if decl.is_method {
        v_type_name := g.receiver_type_to_scope_name(decl.receiver.typ)
        if v_type_name != '' {
            '${v_type_name}__${decl.name}'
        } else {
            decl.name
        }
    } else {
        decl.name
    }
    g.cur_fn_name = decl.name
    g.cur_fn_c_name = g.get_fn_name(decl)
    g.cur_fn_scope = unsafe { nil }
    if fn_scope := g.env.get_fn_scope(g.cur_module, scope_fn_name) {
        g.cur_fn_scope = fn_scope
    }
    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.seed_fn_scan_runtime_types(decl, g.cur_fn_c_name)
    g.scan_fn_body_for_generic_types_from_source(decl, body_cursor, use_cursor, 'direct')
    g.cur_fn_name = prev_fn_name
    g.cur_fn_c_name = prev_fn_c_name
    g.cur_fn_scope = prev_fn_scope
    g.active_generic_types = prev_active_generic_types.move()
    g.runtime_local_types = prev_runtime_local_types.move()
    g.runtime_decl_types = prev_runtime_decl_types.move()
    g.not_local_var_cache = prev_not_local_var_cache.move()
    g.is_module_ident_cache = prev_is_module_ident_cache.move()
    g.resolved_module_names = prev_resolved_module_names.move()
    g.cur_fn_generic_params = prev_cur_fn_generic_params.move()
}

fn (mut g Gen) seed_fn_scan_runtime_types(node ast.FnDecl, fn_name string) {
    if node.is_method && !node.is_static && node.receiver.name != '' {
        mut receiver_type := ''
        if sig_param_types := g.fn_param_types[fn_name] {
            if sig_param_types.len > 0 {
                receiver_type = normalize_signature_type_name(sig_param_types[0], '')
            }
        }
        if receiver_type == '' {
            receiver_type = g.expr_type_to_c(node.receiver.typ)
        }
        if receiver_type != '' {
            g.remember_runtime_local_type(node.receiver.name, receiver_type)
        }
    }
    mut param_ptr_offset := 0
    if node.is_method && !node.is_static && node.receiver.name != '' {
        if sig_param_types := g.fn_param_types[fn_name] {
            if sig_param_types.len >= node.typ.params.len + 1 {
                param_ptr_offset = 1
            }
        } else if !node.is_static {
            param_ptr_offset = 1
        }
    }
    if g.needs_implicit_veb_ctx_param(&node, fn_name) {
        ctx_type := g.implicit_veb_ctx_c_type()
        g.remember_runtime_local_type('ctx', ctx_type)
        param_ptr_offset++
    }
    for param_idx, param in node.typ.params {
        mut param_type := g.fn_param_signature_c_type(param)
        mut param_is_ptr := param.is_mut
        if sig_param_types := g.fn_param_types[fn_name] {
            sig_idx := param_idx + param_ptr_offset
            if sig_idx < sig_param_types.len {
                sig_type := normalize_signature_type_name(sig_param_types[sig_idx], '')
                if sig_type != '' {
                    param_type = sig_type
                    if sig_type.ends_with('*') {
                        param_is_ptr = true
                    }
                }
            }
        }
        if param_type != '' && param.name != '' {
            ptype := if param_is_ptr && !param_type.ends_with('*') {
                param_type + '*'
            } else {
                param_type
            }
            g.remember_runtime_local_type(param.name, ptype)
            if param.name == 'array' {
                g.remember_runtime_local_type('_v_array', ptype)
            }
        }
        placeholder := direct_generic_placeholder_name(param.typ)
        if placeholder != '' {
            g.cur_fn_generic_params[param.name] = placeholder
        }
    }
}

fn generic_param_names(params []ast.Expr) []string {
    mut seen := map[string]bool{}
    mut names := []string{}
    for param in params {
        collect_generic_placeholder_names_from_expr(param, mut seen, mut names)
    }
    return names
}

fn (g &Gen) fallback_generic_bindings_for_names(param_names []string) ?map[string]types.Type {
    if param_names.len == 0 || g.env == unsafe { nil } {
        return none
    }
    mut bindings := map[string]types.Type{}
    for param_name in param_names {
        mut found := false
        for _, generic_maps in g.env.generic_types {
            for generic_types in generic_maps {
                concrete := generic_types[param_name] or { continue }
                if concrete.name() == param_name || type_contains_generic_placeholder(concrete) {
                    continue
                }
                if !g.generic_concrete_type_is_runtime_specializable(concrete) {
                    continue
                }
                if !g.generic_specialization_belongs_to_emit_modules({
                    param_name: concrete
                }) {
                    continue
                }
                bindings[param_name] = concrete
                found = true
                break
            }
            if found {
                break
            }
        }
        if !found {
            return none
        }
    }
    return bindings
}

fn (mut g Gen) direct_generic_fn_specializations(node ast.FnDecl) []GenericFnSpecialization {
    return g.generic_fn_specializations_with_fallback(node, false)
}

fn (mut g Gen) generic_fn_specializations(node ast.FnDecl) []GenericFnSpecialization {
    return g.generic_fn_specializations_with_fallback(node, true)
}

fn (mut g Gen) generic_fn_specializations_for_emit_scope(node ast.FnDecl) []GenericFnSpecialization {
    mut specs := if g.emit_files.len == 0 {
        g.generic_fn_specializations(node)
    } else {
        g.direct_generic_fn_specializations(node)
    }
    mut seen := map[string]bool{}
    for spec in specs {
        seen[spec.name] = true
    }
    mut needed_names := g.called_fn_names.clone()
    for spec in g.late_generic_fn_specializations(node) {
        needed_names[spec.name] = true
        if spec.name in seen {
            continue
        }
        seen[spec.name] = true
        specs << spec
    }
    generic_params := g.generic_fn_param_names(node)
    if needed_names.len > 0 && generic_params.len > 0 {
        mut prev_generic_types := g.active_generic_types.move()
        g.active_generic_types = map[string]types.Type{}
        base_name := g.get_fn_name(node)
        g.active_generic_types = prev_generic_types.move()
        prefix := '${base_name}_T_'
        for called_name, _ in needed_names {
            if !called_name.starts_with(prefix) || called_name in seen {
                continue
            }
            generic_types := g.generic_types_from_specialized_fn_name(node, called_name) or {
                continue
            }
            seen[called_name] = true
            specs << GenericFnSpecialization{
                name:          called_name
                generic_types: generic_types.clone()
            }
        }
    }
    return specs
}

fn (mut g Gen) generic_fn_specializations_for_emit_scope_with_receiver_bindings(node ast.FnDecl) []GenericFnSpecialization {
    specs := g.generic_fn_specializations_for_emit_scope(node)
    recv_params := receiver_generic_param_names(node)
    if recv_params.len == 0 {
        return specs
    }
    mut receiver_bindings := g.get_all_receiver_generic_bindings(node)
    if receiver_bindings.len == 0 {
        if bindings := g.get_receiver_generic_bindings(node) {
            receiver_bindings << bindings
        }
    }
    if receiver_bindings.len == 0 {
        return specs
    }
    mut out := []GenericFnSpecialization{}
    mut seen := map[string]bool{}
    for spec in specs {
        for bindings in receiver_bindings {
            mut generic_types := bindings.clone()
            for param_name, concrete in spec.generic_types {
                generic_types[param_name] = concrete
            }
            name := g.specialized_fn_name(node, generic_types)
            if name == '' || name in seen {
                continue
            }
            seen[name] = true
            out << GenericFnSpecialization{
                name:          name
                generic_types: generic_types.clone()
            }
        }
    }
    if out.len == 0 {
        return specs
    }
    return out
}

fn (mut g Gen) generic_fn_specializations_with_fallback(node ast.FnDecl, include_fallback bool) []GenericFnSpecialization {
    generic_params := g.generic_fn_param_names(node)
    if generic_params.len == 0 || g.env == unsafe { nil } {
        return []GenericFnSpecialization{}
    }
    mut specs := []GenericFnSpecialization{}
    mut seen := map[string]bool{}
    // Use precomputed index for O(1) lookup instead of iterating all generic types.
    matching_keys := g.generic_spec_index[node.name]
    for key in matching_keys {
        if !g.generic_key_matches_decl(node, key) {
            continue
        }
        // Merge env specs and late-discovered comptime specs for this key
        mut all_maps := g.env.generic_types[key].clone()
        for late_spec in g.late_generic_specs[key] {
            all_maps << late_spec
        }
        for generic_types in all_maps {
            mut skip_spec := false
            mut normalized_generic_types := generic_types.clone()
            for param_name in generic_params {
                concrete0 := generic_types[param_name] or {
                    skip_spec = true
                    break
                }
                concrete := normalize_generic_concrete_type(concrete0)
                normalized_generic_types[param_name] = concrete
                // `void` can be discovered from dereferencing `voidptr` in
                // comptime-generic code, but a C value parameter of type `void`
                // is invalid. Keep `voidptr` specializations, skip only true void.
                if concrete.name() == 'void' || concrete.name() == param_name
                    || type_contains_generic_placeholder(concrete)
                    || !g.generic_concrete_type_is_runtime_specializable(concrete) {
                    skip_spec = true
                    break
                }
            }
            if skip_spec
                || !g.generic_specialization_belongs_to_emit_modules(normalized_generic_types) {
                continue
            }
            mut body_requirements_satisfied := true
            for param_name in generic_params {
                concrete := normalized_generic_types[param_name] or { continue }
                param_ok := g.generic_fallback_type_satisfies_body_requirements_for_param(node,
                    param_name, concrete, 0)
                if !param_ok {
                    body_requirements_satisfied = false
                    break
                }
            }
            if !body_requirements_satisfied {
                continue
            }
            spec_name := g.specialized_fn_name(node, normalized_generic_types)
            if spec_name == '' || spec_name in seen {
                continue
            }
            seen[spec_name] = true
            specs << GenericFnSpecialization{
                name:          spec_name
                generic_types: normalized_generic_types.clone()
            }
        }
    }
    if g.cur_module == 'json2' && node.is_method && node.name == 'decode_string'
        && generic_params_are_single_t(generic_params) {
        generic_types := {
            'T': types.Type(types.string_)
        }
        spec_name := g.specialized_fn_name(node, generic_types)
        if spec_name != '' && spec_name !in seen {
            seen[spec_name] = true
            specs << GenericFnSpecialization{
                name:          spec_name
                generic_types: generic_types.clone()
            }
        }
    }
    if g.is_stdatomic_atomic_val_method(node, generic_params) {
        generic_types := {
            'T': types.Type(types.int_)
        }
        spec_name := g.specialized_fn_name(node, generic_types)
        if spec_name != '' && spec_name !in seen {
            seen[spec_name] = true
            specs << GenericFnSpecialization{
                name:          spec_name
                generic_types: generic_types.clone()
            }
        }
        return specs
    }
    use_json2_decode_fallback := g.cur_module == 'json2'
        && generic_params_are_single_t(generic_params)
        && ((!node.is_method && node.name in ['decode_struct_key', 'check_required_struct_fields'])
        || (node.is_method && node.name in ['decode_value', 'cached_struct_field_infos']))
    use_json2_encode_fallback := g.cur_module == 'json2'
        && generic_params_are_single_t(generic_params)
        && ((!node.is_method && node.name == 'encode') || (node.is_method
        && node.name in ['encode_value', 'encode_struct_fields', 'cached_field_infos']))
    use_json2_encode_helper_fallback := g.cur_module == 'json2'
        && generic_params_are_single_t(generic_params)
        && ((!node.is_method && node.name == 'enum_uses_json_as_number')
        || (node.is_method && node.name == 'encode_number'))
    use_json2_fallback := use_json2_decode_fallback || use_json2_encode_fallback
        || use_json2_encode_helper_fallback
    if generic_params.len == 0 || !include_fallback {
        return specs
    }
    if !use_json2_fallback {
        return specs
    }
    // Fallback: nested generic helpers inside another specialized generic function
    // may only record placeholder bindings like `T -> T` in env.generic_types.
    // Reuse concrete bindings seen for the same generic parameter names elsewhere.
    if generic_params.len == 1 {
        param_name := generic_params[0]
        mut fallback_types := map[string]types.Type{}
        allow_direct_bound_fallback := generic_param_accepts_direct_fallback_binding(node,
            param_name)
        if use_json2_decode_fallback {
            g.add_json2_decode_root_fallback_types(mut fallback_types)
            if node.is_method && node.name == 'cached_struct_field_infos' {
                g.add_json2_fallback_types_from_specialized_fns(mut fallback_types, [
                    'json2__Decoder__decode_value_T_',
                ])
            }
        } else if use_json2_encode_fallback {
            g.add_json2_encode_root_fallback_types(mut fallback_types)
            if node.is_method && node.name == 'cached_field_infos' {
                g.add_json2_fallback_types_from_specialized_fns(mut fallback_types, [
                    'json2__Encoder__encode_value_T_',
                    'json2__Encoder__encode_struct_fields_T_',
                ])
            }
        } else if use_json2_encode_helper_fallback {
            if node.is_method && node.name == 'encode_number' {
                add_json2_encode_number_fallback_types(mut fallback_types)
            } else {
                g.add_json2_encode_enum_fallback_types(mut fallback_types)
            }
        } else {
            for _, generic_maps in g.env.generic_types {
                for generic_types in generic_maps {
                    for _, concrete0 in generic_types {
                        concrete := normalize_generic_concrete_type(concrete0)
                        if derived := generic_container_fallback_type(node, param_name, concrete) {
                            if derived.name() != param_name
                                && !type_contains_generic_placeholder(derived)
                                && generic_concrete_type_is_runtime_specializable(derived)
                                && g.accepts_broad_generic_fallback_type(node, derived) {
                                fallback_types[derived.name()] = derived
                            }
                        }
                    }
                    if allow_direct_bound_fallback {
                        if bound_concrete := generic_types[param_name] {
                            concrete := normalize_generic_concrete_type(bound_concrete)
                            if concrete.name() == param_name
                                || type_contains_generic_placeholder(concrete)
                                || !g.generic_concrete_type_is_runtime_specializable(concrete) {
                                continue
                            }
                            if !g.accepts_broad_generic_fallback_type(node, concrete) {
                                continue
                            }
                            fallback_types[concrete.name()] = concrete
                        }
                    }
                }
            }
            // Also include late-discovered comptime specs
            for _, late_maps in g.late_generic_specs {
                for late_spec in late_maps {
                    for _, concrete0 in late_spec {
                        concrete := normalize_generic_concrete_type(concrete0)
                        if derived := generic_container_fallback_type(node, param_name, concrete) {
                            if derived.name() != param_name
                                && !type_contains_generic_placeholder(derived)
                                && generic_concrete_type_is_runtime_specializable(derived)
                                && g.accepts_broad_generic_fallback_type(node, derived) {
                                fallback_types[derived.name()] = derived
                            }
                        }
                    }
                    if allow_direct_bound_fallback {
                        if bound_concrete := late_spec[param_name] {
                            concrete := normalize_generic_concrete_type(bound_concrete)
                            if concrete.name() == param_name
                                || type_contains_generic_placeholder(concrete)
                                || !g.generic_concrete_type_is_runtime_specializable(concrete) {
                                continue
                            }
                            if !g.accepts_broad_generic_fallback_type(node, concrete) {
                                continue
                            }
                            fallback_types[concrete.name()] = concrete
                        }
                    }
                }
            }
        }
        if g.cur_module == 'json2' && node.is_method
            && node.name in ['encode_value', 'encode_struct_fields'] && param_name == 'T' {
            add_json2_encode_value_nested_fallback_types(mut fallback_types)
        }
        for _, concrete in fallback_types {
            if !g.generic_concrete_type_is_runtime_specializable(concrete) {
                continue
            }
            if !g.accepts_broad_generic_fallback_type(node, concrete) {
                continue
            }
            generic_types := {
                param_name: concrete
            }
            if !g.generic_specialization_belongs_to_emit_modules(generic_types) {
                continue
            }
            spec_name := g.specialized_fn_name(node, generic_types)
            if spec_name == '' || spec_name in seen {
                continue
            }
            seen[spec_name] = true
            specs << GenericFnSpecialization{
                name:          spec_name
                generic_types: generic_types.clone()
            }
        }
    }
    if specs.len == 0 && generic_params.len == 1 {
        if bindings := g.fallback_generic_bindings_for_names(generic_params) {
            mut bindings_match_param_shape := true
            for param_name, _ in bindings {
                if !generic_param_accepts_direct_fallback_binding(node, param_name) {
                    bindings_match_param_shape = false
                    break
                }
            }
            if !bindings_match_param_shape {
                return specs
            }
            mut bindings_supported := true
            for _, concrete in bindings {
                if !g.generic_concrete_type_is_runtime_specializable(concrete)
                    || !g.accepts_broad_generic_fallback_type(node, concrete) {
                    bindings_supported = false
                    break
                }
            }
            if bindings_supported && !g.generic_specialization_belongs_to_emit_modules(bindings) {
                bindings_supported = false
            }
            if !bindings_supported {
                return specs
            }
            prev_generic_types := g.active_generic_types.clone()
            g.active_generic_types = bindings.clone()
            spec_name := g.get_fn_name(node)
            g.active_generic_types = prev_generic_types.clone()
            if spec_name != '' && spec_name !in seen {
                seen[spec_name] = true
                specs << GenericFnSpecialization{
                    name:          spec_name
                    generic_types: bindings.clone()
                }
            }
        }
    }
    return specs
}

fn generic_param_accepts_direct_fallback_binding(node ast.FnDecl, param_name string) bool {
    value_names, container_names := generic_param_value_and_container_names(node, param_name)
    return value_names.len > 0 || container_names.len == 0
}

fn (g &Gen) generic_specialization_belongs_to_emit_modules(generic_types map[string]types.Type) bool {
    if g.cache_bundle_name.len == 0 {
        return true
    }
    for _, concrete0 in generic_types {
        concrete := normalize_generic_concrete_type(concrete0)
        c_name := g.types_type_to_c(concrete).trim_space()
        if c_name != '' && !g.generic_concrete_c_name_belongs_to_emit_modules(c_name) {
            return false
        }
    }
    return true
}

fn (g &Gen) module_has_emit_file(module_name string) bool {
    if module_name in g.emit_file_modules {
        return true
    }
    if g.emit_file_modules.len > 0 || g.declared_type_names_in_emit_files.len > 0 {
        return false
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            if flat_file_module_name(fc) != module_name {
                continue
            }
            file_name := fc.name()
            if os.norm_path(file_name) in g.emit_files
                || os.norm_path(os.abs_path(file_name)) in g.emit_files {
                return true
            }
        }
        return false
    }
    for file in g.files {
        if file_module_name(file) != module_name {
            continue
        }
        if os.norm_path(file.name) in g.emit_files
            || os.norm_path(os.abs_path(file.name)) in g.emit_files {
            return true
        }
    }
    return false
}

fn (g &Gen) unqualified_type_name_declared_in_emit_files(name string) bool {
    if name in g.declared_type_names_in_emit_files {
        return true
    }
    if g.emit_file_modules.len > 0 || g.declared_type_names_in_emit_files.len > 0 {
        return false
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            file_name := fc.name()
            if !(os.norm_path(file_name) in g.emit_files
                || os.norm_path(os.abs_path(file_name)) in g.emit_files) {
                continue
            }
            module_name := flat_file_module_name(fc)
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                match stmt.kind() {
                    .stmt_struct_decl, .stmt_enum_decl, .stmt_interface_decl, .stmt_type_decl {
                        if type_decl_name_matches_cache_alias(stmt.name(), module_name, name) {
                            return true
                        }
                    }
                    else {}
                }
            }
        }
        return false
    }
    for file in g.files {
        if !(os.norm_path(file.name) in g.emit_files
            || os.norm_path(os.abs_path(file.name)) in g.emit_files) {
            continue
        }
        module_name := file_module_name(file)
        for stmt in file.stmts {
            match stmt {
                ast.StructDecl {
                    if type_decl_name_matches_cache_alias(stmt.name, module_name, name) {
                        return true
                    }
                }
                ast.EnumDecl {
                    if type_decl_name_matches_cache_alias(stmt.name, module_name, name) {
                        return true
                    }
                }
                ast.InterfaceDecl {
                    if type_decl_name_matches_cache_alias(stmt.name, module_name, name) {
                        return true
                    }
                }
                ast.TypeDecl {
                    if type_decl_name_matches_cache_alias(stmt.name, module_name, name) {
                        return true
                    }
                }
                else {}
            }
        }
    }
    return false
}

fn (g &Gen) generic_concrete_c_name_belongs_to_emit_modules(raw_name string) bool {
    c_name := g.qualify_module_local_generic_c_name(raw_name)
    if !g.alias_type_belongs_to_emit_modules(c_name) {
        return false
    }
    return g.generic_concrete_c_name_has_cache_visible_origin(c_name)
}

fn (g &Gen) generic_concrete_c_name_has_cache_visible_origin(raw_name string) bool {
    mut name := raw_name.trim_space()
    if name == '' {
        return true
    }
    for name.ends_with('*') {
        name = name[..name.len - 1].trim_space()
    }
    if name.starts_with('struct ') {
        name = name['struct '.len..].trim_space()
    }
    if name == '' || name in primitive_types
        || name in ['string', 'array', 'map', 'chan', 'None__', 'IError']
        || is_generic_placeholder_type_name(name) {
        return true
    }
    if name.starts_with('Array_fixed_') {
        rest := name['Array_fixed_'.len..]
        last_underscore := rest.last_index_u8(`_`)
        if last_underscore < 0 {
            return true
        }
        return g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(rest[..last_underscore]))
    }
    if name.starts_with('Array_') {
        return g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(name['Array_'.len..]))
    }
    if name.starts_with('Map_') {
        rest := name['Map_'.len..]
        key, value := g.parse_map_kv_types(rest)
        if key == '' || value == '' {
            return g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(rest))
        }
        return
            g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(key))
            && g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(value))
    }
    if name.starts_with('Tuple_') {
        for part in name['Tuple_'.len..].split('_') {
            if part != ''
                && !g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(part)) {
                return false
            }
        }
        return true
    }
    if name.starts_with('_option_') {
        return g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(name['_option_'.len..]))
    }
    if name.starts_with('_result_') {
        return g.generic_concrete_c_name_has_cache_visible_origin(unmangle_alias_component_to_c(name['_result_'.len..]))
    }
    if name.contains('__') {
        return true
    }
    if name in g.c_struct_types || name in g.typedef_c_types || is_known_external_c_type_name(name) {
        return true
    }
    return g.unqualified_type_name_declared_in_files(name)
}

fn generic_spec_key_short_name(key string) string {
    mut base := key
    bracket_idx := base.index_u8(`[`)
    if bracket_idx >= 0 {
        base = base[..bracket_idx]
    }
    dot_idx := base.last_index_u8(`.`)
    if dot_idx >= 0 && dot_idx < base.len - 1 {
        return base[dot_idx + 1..]
    }
    double_underscore_idx := base.last_index('__') or { -1 }
    if double_underscore_idx >= 0 && double_underscore_idx < base.len - 2 {
        return base[double_underscore_idx + 2..]
    }
    return base
}

fn (mut g Gen) add_json2_decode_root_fallback_types(mut fallback_types map[string]types.Type) {
    if g.env == unsafe { nil } {
        return
    }
    for key, generic_maps in g.env.generic_types {
        if generic_spec_key_short_name(key) !in ['decode', 'decode_value'] {
            continue
        }
        for generic_types in generic_maps {
            if concrete := generic_types['T'] {
                g.add_json2_decode_value_fallback_type(mut fallback_types, concrete)
            }
        }
    }
    for key, late_maps in g.late_generic_specs {
        if generic_spec_key_short_name(key) !in ['decode', 'decode_value'] {
            continue
        }
        for late_spec in late_maps {
            if concrete := late_spec['T'] {
                g.add_json2_decode_value_fallback_type(mut fallback_types, concrete)
            }
        }
    }
    g.add_json2_decode_value_nested_fallback_types(mut fallback_types)
}

fn add_json2_encode_number_fallback_types(mut fallback_types map[string]types.Type) {
    for name in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'usize', 'isize',
        'f32', 'f64'] {
        if concrete := resolve_primitive_type_name(name) {
            fallback_types[concrete.name()] = concrete
        }
    }
}

fn (mut g Gen) add_json2_encode_root_fallback_types(mut fallback_types map[string]types.Type) {
    if g.env == unsafe { nil } {
        return
    }
    for key, generic_maps in g.env.generic_types {
        if generic_spec_key_short_name(key) !in ['encode', 'encode_value'] {
            continue
        }
        for generic_types in generic_maps {
            if concrete := generic_types['T'] {
                add_json2_encode_value_fallback_type(mut fallback_types, concrete)
            }
        }
    }
    for key, late_maps in g.late_generic_specs {
        if generic_spec_key_short_name(key) !in ['encode', 'encode_value'] {
            continue
        }