// 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
        }
        for late_spec in late_maps {
            if concrete := late_spec['T'] {
                add_json2_encode_value_fallback_type(mut fallback_types, concrete)
            }
        }
    }
}

fn (mut g Gen) add_json2_encode_enum_fallback_types(mut fallback_types map[string]types.Type) {
    if g.env == unsafe { nil } {
        return
    }
    for fn_name, _ in g.fn_return_types {
        g.add_json2_encode_enum_fallback_type_from_fn_name(mut fallback_types, fn_name)
    }
    for fn_name, _ in g.called_fn_names {
        g.add_json2_encode_enum_fallback_type_from_fn_name(mut fallback_types, fn_name)
    }
    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)
                concrete_name := concrete.name()
                if concrete is types.Enum {
                    fallback_types[concrete_name] = concrete
                }
            }
        }
    }
    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)
                concrete_name := concrete.name()
                if concrete is types.Enum {
                    fallback_types[concrete_name] = concrete
                }
            }
        }
    }
}

fn (mut g Gen) add_json2_encode_enum_fallback_type_from_fn_name(mut fallback_types map[string]types.Type, fn_name string) {
    prefix := 'json2__Encoder__encode_value_T_'
    if !fn_name.starts_with(prefix) {
        return
    }
    type_name := fn_name[prefix.len..]
    concrete := g.concrete_type_from_c_name(type_name) or { return }
    concrete_name := concrete.name()
    if concrete is types.Enum {
        fallback_types[concrete_name] = concrete
    }
}

fn (mut g Gen) add_json2_fallback_types_from_specialized_fns(mut fallback_types map[string]types.Type, prefixes []string) {
    for fn_name, _ in g.fn_return_types {
        g.add_json2_fallback_type_from_specialized_fn_name(mut fallback_types, fn_name, prefixes)
    }
    for fn_name, _ in g.called_fn_names {
        g.add_json2_fallback_type_from_specialized_fn_name(mut fallback_types, fn_name, prefixes)
    }
}

fn (mut g Gen) add_json2_fallback_type_from_specialized_fn_name(mut fallback_types map[string]types.Type, fn_name string, prefixes []string) {
    for prefix in prefixes {
        if !fn_name.starts_with(prefix) {
            continue
        }
        token := fn_name[prefix.len..]
        if token == '' {
            continue
        }
        concrete := g.concrete_type_from_specialization_token(token)
        if type_contains_generic_placeholder(concrete)
            || !g.generic_concrete_type_is_runtime_specializable(concrete) {
            continue
        }
        fallback_types[concrete.name()] = concrete
    }
}

fn (mut g Gen) concrete_type_from_specialization_token(token string) types.Type {
    c_name := unmangle_alias_component_to_c(token)
    if c_name.ends_with('*') {
        base_name := g.c_name_from_specialization_token_base(c_name.trim_right('*'))
        mut base_type := if primitive := resolve_primitive_type_name(base_name) {
            primitive
        } else {
            types.Type(types.Struct{
                name: base_name
            })
        }
        if resolved := g.lookup_type_by_c_name(base_name) {
            base_type = resolved
        }
        return types.Type(types.Pointer{
            base_type: normalize_generic_concrete_type(base_type)
        })
    }
    resolved_c_name := g.c_name_from_specialization_token_base(c_name)
    if resolved_c_name != c_name {
        return g.concrete_type_from_specialization_token(resolved_c_name)
    }
    if primitive := resolve_primitive_type_name(c_name) {
        return normalize_generic_concrete_type(primitive)
    }
    if resolved := g.lookup_type_by_c_name(c_name) {
        return normalize_generic_concrete_type(resolved)
    }
    return normalize_generic_concrete_type(types.Type(types.Struct{
        name: c_name
    }))
}

fn (g &Gen) c_name_from_specialization_token_base(name string) string {
    if name == '' || name.contains('__') || is_builtin_specialization_base(name)
        || name.starts_with('Array_') || name.starts_with('Array_fixed_')
        || name.starts_with('Map_') || name.starts_with('_option_') || name.starts_with('_result_') {
        return name
    }
    sep := name.index_u8(`_`)
    if sep <= 0 || sep >= name.len - 1 {
        return name
    }
    mod_name := name[..sep]
    type_name := name[sep + 1..]
    if is_builtin_specialization_base(type_name)
        && !g.c_type_name_declared_in_module(mod_name, type_name) {
        return type_name
    }
    candidate := '${mod_name}__${type_name}'
    if candidate in g.c_struct_types || candidate in g.typedef_c_types
        || 'enum_${candidate}' in g.emitted_types || candidate in g.enum_type_fields {
        return candidate
    }
    if g.c_type_name_declared_in_module(mod_name, type_name) {
        return candidate
    }
    if scope := g.env_scope(mod_name) {
        if _ := scope.lookup_type(type_name) {
            return candidate
        }
    }
    return name
}

fn (g &Gen) c_type_name_declared_in_module(mod_name string, type_name string) bool {
    if mod_name == '' || type_name == '' {
        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) != mod_name {
                continue
            }
            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 stmt.name() == type_name {
                            return true
                        }
                    }
                    else {}
                }
            }
        }
        return false
    }
    for file in g.files {
        if file_module_name(file) != mod_name {
            continue
        }
        for stmt in file.stmts {
            match stmt {
                ast.StructDecl, ast.EnumDecl, ast.InterfaceDecl {
                    if stmt.name == type_name {
                        return true
                    }
                }
                ast.TypeDecl {
                    if stmt.name == type_name {
                        return true
                    }
                }
                else {}
            }
        }
    }
    return false
}

fn add_json2_encode_value_nested_fallback_types(mut fallback_types map[string]types.Type) {
    for _ in 0 .. 4 {
        before := fallback_types.len
        snapshot := fallback_types.clone()
        for _, concrete0 in snapshot {
            concrete := normalize_generic_concrete_type(concrete0)
            match concrete {
                types.Array {
                    add_json2_encode_value_fallback_type(mut fallback_types, concrete.elem_type)
                }
                types.ArrayFixed {
                    add_json2_encode_value_fallback_type(mut fallback_types, concrete.elem_type)
                }
                types.Map {
                    add_json2_encode_value_fallback_type(mut fallback_types, concrete.key_type)
                    add_json2_encode_value_fallback_type(mut fallback_types, concrete.value_type)
                }
                types.Pointer {
                    add_json2_encode_value_fallback_type(mut fallback_types, concrete.base_type)
                }
                else {}
            }
        }
        if fallback_types.len == before {
            break
        }
    }
}

fn add_json2_encode_value_fallback_type(mut fallback_types map[string]types.Type, typ types.Type) {
    concrete := normalize_generic_concrete_type(typ)
    if concrete.name() == '' || concrete.name() == 'void'
        || type_contains_generic_placeholder(concrete) {
        return
    }
    fallback_types[concrete.name()] = concrete
}

fn (mut g Gen) add_json2_decode_value_nested_fallback_types(mut fallback_types map[string]types.Type) {
    for _ in 0 .. 6 {
        before := fallback_types.len
        snapshot := fallback_types.clone()
        for _, concrete0 in snapshot {
            concrete := normalize_generic_concrete_type(concrete0)
            match concrete {
                types.Array {
                    g.add_json2_decode_value_fallback_type(mut fallback_types, concrete.elem_type)
                }
                types.Map {
                    g.add_json2_decode_value_fallback_type(mut fallback_types, concrete.value_type)
                }
                types.OptionType {
                    g.add_json2_decode_value_fallback_type(mut fallback_types, concrete.base_type)
                }
                types.ResultType {
                    g.add_json2_decode_value_fallback_type(mut fallback_types, concrete.base_type)
                }
                types.Alias {
                    g.add_json2_decode_value_fallback_type(mut fallback_types, concrete.base_type)
                }
                types.Struct {
                    mut struct_type := concrete
                    if struct_type.fields.len == 0 {
                        struct_c_name := g.types_type_to_c(concrete).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
                        }
                    }
                    for field in struct_type.fields {
                        g.add_json2_decode_value_fallback_type(mut fallback_types, field.typ)
                    }
                }
                else {}
            }
        }
        if fallback_types.len == before {
            break
        }
    }
}

fn (mut g Gen) add_json2_decode_value_fallback_type(mut fallback_types map[string]types.Type, typ types.Type) {
    concrete := normalize_generic_concrete_type(typ)
    if concrete.name() == '' || concrete.name() in ['void', 'voidptr']
        || type_contains_generic_placeholder(concrete) || is_json2_runtime_internal_type(concrete) {
        return
    }
    fallback_types[concrete.name()] = concrete
}

fn (mut g Gen) add_json2_decode_value_fallback_types(mut fallback_types map[string]types.Type) {
    prev_module := g.cur_module
    prev_file_name := g.cur_file_name
    prev_active_generic_types := g.active_generic_types.clone()
    defer {
        g.cur_module = prev_module
        g.cur_file_name = prev_file_name
        g.active_generic_types = prev_active_generic_types.clone()
    }
    for file in g.files {
        g.set_file_module(file)
        if g.cur_module != 'json2' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.is_method && stmt.name == 'decode_value'
                && generic_params_are_single_t(g.generic_fn_param_names(stmt)) {
                for spec in g.generic_fn_specializations(stmt) {
                    concrete := spec.generic_types['T'] or { continue }
                    if concrete.name() == 'T' || type_contains_generic_placeholder(concrete) {
                        continue
                    }
                    fallback_types[concrete.name()] = concrete
                }
            }
        }
    }
}

fn (mut g Gen) infer_generic_type_bindings_from_generic_container(name ast.Expr, params []ast.Expr, concrete types.Type, generic_params []string, mut bindings map[string]types.Type) {
    base_name := g.expr_type_to_c(name).trim_space()
    if base_name == '' {
        return
    }
    runtime_params := runtime_generic_args(params)
    if runtime_params.len == 0 {
        return
    }
    concrete_name := g.generic_container_concrete_c_name(concrete)
    if concrete_name == '' {
        return
    }
    mut struct_type := g.lookup_struct_type_by_c_name(base_name)
    if struct_type.generic_params.len == 0 {
        struct_base := if base_name.contains('__') {
            base_name.all_after_last('__')
        } else {
            base_name
        }
        struct_type = g.lookup_struct_type(struct_base)
    }
    struct_params := runtime_generic_param_names(struct_type.generic_params)
    if struct_params.len == 0 || struct_params.len != runtime_params.len {
        return
    }
    mut concrete_bindings := map[string]types.Type{}
    if concrete_name == base_name {
        if primary := g.generic_struct_bindings[base_name] {
            concrete_bindings = primary.clone()
        }
    }
    if concrete_bindings.len == 0 {
        if instances := g.generic_struct_instances[base_name] {
            for inst in instances {
                if inst.c_name == concrete_name {
                    concrete_bindings = inst.bindings.clone()
                    break
                }
            }
        }
    }
    if concrete_bindings.len == 0 && concrete_name.starts_with('${base_name}_T_') {
        arg_names := generic_call_embedded_type_arg_names_from_name(concrete_name,
            struct_params.len)
        if arg_names.len == struct_params.len {
            for i, struct_param in struct_params {
                concrete_bindings[struct_param] =
                    g.concrete_type_from_specialization_token(arg_names[i])
            }
        }
    }
    if concrete_bindings.len != struct_params.len {
        return
    }
    for i, param_expr in runtime_params {
        struct_param := struct_params[i]
        concrete_arg := concrete_bindings[struct_param] or { continue }
        g.infer_generic_type_bindings_from_param(param_expr, concrete_arg, generic_params, mut
            bindings)
    }
}

fn (mut g Gen) generic_container_concrete_c_name(concrete types.Type) string {
    match concrete {
        types.Pointer {
            return g.generic_container_concrete_c_name(concrete.base_type)
        }
        types.Struct {
            return concrete.name
        }
        types.Alias {
            return concrete.name
        }
        types.NamedType {
            return string(concrete)
        }
        else {}
    }

    return strip_pointer_type_name(g.types_type_to_c(concrete).trim_space())
}

fn (mut g Gen) infer_generic_type_bindings_from_param(param ast.Expr, concrete types.Type, generic_params []string, mut bindings map[string]types.Type) {
    match param {
        ast.Ident {
            if param.name in generic_params {
                if param.name !in bindings {
                    bindings[param.name] = concrete
                }
            }
        }
        ast.PrefixExpr {
            if concrete is types.Pointer {
                g.infer_generic_type_bindings_from_param(param.expr, concrete.base_type,
                    generic_params, mut bindings)
            }
        }
        ast.ModifierExpr {
            g.infer_generic_type_bindings_from_param(param.expr, concrete, generic_params, mut
                bindings)
        }
        ast.GenericArgOrIndexExpr {
            g.infer_generic_type_bindings_from_generic_container(param.lhs, [param.expr], concrete,
                generic_params, mut bindings)
        }
        ast.GenericArgs {
            g.infer_generic_type_bindings_from_generic_container(param.lhs, param.args, concrete,
                generic_params, mut bindings)
        }
        ast.Type {
            match param {
                ast.ArrayType {
                    if concrete is types.Array {
                        g.infer_generic_type_bindings_from_param(param.elem_type,
                            concrete.elem_type, generic_params, mut bindings)
                    }
                }
                ast.ArrayFixedType {
                    if concrete is types.ArrayFixed {
                        g.infer_generic_type_bindings_from_param(param.elem_type,
                            concrete.elem_type, generic_params, mut bindings)
                    }
                }
                ast.MapType {
                    if concrete is types.Map {
                        g.infer_generic_type_bindings_from_param(param.key_type, concrete.key_type,
                            generic_params, mut bindings)
                        g.infer_generic_type_bindings_from_param(param.value_type,
                            concrete.value_type, generic_params, mut bindings)
                    }
                }
                ast.PointerType {
                    if concrete is types.Pointer {
                        g.infer_generic_type_bindings_from_param(param.base_type,
                            concrete.base_type, generic_params, mut bindings)
                    }
                }
                ast.OptionType {
                    if concrete is types.OptionType {
                        g.infer_generic_type_bindings_from_param(param.base_type,
                            concrete.base_type, generic_params, mut bindings)
                    }
                }
                ast.ResultType {
                    if concrete is types.ResultType {
                        g.infer_generic_type_bindings_from_param(param.base_type,
                            concrete.base_type, generic_params, mut bindings)
                    }
                }
                ast.GenericType {
                    g.infer_generic_type_bindings_from_generic_container(param.name, param.params,
                        concrete, generic_params, mut bindings)
                }
                else {}
            }
        }
        else {}
    }
}

fn (g &Gen) concrete_type_for_generic_param(param ast.Parameter, concrete types.Type) types.Type {
    mut normalized := normalize_generic_concrete_type(concrete)
    if direct_generic_placeholder_name(param.typ) != '' && !param_type_is_pointer_expr(param.typ)
        && normalized is types.Pointer && type_contains_generic_placeholder(normalized.base_type) {
        normalized = g.concrete_type_with_active_generics(normalized.base_type)
    }
    normalized = g.concrete_type_with_active_generics(normalized)
    if param.is_mut && !param_type_is_pointer_expr(param.typ) && normalized is types.Pointer {
        normalized = normalized.base_type
    }
    if active := g.active_generic_types[normalized.name()] {
        return normalize_generic_concrete_type(active)
    }
    return normalized
}

fn (mut g Gen) active_generic_concrete_from_arg(arg ast.Expr) ?types.Type {
    if g.active_generic_types.len == 0 {
        return none
    }
    if arg is ast.PrefixExpr && arg.op == .amp {
        if concrete := g.active_generic_concrete_from_arg(arg.expr) {
            return types.Type(types.Pointer{
                base_type: concrete
            })
        }
    }
    if arg is ast.Ident {
        if param_name := g.cur_fn_generic_params[arg.name] {
            if concrete := g.active_generic_types[param_name] {
                return normalize_generic_concrete_type(concrete)
            }
        }
    }
    raw := g.get_raw_type(arg) or { return none }
    concrete := g.concrete_type_with_active_generics(raw)
    // Function-typed generic parameters use `void*` at the C ABI. Keep the
    // active generic binding (for example `T = fn_i64`) so nested generic calls
    // specialize by the V type, not by the erased ABI carrier.
    if type_contains_generic_placeholder(concrete) || concrete.name() == raw.name() {
        return none
    }
    return normalize_generic_concrete_type(concrete)
}

fn (g &Gen) concrete_type_with_active_generics(typ types.Type) types.Type {
    if g.active_generic_types.len == 0 || !type_contains_generic_placeholder(typ) {
        return normalize_generic_concrete_type(typ)
    }
    match typ {
        types.NamedType {
            name := string(typ)
            if concrete := g.active_generic_types[name] {
                return normalize_generic_concrete_type(concrete)
            }
        }
        types.Pointer {
            return types.Type(types.Pointer{
                base_type: g.concrete_type_with_active_generics(typ.base_type)
                lifetime:  typ.lifetime
            })
        }
        types.Array {
            return types.Type(types.Array{
                elem_type: g.concrete_type_with_active_generics(typ.elem_type)
            })
        }
        types.ArrayFixed {
            return types.Type(types.ArrayFixed{
                len:       typ.len
                elem_type: g.concrete_type_with_active_generics(typ.elem_type)
            })
        }
        types.Map {
            return types.Type(types.Map{
                key_type:   g.concrete_type_with_active_generics(typ.key_type)
                value_type: g.concrete_type_with_active_generics(typ.value_type)
            })
        }
        types.OptionType {
            return types.Type(types.OptionType{
                base_type: g.concrete_type_with_active_generics(typ.base_type)
            })
        }
        types.ResultType {
            return types.Type(types.ResultType{
                base_type: g.concrete_type_with_active_generics(typ.base_type)
            })
        }
        types.Alias {
            return types.Type(types.Alias{
                name:      typ.name
                base_type: g.concrete_type_with_active_generics(typ.base_type)
            })
        }
        else {}
    }

    return normalize_generic_concrete_type(typ)
}

fn generic_container_fallback_type(node ast.FnDecl, param_name string, concrete types.Type) ?types.Type {
    for param in node.typ.params {
        if !expr_has_generic_placeholder(param.typ) {
            continue
        }
        if derived := generic_container_fallback_type_from_expr(param.typ, concrete, param_name) {
            return derived
        }
    }
    return none
}

fn generic_container_fallback_type_from_expr(expr ast.Expr, concrete types.Type, param_name string) ?types.Type {
    match expr {
        ast.Ident {
            if expr.name == param_name {
                return concrete
            }
        }
        ast.ModifierExpr {
            return generic_container_fallback_type_from_expr(expr.expr, concrete, param_name)
        }
        ast.PrefixExpr {
            if concrete is types.Pointer {
                return generic_container_fallback_type_from_expr(expr.expr, concrete.base_type,
                    param_name)
            }
        }
        ast.Type {
            match expr {
                ast.ArrayType {
                    if concrete is types.Array {
                        return generic_container_fallback_type_from_expr(expr.elem_type,
                            concrete.elem_type, param_name)
                    }
                }
                ast.MapType {
                    if concrete is types.Map {
                        if derived := generic_container_fallback_type_from_expr(expr.key_type,
                            concrete.key_type, param_name)
                        {
                            return derived
                        }
                        return generic_container_fallback_type_from_expr(expr.value_type,
                            concrete.value_type, param_name)
                    }
                }
                ast.OptionType {
                    if concrete is types.OptionType {
                        return generic_container_fallback_type_from_expr(expr.base_type,
                            concrete.base_type, param_name)
                    }
                }
                ast.ResultType {
                    if concrete is types.ResultType {
                        return generic_container_fallback_type_from_expr(expr.base_type,
                            concrete.base_type, param_name)
                    }
                }
                ast.PointerType {
                    if concrete is types.Pointer {
                        return generic_container_fallback_type_from_expr(expr.base_type,
                            concrete.base_type, param_name)
                    }
                }
                else {}
            }
        }
        else {}
    }

    return none
}

fn param_type_is_pointer_expr(expr ast.Expr) bool {
    match expr {
        ast.PrefixExpr {
            return expr.op == .amp
        }
        ast.Type {
            return expr is ast.PointerType
        }
        ast.ModifierExpr {
            return param_type_is_pointer_expr(expr.expr)
        }
        else {}
    }

    return false
}

fn param_type_is_array_expr(expr ast.Expr) bool {
    match expr {
        ast.Type {
            match expr {
                ast.ArrayType {
                    return true
                }
                else {}
            }
        }
        ast.ModifierExpr {
            return param_type_is_array_expr(expr.expr)
        }
        else {}
    }

    return false
}

fn direct_generic_placeholder_name(e ast.Expr) string {
    match e {
        ast.Ident {
            if is_generic_placeholder_type_name(e.name) {
                return e.name
            }
        }
        ast.PrefixExpr {
            return direct_generic_placeholder_name(e.expr)
        }
        ast.ModifierExpr {
            return direct_generic_placeholder_name(e.expr)
        }
        ast.Type {
            match e {
                ast.ArrayType {
                    return direct_generic_placeholder_name(e.elem_type)
                }
                ast.ArrayFixedType {
                    return direct_generic_placeholder_name(e.elem_type)
                }
                ast.MapType {
                    key_placeholder := direct_generic_placeholder_name(e.key_type)
                    if key_placeholder != '' {
                        return key_placeholder
                    }
                    return direct_generic_placeholder_name(e.value_type)
                }
                ast.OptionType {
                    return direct_generic_placeholder_name(e.base_type)
                }
                ast.ResultType {
                    return direct_generic_placeholder_name(e.base_type)
                }
                ast.PointerType {
                    return direct_generic_placeholder_name(e.base_type)
                }
                else {}
            }
        }
        else {}
    }

    return ''
}

fn generic_specialization_token_for_direct_param(param ast.Expr, concrete_type_name string) string {
    raw_ctype := concrete_type_name.trim_space()
    mut ctype := raw_ctype.trim_right('*')
    if raw_ctype == 'void*' || raw_ctype == 'voidptr' {
        ctype = 'voidptr'
    }
    match param {
        ast.PrefixExpr {
            return generic_specialization_token_for_direct_param(param.expr, ctype)
        }
        ast.ModifierExpr {
            return generic_specialization_token_for_direct_param(param.expr, ctype)
        }
        ast.Type {
            match param {
                ast.ArrayType {
                    if ctype.starts_with('Array_') {
                        ctype = ctype['Array_'.len..]
                    }
                    return generic_specialization_token_for_direct_param(param.elem_type, ctype)
                }
                ast.ArrayFixedType {
                    if ctype.starts_with('Array_fixed_') {
                        ctype = ctype['Array_fixed_'.len..]
                        if last_sep := ctype.last_index('_') {
                            ctype = ctype[..last_sep]
                        }
                    }
                    return generic_specialization_token_for_direct_param(param.elem_type, ctype)
                }
                ast.PointerType {
                    return generic_specialization_token_for_direct_param(param.base_type, ctype)
                }
                ast.OptionType {
                    if ctype.starts_with('_option_') {
                        ctype = ctype['_option_'.len..]
                    }
                    return generic_specialization_token_for_direct_param(param.base_type, ctype)
                }
                ast.ResultType {
                    if ctype.starts_with('_result_') {
                        ctype = ctype['_result_'.len..]
                    }
                    return generic_specialization_token_for_direct_param(param.base_type, ctype)
                }
                else {}
            }
        }
        else {}
    }

    if param is ast.Ident && is_generic_placeholder_type_name(param.name)
        && raw_ctype.ends_with('*') && raw_ctype != 'void*' {
        return generic_specialization_token_from_c_type_name(raw_ctype)
    }
    return generic_specialization_token_from_c_type_name(ctype)
}

fn generic_specialization_token_from_c_type_name(c_type string) string {
    mut base := c_type.trim_space()
    if base == 'void*' || base == 'voidptr' {
        return 'voidptr'
    }
    mut ptr_count := 0
    for base.ends_with('*') {
        ptr_count++
        base = base[..base.len - 1].trim_space()
    }
    mut token := sanitize_generic_token_part(base)
    for _ in 0 .. ptr_count {
        token += 'ptr'
    }
    return token
}

fn (g &Gen) qualify_local_call_name(name string) string {
    if name != '' && g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
        && !name.contains('__') {
        return '${g.cur_module}__${name}'
    }
    return name
}

fn (g &Gen) has_generic_fn_decl_by_base_name(name string) bool {
    lookup_name := g.qualified_generic_fn_base_name(name) or { name }
    info := g.generic_fn_decl_index[lookup_name] or { return false }
    if g.has_flat() {
        if info.file_idx < 0 || info.file_idx >= g.flat.files.len {
            return false
        }
        stmts := g.flat.file_cursor(info.file_idx).stmts()
        if info.stmt_idx < 0 || info.stmt_idx >= stmts.len() {
            return false
        }
        return stmts.at(info.stmt_idx).kind() == .stmt_fn_decl
    }
    if info.file_idx < 0 || info.file_idx >= g.files.len {
        return false
    }
    file := g.files[info.file_idx]
    if info.stmt_idx < 0 || info.stmt_idx >= file.stmts.len {
        return false
    }
    return file.stmts[info.stmt_idx] is ast.FnDecl
}

fn (mut g Gen) find_generic_fn_decl_by_base_name(name string) ?ast.FnDecl {
    lookup_name := g.qualified_generic_fn_base_name(name) or { name }
    info := g.generic_fn_decl_index[lookup_name] or { return none }
    if g.has_flat() {
        if info.file_idx < 0 || info.file_idx >= g.flat.files.len {
            return none
        }
        stmts := g.flat.file_cursor(info.file_idx).stmts()
        if info.stmt_idx < 0 || info.stmt_idx >= stmts.len() {
            return none
        }
        stmt := stmts.at(info.stmt_idx)
        if stmt.kind() == .stmt_fn_decl {
            return stmt.fn_decl()
        }
        return none
    }
    if info.file_idx < 0 || info.file_idx >= g.files.len {
        return none
    }
    file := g.files[info.file_idx]
    if info.stmt_idx < 0 || info.stmt_idx >= file.stmts.len {
        return none
    }
    stmt := file.stmts[info.stmt_idx]
    if stmt is ast.FnDecl {
        return stmt
    }
    return none
}

fn (g &Gen) qualified_generic_fn_base_name(name string) ?string {
    if name == '' {
        return none
    }
    if name in g.generic_fn_decl_index {
        return name
    }
    if !name.contains('__') {
        return none
    }
    if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
        local_name := '${g.cur_module}__${name}'
        if local_name in g.generic_fn_decl_index {
            return local_name
        }
    }
    suffix := '__${name}'
    mut found := ''
    for candidate, _ in g.generic_fn_decl_index {
        if candidate.ends_with(suffix) {
            if found != '' && found != candidate {
                return none
            }
            found = candidate
        }
    }
    if found != '' {
        return found
    }
    return none
}

fn (mut g Gen) find_generic_fn_decl_by_spec_key(key string) ?ast.FnDecl {
    if decl := g.find_generic_fn_decl_by_base_name(key) {
        return decl
    }
    mut base_name := key
    bracket_pos := base_name.index_u8(`[`)
    if bracket_pos > 0 {
        base_name = base_name[..bracket_pos]
    }
    dot_pos := base_name.last_index_u8(`.`)
    short_name := if dot_pos > 0 && dot_pos < base_name.len - 1 {
        base_name[dot_pos + 1..]
    } else {
        base_name
    }
    if short_name != key {
        if decl := g.find_generic_fn_decl_by_base_name(short_name) {
            return decl
        }
    }
    if g.generic_fn_decl_index.len > 0 {
        return none
    }
    prev_module := g.cur_module
    prev_file_name := g.cur_file_name
    defer {
        g.cur_module = prev_module
        g.cur_file_name = prev_file_name
    }
    if g.has_flat() {
        for i in 0 .. g.flat.files.len {
            fc := g.flat.file_cursor(i)
            g.set_file_cursor_module(fc)
            stmts := fc.stmts()
            for j in 0 .. stmts.len() {
                stmt := stmts.at(j)
                if stmt.kind() != .stmt_fn_decl || stmt.name() != short_name {
                    continue
                }
                decl := stmt.fn_decl_signature()
                if g.generic_fn_param_names(decl).len > 0 {
                    return stmt.fn_decl()
                }
            }
        }
        return none
    }
    for file in g.files {
        g.set_file_module(file)
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == short_name
                && g.generic_fn_param_names(stmt).len > 0 {
                return stmt
            }
        }
    }
    return none
}

fn (g &Gen) find_specialized_call_name(name string, token string) ?string {
    if name == '' || token == '' {
        return none
    }
    candidate := '${name}_T_${token}'
    if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
        return candidate
    }
    if !name.contains('__') {
        qualified := g.qualify_local_call_name(candidate)
        if qualified != candidate
            && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
            return qualified
        }
    }
    return none
}

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

fn (mut g Gen) generic_specialization_arg_type_name(arg ast.Expr) string {
    base_arg := if arg is ast.ModifierExpr {
        arg.expr
    } else {
        arg
    }
    if base_arg is ast.PrefixExpr && base_arg.op == .amp {
        inner_type_name := g.generic_specialization_arg_type_name(base_arg.expr)
        if inner_type_name != '' && inner_type_name != 'int' {
            return inner_type_name.trim_right('*') + '*'
        }
    }
    mut arg_type_name := ''
    if base_arg is ast.SelectorExpr {
        if is_comptime_selector_rhs_name(base_arg.rhs.name) {
            comptime_type := g.get_comptime_selector_type(base_arg).trim_space()
            if comptime_type != '' && comptime_type != 'int' {
                return comptime_type
            }
        }
        if g.active_generic_types.len > 0 {
            arg_type_name = g.selector_field_type(base_arg).trim_space()
            if arg_type_name == '' || arg_type_name == 'array' {
                arg_type_name = g.selector_declared_field_type(base_arg).trim_space()
            }
        } else {
            arg_type_name = g.selector_declared_field_type(base_arg).trim_space()
            if arg_type_name == '' || arg_type_name == 'array' {
                arg_type_name = g.selector_field_type(base_arg).trim_space()
            }
        }
        if base_arg.lhs is ast.Ident {
            lhs_name := base_arg.lhs.name
            if placeholder := g.cur_fn_generic_params[lhs_name] {
                if concrete := g.active_generic_types[placeholder] {
                    mut struct_type := g.resolve_type_to_struct(concrete)
                    if struct_type.fields.len == 0 {
                        struct_c_name := g.types_type_to_c(concrete).trim_space().trim_right('*')
                        struct_type = g.lookup_struct_type_by_c_name(struct_c_name)
                    }
                    for field in struct_type.fields {
                        if field.name == base_arg.rhs.name {
                            arg_type_name = g.types_type_to_c(field.typ)
                            break
                        }
                    }
                }
            }
        }
    }
    if arg_type_name == '' {
        if active_concrete := g.active_generic_concrete_from_arg(base_arg) {
            arg_type_name = g.generic_specialization_token_from_type(active_concrete)
        }
    }
    if arg_type_name == '' && base_arg is ast.InitExpr {
        arg_type_name = g.expr_type_to_c(base_arg.typ).trim_space()
    }
    if arg_type_name == '' || arg_type_name == 'int' {
        arg_type_name = g.get_expr_type(base_arg).trim_space()
    }
    if (arg_type_name == '' || arg_type_name == 'int') && base_arg is ast.Ident {
        arg_type_name = (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space()
    }
    if arg_type_name == '' || arg_type_name == 'int' {
        if raw := g.get_raw_type(base_arg) {
            arg_type_name = g.types_type_to_c(raw).trim_space()
        }
    }
    return if arg_type_name.trim_space() == 'void*' {
        'voidptr'
    } else {
        g.resolve_sum_payload_arg_type_name(base_arg, arg_type_name).trim_space()
    }
}

fn (g &Gen) find_known_qualified_fn_name(name string) ?string {
    if name == '' {
        return none
    }
    if !name.contains('__') {
        qualified := g.qualify_local_call_name(name)
        if qualified != name && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
            return qualified
        }
        suffix := '__${name}'
        mut found := ''
        for fn_name, _ in g.fn_param_is_ptr {
            if fn_name.ends_with(suffix) {
                if found != '' && found != fn_name {
                    return none
                }
                found = fn_name
            }
        }
        for fn_name, _ in g.fn_return_types {
            if fn_name.ends_with(suffix) {
                if found != '' && found != fn_name {
                    return none
                }
                found = fn_name
            }
        }
        if found != '' {
            return found
        }
        if name.contains('_T_') {
            base_name := name.all_before('_T_')
            token := name.all_after('_T_')
            if base_name != '' && token != '' {
                prefix := '__${base_name}_T_'
                mut generic_found := ''
                for fn_name, _ in g.fn_param_is_ptr {
                    if fn_name.contains(prefix)
                        && generic_token_matches_short_name(fn_name.all_after(prefix), token) {
                        if generic_found != '' && generic_found != fn_name {
                            return none
                        }
                        generic_found = fn_name
                    }
                }
                for fn_name, _ in g.fn_return_types {
                    if fn_name.contains(prefix)
                        && generic_token_matches_short_name(fn_name.all_after(prefix), token) {
                        if generic_found != '' && generic_found != fn_name {
                            return none
                        }
                        generic_found = fn_name
                    }
                }
                if generic_found != '' {
                    return generic_found
                }
            }
        }
    }
    if name in g.fn_param_is_ptr || name in g.fn_return_types {
        return name
    }
    return none
}

fn generic_token_matches_short_name(actual string, expected string) bool {
    if actual == expected {
        return true
    }
    return actual.ends_with('_${expected}')
}

fn (g &Gen) has_specialized_fn_base(name string) bool {
    if name == '' {
        return false
    }
    return name in g.specialized_fn_bases
}

fn (g &Gen) same_receiver_specialized_method_name(name string) ?string {
    if name == '' || g.cur_fn_c_name == '' || !name.contains('_T_')
        || !g.cur_fn_c_name.contains('_T_') {
        return none
    }
    base_name := name.all_before('_T_')
    cur_base_name := g.cur_fn_c_name.all_before('_T_')
    if base_name == '' || base_name != cur_base_name {
        return none
    }
    rest := name.all_after('_T_')
    cur_rest := g.cur_fn_c_name.all_after('_T_')
    method_sep := rest.last_index('__') or { return none }
    cur_method_sep := cur_rest.last_index('__') or { return none }
    suffix := rest[..method_sep]
    cur_suffix := cur_rest[..cur_method_sep]
    if suffix == '' || cur_suffix == '' || suffix == cur_suffix {
        return none
    }
    candidate := '${base_name}_T_${cur_suffix}${rest[method_sep..]}'
    if g.knows_fn_signature(candidate) || base_name in g.specialized_fn_bases {
        return candidate
    }
    return none
}

fn (mut g Gen) ensure_specialized_call_signature(name string) {
    if name == '' || !name.contains('_T_') || name in g.fn_param_is_ptr || name in g.fn_return_types {
        return
    }
    base_name := specialized_fn_decl_base_name(name)
    decl := g.find_generic_fn_decl_by_base_name(base_name) or { return }
    generic_types := g.generic_types_from_specialized_fn_name(decl, name) or {
        g.register_fn_signature(decl, name)
        return
    }
    prev_generic_types := g.active_generic_types.clone()
    g.active_generic_types = generic_types.clone()
    g.register_fn_signature(decl, name)
    g.active_generic_types = prev_generic_types.clone()
}

fn (g &Gen) receiver_only_specialized_call_name(name string) ?string {
    if name == '' {
        return none
    }
    base_name := generic_call_base_name_for_specialization(name)
    if base_name == '' || base_name == name {
        return none
    }
    if base_name in g.fn_param_types || base_name in g.fn_return_types
        || base_name in g.fn_param_is_ptr {
        return base_name
    }
    return none
}

fn specialized_fn_decl_base_name(name string) string {
    base_name := generic_call_base_name_for_specialization(name)
    if base_name == '' || !base_name.contains('_T_') {
        return base_name
    }
    method_sep := base_name.last_index('__') or { return base_name.all_before('_T_') }
    receiver_name := base_name[..method_sep]
    if !receiver_name.contains('_T_') {
        return base_name
    }
    return receiver_name.all_before('_T_') + base_name[method_sep..]
}

fn (mut g Gen) record_late_single_generic_call_spec_from_c_type(fn_name string, param_name string, c_type string) {
    if fn_name == '' || param_name == '' {
        return
    }
    concrete := g.concrete_type_from_call_arg_c_name(c_type.trim_space()) or { return }
    if type_contains_generic_placeholder(concrete) {
        return
    }
    if !g.generic_concrete_type_is_runtime_specializable(concrete) {
        return
    }
    g.record_late_generic_call_spec(fn_name, {
        param_name: concrete
    })
}

fn (mut g Gen) concrete_type_from_call_arg_c_name(c_name string) ?types.Type {
    raw_name := c_name.trim_space()
    if raw_name == 'void*' || raw_name == 'voidptr' {
        return types.Type(types.voidptr_)
    }
    clean_name := raw_name.trim_right('*')
    if clean_name == '' {
        return none
    }
    mut concrete := if primitive := resolve_primitive_type_name(clean_name) {
        normalize_generic_concrete_type(primitive)
    } else if named := g.concrete_type_from_c_name(clean_name) {
        normalize_generic_concrete_type(named)
    } else {
        return none
    }
    if raw_name.ends_with('*') {
        return types.Type(types.Pointer{
            base_type: concrete
        })
    }
    return concrete
}

fn (mut g Gen) concrete_type_from_current_return_c_name(c_name string, return_type ast.Expr) ?types.Type {
    raw_name := c_name.trim_space()
    if raw_name == '' || raw_name == 'void' {
        return none
    }
    if return_type is ast.Type && return_type is ast.ResultType {
        if !raw_name.starts_with('_result_') {
            return none
        }
        payload_name := g.result_value_type(raw_name).trim_space()
        if payload_name == '' || payload_name == 'void' {
            return none
        }
        payload_type := g.concrete_type_from_call_arg_c_name(payload_name) or { return none }
        return types.Type(types.ResultType{
            base_type: payload_type
        })
    }
    if return_type is ast.Type && return_type is ast.OptionType {
        if !raw_name.starts_with('_option_') {
            return none
        }
        payload_name := option_value_type(raw_name).trim_space()
        if payload_name == '' || payload_name == 'void' {
            return none
        }
        payload_type := g.concrete_type_from_call_arg_c_name(payload_name) or { return none }
        return types.Type(types.OptionType{
            base_type: payload_type
        })
    }
    return g.concrete_type_from_call_arg_c_name(raw_name)
}

fn (mut g Gen) infer_generic_bindings_from_current_return(decl ast.FnDecl, generic_params []string) ?map[string]types.Type {
    if generic_params.len == 0 || g.cur_fn_ret_type == '' || decl.typ.return_type is ast.EmptyExpr
        || !expr_has_generic_placeholder(decl.typ.return_type) {
        return none
    }
    concrete_return := g.concrete_type_from_current_return_c_name(g.cur_fn_ret_type,
        decl.typ.return_type) or { return none }
    mut bindings := map[string]types.Type{}
    g.infer_generic_type_bindings_from_param(decl.typ.return_type, concrete_return, generic_params, mut
        bindings)
    if bindings.len != generic_params.len {
        return none
    }
    for _, concrete in bindings {
        if type_contains_generic_placeholder(concrete)
            || !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return none
        }
    }
    return bindings
}

fn (mut g Gen) generic_call_has_concrete_arg_bindings(decl ast.FnDecl, call_args []ast.Expr, generic_params []string) bool {
    if generic_params.len == 0 || g.env == unsafe { nil } {
        return false
    }
    mut bindings := map[string]types.Type{}
    if decl.is_method && call_args.len > 0 && expr_has_generic_placeholder(decl.receiver.typ) {
        recv_arg := if call_args[0] is ast.ModifierExpr {
            (call_args[0] as ast.ModifierExpr).expr
        } else {
            call_args[0]
        }
        if expr_has_valid_data(recv_arg) {
            if concrete := g.concrete_type_from_generic_call_arg(recv_arg) {
                g.infer_generic_type_bindings_from_param(decl.receiver.typ,
                    g.concrete_type_with_active_generics(concrete), generic_params, mut bindings)
            }
        }
    }
    arg_offset := if decl.is_method && call_args.len == decl.typ.params.len + 1 { 1 } else { 0 }
    for i, param in decl.typ.params {
        arg_idx := i + arg_offset
        if arg_idx >= call_args.len || !expr_has_generic_placeholder(param.typ) {
            continue
        }
        arg := if call_args[arg_idx] is ast.ModifierExpr {
            (call_args[arg_idx] as ast.ModifierExpr).expr
        } else {
            call_args[arg_idx]
        }
        if !expr_has_valid_data(arg) {
            continue
        }
        mut concrete := types.Type(types.void_)
        mut found_concrete := false
        if arg is ast.InitExpr {
            c_name := g.expr_type_to_c(arg.typ).trim_space()
            if concrete_type := g.concrete_type_from_call_arg_c_name(c_name) {
                concrete = concrete_type
                found_concrete = true
            }
        }
        if !found_concrete && arg is ast.CastExpr {
            c_name := g.expr_type_to_c(arg.typ).trim_space()
            if concrete_type := g.concrete_type_from_call_arg_c_name(c_name) {
                concrete = concrete_type
                found_concrete = true
            }
        }
        if !found_concrete {
            if active_concrete := g.active_generic_concrete_from_arg(arg) {
                concrete = active_concrete
                found_concrete = true
            }
        }
        if !found_concrete && arg is ast.SelectorExpr {
            arg_type_name := g.selector_declared_field_type(arg).trim_space()
            if arg_type_name != '' {
                if selector_type := g.concrete_type_from_call_arg_c_name(arg_type_name) {
                    concrete = selector_type
                    found_concrete = true
                }
            }
        }
        if !found_concrete && arg is ast.Ident {
            arg_type_name := (g.get_local_var_c_type(arg.name) or { '' }).trim_space()
            if arg_type_name != '' {
                if local_type := g.concrete_type_from_call_arg_c_name(arg_type_name) {
                    concrete = local_type
                    found_concrete = true
                }
            }
        }
        pos := arg.pos()
        if !found_concrete && pos.id != 0 {
            if env_type := g.env.get_expr_type(pos.id) {
                concrete = env_type
                found_concrete = true
            }
        }
        if !found_concrete {
            if raw := g.get_raw_type(arg) {
                if raw.name() != 'int' {
                    concrete = raw
                    found_concrete = true
                }
            }
        }
        if !found_concrete {
            continue
        }
        g.infer_generic_type_bindings_from_param(param.typ, g.concrete_type_for_generic_param(param,
            concrete), generic_params, mut bindings)
    }
    for param_name in generic_params {
        concrete := bindings[param_name] or { return false }
        if !g.generic_concrete_type_is_runtime_specializable(concrete) {
            return false
        }
    }
    return true
}

fn (mut g Gen) try_specialize_generic_call_name(name string, call_args []ast.Expr) ?string {
    if name == '' {
        return none
    }
    if candidate := g.same_receiver_specialized_method_name(name) {
        return candidate
    }
    if name == 'copy' {
        return none
    }
    is_struct_field_should_encode :=
        name in ['struct_field_should_encode_T', 'json2__struct_field_should_encode_T', 'struct_field_should_encode', 'json2__struct_field_should_encode']
        || name.starts_with('struct_field_should_encode_T_')
        || name.starts_with('json2__struct_field_should_encode_T_')
    if is_struct_field_should_encode && call_args.len > 1 {
        arg_type_name := g.generic_specialization_arg_type_name(call_args[1])
        if arg_type_name != '' {
            g.record_late_single_generic_call_spec_from_c_type('struct_field_should_encode', 'T',
                arg_type_name)
            token := generic_specialization_token_from_c_type_name(arg_type_name)
            for base_name in [g.qualify_local_call_name('struct_field_should_encode'),
                'json2__struct_field_should_encode', 'struct_field_should_encode'] {
                if candidate := g.find_specialized_call_name(base_name, token) {
                    return candidate
                }
                g.ensure_specialized_call_signature('${base_name}_T_${token}')
                if candidate := g.find_specialized_call_name(base_name, token) {
                    return candidate
                }
            }
        }
    }
    is_encode_struct_field_value :=
        name in ['Encoder__encode_struct_field_value_T', 'json2__Encoder__encode_struct_field_value_T', 'Encoder__encode_struct_field_value', 'json2__Encoder__encode_struct_field_value']
        || name.starts_with('Encoder__encode_struct_field_value_T_')
        || name.starts_with('json2__Encoder__encode_struct_field_value_T_')
    if is_encode_struct_field_value && call_args.len > 1 {
        arg_type_name := g.generic_specialization_arg_type_name(call_args[1])
        if arg_type_name != '' {
            g.record_late_single_generic_call_spec_from_c_type('encode_struct_field_value', 'T',
                arg_type_name)
            token := generic_specialization_token_from_c_type_name(arg_type_name)
            for base_name in [
                g.qualify_local_call_name('Encoder__encode_struct_field_value'),
                'json2__Encoder__encode_struct_field_value',
                'Encoder__encode_struct_field_value',
            ] {
                if candidate := g.find_specialized_call_name(base_name, token) {
                    return candidate
                }
                g.ensure_specialized_call_signature('${base_name}_T_${token}')
                if candidate := g.find_specialized_call_name(base_name, token) {
                    return candidate
                }
            }
        }
    }
    if name.ends_with('_T') {
        base_name := generic_call_base_name_for_specialization(name)
        if base_name != '' {
            mut has_arg_bindings := false
            if generic_decl := g.find_generic_fn_decl_by_base_name(base_name) {
                has_arg_bindings = g.generic_call_has_concrete_arg_bindings(generic_decl,
                    call_args, g.generic_fn_param_names(generic_decl))
            }
            cur_fn_specialized_name := if g.cur_fn_c_name != '' {
                g.cur_fn_c_name
            } else {
                g.cur_fn_name
            }
            if cur_fn_specialized_name.contains('_T_') && !has_arg_bindings {
                suffix := cur_fn_specialized_name.all_after('_T_')
                if suffix != '' {
                    candidate := '${base_name}_T_${suffix}'
                    g.ensure_specialized_call_signature(candidate)
                    if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                        return candidate
                    }
                    if !base_name.contains('__') {
                        qualified := g.qualify_local_call_name(candidate)
                        g.ensure_specialized_call_signature(qualified)
                        if qualified != candidate
                            && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                            return qualified
                        }
                    }
                }
            }
            if g.active_generic_types.len > 0 && !has_arg_bindings {
                if concrete := g.active_generic_types['T'] {
                    token := g.generic_specialization_token_from_type(concrete)
                    candidate := '${base_name}_T_${token}'
                    g.ensure_specialized_call_signature(candidate)
                    if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                        return candidate
                    }
                    if !base_name.contains('__') {
                        qualified := g.qualify_local_call_name(candidate)
                        g.ensure_specialized_call_signature(qualified)
                        if qualified != candidate
                            && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                            return qualified
                        }
                    }
                }
            }
            if g.active_generic_types.len == 0 {
                if candidate := g.find_specialized_call_name(g.qualify_local_call_name(base_name),
                    'f64')
                {
                    return candidate
                }
                if candidate := g.find_specialized_call_name(base_name, 'f64') {
                    return candidate
                }
            }
        }
    }
    if name in ['decode_value_T', 'json2__decode_value_T'] && call_args.len > 1 {
        base_arg := if call_args[1] is ast.ModifierExpr {
            (call_args[1] as ast.ModifierExpr).expr
        } else {
            call_args[1]
        }
        arg_type_name := g.get_expr_type(base_arg).trim_space().trim_right('*')
        if arg_type_name != '' && arg_type_name != 'int' {
            if candidate := g.find_specialized_call_name(g.qualify_local_call_name('decode_value'),
                sanitize_generic_token_part(arg_type_name))
            {
                return candidate
            }
        }
    }
    if name in ['Encoder__encode_value_T', 'json2__Encoder__encode_value_T', 'Encoder__encode_value', 'json2__Encoder__encode_value']
        && call_args.len > 1 {
        base_arg := if call_args[1] is ast.ModifierExpr {
            (call_args[1] as ast.ModifierExpr).expr
        } else {
            call_args[1]
        }
        mut arg_type_name := g.get_expr_type(base_arg).trim_space().trim_right('*')
        if (arg_type_name == '' || arg_type_name == 'int') && base_arg is ast.Ident {
            arg_type_name =
                (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space().trim_right('*')
        }
        if arg_type_name != '' && arg_type_name != 'int' {
            if candidate := g.find_specialized_call_name('json2__Encoder__encode_value',
                sanitize_generic_token_part(arg_type_name))
            {
                return candidate
            }
        }
    }
    if g.active_generic_types.len > 0 && name.contains('_T_') {
        base_name := name.all_before('_T_')
        mut parts := name.all_after('_T_').split('_')
        mut c_parts := parts.clone()
        mut changed := false
        for i, part in parts {
            if concrete := g.active_generic_types[part] {
                parts[i] = g.generic_specialization_token_from_type(concrete)
                c_type := g.types_type_to_c(concrete).trim_space().trim_right('*')
                c_parts[i] = if c_type == '' {
                    parts[i]
                } else {
                    sanitize_generic_token_part(c_type)
                }
                changed = true
            }
        }
        if changed {
            candidate := '${base_name}_T_${parts.join('_')}'
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            g.ensure_specialized_call_signature(candidate)
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            if !base_name.contains('__') {
                qualified := g.qualify_local_call_name(candidate)
                if qualified != candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
                g.ensure_specialized_call_signature(qualified)
                if qualified != candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
            }
            c_candidate := '${base_name}_T_${c_parts.join('_')}'
            if c_candidate != candidate
                && (c_candidate in g.fn_param_is_ptr || c_candidate in g.fn_return_types) {
                return c_candidate
            }
            if c_candidate != candidate {
                g.ensure_specialized_call_signature(c_candidate)
                if c_candidate in g.fn_param_is_ptr || c_candidate in g.fn_return_types {
                    return c_candidate
                }
            }
            if c_candidate != candidate && !base_name.contains('__') {
                qualified := g.qualify_local_call_name(c_candidate)
                if qualified != c_candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
                g.ensure_specialized_call_signature(qualified)
                if qualified != c_candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
            }
        }
    }
    if g.active_generic_types.len > 0 {
        mut parts := name.split('_')
        mut changed := false
        for i, part in parts {
            if concrete := g.active_generic_types[part] {
                parts[i] = 'T_${g.generic_specialization_token_from_type(concrete)}'
                changed = true
            }
        }
        if changed {
            candidate := parts.join('_')
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
        }
    }
    if !name.contains('__') {
        qualified := g.qualify_local_call_name(name)
        if qualified != name && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types)
            && !g.has_generic_fn_decl_by_base_name(qualified) {
            return none
        }
    }
    mut skip_arg0_specialization := false
    arg0_lookup_name := if name.contains('_T_') {
        name.all_before('_T_')
    } else if name.ends_with('_T') {
        name[..name.len - 2]
    } else {
        name
    }
    if generic_decl := g.find_generic_fn_decl_by_base_name(arg0_lookup_name) {
        skip_arg0_specialization = generic_decl.is_method || generic_decl.typ.params.len == 0
            || !expr_has_generic_placeholder(generic_decl.typ.params[0].typ)
    }
    if call_args.len > 0 && !skip_arg0_specialization {
        base_arg := if call_args[0] is ast.ModifierExpr {
            (call_args[0] as ast.ModifierExpr).expr
        } else {
            call_args[0]
        }
        mut arg_type_name := ''
        if active_concrete := g.active_generic_concrete_from_arg(base_arg) {
            // If the argument is a parameter whose V type is the current generic T,
            // specialize by that V type. Its C ABI type may be erased to void*,
            // especially for function values.
            arg_type_name = g.generic_specialization_token_from_type(active_concrete)
        }
        if arg_type_name == '' && base_arg is ast.InitExpr {
            arg_type_name = g.expr_type_to_c(base_arg.typ).trim_space()
        }
        if arg_type_name == '' || arg_type_name == 'int' {
            arg_type_name = g.get_expr_type(base_arg).trim_space()
        }
        if (arg_type_name == '' || arg_type_name == 'int') && base_arg is ast.Ident {
            arg_type_name = (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space()
        }
        if arg_type_name == '' || arg_type_name == 'int' {
            if raw := g.get_raw_type(base_arg) {
                arg_type_name = g.types_type_to_c(raw).trim_space()
            }
        }
        if arg_type_name != '' && arg_type_name != 'int' && arg_type_name.trim_space() != 'void*' {
            arg_type_name = g.resolve_sum_payload_arg_type_name(base_arg, arg_type_name)
        }
        arg_type_name = if arg_type_name.trim_space() == 'void*' {
            'voidptr'
        } else {
            arg_type_name.trim_right('*')
        }
        if arg_type_name != '' && arg_type_name != 'int' {
            mut candidate_types := [arg_type_name]
            if !arg_type_name.contains('__') && g.cur_module != '' && g.cur_module != 'main'
                && g.cur_module != 'builtin' {
                candidate_types << '${g.cur_module}__${arg_type_name}'
                if arg_type_name.starts_with('Array_') && arg_type_name.len > 'Array_'.len {
                    elem_type_name := arg_type_name['Array_'.len..]
                    if !elem_type_name.contains('__') {
                        candidate_types << 'Array_${g.cur_module}__${elem_type_name}'
                    }
                }
            }
            for concrete_type_name in candidate_types {
                if candidate := g.find_specialized_call_name(name,
                    sanitize_generic_token_part(concrete_type_name))
                {
                    return candidate
                }
            }
        }
    }
    if name in ['decode_value', 'json2__decode_value'] && g.cur_fn_ret_type.starts_with('_result_') {
        result_base := g.cur_fn_ret_type['_result_'.len..]
        if candidate := g.find_specialized_call_name(g.qualify_local_call_name('decode_value'),
            sanitize_generic_token_part(result_base))
        {
            return candidate
        }
    }
    mut generic_base_name := generic_call_base_name_for_specialization(name)
    if qualified_name := g.qualified_generic_fn_base_name(generic_base_name) {
        generic_base_name = qualified_name
    }
    decl := g.find_generic_fn_decl_by_base_name(generic_base_name) or {
        if generic_base_name.contains('__') {
            g.find_generic_fn_decl_by_base_name(generic_base_name.all_after_last('__')) or {
                return none
            }
        } else {
            return none
        }
    }
    generic_params := g.generic_fn_param_names(decl)
    if generic_params.len == 0 || g.env == unsafe { nil } {
        return none
    }
    if name.contains('_T_') {
        if active_bindings := g.active_generic_bindings_matching_name_suffix(name, generic_params) {
            mut suffixes := []string{cap: generic_params.len}
            for param_name in generic_params {
                concrete := active_bindings[param_name] or { return none }
                suffixes << g.generic_specialization_token_from_type(concrete)
            }
            candidate := '${generic_base_name}_T_${suffixes.join('_')}'
            g.ensure_specialized_call_signature(candidate)
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            specialized_candidate := g.specialized_fn_name(decl, active_bindings)
            if specialized_candidate != candidate {
                g.ensure_specialized_call_signature(specialized_candidate)
                if specialized_candidate in g.fn_param_is_ptr
                    || specialized_candidate in g.fn_return_types {
                    return specialized_candidate
                }
            }
        }
    }
    has_arg_bindings := g.generic_call_has_concrete_arg_bindings(decl, call_args, generic_params)
    cur_fn_specialized_name := if g.cur_fn_c_name != '' { g.cur_fn_c_name } else { g.cur_fn_name }
    if cur_fn_specialized_name.contains('_T_') && !has_arg_bindings {
        suffix := cur_fn_specialized_name.all_after('_T_')
        if suffix != '' {
            candidate := '${generic_base_name}_T_${suffix}'
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            if !generic_base_name.contains('__') {
                qualified := g.qualify_local_call_name(candidate)
                if qualified != candidate
                    && (qualified in g.fn_param_is_ptr || qualified in g.fn_return_types) {
                    return qualified
                }
            }
        }
    }
    if g.active_generic_types.len > 0 && !has_arg_bindings {
        mut active_bindings := map[string]types.Type{}
        mut suffixes := []string{}
        for param_name in generic_params {
            concrete := g.active_generic_types[param_name] or { break }
            active_bindings[param_name] = concrete
            suffixes << g.generic_specialization_token_from_type(concrete)
        }
        if active_bindings.len == generic_params.len {
            candidate := g.specialized_fn_name(decl, active_bindings)
            g.ensure_specialized_call_signature(candidate)
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            alt_candidate := '${generic_base_name}_T_${suffixes.join('_')}'
            g.ensure_specialized_call_signature(alt_candidate)
            if alt_candidate in g.fn_param_is_ptr || alt_candidate in g.fn_return_types {
                return alt_candidate
            }
        }
    }
    if g.generic_call_name_has_placeholder_suffix(name) {
        if return_bindings := g.infer_generic_bindings_from_current_return(decl, generic_params) {
            g.record_late_generic_call_spec(generic_base_name, return_bindings)
            candidate := g.specialized_fn_name(decl, return_bindings)
            g.ensure_specialized_call_signature(candidate)
            if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
                return candidate
            }
            mut suffixes := []string{cap: generic_params.len}
            for param_name in generic_params {
                concrete := return_bindings[param_name] or { return none }
                suffixes << g.generic_specialization_token_from_type(concrete)
            }
            alt_candidate := '${generic_base_name}_T_${suffixes.join('_')}'
            g.ensure_specialized_call_signature(alt_candidate)
            if alt_candidate in g.fn_param_is_ptr || alt_candidate in g.fn_return_types {
                return alt_candidate
            }
        }
    }
    if generic_params.len == 1 {
        param_name := generic_params[0]
        arg_offset := if decl.is_method && call_args.len == decl.typ.params.len + 1 { 1 } else { 0 }
        for i, param in decl.typ.params {
            arg_idx := i + arg_offset
            if arg_idx >= call_args.len || !expr_has_generic_placeholder(param.typ) {
                continue
            }
            direct_placeholder := direct_generic_placeholder_name(param.typ)
            if direct_placeholder != param_name {
                continue
            }
            base_arg := if call_args[arg_idx] is ast.ModifierExpr {
                (call_args[arg_idx] as ast.ModifierExpr).expr
            } else {
                call_args[arg_idx]
            }
            mut arg_type_name := g.generic_specialization_arg_type_name(base_arg)
            if base_arg is ast.InitExpr {
                arg_type_name = g.expr_type_to_c(base_arg.typ).trim_space()
            }
            if arg_type_name == '' || arg_type_name == 'int' {
                mut found_local_arg_type := false
                if base_arg is ast.Ident {
                    arg_type_name = (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space()
                    found_local_arg_type = arg_type_name != ''
                }
                if !found_local_arg_type && (arg_type_name == '' || arg_type_name == 'int') {
                    arg_type_name = g.get_expr_type(base_arg).trim_space()
                }
            }
            if arg_type_name == '' && base_arg is ast.Ident {
                arg_type_name = (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space()
            }
            if arg_type_name == '' || arg_type_name == 'int' {
                if raw := g.get_raw_type(base_arg) {
                    arg_type_name = g.types_type_to_c(raw).trim_space()
                }
            }
            if arg_type_name != '' && arg_type_name != 'int'
                && arg_type_name.trim_space() != 'void*' {
                arg_type_name = g.resolve_sum_payload_arg_type_name(base_arg, arg_type_name)
            }
            arg_type_name = if arg_type_name.trim_space() == 'void*' {
                'voidptr'
            } else {
                arg_type_name.trim_space()
            }
            if arg_type_name == '' || arg_type_name == 'int' {
                continue
            }
            is_direct_array_param := param.typ is ast.Type && param.typ is ast.ArrayType
            mut candidate_types := [arg_type_name]
            if !arg_type_name.contains('__') && g.cur_module != '' && g.cur_module != 'main'
                && g.cur_module != 'builtin' {
                candidate_types << '${g.cur_module}__${arg_type_name}'
                if is_direct_array_param && arg_type_name.starts_with('Array_')
                    && arg_type_name.len > 'Array_'.len {
                    elem_type_name := arg_type_name['Array_'.len..]
                    if !elem_type_name.contains('__') {
                        candidate_types << 'Array_${g.cur_module}__${elem_type_name}'
                    }
                }
            }
            for concrete_type_name in candidate_types {
                token := generic_specialization_token_for_direct_param(param.typ,
                    concrete_type_name)
                if candidate := g.find_specialized_call_name(name, token) {
                    return candidate
                }
                if !is_direct_array_param {
                    continue
                }
                candidate_name := '${name}_T_${token}'
                g.ensure_specialized_call_signature(candidate_name)
                if candidate := g.find_specialized_call_name(name, token) {
                    return candidate
                }
                if !name.contains('__') {
                    qualified := g.qualify_local_call_name(candidate_name)
                    g.ensure_specialized_call_signature(qualified)
                    if candidate := g.find_specialized_call_name(name, token) {
                        return candidate
                    }
                }
            }
        }
    }
    mut bindings := map[string]types.Type{}
    mut receiver_bindings := map[string]types.Type{}
    if decl.is_method && call_args.len > 0 && expr_has_generic_placeholder(decl.receiver.typ) {
        recv_arg := if call_args[0] is ast.ModifierExpr {
            (call_args[0] as ast.ModifierExpr).expr
        } else {
            call_args[0]
        }
        if expr_has_valid_data(recv_arg) {
            if concrete := g.concrete_type_from_generic_call_arg(recv_arg) {
                g.infer_generic_type_bindings_from_param(decl.receiver.typ,
                    g.concrete_type_with_active_generics(concrete),
                    receiver_generic_param_names(decl), mut receiver_bindings)
            }
        }
    }
    arg_offset := if decl.is_method && call_args.len == decl.typ.params.len + 1 { 1 } else { 0 }
    for i, param in decl.typ.params {
        arg_idx := i + arg_offset
        if arg_idx >= call_args.len || !expr_has_generic_placeholder(param.typ) {
            continue
        }
        arg := if call_args[arg_idx] is ast.ModifierExpr {
            (call_args[arg_idx] as ast.ModifierExpr).expr
        } else {
            call_args[arg_idx]
        }
        if !expr_has_valid_data(arg) {
            continue
        }
        mut concrete := types.Type(types.void_)
        mut found_concrete := false
        if arg is ast.InitExpr {
            c_name := g.expr_type_to_c(arg.typ).trim_space()
            if concrete_type := g.concrete_type_from_call_arg_c_name(c_name) {
                concrete = concrete_type
                found_concrete = true
            }
        }
        if !found_concrete && arg is ast.CastExpr {
            c_name := g.expr_type_to_c(arg.typ).trim_space()
            if concrete_type := g.concrete_type_from_call_arg_c_name(c_name) {
                concrete = concrete_type
                found_concrete = true
            }
        }
        if !found_concrete {
            c_name := g.generic_specialization_arg_type_name(arg).trim_space()
            if c_name != '' && c_name != 'int' && c_name != 'void*' {
                if concrete_type := g.concrete_type_from_call_arg_c_name(c_name) {
                    concrete = concrete_type
                    found_concrete = true
                }
            }
        }
        if !found_concrete {
            if active_concrete := g.active_generic_concrete_from_arg(arg) {
                concrete = active_concrete
                found_concrete = true
            }
        }
        pos := arg.pos()
        if !found_concrete && arg is ast.Ident {
            arg_type_name := (g.get_local_var_c_type(arg.name) or { '' }).trim_space()
            if arg_type_name != '' {
                if local_type := g.concrete_type_from_call_arg_c_name(arg_type_name) {
                    concrete = local_type
                    found_concrete = true
                }
            }
        }
        if !found_concrete && pos.id != 0 {
            if env_type := g.env.get_expr_type(pos.id) {
                concrete = env_type
                found_concrete = true
            }
        }
        if !found_concrete {
            if raw := g.get_raw_type(arg) {
                if raw.name() != 'int' {
                    concrete = raw
                    found_concrete = true
                }
            }
        }
        if !found_concrete {
            continue
        }
        g.infer_generic_type_bindings_from_param(param.typ, g.concrete_type_for_generic_param(param,
            concrete), generic_params, mut bindings)
    }
    if bindings.len != generic_params.len {
        return none
    }
    for _, concrete in bindings {
        if type_contains_generic_placeholder(concrete) {
            return none
        }
    }
    g.record_late_generic_call_spec(generic_base_name, bindings)
    mut suffixes := []string{}
    for param_name in generic_params {
        if concrete := bindings[param_name] {
            suffixes << g.generic_specialization_token_from_type(concrete)
        }
    }
    if suffixes.len > 0 {
        lookup_name := generic_base_name
        if candidate := g.find_specialized_call_name(lookup_name, suffixes.join('_')) {
            return candidate
        }
        suffix := suffixes.join('_')
        alt_candidate := '${lookup_name}_T_${suffix}'
        g.ensure_specialized_call_signature(alt_candidate)
        if alt_candidate in g.fn_param_is_ptr || alt_candidate in g.fn_return_types {
            return alt_candidate
        }
    }
    mut combined_bindings := receiver_bindings.clone()
    for param_name, concrete in bindings {
        combined_bindings[param_name] = concrete
    }
    candidate := g.specialized_fn_name(decl, combined_bindings)
    g.ensure_specialized_call_signature(candidate)
    if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
        return candidate
    }
    if candidate.contains('__') {
        if known_candidate := g.find_known_qualified_fn_name(candidate.all_after_last('__')) {
            return known_candidate
        }
    }
    return candidate
}

fn (mut g Gen) specialize_direct_method_call_name(name string, receiver ast.Expr, args []ast.Expr) string {
    if name == '' {
        return name
    }
    mut call_args := []ast.Expr{cap: args.len + 1}
    call_args << receiver
    call_args << args
    if specialized_name := g.try_specialize_generic_call_name(name, call_args) {
        if g.generic_specialization_should_replace_call_name(name, specialized_name) {
            return specialized_name
        }
    }
    return name
}

// register_builder_methods ensures strings__Builder methods are known to
// fn_param_is_ptr so call sites emit &sb for the receiver.  The Builder
// is a typedef for array and its methods take a mutable (pointer) receiver.
fn (mut g Gen) register_builder_methods() {
    builder_methods := [
        // name, has_extra_param, return_type
        ['strings__Builder__write_rune', 'true', 'void'],
        ['strings__Builder__write_u8', 'true', 'void'],
        ['strings__Builder__write_string', 'true', 'void'],
        ['strings__Builder__write_ptr', 'true', 'void'],
        ['strings__Builder__write_repeated_rune', 'true', 'void'],
        ['strings__Builder__spart', 'false', 'string'],
        ['strings__Builder__cut_last', 'true', 'void'],
        ['strings__Builder__str', 'false', 'string'],
    ]
    for entry in builder_methods {
        name := entry[0]
        has_extra := entry[1] == 'true'
        ret := entry[2]
        if name !in g.fn_param_is_ptr {
            if has_extra {
                g.fn_param_is_ptr[name] = [true, false]
                g.fn_param_types[name] = ['strings__Builder*', 'int']
            } else {
                g.fn_param_is_ptr[name] = [true]
                g.fn_param_types[name] = ['strings__Builder*']
            }
            g.fn_return_types[name] = ret
        }
    }
}

fn (mut g Gen) emit_fixed_array_return_wrappers() {
    mut fixed_types := g.fixed_array_ret_wrappers.keys()
    fixed_types.sort()
    for fixed_type in fixed_types {
        wrapper_name := g.fixed_array_ret_wrappers[fixed_type] or {
            fixed_array_return_wrapper_name(fixed_type)
        }
        key := 'fixed_ret_wrapper_${wrapper_name}'
        if key in g.emitted_types {
            continue
        }
        g.emitted_types[key] = true
        g.sb.writeln('typedef struct ${wrapper_name} {')
        g.sb.writeln('\t${fixed_type} ret_arr;')
        g.sb.writeln('} ${wrapper_name};')
        g.sb.writeln('')
    }
}

fn (mut g Gen) gen_fn_decl(node ast.FnDecl) {
    g.gen_fn_decl_ptr(&node)
}

fn (mut g Gen) gen_fn_decl_ptr(node &ast.FnDecl) {
    if !g.should_emit_fn_decl_cached(g.cur_module, *node) {
        return
    }
    // All other functions are resolved from the host executable.
    if g.pref != unsafe { nil } && g.pref.is_shared_lib {
        if !node.attributes.has('live') {
            return
        }
    }
    // Generate V and .c.v function bodies, but skip JS and C extern declarations.
    if node.language == .js {
        return
    }
    // Header files carry declaration-only function nodes.
    if g.cur_file_name.ends_with('.vh') {
        return
    }
    if node.language == .c && node.stmts.len == 0 {
        return
    }
    if g.should_skip_backend_generic_fn(*node) {
        return
    }
    if g.generic_fn_param_names(*node).len > 0 {
        // maxof[T]/minof[T] are compile-time functions fully inlined by the transformer.
        // Skip emitting stub bodies (which contain invalid C).
        if node.name in ['maxof', 'minof'] {
            return
        }
        prev_generic_types := g.active_generic_types.clone()
        specs := g.generic_fn_specializations_for_emit_scope_with_receiver_bindings(*node)
        for spec in specs {
            g.active_generic_types = spec.generic_types.clone()
            g.gen_fn_decl_with_name_ptr(node, spec.name)
        }
        g.active_generic_types = prev_generic_types.clone()
        return
    }

    // For methods on generic structs (e.g. LinkedList[T].push), resolve the
    // generic params from the receiver type using recorded struct bindings.
    // This ensures T resolves to the concrete type (e.g. ValueInfo) instead
    // of the default fallback (f64).
    recv_generic_params := receiver_generic_param_names(*node)
    if recv_generic_params.len > 0 {
        all_bindings := g.get_all_receiver_generic_bindings(*node)
        if all_bindings.len > 0 {
            prev_generic_types := g.active_generic_types.clone()
            for bi in all_bindings {
                g.active_generic_types = bi.clone()
                fn_name := g.get_fn_name(*node)
                if fn_name != '' {
                    g.gen_fn_decl_with_name_ptr(node, fn_name)
                }
            }
            g.active_generic_types = prev_generic_types.clone()
            return
        } else if bindings := g.get_receiver_generic_bindings(*node) {
            prev_generic_types := g.active_generic_types.clone()
            g.active_generic_types = bindings.clone()
            fn_name := g.get_fn_name(*node)
            if fn_name != '' {
                g.gen_fn_decl_with_name_ptr(node, fn_name)
            }
            g.active_generic_types = prev_generic_types.clone()
            return
        }
        return
    }
    if node.is_method && node.receiver.typ !is ast.EmptyExpr {
        recv_c_name := g.decl_expr_type_to_c(node.receiver.typ).trim_right('*')
        recv_lookup_name := if recv_c_name.contains('__') {
            recv_c_name.all_after_last('__')
        } else {
            recv_c_name
        }
        recv_struct := g.lookup_struct_type(recv_lookup_name)
        if recv_struct.generic_params.len > 0 {
            body_key := 'body_${recv_c_name}'
            if body_key !in g.emitted_types && body_key !in g.pending_late_body_keys {
                return
            }
        }
    }

    mut fn_name := g.get_fn_name(*node)
    if fn_name == '' {
        return
    }
    if specialized_name := g.called_specialized_name_for_base(fn_name) {
        g.copy_fn_signature(fn_name, specialized_name)
        fn_name = specialized_name
    }
    g.gen_fn_decl_with_name_ptr(node, fn_name)
}

fn (mut g Gen) gen_fn_decl_with_name(node ast.FnDecl, fn_name string) {
    g.gen_fn_decl_with_name_ptr(&node, fn_name)
}

fn (mut g Gen) remember_called_specialized_name(name string) {
    if name == '' || !name.contains('_T_') {
        return
    }
    base := name.all_before('_T_')
    if base == '' || base in g.called_specialized_names {
        return
    }
    g.called_specialized_names[base] = name
}

fn (mut g Gen) ensure_called_specialized_name_index() {
    if g.called_specialized_names_indexed {
        return
    }
    g.called_specialized_names = map[string]string{}
    for name, _ in g.called_fn_names {
        g.remember_called_specialized_name(name)
    }
    g.called_specialized_names_indexed = true
}

fn (g &Gen) called_specialized_name_for_base(base string) ?string {
    if base.contains('_T_') {
        return none
    }
    if g.called_specialized_names_indexed {
        if name := g.called_specialized_names[base] {
            return name
        }
        return none
    }
    prefix := '${base}_T_'
    for name, _ in g.called_fn_names {
        if name.starts_with(prefix) {
            return name
        }
    }
    return none
}

fn (mut g Gen) copy_fn_signature(from_name string, to_name string) {
    if to_name in g.fn_return_types || to_name in g.fn_param_is_ptr {
        return
    }
    if ret := g.fn_return_types[from_name] {
        g.fn_return_types[to_name] = ret
    }
    if params := g.fn_param_is_ptr[from_name] {
        g.fn_param_is_ptr[to_name] = params.clone()
    }
    if param_types := g.fn_param_types[from_name] {
        g.fn_param_types[to_name] = param_types.clone()
    }
    g.remember_specialized_fn_base(to_name)
}

// Keep pass 5 on pointer-based FnDecl access; large by-value copies here
// corrupt the self-hosted cleanc caller after the first emitted body.
fn (mut g Gen) gen_fn_decl_with_name_ptr(node &ast.FnDecl, fn_name string) {
    if g.should_skip_backend_generic_fn(*node) {
        return
    }
    fn_key := 'fn_${fn_name}'
    if fn_key in g.blocked_fn_keys && !g.explicit_slice_emit_allows(fn_key) {
        return
    }
    if g.should_skip_plain_v_fallback_fn(fn_key) {
        return
    }
    if fn_key in g.emitted_types {
        return
    }
    g.emitted_types[fn_key] = true
    saved_module := g.cur_module
    saved_import_modules := g.cur_import_modules.clone()
    defer {
        g.cur_module = saved_module
        g.cur_import_modules = saved_import_modules.clone()
        g.is_module_ident_cache.clear()
        g.resolved_module_names.clear()
    }
    fn_module := module_prefix_from_fn_name(fn_name)
    if fn_module.len > 0 && fn_module[0] >= `a` && fn_module[0] <= `z`
        && g.source_module_exists(fn_module) && g.cur_module != fn_module {
        g.cur_module = fn_module
        g.cur_import_modules.clear()
        g.is_module_ident_cache.clear()
        g.resolved_module_names.clear()
    }

    // Set function scope for type lookups
    g.cur_fn_name = node.name
    g.cur_fn_c_name = fn_name
    g.runtime_local_types.clear()
    g.runtime_decl_types.clear()
    // Drop/RAII (Phase 1B): preload per-return drop snapshots for this fn
    // so the ReturnStmt handler can emit `Type__drop(&var)` in source order.
    g.cur_fn_return_drops = if g.env != unsafe { nil } {
        g.env.drop_at_returns[fn_name] or { [][]types.DropEntry{} }
    } else {
        [][]types.DropEntry{}
    }
    g.cur_fn_return_index = 0
    g.cur_fn_returned_idents = g.collect_returned_idents(node.stmts)
    g.is_module_ident_cache.clear()
    g.not_local_var_cache.clear()
    g.resolved_module_names.clear()
    is_program_main := g.is_program_main_fn(node)
    g.cur_fn_ret_type = if is_program_main {
        'int'
    } else 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'
    }
    g.cur_fn_ret_type = normalize_signature_type_name(g.cur_fn_ret_type, 'void')
    g.cur_fn_c_ret_type = g.c_fn_return_type_from_v(g.cur_fn_ret_type)
    if g.env != unsafe { nil } {
        // For methods, the checker stores scopes using V-style receiver type names
        // (e.g. "[]string__free"), while get_fn_name returns C-style names
        // (e.g. "Array_string__free"). Use V-style name for scope lookup.
        scope_fn_name := if node.is_method {
            // The checker stores scopes using V-style receiver type names
            // (e.g. "[]string__free", "Builder__go_back"). Convert the AST
            // receiver type expression to match.
            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
        } else if node.is_method {
            // Fallback: for type aliases (e.g. Builder = []u8), the checker resolves
            // the alias and uses the underlying type name. Try env-based resolution.
            mut found := false
            if expr_has_valid_data(node.receiver.typ) {
                receiver_pos := node.receiver.typ.pos()
                if receiver_pos.is_valid() {
                    if recv_type := g.env.get_expr_type(receiver_pos.id) {
                        base_type := recv_type.base_type()
                        alt_scope_name := '${base_type.name()}__${node.name}'
                        if fn_scope2 := g.env.get_fn_scope(g.cur_module, alt_scope_name) {
                            g.cur_fn_scope = fn_scope2
                            found = true
                        }
                    }
                }
            }
            if !found {
                g.cur_fn_scope = unsafe { nil }
            }
        } else {
            g.cur_fn_scope = unsafe { nil }
        }
    }

    // Track mut parameter names for pointer detection
    g.cur_fn_mut_params.clear()
    g.cur_fn_generic_params.clear()
    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 node.receiver.is_mut || receiver_type.ends_with('*') {
            g.cur_fn_mut_params[node.receiver.name] = true
        }
    }
    // Register receiver type in local runtime type cache so chained selector
    // resolution (e.g. a.x.y) can infer field types reliably.
    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)
        }
    }
    if g.needs_implicit_veb_ctx_param(node, fn_name) {
        ctx_type := g.implicit_veb_ctx_c_type()
        g.cur_fn_mut_params['ctx'] = true
        g.remember_runtime_local_type('ctx', ctx_type)
    }
    mut param_ptr_offset := 0
    if node.is_method && 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) {
        param_ptr_offset++
    }
    for param_idx, param in node.typ.params {
        mut param_is_ptr := param.is_mut
        mut param_type := g.fn_param_signature_c_type(param)
        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 ptr_params := g.fn_param_is_ptr[fn_name] {
            ptr_idx := param_idx + param_ptr_offset
            if ptr_idx < ptr_params.len && ptr_params[ptr_idx] {
                param_is_ptr = true
            }
        }
        if param_is_ptr {
            g.cur_fn_mut_params[param.name] = true
        }
        // Register parameter types from the function declaration.
        // The declaration type is authoritative and ensures correct types
        // even when the env position lookup returns wrong results.
        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)
            // Also register under the C-renamed name (e.g. 'array' → '_v_array')
            // so that body references using the renamed identifier can find the type.
            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
        }
    }

    // Check for @[live] attribute
    is_live_fn := !is_program_main && node.attributes.has('live') && g.cache_bundle_name.len == 0

    // Generate function header (with impl_live_ prefix for @[live] functions)
    if is_live_fn {
        g.gen_fn_head_live_ptr(node, fn_name)
    } else {
        g.gen_fn_head_with_name_ptr(node, fn_name)
    }
    g.sb.writeln(' {')
    g.indent++

    if fn_name.starts_with('Array_') && fn_name.ends_with('_contains') && g.is_freestanding_target()
        && g.pref != unsafe { nil } && g.pref.skip_builtin {
        g.write_indent()
        g.sb.writeln('_Static_assert(0, "${freestanding_missing_heap_runtime_message}: ${fn_name}");')
        g.write_indent()
        g.sb.writeln('return false;')
        g.indent--
        g.sb.writeln('}')
        g.sb.writeln('')
        return
    }

    if g.gen_json2_decode_string_body(node) {
        g.indent--
        g.sb.writeln('}')
        g.sb.writeln('')
        return
    }

    if g.gen_json2_cached_struct_field_infos_body(node) {
        g.indent--
        g.sb.writeln('}')
        g.sb.writeln('')
        return
    }

    // Main function: initialize argc/argv
    if is_program_main {
        g.write_indent()
        g.sb.writeln('g_main_argc = ___argc;')
        g.write_indent()
        g.sb.writeln('g_main_argv = (void*)___argv;')
        // Prealloc arena initialization (must run before any V allocations)
        if g.pref != unsafe { nil } && g.pref.prealloc {
            g.write_indent()
            g.sb.writeln('prealloc_vinit();')
        }
        // GC initialization (translated from Go's runtime GC init)
        if g.pref != unsafe { nil } && g.pref.gc_mode == .vgc {
            g.write_indent()
            g.sb.writeln('// VGC initialization (concurrent tri-color mark-and-sweep)')
            g.write_indent()
            g.sb.writeln('builtin__vgc_init();')
        }
        for init_call in g.cached_init_calls {
            g.write_indent()
            g.sb.writeln('${init_call}();')
        }
        g.write_indent()
        g.sb.writeln('g_main_argc = ___argc;')
        g.write_indent()
        g.sb.writeln('g_main_argv = (void*)___argv;')
    }
    // Live reload is only present when the program actually declares @[live] functions.
    if is_program_main && g.has_live_reload_functions() {
        g.write_indent()
        g.sb.writeln('__v_live_init();')
    }
    g.gen_stmts(node.stmts)

    // Drop/RAII: invoke `Type__drop(&var)` for each still-owned binding
    // the checker scheduled. Only emitted at the natural fn exit (no
    // early-return support yet) and skipped when the body ends in an
    // explicit `return` (those drops would be unreachable). Phase 1B
    // will weave drops through every return point.
    g.emit_scheduled_drops(node.stmts, fn_name)

    // Implicit return 0 for main
    if is_program_main {
        g.write_indent()
        g.sb.writeln('return 0;')
    } else if g.cur_fn_ret_type.starts_with('_result_') {
        g.write_indent()
        g.sb.writeln('return (${g.cur_fn_ret_type}){0};')
    } else if g.cur_fn_ret_type.starts_with('_option_') {
        g.write_indent()
        g.sb.writeln('return (${g.cur_fn_ret_type}){0};')
    }

    g.indent--
    g.sb.writeln('}')
    g.sb.writeln('')
}

// emit_scheduled_drops writes destructor calls for the bindings the
// checker recorded under `fn_name` in `env.drop_at_fn_exit`. Calls are
// emitted in reverse declaration order (LIFO: last declared, first
// dropped) and skipped entirely if the body's last statement is an
// explicit `return` — the drops would be unreachable code after such a
// return, and Phase 1B will handle per-return drop weaving instead.
fn (mut g Gen) emit_scheduled_drops(stmts []ast.Stmt, fn_name string) {
    if g.env == unsafe { nil } {
        return
    }
    entries := g.env.drop_at_fn_exit[fn_name] or { return }
    if entries.len == 0 {
        return
    }
    if cleanc_stmts_end_with_return(stmts) {
        return
    }
    for i := entries.len - 1; i >= 0; i-- {
        entry := entries[i]
        g.write_indent()
        g.sb.writeln('${entry.type_name}__drop(&${entry.var_name});')
    }
}

// emit_scheduled_drops_at_return writes destructor calls for the bindings
// the checker recorded for the current ReturnStmt (Phase 1B). Snapshots
// are consumed positionally — the counter advances every call so the next
// ReturnStmt picks up the next snapshot. Drops emit in LIFO order
// (declaration-order reverse) for a single coherent scope. Bindings being
// returned (and thus moved out) were excluded by the checker.
fn (mut g Gen) emit_scheduled_drops_at_return() {
    if g.suppress_return_drop_emit {
        return
    }
    if g.cur_fn_return_index >= g.cur_fn_return_drops.len {
        return
    }
    entries := g.cur_fn_return_drops[g.cur_fn_return_index]
    g.cur_fn_return_index++
    for i := entries.len - 1; i >= 0; i-- {
        entry := entries[i]
        g.write_indent()
        g.sb.writeln('${entry.type_name}__drop(&${entry.var_name});')
    }
}

fn cleanc_stmts_end_with_return(stmts []ast.Stmt) bool {
    for i := stmts.len - 1; i >= 0; i-- {
        stmt := stmts[i]
        if stmt is ast.EmptyStmt {
            continue
        }
        return stmt is ast.ReturnStmt
    }
    return false
}

fn (mut g Gen) gen_json2_decode_string_body(node &ast.FnDecl) bool {
    if g.cur_module != 'json2' || !node.is_method || node.name != 'decode_string' {
        return false
    }
    concrete := g.active_generic_types['T'] or { return false }
    if concrete !is types.String && concrete.name() != 'string' {
        return false
    }
    g.write_indent()
    g.sb.writeln('json2__ValueInfo string_info = decoder->current_node->value;')
    g.write_indent()
    g.sb.writeln('if (string_info.value_kind == json2__ValueKind__string) {')
    g.indent++
    g.write_indent()
    g.sb.writeln('int string_start = string_info.position + 1;')
    g.write_indent()
    g.sb.writeln('int string_end = string_info.position + string_info.length - 1;')
    g.write_indent()
    g.sb.writeln('string string_body = string__substr(decoder->json, string_start, string_end);')
    g.write_indent()
    g.sb.writeln('*val = string_body;')
    g.write_indent()
    g.sb.writeln('return (_result_void){ .is_error=false };')
    g.indent--
    g.write_indent()
    g.sb.writeln('}')
    g.write_indent()
    g.sb.writeln('_result_void _err = json2__Decoder__decode_error(decoder, (string){.str = "Expected string", .len = sizeof("Expected string") - 1, .is_lit = 1});')
    g.write_indent()
    g.sb.writeln('if (_err.is_error) {')
    g.indent++
    g.write_indent()
    g.sb.writeln('IError err = _err.err;')
    g.write_indent()
    g.sb.writeln('return (_result_void){ .is_error=true, .err=err };')
    g.indent--
    g.write_indent()
    g.sb.writeln('}')
    g.write_indent()
    g.sb.writeln('return (_result_void){ .is_error=false };')
    return true
}

fn (mut g Gen) gen_json2_cached_struct_field_infos_body(node &ast.FnDecl) bool {
    if g.cur_module != 'json2' || !node.is_method || node.name != 'cached_struct_field_infos' {
        return false
    }
    concrete := g.active_generic_types['T'] or { return false }
    mut fields := []types.Field{}
    if concrete is types.Struct {
        mut struct_type := concrete
        if struct_type.fields.len == 0 {
            struct_c_name := g.types_type_to_c(concrete).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
            }
        }
        fields = struct_type.fields.clone()
    }
    g.write_indent()
    g.sb.writeln('Array_json2__StructFieldInfo field_infos = __new_array_with_default_noscan(0, ${fields.len}, sizeof(json2__StructFieldInfo), NULL);')
    for field in fields {
        json_name, is_skip_from_json := json2_field_json_name_and_skip(field)
        json_name_literal := c_string_literal_content_to_c(json_name)
        g.write_indent()
        g.sb.writeln('array__push((array*)&field_infos, &(json2__StructFieldInfo){.json_name_ptr = (void*)(${json_name_literal}), .json_name_len = ${json_name.len}, .is_omitempty = ${field_has_attr(field.attributes,
            'omitempty')}, .is_skip = ${field_has_attr(field.attributes, 'skip')
            || is_skip_from_json}, .is_required = ${field_has_attr(field.attributes, 'required')}, .is_raw = ${field_has_attr(field.attributes,
            'raw')}});')
    }
    g.write_indent()
    g.sb.writeln('return field_infos;')
    return true
}

fn field_has_attr(attrs []ast.Attribute, name string) bool {
    for attr in attrs {
        if attr.name == name {
            return true
        }
        if attr.name == '' && attr.value.name().trim('\'"') == name {
            return true
        }
    }
    return false
}

fn json2_field_json_name_and_skip(field types.Field) (string, bool) {
    for attr in field.attributes {
        if attr.name == 'json' && attr.value is ast.StringLiteral {
            value := attr.value.value.trim('\'"')
            if value == '-' {
                return field.name, true
            }
            if value != '' {
                return value, false
            }
        }
    }
    return field.name, false
}

fn (mut g Gen) collect_returned_idents(stmts []ast.Stmt) map[string]bool {
    mut out := map[string]bool{}
    g.collect_returned_idents_from_stmts(stmts, mut out)
    return out
}

fn (mut g Gen) collect_returned_idents_from_stmts(stmts []ast.Stmt, mut out map[string]bool) {
    for stmt in stmts {
        g.collect_returned_idents_from_stmt(stmt, mut out)
    }
}

fn (mut g Gen) collect_returned_idents_from_stmt(stmt ast.Stmt, mut out map[string]bool) {
    match stmt {
        ast.ReturnStmt {
            if stmt.exprs.len == 1 {
                if name := returned_ident_name(stmt.exprs[0]) {
                    out[name] = true
                }
            }
        }
        ast.BlockStmt {
            g.collect_returned_idents_from_stmts(stmt.stmts, mut out)
        }
        ast.ComptimeStmt {
            if stmt.stmt !is ast.EmptyStmt {
                g.collect_returned_idents_from_stmt(stmt.stmt, mut out)
            }
        }
        ast.DeferStmt {
            g.collect_returned_idents_from_stmts(stmt.stmts, mut out)
        }
        ast.ForStmt {
            if stmt.init !is ast.EmptyStmt {
                g.collect_returned_idents_from_stmt(stmt.init, mut out)
            }
            if stmt.post !is ast.EmptyStmt {
                g.collect_returned_idents_from_stmt(stmt.post, mut out)
            }
            g.collect_returned_idents_from_stmts(stmt.stmts, mut out)
        }
        ast.LabelStmt {
            if stmt.stmt !is ast.EmptyStmt {
                g.collect_returned_idents_from_stmt(stmt.stmt, mut out)
            }
        }
        ast.ExprStmt {
            g.collect_returned_idents_from_expr(stmt.expr, mut out)
        }
        else {}
    }
}

fn (mut g Gen) collect_returned_idents_from_expr(expr ast.Expr, mut out map[string]bool) {
    match expr {
        ast.IfExpr {
            g.collect_returned_idents_from_stmts(expr.stmts, mut out)
            if expr.else_expr !is ast.EmptyExpr {
                g.collect_returned_idents_from_expr(expr.else_expr, mut out)
            }
        }
        ast.MatchExpr {
            for branch in expr.branches {
                g.collect_returned_idents_from_stmts(branch.stmts, mut out)
            }
        }
        ast.SelectExpr {
            g.collect_returned_idents_from_stmts(expr.stmts, mut out)
            if expr.next !is ast.EmptyExpr {
                g.collect_returned_idents_from_expr(expr.next, mut out)
            }
        }
        ast.UnsafeExpr {
            g.collect_returned_idents_from_stmts(expr.stmts, mut out)
        }
        ast.ParenExpr {
            g.collect_returned_idents_from_expr(expr.expr, mut out)
        }
        ast.ModifierExpr {
            g.collect_returned_idents_from_expr(expr.expr, mut out)
        }
        ast.CastExpr {
            g.collect_returned_idents_from_expr(expr.expr, mut out)
        }
        else {}
    }
}

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

    return none
}

fn (mut g Gen) gen_fn_head(node ast.FnDecl) {
    fn_name := g.get_fn_name(node)
    if fn_name == '' {
        return
    }
    g.gen_fn_head_with_name_ptr(&node, fn_name)
}

fn (mut g Gen) gen_fn_head_with_name(node ast.FnDecl, fn_name string) {
    g.gen_fn_head_with_name_ptr(&node, fn_name)
}

fn (mut g Gen) gen_fn_head_with_name_ptr(node &ast.FnDecl, fn_name string) {
    if g.should_skip_backend_generic_fn(*node) {
        return
    }
    g.declared_fn_names[fn_name] = true
    is_program_main := g.is_program_main_fn(node)
    mut ret := ''
    if fn_ret := g.fn_return_types[fn_name] {
        ret = fn_ret
    } else if node.typ.return_type !is ast.EmptyExpr {
        ret = g.expr_type_to_c(node.typ.return_type)
    } else {
        ret = 'void'
    }
    ret = normalize_signature_type_name(ret, 'void')
    mut c_ret := g.c_fn_return_type_from_v(ret)
    if ret.starts_with('Tuple_') {
        g.ensure_tuple_alias_for_fn_return(*node, ret)
        g.emit_tuple_aliases()
    }
    if is_program_main {
        ret = 'int'
        c_ret = 'int'
    }
    sig_param_types := g.fn_param_types[fn_name] or { []string{} }

    // main takes argc/argv
    if is_program_main {
        g.sb.write_string(c_ret)
        g.sb.write_string(' ')
        g.sb.write_string(fn_name)
        g.sb.write_string('(int ___argc, char** ___argv)')
        return
    }

    g.sb.write_string(c_ret)
    g.sb.write_string(' ')
    g.sb.write_string(fn_name)
    g.sb.write_string('(')

    mut first := true
    mut sig_idx := 0
    // Receiver as first param for methods
    if node.is_method && node.receiver.name != '' {
        receiver_type := if sig_idx < sig_param_types.len {
            normalize_signature_type_name(sig_param_types[sig_idx], 'void*')
        } else if node.receiver.is_mut {
            rt := normalize_signature_type_name(g.decl_expr_type_to_c(node.receiver.typ), 'void*')
            if rt.ends_with('*') {
                rt
            } else {
                rt + '*'
            }
        } else {
            normalize_signature_type_name(g.decl_expr_type_to_c(node.receiver.typ), 'void*')
        }
        g.sb.write_string(receiver_type)
        g.sb.write_string(' ')
        g.sb.write_string(node.receiver.name)
        sig_idx++
        first = false
    }
    if g.needs_implicit_veb_ctx_param(node, fn_name) {
        if !first {
            g.sb.write_string(', ')
        }
        first = false
        g.sb.write_string(g.implicit_veb_ctx_c_type())
        g.sb.write_string(' ctx')
        sig_idx++
    }

    for param_idx, param in node.typ.params {
        if !first {
            g.sb.write_string(', ')
        }
        first = false
        pname := c_fn_param_name(param.name, param_idx)
        if param.typ is ast.Type {
            if param.typ is ast.FnType {
                g.gen_fn_type_param_decl(param.typ as ast.FnType, pname)
                sig_idx++
                continue
            }
        }
        t := if sig_idx < sig_param_types.len {
            normalize_signature_type_name(sig_param_types[sig_idx], 'int')
        } else if param.is_mut {
            pt := normalize_signature_type_name(g.expr_type_to_c(param.typ), 'int')
            if pt.ends_with('*') {
                pt
            } else {
                pt + '*'
            }
        } else {
            normalize_signature_type_name(g.expr_type_to_c(param.typ), 'int')
        }
        if t.contains('(*)') {
            fn_ptr_decl := c_fn_pointer_type_with_name(t, pname)
            if fn_ptr_decl != '' {
                g.sb.write_string(fn_ptr_decl)
            } else {
                g.sb.write_string(t)
                g.sb.write_string(' ')
                g.sb.write_string(pname)
            }
        } else {
            g.sb.write_string(t)
            g.sb.write_string(' ')
            // Rename V variables that clash with C type names (matches expr.v Ident handler)
            g.sb.write_string(pname)
        }
        sig_idx++
    }
    g.sb.write_string(')')
}

fn c_fn_pointer_type_with_name(fn_type string, name string) string {
    if !fn_type.contains('(*)') {
        return ''
    }
    return fn_type.replace_once('(*)', '(*${name})')
}

fn (mut g Gen) fn_param_signature_c_type(param ast.Parameter) string {
    if param.typ is ast.Type {
        if param.typ is ast.FnType {
            return g.fn_type_c_type(param.typ as ast.FnType)
        }
    }
    return g.signature_expr_type_to_c(param.typ)
}

fn (mut g Gen) fn_type_c_type(fn_type ast.FnType) string {
    mut ret_type := 'void'
    if fn_type.return_type !is ast.EmptyExpr {
        ret_type = g.expr_type_to_c(fn_type.return_type)
    }
    ret_type = normalize_signature_type_name(ret_type, 'void')
    ret_type = g.c_callback_return_type_from_v(ret_type)
    mut params := []string{cap: fn_type.params.len}
    for param in fn_type.params {
        mut param_type := normalize_signature_type_name(g.expr_type_to_c(param.typ), 'int')
        if param.is_mut && !param_type.ends_with('*') {
            param_type += '*'
        }
        params << param_type
    }
    if params.len == 0 {
        params << 'void'
    }
    return '${ret_type} (*)(${params.join(', ')})'
}

fn (mut g Gen) gen_fn_type_param_decl(fn_type ast.FnType, name string) {
    decl := c_fn_pointer_type_with_name(g.fn_type_c_type(fn_type), name)
    if decl != '' {
        g.sb.write_string(decl)
    }
}

// gen_c_extern_forward_decl emits a forward declaration for a C extern function.
// e.g., `fn C.macos_objc_msg_void1(obj Id, selector Sel, a0 voidptr)` emits:
//   `void macos_objc_msg_void1(void* obj, void* selector, void* a0);`
fn (mut g Gen) gen_c_extern_forward_decl(node ast.FnDecl) {
    // Extract C function name: strip 'C.' prefix if present
    mut c_name := node.name
    if c_name.starts_with('C.') {
        c_name = c_name[2..]
    }
    if c_name == '' {
        return
    }
    // Skip C stdlib functions — they're already declared by system headers.
    if c_name in c_stdlib_fns || is_c_runtime_function(c_name) {
        return
    }
    // Only emit C extern forward declarations for user/third-party modules
    // (from .vmodules/ or the project directory). Skip all vlib modules since
    // they wrap system functions already declared by system headers.
    if !g.cur_file_name.contains('.vmodules/') && g.cur_module != 'main' {
        return
    }
    // Skip already-emitted declarations
    decl_key := 'c_extern_${c_name}'
    if decl_key in g.emitted_types {
        return
    }
    g.emitted_types[decl_key] = true

    // Return type
    mut ret := if node.typ.return_type !is ast.EmptyExpr {
        g.expr_type_to_c(node.typ.return_type)
    } else {
        'void'
    }
    ret = normalize_signature_type_name(ret, 'void')
    c_ret := g.c_fn_return_type_from_v(ret)

    g.sb.write_string(c_ret)
    g.sb.write_string(' ')
    g.sb.write_string(c_name)
    g.sb.write_string('(')

    mut first := true
    for param_idx, param in node.typ.params {
        if !first {
            g.sb.write_string(', ')
        }
        first = false
        mut t := normalize_signature_type_name(g.expr_type_to_c(param.typ), 'int')
        if param.is_mut && !t.ends_with('*') {
            t = t + '*'
        }
        g.sb.write_string(t)
        if param.name != '' {
            pname := c_fn_param_name(param.name, param_idx)
            g.sb.write_string(' ')
            g.sb.write_string(pname)
        }
    }
    if first {
        g.sb.write_string('void')
    }
    g.sb.writeln(');')
}

// gen_fn_head_live generates the function signature with `impl_live_` prefix for @[live]
// functions, and records the function info for generating wrappers and dlsym binding.
fn (mut g Gen) gen_fn_head_live(node ast.FnDecl, fn_name string) {
    g.gen_fn_head_live_ptr(&node, fn_name)
}

// gen_fn_head_live_ptr mirrors gen_fn_head_live without copying ast.FnDecl in pass 5.
fn (mut g Gen) gen_fn_head_live_ptr(node &ast.FnDecl, fn_name string) {
    sig_param_types := g.fn_param_types[fn_name] or { []string{} }

    mut c_ret := g.cur_fn_c_ret_type
    is_void := c_ret == 'void'

    // Build parameter list string and arg forwarding string
    mut params_parts := []string{}
    mut args_parts := []string{}
    mut sig_idx := 0

    // Receiver as first param for methods
    if node.is_method && node.receiver.name != '' {
        receiver_type := if sig_idx < sig_param_types.len {
            normalize_signature_type_name(sig_param_types[sig_idx], 'void*')
        } else if node.receiver.is_mut {
            rt := normalize_signature_type_name(g.decl_expr_type_to_c(node.receiver.typ), 'void*')
            if rt.ends_with('*') {
                rt
            } else {
                rt + '*'
            }
        } else {
            normalize_signature_type_name(g.decl_expr_type_to_c(node.receiver.typ), 'void*')
        }
        params_parts << '${receiver_type} ${node.receiver.name}'
        args_parts << node.receiver.name
        sig_idx++
    }
    if g.needs_implicit_veb_ctx_param(node, fn_name) {
        params_parts << '${g.implicit_veb_ctx_c_type()} ctx'
        args_parts << 'ctx'
        sig_idx++
    }

    for param_idx, param in node.typ.params {
        t := if sig_idx < sig_param_types.len {
            normalize_signature_type_name(sig_param_types[sig_idx], 'int')
        } else if param.is_mut {
            pt := normalize_signature_type_name(g.expr_type_to_c(param.typ), 'int')
            if pt.ends_with('*') {
                pt
            } else {
                pt + '*'
            }
        } else {
            normalize_signature_type_name(g.expr_type_to_c(param.typ), 'int')
        }
        pname := c_fn_param_name(param.name, param_idx)
        params_parts << '${t} ${pname}'
        args_parts << pname
        sig_idx++
    }

    params_str := params_parts.join(', ')
    args_str := args_parts.join(', ')

    // Record live function info for later wrapper generation
    g.live_fns << LiveFnInfo{
        c_name:   fn_name
        ret_type: c_ret
        params:   params_str
        args:     args_str
        is_void:  is_void
    }
    if g.cur_file_name.len > 0 {
        g.live_source_file = os.real_path(g.cur_file_name)
    }

    // Write function signature: ret_type impl_live_FUNC(params)
    // Mark with visibility("default") so it's exported from shared libraries
    // even when -fvisibility=hidden is used.
    g.sb.write_string('__attribute__((visibility("default"))) ')
    g.sb.write_string(c_ret)
    g.sb.write_string(' impl_live_')
    g.sb.write_string(fn_name)
    g.sb.write_string('(')
    g.sb.write_string(params_str)
    g.sb.write_string(')')
}

fn (mut g Gen) get_fn_name(node ast.FnDecl) string {
    // Check for @[export: 'name'] attribute — use the export name as the C symbol.
    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 {
                    return export_name
                }
            }
        }
    }
    if g.is_program_main_fn(&node) {
        return 'main'
    }
    // Prevent collisions with libc symbols from builtin wrappers.
    if !node.is_method && (node.name in c_stdlib_fns || is_c_runtime_function(node.name))
        && (g.cur_module == '' || g.cur_module == 'main' || g.cur_module == 'builtin') {
        return ''
    }
    name := sanitize_fn_ident(node.name)
    // Methods: ReceiverType__method_name
    if node.is_method && node.receiver.name != '' {
        // For pointer alias types (byteptr, charptr), use the V name directly
        // to avoid collisions. e.g., byteptr.str() -> byteptr__str, not u8__str
        // which would conflict with the actual u8.str() method.
        if node.receiver.typ is ast.Ident && node.receiver.typ.name in ['byteptr', 'charptr'] {
            return node.receiver.typ.name + '__' + name
        }
        receiver_type := if concrete_receiver := g.receiver_generic_instance_c_name_for_active_bindings(node) {
            concrete_receiver
        } else {
            g.decl_expr_type_to_c(node.receiver.typ)
        }
        // Strip pointer suffix and 'struct ' prefix for method naming.
        // C struct types like 'struct sg_pipeline' must become 'sg_pipeline'
        // in function names to produce valid C identifiers.
        mut base_type := if receiver_type.ends_with('*') {
            receiver_type[..receiver_type.len - 1]
        } else {
            receiver_type
        }
        if base_type.starts_with('struct ') {
            base_type = base_type[7..]
        }
        recv_scope_name := g.receiver_type_to_scope_name(node.receiver.typ)
        if recv_scope_name != '' && base_type == recv_scope_name
            && g.is_module_local_type(base_type) {
            base_type = '${g.cur_module}__${base_type}'
        }
        if g.cur_module != 'builtin' && base_type in primitive_types {
            // Non-builtin primitive receiver methods are typically accidental generic
            // instantiations (e.g. int__multiply) that produce invalid scalar field access.
            return ''
        }
        method_name := if base_type == 'string' { legacy_operator_fn_ident(node.name) } else { name }
        return base_type + '__' + method_name
    }
    // Static methods: Type.method() -> Type__method
    if node.is_static {
        receiver_type := g.decl_expr_type_to_c(node.receiver.typ)
        mut base_type := if receiver_type.ends_with('*') {
            receiver_type[..receiver_type.len - 1]
        } else {
            receiver_type
        }
        if base_type.starts_with('struct ') {
            base_type = base_type[7..]
        }
        return base_type + '__' + name
    }
    if is_generated_global_helper_name(name) {
        return name
    }
    if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
        // Don't add module prefix if name already starts with it (e.g., generated
        // enum str functions placed back in their source module).
        if name.starts_with(g.cur_module + '__') {
            return name
        }
        fn_module := module_prefix_from_fn_name(name)
        if fn_module.len > 0 && fn_module[0] >= `a` && fn_module[0] <= `z`
            && g.source_module_exists(fn_module) {
            return name
        }
        return g.cur_module + '__' + name
    }
    // Rename builtin `panic` to avoid conflict with macOS mach/mach.h's
    // `extern void panic(const char *, ...)`.
    if name == 'panic' {
        return 'v_panic'
    }
    return name
}

fn is_generated_global_helper_name(name string) bool {
    return name == 'map_map_eq' || name.starts_with('__sort_cmp_') || name.starts_with('Array_')
        || name.starts_with('Map_')
}

fn (g &Gen) is_program_main_fn(node &ast.FnDecl) bool {
    return !node.is_method && !node.is_static && node.name == 'main'
        && (g.cur_module == '' || g.cur_module == 'main')
}

fn c_fn_param_name(name string, idx int) string {
    if name == '' || name == '_' {
        return '_arg${idx}'
    }
    return c_local_name(name)
}

fn (g &Gen) contains_call_expr(e ast.Expr) bool {
    if e is ast.CallExpr {
        return true