module c

import v3.flat
import v3.types

struct TestHarnessFn {
    name   string
    c_name string
    ret    types.Type
}

struct TestHarnessHooks {
mut:
    testsuite_begin string
    testsuite_end   string
    before_each     string
    after_each      string
}

struct TopLevelStmt {
    id     flat.NodeId
    file   string
    module string
}

// gen_fns emits fns output for c.
fn (mut g FlatGen) gen_fns() {
    mut cur_module := ''
    mut cur_file := ''
    for i in 0 .. g.a.nodes.len {
        node := g.a.nodes[i]
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_file = node.value
            g.tc.cur_file = cur_file
            cur_module = ''
            g.tc.cur_module = cur_module
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            continue
        }

        if kind_id == 61 {
            if !g.should_emit_fn_node_in_module(node, i, cur_module) {
                continue
            }
            qfn := g.fn_c_name_in_module(cur_module, node.value)
            if g.emitted_fn_contains(qfn) {
                continue
            }
            g.emitted_fns[qfn] = true
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            g.gen_fn_in_module(node, cur_module)
        }
    }
}

fn (mut g FlatGen) gen_synthetic_main_after_fns() {
    if g.test_files.len > 0 {
        g.gen_test_main()
        return
    }
    if g.has_entry_main() {
        return
    }
    top_level_stmts := g.top_level_stmts()
    if top_level_stmts.len > 0 {
        g.gen_top_level_main(top_level_stmts)
    }
}

fn (g &FlatGen) has_entry_main() bool {
    mut cur_module := ''
    for node in g.a.nodes {
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_module = ''
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            continue
        }
        if kind_id == 61 && node.value == 'main' && (cur_module.len == 0 || cur_module == 'main') {
            return true
        }
    }
    return false
}

fn (g &FlatGen) top_level_stmts() []TopLevelStmt {
    mut stmts := []TopLevelStmt{}
    for file_idx, file_node in g.a.nodes {
        if !g.should_emit_top_level_file(file_idx, file_node) {
            continue
        }
        module_name := g.top_level_file_module_name(file_node)
        for i in 0 .. file_node.children_count {
            child_id := g.a.child(&file_node, i)
            if int(child_id) < g.a.user_code_start {
                continue
            }
            if g.cgen_is_top_level_stmt(child_id) {
                stmts << TopLevelStmt{
                    id:     child_id
                    file:   file_node.value
                    module: if module_name.len == 0 { 'main' } else { module_name }
                }
            }
        }
    }
    return stmts
}

fn (g &FlatGen) should_emit_top_level_file(file_idx int, file_node flat.Node) bool {
    if file_idx < g.a.user_code_start || file_node.kind != .file || file_node.children_count == 0 {
        return false
    }
    module_name := g.top_level_file_module_name(file_node)
    return module_name.len == 0 || module_name == 'main'
}

fn (g &FlatGen) top_level_file_module_name(file_node flat.Node) string {
    for i in 0 .. file_node.children_count {
        child := g.a.child_node(&file_node, i)
        if child.kind == .module_decl {
            return child.value
        }
    }
    return ''
}

fn (g &FlatGen) cgen_is_top_level_stmt(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := g.a.nodes[int(id)]
    return match node.kind {
        .expr_stmt, .assign, .decl_assign, .selector_assign, .index_assign, .for_stmt,
        .for_in_stmt, .if_expr, .assert_stmt, .defer_stmt {
            true
        }
        .block, .comptime_if {
            for i in 0 .. node.children_count {
                if g.cgen_is_top_level_stmt(g.a.child(&node, i)) {
                    return true
                }
            }
            false
        }
        else {
            false
        }
    }
}

// should_emit_fn_node reports whether should emit fn node applies in c.
fn (mut g FlatGen) should_emit_fn_node(node flat.Node, node_index int) bool {
    return g.should_emit_fn_node_in_module(node, node_index, g.tc.cur_module)
}

// should_emit_fn_node_in_module reports whether should emit fn node in module applies in c.
fn (mut g FlatGen) should_emit_fn_node_in_module(node flat.Node, node_index int, module_name string) bool {
    _ = node_index
    qfn := qualified_fn_name_in_module(module_name, node.value)
    if g.should_rename_user_main_for_tests(module_name, node.value) {
        return true
    }
    if module_name == 'builtin' && node.value == 'exit' {
        return true
    }
    if node.value.starts_with('__anon_fn_') || qfn.contains('__anon_fn_') {
        return true
    }
    if g.has_used_fn_filter() && !g.used_fn_contains_in_module(node.value, module_name) {
        return false
    }
    return true
}

fn is_generated_fn_after_markused(name string) bool {
    return name.starts_with('__anon_fn_')
}

// used_fn_contains reports whether used fn contains applies in c.
fn (g &FlatGen) used_fn_contains(name string) bool {
    if name.len == 0 {
        return false
    }
    return g.used_fns[name]
}

fn (g &FlatGen) used_fn_contains_in_module(name string, module_name string) bool {
    dfn := dotted_fn_name_in_module(module_name, name)
    qfn := qualified_fn_name_in_module(module_name, name)
    if g.used_fn_contains(dfn) || g.used_fn_contains(qfn) {
        return true
    }
    if module_name.len == 0 || module_name == 'main' || module_name == 'builtin' {
        cfn := c_name(name)
        return g.used_fn_contains(name) || g.used_fn_contains(cfn)
    }
    return false
}

// has_used_fn_filter reports whether has used fn filter applies in c.
fn (g &FlatGen) has_used_fn_filter() bool {
    return g.used_fns.len > 0 && g.used_fn_contains('main')
}

// emitted_fn_contains reports whether emitted fn contains applies in c.
fn (g &FlatGen) emitted_fn_contains(name string) bool {
    return name.len > 0 && g.emitted_fns[name]
}

// qualified_fn_name supports qualified fn name handling for FlatGen.
fn (g &FlatGen) qualified_fn_name(name string) string {
    return qualified_fn_name_in_module(g.tc.cur_module, name)
}

fn (g &FlatGen) export_fn_name_in_module(module_name string, name string) ?string {
    qname := dotted_fn_name_in_module(module_name, name)
    if export_name := g.a.export_fn_names[qname] {
        return export_name
    }
    if (module_name.len == 0 || module_name == 'main' || module_name == 'builtin')
        && name in g.a.export_fn_names {
        return g.a.export_fn_names[name]
    }
    return none
}

// qualified_fn_name_in_module supports qualified fn name in module handling for c.
fn qualified_fn_name_in_module(module_name string, name string) string {
    if module_name == 'builtin' && name == 'free' {
        return 'v_free'
    }
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        return c_name('${module_name}.${name}')
    }
    if name == 'free' {
        return 'v_free'
    }
    return c_name(name)
}

fn is_main_fn_in_main_module(module_name string, name string) bool {
    return name == 'main' && (module_name.len == 0 || module_name == 'main')
}

fn (g &FlatGen) should_rename_user_main_for_tests(module_name string, name string) bool {
    return g.test_files.len > 0 && is_main_fn_in_main_module(module_name, name)
}

fn (g &FlatGen) fn_c_name_in_module(module_name string, name string) string {
    if g.should_rename_user_main_for_tests(module_name, name) {
        return g.test_user_main_c_name()
    }
    return qualified_fn_name_in_module(module_name, name)
}

fn (g &FlatGen) test_user_main_c_name() string {
    base := 'main__user_main'
    if !g.c_fn_symbol_exists(base) {
        return base
    }
    limit := g.a.nodes.len + 2
    for idx in 1 .. limit {
        candidate := '${base}_${idx}'
        if !g.c_fn_symbol_exists(candidate) {
            return candidate
        }
    }
    return '${base}_${limit}'
}

fn (g &FlatGen) c_fn_symbol_exists(candidate string) bool {
    mut cur_module := ''
    for node in g.a.nodes {
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_module = ''
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            continue
        }
        if kind_id != 61 {
            continue
        }
        if qualified_fn_name_in_module(cur_module, node.value) == candidate {
            return true
        }
        if export_name := g.export_fn_name_in_module(cur_module, node.value) {
            if export_name == candidate {
                return true
            }
        }
    }
    return false
}

// direct_call_name supports direct call name handling for FlatGen.
fn (mut g FlatGen) direct_call_name(name string) string {
    if compat_name := g.libc_compat_call_name(name) {
        return compat_name
    }
    if g.test_files.len > 0 && (name == 'main' || name == 'main.main') {
        return g.test_user_main_c_name()
    }
    if name == 'free' {
        return 'v_free'
    }
    if name == 'int_str' {
        return 'int__str'
    }
    if name == 'bool_str' {
        return 'bool__str'
    }
    return c_name(name)
}

fn (mut g FlatGen) direct_call_name_for_call(id flat.NodeId, name string) string {
    if g.test_files.len > 0 && (name == 'main' || name == 'main.main') {
        if resolved := g.tc.resolved_call_name(id) {
            if resolved == 'main' || resolved == 'main.main' {
                return g.test_user_main_c_name()
            }
        }
        return c_name(name)
    }
    return g.direct_call_name(name)
}

fn (mut g FlatGen) libc_compat_call_name(name string) ?string {
    // `builtin.v_gettid()` reaches libc through `C.gettid()` on Linux/glibc, but
    // that symbol is not declared by all usable C header sets. Route it through a
    // tiny runtime compatibility helper instead of emitting an undeclared call.
    if name == 'C.gettid' {
        g.libc_compat_fns['gettid'] = true
        return 'v3_gettid'
    }
    return none
}

fn (g &FlatGen) test_user_main_fn_value_c_name(id flat.NodeId, node flat.Node) ?string {
    if g.test_files.len == 0 || node.kind != .ident || node.value != 'main' {
        return none
    }
    looked_up := g.tc.cur_scope.lookup(node.value) or { types.Type(types.void_) }
    if looked_up !is types.Void {
        return none
    }
    if resolved := g.tc.resolved_fn_value_name(id) {
        if resolved == 'main' || resolved == 'main.main' {
            return g.test_user_main_c_name()
        }
        return none
    }
    if g.usable_expr_type(id) is types.FnType {
        return g.test_user_main_c_name()
    }
    return none
}

fn (g &FlatGen) import_alias_module(alias string) ?string {
    if alias.len == 0 {
        return none
    }
    if g.tc != unsafe { nil } && g.tc.cur_file.len > 0 {
        key := g.tc.cur_file + '\n' + alias
        if mod := g.tc.file_imports[key] {
            return mod
        }
    }
    if mod := g.modules[alias] {
        return mod
    }
    return none
}

fn (g &FlatGen) has_import_alias(alias string) bool {
    if _ := g.import_alias_module(alias) {
        return true
    }
    return false
}

// dotted_fn_name supports dotted fn name handling for FlatGen.
fn (g &FlatGen) dotted_fn_name(name string) string {
    return dotted_fn_name_in_module(g.tc.cur_module, name)
}

// dotted_fn_name_in_module supports dotted fn name in module handling for c.
fn dotted_fn_name_in_module(module_name string, name string) string {
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        return '${module_name}.${name}'
    }
    return name
}

// qualify_name_in_module supports qualify name in module handling for c.
fn qualify_name_in_module(module_name string, name string) string {
    if module_name.len == 0 || module_name == 'main' || module_name == 'builtin' {
        return name
    }
    if name.contains('.') {
        return name
    }
    return '${module_name}.${name}'
}

// gen_fn emits fn output for c.
fn (mut g FlatGen) gen_fn(node flat.Node) {
    g.gen_fn_in_module(node, g.tc.cur_module)
}

fn (mut g FlatGen) write_method_c_name(id flat.NodeId, node flat.Node, method_name string) {
    _ = id
    _ = node
    g.write(c_name(method_name))
}

// static_method_fn_name resolves `Type.method(...)` static calls where `Type` is a
// named type, struct, enum, sum type or type alias (e.g. `SimdFloat4.new` for
// `type SimdFloat4 = vec.Vec4[f32]`). Returns the fn key, or none if `type_ident`
// is not a type or has no such static method.
fn (g &FlatGen) static_method_fn_name(type_ident string, method string) ?string {
    qtype := g.tc.qualify_name(type_ident)
    is_type := type_ident in g.tc.type_aliases || qtype in g.tc.type_aliases
        || type_ident in g.tc.structs || qtype in g.tc.structs || type_ident in g.tc.enum_names
        || qtype in g.tc.enum_names || type_ident in g.tc.sum_types || qtype in g.tc.sum_types
    if !is_type {
        return none
    }
    // Prefer the module-qualified key: a static method defined in the current (or the
    // type's) module is emitted under its qualified C name (`game__Animation__load`),
    // so the call must resolve to the same qualified key even though an unqualified
    // alias (`Animation.load`) may also be registered.
    qdirect := '${qtype}.${method}'
    if qtype != type_ident && (qdirect in g.tc.fn_ret_types || qdirect in g.tc.fn_param_types) {
        return qdirect
    }
    direct := '${type_ident}.${method}'
    if direct in g.tc.fn_ret_types || direct in g.tc.fn_param_types {
        return direct
    }
    if qdirect in g.tc.fn_ret_types || qdirect in g.tc.fn_param_types {
        return qdirect
    }
    return none
}

fn (g &FlatGen) resolve_method_name(type_name string, method string) string {
    direct := '${type_name}.${method}'
    if direct in g.tc.fn_param_types || direct in g.tc.fn_ret_types {
        return direct
    }
    if g.tc.cur_module.len > 0 && g.tc.cur_module != 'main' && g.tc.cur_module != 'builtin'
        && !type_name.contains('.') {
        qualified := '${g.tc.cur_module}.${type_name}.${method}'
        if qualified in g.tc.fn_param_types || qualified in g.tc.fn_ret_types {
            return qualified
        }
    }
    return ''
}

fn c_string_literal_pointer_arg(arg_node flat.Node, expected types.Type) bool {
    if arg_node.kind != .char_literal || !arg_node.value.starts_with('c:') {
        return false
    }
    if expected is types.Pointer {
        base := types.unwrap_pointer(expected)
        return base is types.Char
    }
    return false
}

fn (mut g FlatGen) gen_special_c_callback_arg(fn_name string, arg_idx int, arg_id flat.NodeId, expected_param types.Type) bool {
    clean_name := fn_name.trim_string_left('C.').all_after_last('.')
    if clean_name == 'mbedtls_ssl_conf_sni' && arg_idx == 1 {
        g.write('(int (*)(void *, mbedtls_ssl_context *, const unsigned char *, size_t))')
        g.gen_expr(arg_id)
        return true
    }
    // Only convert to `(void*)` for an actual C-callback slot. A V `fn (...) ...`
    // parameter is generated as a `_fn_ptr_*` typedef and must receive the function
    // pointer directly: `(void*)foo` is an object-pointer-to-function-pointer cast that
    // strict C rejects and that is not portable across ABIs. C functions (and loosely
    // typed `voidptr` slots) still need it, because C uses the header prototype.
    // `fn_type_from` is alias-aware, so a `type Cb = fn ()` parameter is recognised too.
    if _ := fn_type_from(expected_param) {
        return false
    }
    // A V function passed by name to a C function (a callback) must be cast: the V
    // declaration's parameter type (often `voidptr`) is ignored by C in favour of the
    // real header prototype, so the bare name trips -Wincompatible-function-pointer-types.
    // `(void*)` converts cleanly to any function-pointer parameter.
    if int(arg_id) >= 0 {
        arg_node := g.a.nodes[int(arg_id)]
        if arg_node.kind == .ident {
            is_local := (g.tc.cur_scope.lookup(arg_node.value) or { types.Type(types.void_) }) !is types.Void
            if !is_local {
                call_name := g.call_key(arg_id, arg_node.value)
                fn_key := if call_name in g.tc.fn_ret_types {
                    call_name
                } else if arg_node.value in g.tc.fn_ret_types {
                    arg_node.value
                } else {
                    ''
                }
                if fn_key.len > 0 && !fn_key.starts_with('C.') {
                    g.write('(void*)')
                    g.write(c_name(fn_key))
                    return true
                }
            }
        }
    }
    return false
}

fn (mut g FlatGen) spawn_wrapper_decls() {
    for def in g.spawn_wrapper_defs {
        g.writeln(def)
    }
    if g.spawn_wrapper_defs.len > 0 {
        g.writeln('')
    }
}

// expr_is_addressable reports whether an expression denotes a stable lvalue whose address
// outlives the enclosing statement expression — a variable, a field/index access reaching one,
// or a dereference. Rvalues (struct literals, calls, ...) only have temporary storage, so their
// address must not be captured in a method value's static receiver slot.
fn (g &FlatGen) expr_is_addressable(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := g.a.nodes[int(id)]
    return match node.kind {
        .ident { true }
        .index { node.children_count > 0 && g.expr_is_addressable(g.a.child(&node, 0)) }
        .selector { node.children_count > 0 && g.expr_is_addressable(g.a.child(&node, 0)) }
        .prefix { node.op == .mul }
        else { false }
    }
}

// gen_method_value_closure handles a method used as a *value* (e.g. `game.draw`
// passed where a `fn ()` callback is expected) rather than called. A plain struct
// field access can't represent the bound receiver, so it binds the receiver into a
// per-site context global and yields a wrapper function that invokes the method on
// it. Returns false when the selector is an ordinary field access (handled normally).
//
// LIMITATION: the captured receiver lives in a single per-site global, so it is
// only valid while no later evaluation of the *same* selector site overwrites it.
// That covers the supported cases — passing/storing a method value and invoking it
// before the site is re-evaluated (immediate callbacks, a single stored callback).
// It does NOT support keeping several live method values from one site with
// different receivers (e.g. building an array of `obj.method` in a loop): they all
// share the global and would observe the last-bound receiver. A correct general
// form needs a real per-closure captured environment, which the v3 backend has no
// ABI for yet (anonymous fns are lifted without true capture). Such escaping method
// values should be reworked (e.g. capture into an explicit struct + free fn) until
// closure support lands.
fn (mut g FlatGen) gen_method_value_closure(base_id flat.NodeId, base_type types.Type, method string) bool {
    clean := types.unwrap_pointer(base_type)
    if clean !is types.Struct {
        return false
    }
    struct_name := (clean as types.Struct).name
    // A real field shadows any same-named method: that's a field access, not a value.
    if _ := g.struct_field_type(struct_name, method) {
        return false
    }
    method_key := g.resolve_method_name(struct_name, method)
    mut params := []types.Type{}
    mut ret := types.Type(types.void_)
    mut cname := ''
    if method_key.len > 0 {
        params = g.tc.fn_param_types[method_key] or { return false }
        ret = g.tc.fn_ret_types[method_key] or { types.Type(types.void_) }
        cname = c_name(method_key)
    } else if ci := g.tc.generic_method_value_info['${struct_name}.${method}'] {
        // Generic receiver (`Box[int]`): the open `Box[T].get` registration is gone by
        // cgen, so use the substituted params/return the checker stashed, plus the
        // monomorphised C name `c_name('Box[int].get')` == `Box_int__get`.
        params = ci.params.clone()
        // The receiver param is the un-substituted open `Box[T]`; replace it with the
        // concrete receiver type (keeping the method's pointer-ness) so its C name
        // resolves to `Box_int` rather than the template `Box`.
        if params.len > 0 {
            recv_concrete := types.unwrap_pointer(base_type)
            params[0] = if params[0] is types.Pointer {
                types.Type(types.Pointer{
                    base_type: recv_concrete
                })
            } else {
                recv_concrete
            }
        }
        ret = ci.return_type
        cname = c_name('${struct_name}.${method}')
    } else {
        return false
    }
    if params.len == 0 {
        return false
    }
    recv_is_ptr := params[0] is types.Pointer
    recv_ct := g.tc.c_type(params[0])
    // Use the method's ABI return type (matching `cname`'s signature and the callback
    // fn-pointer typedef): an option/result is `Optional_T`, a fixed array its
    // `_v_ret_*` wrapper — not the bare `c_type` (`Optional`/`Array_fixed_*`).
    ret_ct := g.fn_return_type_name(ret)
    idx := g.tmp_count
    g.tmp_count++
    ctx_name := '_mvctx_${idx}'
    wrap_name := '_mvwrap_${idx}'
    mut wparams := []string{}
    mut call_args := [ctx_name]
    for i in 1 .. params.len {
        pt := g.tc.c_type(params[i])
        wparams << '${pt} a${i}'
        call_args << 'a${i}'
    }
    wparam_str := if wparams.len == 0 { 'void' } else { wparams.join(', ') }
    g.spawn_wrapper_defs << 'static ${recv_ct} ${ctx_name};'
    ret_prefix := if ret_ct == 'void' { '' } else { 'return ' }
    g.spawn_wrapper_defs << 'static ${ret_ct} ${wrap_name}(${wparam_str}) { ${ret_prefix}${cname}(${call_args.join(', ')}); }'
    base_is_ptr := base_type is types.Pointer
    // Set the context global to the receiver, then yield the wrapper as the value.
    if recv_is_ptr && !base_is_ptr && !g.expr_is_addressable(base_id) {
        // Pointer receiver bound to an rvalue base (`Foo{..}.tick`, `make_foo().tick`): taking
        // `&(rvalue)` captures a temporary that dies with the enclosing statement expression,
        // before the callback runs. Copy the receiver into a durable static slot and point at it.
        val_ct := g.tc.c_type(types.unwrap_pointer(params[0]))
        g.spawn_wrapper_defs << 'static ${val_ct} ${ctx_name}_recv;'
        g.write('({ ${ctx_name}_recv = ')
        g.gen_expr(base_id)
        g.write('; ${ctx_name} = &${ctx_name}_recv')
    } else {
        g.write('({ ${ctx_name} = ')
        if recv_is_ptr && !base_is_ptr {
            g.write('&(')
            g.gen_expr(base_id)
            g.write(')')
        } else if !recv_is_ptr && base_is_ptr {
            g.write('*(')
            g.gen_expr(base_id)
            g.write(')')
        } else {
            g.gen_expr(base_id)
        }
    }
    // Yield the wrapper as the callback value. A V `fn (...) ...` parameter is a
    // `_fn_ptr_*` typedef and needs the wrapper cast to that function-pointer type; only
    // a C / `voidptr` callback slot gets the object-pointer `(void*)` cast (which strict
    // C rejects for function pointers). `fn_type_from` is alias-aware, so a method value
    // passed through a `type Cb = fn ()` parameter (an `Alias`, not a bare `FnType`) is
    // recognised too and cast to the function-pointer typedef rather than `(void*)`.
    if fnt := fn_type_from(g.expected_expr_type) {
        fnptr_ct := g.value_c_type(fnt)
        g.write('; (${fnptr_ct})${wrap_name}; })')
    } else {
        g.write('; (void*)${wrap_name}; })')
    }
    return true
}

fn (mut g FlatGen) callback_wrapper_decls() {
    for def in g.callback_wrapper_defs {
        g.writeln(def)
    }
    if g.callback_wrapper_defs.len > 0 {
        g.writeln('')
    }
}

fn (mut g FlatGen) gen_spawn_expr(node flat.Node) {
    if node.children_count == 0 {
        g.write('(void*)0')
        return
    }
    call_id := g.a.child(&node, 0)
    call_node := g.a.nodes[int(call_id)]
    if call_node.kind != .call || call_node.children_count == 0 {
        g.write('(void*)0')
        return
    }
    fn_node := g.a.child_node(&call_node, 0)
    // The spawned call's return type: heap-captured by the wrapper so a later
    // `[]thread T .wait()` can recover the value (void callees just return NULL).
    // Use the callee's ABI return type, not the bare value type: an option/result
    // return is `Optional_T` (not the generic `Optional`, whose payload is `int`) and a
    // fixed-array return is its `_v_ret_*` wrapper struct. The wrapper mallocs and
    // assigns this type, and `[]thread T.wait()` must read back the same layout.
    ret_ct := g.fn_return_type_name(g.tc.resolve_type(call_id))
    mut wrapper := ''
    mut arg_expr := 'NULL'
    if fn_node.kind == .ident {
        call_key := g.call_key(call_id, fn_node.value)
        looked_up := g.tc.cur_scope.lookup(fn_node.value) or { types.Type(types.void_) }
        cfn := if looked_up !is types.Void && fn_type_from(looked_up) != none {
            c_name(fn_node.value)
        } else if call_key in g.tc.fn_ret_types || call_key in g.tc.fn_param_types {
            g.direct_call_name_for_call(call_id, call_key)
        } else {
            c_name(fn_node.value)
        }
        if call_node.children_count == 1 {
            wrapper = g.ensure_noarg_spawn_wrapper(cfn, ret_ct)
        } else {
            // `spawn work(a, b)` packs the arguments into a heap struct so the
            // spawned thread receives them, instead of silently dropping them.
            param_types := g.param_types_for(call_key, fn_node.value)
            if param_types.len > 0 && param_types.len == int(call_node.children_count) - 1 {
                mut param_cts := []string{}
                mut arg_exprs := []string{}
                for i, pt in param_types {
                    param_cts << g.tc.c_type(pt)
                    arg_exprs << g.expr_to_string(g.a.child(&call_node, i + 1))
                }
                g.emit_args_spawn_expr(cfn, param_cts, arg_exprs, ret_ct)
                return
            }
        }
    } else if fn_node.kind == .selector && fn_node.children_count > 0 {
        base_id := g.a.child(fn_node, 0)
        base_type := g.receiver_base_type(base_id)
        clean_type := types.unwrap_pointer(base_type)
        method_name := g.resolved_method_name_for_spawn(clean_type, fn_node.value)
        if method_name.len > 0 {
            param_types := g.param_types_for(method_name, fn_node.value)
            if param_types.len > 0 {
                receiver_type := param_types[0]
                receiver_ct := g.tc.c_type(receiver_type)
                base_expr := g.expr_to_string(base_id)
                if call_node.children_count == 1 {
                    if receiver_type is types.Pointer {
                        wrapper = g.ensure_receiver_spawn_wrapper(c_name(method_name), receiver_ct,
                            ret_ct)
                        if base_type is types.Pointer {
                            arg_expr = '(${receiver_ct})(${base_expr})'
                        } else {
                            arg_expr = '(${receiver_ct})(&(${base_expr}))'
                        }
                    } else {
                        // Casting the void* thread argument straight to a struct type
                        // is invalid C, so copy the value receiver into the heap arg
                        // struct and dispatch through the argument-packing path.
                        receiver_value := if base_type is types.Pointer {
                            '*(${base_expr})'
                        } else {
                            base_expr
                        }
                        g.emit_args_spawn_expr(c_name(method_name), [receiver_ct], [
                            receiver_value,
                        ], ret_ct)
                        return
                    }
                } else if param_types.len == int(call_node.children_count) {
                    // `spawn recv.method(a, b)` packs the receiver and arguments
                    // into a heap struct rather than dropping the call.
                    receiver_expr := if receiver_type is types.Pointer {
                        if base_type is types.Pointer {
                            '(${receiver_ct})(${base_expr})'
                        } else {
                            '(${receiver_ct})(&(${base_expr}))'
                        }
                    } else if base_type is types.Pointer {
                        '*(${base_expr})'
                    } else {
                        base_expr
                    }
                    mut param_cts := [receiver_ct]
                    mut arg_exprs := [receiver_expr]
                    for i in 1 .. param_types.len {
                        param_cts << g.tc.c_type(param_types[i])
                        arg_exprs << g.expr_to_string(g.a.child(&call_node, i))
                    }
                    g.emit_args_spawn_expr(c_name(method_name), param_cts, arg_exprs, ret_ct)
                    return
                }
            }
        }
    }
    if wrapper.len == 0 {
        g.write('(void*)0')
        return
    }
    tmp := g.tmp_count
    g.tmp_count++
    g.write('({ pthread_t _t${tmp}; pthread_attr_t _a${tmp}; pthread_attr_init(&_a${tmp}); ')
    g.write('pthread_attr_setstacksize(&_a${tmp}, 8388608); ')
    g.write('int _r${tmp} = pthread_create(&_t${tmp}, &_a${tmp}, ${wrapper}, (void*)(${arg_expr})); ')
    g.write('pthread_attr_destroy(&_a${tmp}); (void)_r${tmp}; (void*)_t${tmp}; })')
}

// spawn_wrapper_body builds the thread-wrapper statement that invokes the spawned
// call and returns its result as a `void*`. When the callee returns a value, the
// result is heap-copied so `[]thread T .wait()` can recover it (the wait fn frees
// it); a void callee returns NULL. `post` runs after the call (e.g. `free(p);`).
fn spawn_wrapper_body(call_expr string, ret_ct string, post string) string {
    if ret_ct == 'void' || ret_ct.len == 0 {
        return '${call_expr}; ${post}return NULL;'
    }
    return '${ret_ct}* __tr = (${ret_ct}*)malloc(sizeof(${ret_ct})); *__tr = ${call_expr}; ${post}return (void*)__tr;'
}

fn (mut g FlatGen) ensure_noarg_spawn_wrapper(cfn string, ret_ct string) string {
    key := 'noarg|${cfn}'
    if name := g.spawn_wrapper_names[key] {
        return name
    }
    name := c_name('${cfn}_thread_wrapper')
    g.spawn_wrapper_names[key] = name
    body := spawn_wrapper_body('${cfn}()', ret_ct, '')
    g.spawn_wrapper_defs << 'static void* ${name}(void* arg) { (void)arg; ${body} }'
    return name
}

fn (mut g FlatGen) ensure_receiver_spawn_wrapper(cfn string, receiver_ct string, ret_ct string) string {
    key := 'receiver|${cfn}|${receiver_ct}'
    if name := g.spawn_wrapper_names[key] {
        return name
    }
    name := c_name('${cfn}_thread_wrapper')
    g.spawn_wrapper_names[key] = name
    body := spawn_wrapper_body('${cfn}((${receiver_ct})arg)', ret_ct, '')
    g.spawn_wrapper_defs << 'static void* ${name}(void* arg) { ${body} }'
    return name
}

// ensure_args_spawn_wrapper registers (once per callee) a heap-arg struct plus a
// thread wrapper that unpacks the struct, calls the function with all arguments,
// and frees the struct. Returns the wrapper name and the arg struct name.
fn (mut g FlatGen) ensure_args_spawn_wrapper(cfn string, param_cts []string, ret_ct string) (string, string) {
    struct_name := c_name('${cfn}_thread_args')
    key := 'args|${cfn}'
    if name := g.spawn_wrapper_names[key] {
        return name, struct_name
    }
    name := c_name('${cfn}_args_thread_wrapper')
    g.spawn_wrapper_names[key] = name
    mut fields := ''
    mut call_args := []string{}
    for i, ct in param_cts {
        fields += '${ct} a${i}; '
        call_args << 'p->a${i}'
    }
    g.spawn_wrapper_defs << 'typedef struct { ${fields}} ${struct_name};'
    body := spawn_wrapper_body('${cfn}(${call_args.join(', ')})', ret_ct, 'free(p); ')
    g.spawn_wrapper_defs << 'static void* ${name}(void* arg) { ${struct_name}* p = (${struct_name}*)arg; ${body} }'
    return name, struct_name
}

// emit_args_spawn_expr writes a statement-expression that heap-allocates the arg
// struct, populates it, and starts the thread on the packing wrapper.
fn (mut g FlatGen) emit_args_spawn_expr(cfn string, param_cts []string, arg_exprs []string, ret_ct string) {
    wrapper, struct_name := g.ensure_args_spawn_wrapper(cfn, param_cts, ret_ct)
    tmp := g.tmp_count
    g.tmp_count++
    g.write('({ ${struct_name}* _sa${tmp} = (${struct_name}*)malloc(sizeof(${struct_name})); ')
    for i, e in arg_exprs {
        g.write('_sa${tmp}->a${i} = ${e}; ')
    }
    g.write('pthread_t _t${tmp}; pthread_attr_t _at${tmp}; pthread_attr_init(&_at${tmp}); ')
    g.write('pthread_attr_setstacksize(&_at${tmp}, 8388608); ')
    g.write('int _r${tmp} = pthread_create(&_t${tmp}, &_at${tmp}, ${wrapper}, (void*)_sa${tmp}); ')
    g.write('pthread_attr_destroy(&_at${tmp}); (void)_r${tmp}; (void*)_t${tmp}; })')
}

fn (g &FlatGen) resolved_method_name_for_spawn(clean_type types.Type, method string) string {
    mut type_name := clean_type.name()
    if clean_type is types.Struct {
        type_name = clean_type.name
    }
    method_name := '${type_name}.${method}'
    if method_name in g.tc.fn_param_types {
        return method_name
    }
    for alias, target in g.tc.type_aliases {
        if target == type_name {
            alias_method := '${alias}.${method}'
            if alias_method in g.tc.fn_param_types {
                return alias_method
            }
        }
    }
    return ''
}

// gen_fn_in_module emits fn in module output for c.
fn (mut g FlatGen) gen_fn_in_module(node flat.Node, module_name string) {
    g.tc.cur_module = module_name
    g.cur_fn_name = node.value
    g.tc.push_scope()
    g.defers = []flat.NodeId{}
    g.fn_defers = []flat.NodeId{}
    g.fn_defer_counts = map[int]string{}
    g.defer_capture_names = []string{}
    g.defer_capture_types = map[string]types.Type{}
    g.set_cur_fn_ret(types.Type(types.void_))
    old_param_names := g.cur_param_names.clone()
    old_param_type_values := g.cur_param_type_values.clone()
    old_param_types := g.cur_param_types.clone()
    g.cur_param_names = []string{}
    g.cur_param_type_values = []types.Type{}
    g.cur_param_types = map[string]types.Type{}
    for i in 0 .. node.children_count {
        param_id := g.a.child(&node, i)
        p := g.a.node(param_id)
        if node_kind_id(p) == 75 && p.value.len > 0 {
            param_type := g.tc.parse_type(p.typ)
            g.cur_param_names << p.value
            g.cur_param_type_values << param_type
            g.cur_param_types[p.value] = param_type
            g.tc.cur_scope.insert(p.value, param_type)
        }
    }
    g.insert_cur_implicit_veb_ctx_param(node)
    fn_defer_ids := g.collect_function_defer_ids(node)
    g.prepare_function_defers(fn_defer_ids)
    is_entry_main := is_main_fn_in_main_module(module_name, node.value) && g.test_files.len == 0
    if is_entry_main {
        g.writeln('int main(int argc, char** argv) {')
        if g.has_builtins {
            g.writeln('\tg_main_argc = argc;')
            g.writeln('\tg_main_argv = argv;')
        }
        g.gen_compiler_vexe_env_setup()
        if g.runtime_inits.len > 0 || g.module_init_fns.len > 0 || g.global_inits.len > 0 {
            g.writeln('\t_vinit();')
        }
    } else {
        ret_type := g.fn_node_return_type(node, module_name)
        g.set_cur_fn_ret(ret_type)
        g.write(g.fn_return_type_name(ret_type))
        g.write(' ')
        g.write(g.fn_c_name_in_module(module_name, node.value))
        g.write('(')
        g.write_fn_node_params(node)
        g.writeln(') {')
    }
    g.indent++
    g.gen_function_defer_prelude()

    for i in 0 .. node.children_count {
        id := g.a.child(&node, i)
        child := g.a.node(id)
        if child.kind != .param {
            g.tc.cur_module = module_name
            g.gen_node(id)
        }
    }
    g.gen_all_defers()
    if is_entry_main {
        g.writeln('return 0;')
    } else if g.cur_fn_ret_is_optional {
        ct := g.optional_type_name(g.cur_fn_ret)
        g.writeln('return (${ct}){.ok = true};')
    }
    g.indent--
    g.writeln('}')
    g.writeln('')
    if !is_entry_main {
        g.gen_export_wrapper_for_fn(node, module_name)
    }
    g.cur_param_names = old_param_names.clone()
    g.cur_param_type_values = old_param_type_values.clone()
    g.cur_param_types = old_param_types.clone()
    g.tc.pop_scope()
}

fn (mut g FlatGen) gen_export_wrapper_for_fn(node flat.Node, module_name string) {
    export_name := g.export_fn_name_in_module(module_name, node.value) or { return }
    canonical_name := g.fn_c_name_in_module(module_name, node.value)
    ret_type := g.fn_node_return_type(node, module_name)
    ret_ct := g.fn_return_type_name(ret_type)
    g.write(ret_ct)
    g.write(' ')
    g.write(export_name)
    g.write('(')
    g.write_fn_node_params(node)
    g.writeln(') {')
    g.indent++
    args := g.export_wrapper_arg_names(node)
    call := '${canonical_name}(${args.join(', ')})'
    if ret_type is types.Void {
        g.writeln('${call};')
    } else {
        g.writeln('return ${call};')
    }
    g.indent--
    g.writeln('}')
    g.writeln('')
}

fn (mut g FlatGen) export_wrapper_arg_names(node flat.Node) []string {
    mut args := []string{}
    needs_implicit_ctx := g.fn_needs_implicit_veb_ctx(node)
    insert_implicit_ctx_after_first := needs_implicit_ctx && g.fn_has_receiver_param(node)
    mut written := 0
    mut implicit_ctx_written := false
    for i in 0 .. node.children_count {
        param_id := g.a.child(&node, i)
        p := g.a.node(param_id)
        if p.kind != .param {
            continue
        }
        param_name := if p.value == '_' { '_${written}' } else { c_name(p.value) }
        args << param_name
        written++
        if insert_implicit_ctx_after_first && !implicit_ctx_written {
            args << 'ctx'
            written++
            implicit_ctx_written = true
        }
    }
    if needs_implicit_ctx && !implicit_ctx_written {
        args << 'ctx'
    }
    return args
}

fn (mut g FlatGen) gen_top_level_main(stmts []TopLevelStmt) {
    old_tc_file := g.tc.cur_file
    old_tc_module := g.tc.cur_module
    g.tc.cur_module = 'main'
    old_fn_name := g.cur_fn_name
    g.cur_fn_name = 'main'
    g.tc.push_scope()
    g.defers = []flat.NodeId{}
    g.fn_defers = []flat.NodeId{}
    g.fn_defer_counts = map[int]string{}
    g.defer_capture_names = []string{}
    g.defer_capture_types = map[string]types.Type{}
    g.set_cur_fn_ret(types.Type(types.void_))
    old_param_names := g.cur_param_names.clone()
    old_param_type_values := g.cur_param_type_values.clone()
    old_param_types := g.cur_param_types.clone()
    g.cur_param_names = []string{}
    g.cur_param_type_values = []types.Type{}
    g.cur_param_types = map[string]types.Type{}
    mut fn_defer_ids := []flat.NodeId{}
    for stmt in stmts {
        g.collect_function_defer_ids_from(stmt.id, mut fn_defer_ids)
    }
    g.prepare_function_defers(fn_defer_ids)
    g.writeln('int main(int argc, char** argv) {')
    if g.has_builtins {
        g.writeln('\tg_main_argc = argc;')
        g.writeln('\tg_main_argv = argv;')
    }
    g.gen_compiler_vexe_env_setup()
    if g.runtime_inits.len > 0 || g.module_init_fns.len > 0 || g.global_inits.len > 0 {
        g.writeln('\t_vinit();')
    }
    g.indent++
    g.gen_function_defer_prelude()
    for stmt in stmts {
        g.tc.cur_file = stmt.file
        g.tc.cur_module = stmt.module
        g.gen_top_level_main_stmt(stmt.id)
    }
    g.gen_all_defers()
    g.writeln('return 0;')
    g.indent--
    g.writeln('}')
    g.writeln('')
    g.cur_param_names = old_param_names.clone()
    g.cur_param_type_values = old_param_type_values.clone()
    g.cur_param_types = old_param_types.clone()
    g.cur_fn_name = old_fn_name
    g.tc.cur_file = old_tc_file
    g.tc.cur_module = old_tc_module
    g.tc.pop_scope()
}

fn (mut g FlatGen) gen_top_level_main_stmt(id flat.NodeId) {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return
    }
    node := g.a.nodes[int(id)]
    if node.kind == .block {
        for i in 0 .. node.children_count {
            child_id := g.a.child(&node, i)
            if g.cgen_is_top_level_stmt(child_id) {
                g.gen_top_level_main_stmt(child_id)
            }
        }
        return
    }
    g.gen_node(id)
}

fn (mut g FlatGen) gen_test_main() {
    tests, hooks := g.test_harness_fns()
    g.tc.cur_module = 'main'
    g.writeln('int main(int argc, char** argv) {')
    if g.has_builtins {
        g.writeln('\tg_main_argc = argc;')
        g.writeln('\tg_main_argv = argv;')
    }
    g.gen_compiler_vexe_env_setup()
    if g.runtime_inits.len > 0 || g.module_init_fns.len > 0 || g.global_inits.len > 0 {
        g.writeln('\t_vinit();')
    }
    g.indent++
    if hooks.testsuite_begin.len > 0 {
        g.writeln('${hooks.testsuite_begin}();')
    }
    for idx, test_fn in tests {
        if hooks.before_each.len > 0 {
            g.writeln('${hooks.before_each}();')
        }
        g.gen_test_fn_call(test_fn, hooks, idx)
        if hooks.after_each.len > 0 {
            g.writeln('${hooks.after_each}();')
        }
    }
    if hooks.testsuite_end.len > 0 {
        g.writeln('${hooks.testsuite_end}();')
    }
    g.writeln('return 0;')
    g.indent--
    g.writeln('}')
    g.writeln('')
}

fn (mut g FlatGen) gen_test_fn_call(test_fn TestHarnessFn, hooks TestHarnessHooks, idx int) {
    if test_fn.ret is types.OptionType || test_fn.ret is types.ResultType {
        ct := g.optional_type_name(test_fn.ret)
        tmp_name := '__test_opt_${idx}'
        g.writeln('${ct} ${tmp_name} = ${test_fn.c_name}();')
        g.writeln('if (!${tmp_name}.ok) {')
        g.indent++
        g.writeln('fprintf(stderr, "test failed: ${c_escape(test_fn.name)}\\n");')
        if hooks.after_each.len > 0 {
            g.writeln('${hooks.after_each}();')
        }
        if hooks.testsuite_end.len > 0 {
            g.writeln('${hooks.testsuite_end}();')
        }
        g.writeln('return 1;')
        g.indent--
        g.writeln('}')
        return
    }
    g.writeln('${test_fn.c_name}();')
}

fn (g &FlatGen) test_harness_fns() ([]TestHarnessFn, TestHarnessHooks) {
    mut tests := []TestHarnessFn{}
    mut hooks := TestHarnessHooks{}
    for file_idx, file_node in g.a.nodes {
        if !g.is_user_test_file_node(file_idx, file_node) {
            continue
        }
        module_name := g.test_file_module_name(file_node)
        if module_name.len > 0 && module_name != 'main' {
            continue
        }
        mut decl_ids := []flat.NodeId{}
        g.collect_test_harness_decl_ids(file_node, mut decl_ids)
        for child_id in decl_ids {
            child := g.a.nodes[int(child_id)]
            cname := qualified_fn_name_in_module(module_name, child.value)
            match child.value {
                'testsuite_begin' {
                    if hooks.testsuite_begin.len == 0 && g.is_supported_test_hook_decl(child) {
                        hooks.testsuite_begin = cname
                    }
                }
                'testsuite_end' {
                    if hooks.testsuite_end.len == 0 && g.is_supported_test_hook_decl(child) {
                        hooks.testsuite_end = cname
                    }
                }
                'before_each' {
                    if hooks.before_each.len == 0 && g.is_supported_test_hook_decl(child) {
                        hooks.before_each = cname
                    }
                }
                'after_each' {
                    if hooks.after_each.len == 0 && g.is_supported_test_hook_decl(child) {
                        hooks.after_each = cname
                    }
                }
                else {
                    if child.value.starts_with('test_') && g.is_supported_test_fn_decl(child) {
                        tests << TestHarnessFn{
                            name:   child.value
                            c_name: cname
                            ret:    g.tc.parse_type(child.typ)
                        }
                    }
                }
            }
        }
    }
    return tests, hooks
}

fn (g &FlatGen) collect_test_harness_decl_ids(node flat.Node, mut ids []flat.NodeId) {
    if node.kind != .file && node.kind != .block {
        return
    }
    for i in 0 .. node.children_count {
        child_id := g.a.child(&node, i)
        if int(child_id) < g.a.user_code_start {
            continue
        }
        child := g.a.nodes[int(child_id)]
        if child.kind == .fn_decl {
            ids << child_id
        } else if child.kind == .block {
            g.collect_test_harness_decl_ids(child, mut ids)
        }
    }
}

fn (g &FlatGen) is_supported_test_fn_decl(node flat.Node) bool {
    if node.generic_params.len > 0 {
        return false
    }
    if g.test_fn_param_count(node) != 0 {
        return false
    }
    return test_harness_fn_return_supported(g.tc.parse_type(node.typ))
}

fn (g &FlatGen) is_supported_test_hook_decl(node flat.Node) bool {
    if node.generic_params.len > 0 {
        return false
    }
    return g.test_fn_param_count(node) == 0 && g.tc.parse_type(node.typ) is types.Void
}

fn (g &FlatGen) test_fn_param_count(node flat.Node) int {
    mut count := 0
    for i in 0 .. node.children_count {
        child := g.a.child_node(&node, i)
        if child.kind == .param {
            count++
        }
    }
    return count
}

fn test_harness_fn_return_supported(ret types.Type) bool {
    return ret is types.Void || ret is types.OptionType || ret is types.ResultType
}

fn (g &FlatGen) is_user_test_file_node(file_idx int, file_node flat.Node) bool {
    if file_idx < g.a.user_code_start || file_node.kind != .file || file_node.children_count == 0 {
        return false
    }
    return g.test_files[file_node.value]
}

fn (g &FlatGen) test_file_module_name(file_node flat.Node) string {
    for i in 0 .. file_node.children_count {
        child := g.a.child_node(&file_node, i)
        if child.kind == .module_decl {
            return child.value
        }
    }
    return ''
}

// collect_function_defer_ids updates collect function defer ids state for c.
fn (mut g FlatGen) collect_function_defer_ids(node flat.Node) []flat.NodeId {
    mut ids := []flat.NodeId{}
    for i in 0 .. node.children_count {
        g.collect_function_defer_ids_from(g.a.child(&node, i), mut ids)
    }
    return ids
}

// collect_function_defer_ids_from updates collect function defer ids from state for c.
fn (mut g FlatGen) collect_function_defer_ids_from(id flat.NodeId, mut ids []flat.NodeId) {
    if !g.valid_node_id(id) {
        return
    }
    node := g.a.nodes[int(id)]
    if node.kind == .fn_decl || node.kind == .c_fn_decl || node.kind == .fn_literal {
        return
    }
    if node.kind == .defer_stmt && node.value == 'function' {
        ids << id
        return
    }
    for i in 0 .. node.children_count {
        g.collect_function_defer_ids_from(g.a.child(&node, i), mut ids)
    }
}

// prepare_function_defers supports prepare function defers handling for FlatGen.
fn (mut g FlatGen) prepare_function_defers(fn_defer_ids []flat.NodeId) {
    for idx, defer_id in fn_defer_ids {
        g.fn_defer_counts[int(defer_id)] = '${c_name(g.cur_fn_name)}_defer_${idx}_count'
        defer_node := g.a.nodes[int(defer_id)]
        if defer_node.children_count > 0 {
            g.collect_function_defer_captures(g.a.child(&defer_node, 0))
        }
    }
}

// collect_function_defer_captures updates collect function defer captures state for c.
fn (mut g FlatGen) collect_function_defer_captures(id flat.NodeId) {
    if !g.valid_node_id(id) {
        return
    }
    node := g.a.nodes[int(id)]
    if node.kind == .fn_decl || node.kind == .c_fn_decl || node.kind == .fn_literal {
        return
    }
    if node.kind == .ident {
        g.add_function_defer_capture(id, node.value)
    }
    for i in 0 .. node.children_count {
        g.collect_function_defer_captures(g.a.child(&node, i))
    }
}

// add_function_defer_capture updates add function defer capture state for FlatGen.
fn (mut g FlatGen) add_function_defer_capture(id flat.NodeId, name string) {
    if name.len == 0 || name == '_' || name in g.cur_param_names || g.has_import_alias(name)
        || name in g.global_modules || name in g.defer_capture_types {
        return
    }
    typ := g.usable_expr_type(id)
    if typ is types.Void || typ is types.Unknown || typ is types.FnType {
        return
    }
    ct := g.tc.c_type(typ)
    if ct.len == 0 || ct == 'void' || ct.starts_with('fn_ptr:') {
        return
    }
    g.defer_capture_names << name
    g.defer_capture_types[name] = typ
}

// gen_function_defer_prelude emits function defer prelude output for c.
fn (mut g FlatGen) gen_function_defer_prelude() {
    for _, count_name in g.fn_defer_counts {
        g.writeln('int ${count_name} = 0;')
    }
    for name in g.defer_capture_names {
        typ := g.defer_capture_types[name] or { continue }
        ct := g.tc.c_type(typ)
        g.write('${ct} ${c_name(name)} = ')
        g.gen_default_value_for_type(typ)
        g.writeln(';')
        g.tc.cur_scope.insert(name, typ)
    }
}

// set_cur_fn_ret updates set cur fn ret state for c.
fn (mut g FlatGen) set_cur_fn_ret(ret_type types.Type) {
    g.cur_fn_ret = ret_type
    g.cur_fn_ret_is_optional = false
    g.cur_fn_ret_base = types.Type(types.void_)
    if ret_type is types.OptionType {
        g.cur_fn_ret_is_optional = true
        g.cur_fn_ret_base = ret_type.base_type
    } else if ret_type is types.ResultType {
        g.cur_fn_ret_is_optional = true
        g.cur_fn_ret_base = ret_type.base_type
    }
}

// gen_compiler_vexe_env_setup emits compiler vexe env setup output for c.
fn (mut g FlatGen) gen_compiler_vexe_env_setup() {
    if g.compiler_vroot.len == 0 {
        return
    }
    root := c_escape(g.compiler_vroot)
    g.writeln('\tif (getenv("VEXE") == NULL || getenv("VEXE")[0] == 0) {')
    g.writeln('\t\tconst char* v3_arg0 = argc > 0 ? argv[0] : "v";')
    g.writeln("\t\tconst char* v3_base = strrchr(v3_arg0, '/');")
    g.writeln('\t\tv3_base = v3_base == NULL ? v3_arg0 : v3_base + 1;')
    g.writeln('\t\tif (v3_base[0] == 0) v3_base = "v";')
    g.writeln('\t\tconst char* v3_checkout_root = "${root}";')
    g.writeln('\t\tchar v3_checkout_vexe[4096];')
    g.writeln('\t\tsnprintf(v3_checkout_vexe, sizeof(v3_checkout_vexe), "%s/%s", v3_checkout_root, v3_base);')
    g.writeln('\t\tif (access(v3_checkout_vexe, F_OK) != 0) snprintf(v3_checkout_vexe, sizeof(v3_checkout_vexe), "%s/v", v3_checkout_root);')
    g.writeln('\t\tchar v3_src_real[4096];')
    g.writeln('\t\tchar* v3_src_real_result = realpath(v3_arg0, v3_src_real);')
    g.writeln('\t\tconst char* v3_vexe = v3_src_real_result != NULL ? v3_src_real : v3_arg0;')
    g.writeln('\t\tif (access(v3_checkout_vexe, F_OK) == 0) v3_vexe = v3_checkout_vexe;')
    g.writeln('\t\tif (v3_vexe[0] != 0) {')
    g.writeln('#ifdef _WIN32')
    g.writeln('\t\t\t_putenv_s("VEXE", v3_vexe);')
    g.writeln('#else')
    g.writeln('\t\t\tsetenv("VEXE", v3_vexe, 1);')
    g.writeln('#endif')
    g.writeln('\t\t}')
    g.writeln('\t}')
}

// gen_defers emits defers output for c.
fn (mut g FlatGen) gen_defers() {
    g.gen_defers_from(0)
}

// gen_all_defers emits all defers output for c.
fn (mut g FlatGen) gen_all_defers() {
    g.gen_defers()
    g.gen_fn_defers()
}

// gen_defers_from emits defers from output for c.
fn (mut g FlatGen) gen_defers_from(start int) {
    if g.defers.len == 0 {
        return
    }
    mut i := g.defers.len
    for i > start {
        i--
        defer_body := g.a.nodes[int(g.defers[i])]
        g.writeln('{')
        g.indent++
        for j in 0 .. defer_body.children_count {
            g.gen_node(g.a.child(&defer_body, j))
        }
        g.indent--
        g.writeln('}')
    }
}

// gen_fn_defers emits fn defers output for c.
fn (mut g FlatGen) gen_fn_defers() {
    if g.fn_defers.len == 0 {
        return
    }
    mut i := g.fn_defers.len
    for i > 0 {
        i--
        defer_id := g.fn_defers[i]
        defer_node := g.a.nodes[int(defer_id)]
        defer_body := g.a.nodes[int(g.a.child(&defer_node, 0))]
        count_name := g.fn_defer_counts[int(defer_id)] or { '0' }
        iter_name := '${count_name}_i'
        g.writeln('for (int ${iter_name} = 0; ${iter_name} < ${count_name}; ${iter_name}++) {')
        g.indent++
        for j in 0 .. defer_body.children_count {
            g.gen_node(g.a.child(&defer_body, j))
        }
        g.indent--
        g.writeln('}')
    }
}

// trim_defers transforms trim defers data for c.
fn (mut g FlatGen) trim_defers(start int) {
    if start >= g.defers.len {
        return
    }
    g.defers = g.defers[..start].clone()
}

// gen_ierror_from_error_call converts gen ierror from error call data for c.
fn (mut g FlatGen) gen_ierror_from_error_call(node flat.Node) {
    fn_node := g.a.child_node(&node, 0)
    g.write('(IError){._typ = 0, ._object = NULL, .message = ')
    if node.children_count > 1 {
        g.gen_expr(g.a.child(&node, 1))
    } else {
        g.write('_S("")')
    }
    g.write(', .code = ')
    if fn_node.value == 'error_with_code' && node.children_count > 2 {
        g.gen_expr(g.a.child(&node, 2))
    } else {
        g.write('0')
    }
    g.write('}')
}

// gen_optional_error_from_call converts gen optional error from call data for c.
fn (mut g FlatGen) gen_optional_error_from_call(ct string, node flat.Node) {
    g.write('(${ct}){.ok = false, .err = ')
    g.gen_ierror_from_error_call(node)
    g.write('}')
}

// gen_call emits call output for c.
fn (mut g FlatGen) gen_call(id flat.NodeId, node flat.Node) {
    fn_node := g.a.child_node(&node, 0)
    fn_name := fn_node.value
    target_name := g.call_target_name(g.a.child(&node, 0))
    if target_name in ['json.decode', 'json2.decode'] {
        ret_type := g.json_decode_result_type(g.a.child(&node, 0)) or {
            g.call_default_return_type(id)
        }
        g.gen_default_value_for_type(ret_type)
        return
    }
    if target_name in ['json.encode', 'json2.encode']
        || (g.tc.cur_module == 'json2' && target_name == 'encode') {
        g.gen_default_value_for_type(g.call_default_return_type(id))
        return
    }
    if g.is_veb_json_result_call(fn_node) {
        g.gen_default_value_for_type(g.call_default_return_type(id))
        return
    }
    if target_name == 'veb.run_at' {
        g.gen_default_value_for_type(g.call_default_return_type(id))
        return
    }
    if g.is_missing_middleware_use_call(fn_node) {
        g.write('0')
        return
    }
    if fn_node.kind == .selector && fn_node.value == 'str' {
        base_type := g.tc.resolve_type(g.a.child(fn_node, 0))
        clean_type := types.unwrap_pointer(base_type)
        if clean_type is types.Enum {
            if _ := g.enum_receiver_method_name(clean_type, fn_node.value) {
                // Let normal method call generation handle custom enum str methods.
            } else {
                g.gen_enum_str_call(fn_node, clean_type)
                return
            }
        }
    }
    if fn_node.kind == .selector && fn_node.value == 'close' {
        base_id := g.a.child(fn_node, 0)
        base_type := g.tc.resolve_type(base_id)
        if base_type is types.Channel {
            g.write('sync__Channel__close(')
            g.gen_expr(base_id)
            g.write(', array_new(sizeof(IError), 0, 0))')
            return
        }
    }
    match fn_name {
        'new_map' {
            if node.typ.starts_with('map[') {
                map_type := g.tc.parse_type(node.typ)
                if map_type is types.Map {
                    g.write_new_map(map_type.key_type, map_type.value_type)
                    return
                }
            }
            g.write('new_map(')
            g.gen_call_args(fn_name, node, 1)
            g.write(')')
            return
        }
        'panic' {
            g.write('panic(')
            if node.children_count > 1 {
                arg_id := g.a.child(&node, 1)
                arg_type := g.tc.resolve_type(arg_id)
                if arg_type is types.Struct && arg_type.name == 'IError' {
                    g.gen_expr(arg_id)
                    g.write('.message')
                } else {
                    g.gen_expr(arg_id)
                }
            }
            g.write(')')
            return
        }
        'error' {
            if g.cur_fn_ret_is_optional {
                ct := g.optional_type_name(g.cur_fn_ret)
                g.gen_optional_error_from_call(ct, node)
            } else {
                g.gen_ierror_from_error_call(node)
            }
            return
        }
        'error_with_code' {
            if g.cur_fn_ret_is_optional {
                ct := g.optional_type_name(g.cur_fn_ret)
                g.gen_optional_error_from_call(ct, node)
            } else {
                g.gen_ierror_from_error_call(node)
            }
            return
        }
        else {
            mut is_method := false
            mut is_c_call := false
            mut method_name := ''
            mut base_id := flat.NodeId(0)
            if fn_node.kind == .selector {
                base := g.a.child_node(fn_node, 0)
                base_is_local := if base.kind == .ident {
                    (g.tc.cur_scope.lookup(base.value) or { types.Type(types.void_) }) !is types.Void
                } else {
                    false
                }
                if base.kind == .ident && base.value == 'C' {
                    g.write(g.direct_call_name('C.${fn_node.value}'))
                    is_c_call = true
                } else if g.is_flag_enum_method(fn_node) {
                    g.gen_flag_enum_call(node)
                    return
                } else if base.kind == .ident && !base_is_local && g.has_import_alias(base.value) {
                    mod := g.import_alias_module(base.value) or { '' }
                    full_name := '${mod}.${fn_node.value}'
                    if full_name in g.tc.type_aliases || full_name in g.tc.structs
                        || full_name in g.tc.enum_names || full_name in g.tc.sum_types {
                        target_type := g.tc.parse_type(full_name)
                        ct := g.tc.c_type(target_type)
                        if target_type is types.SumType && node.children_count > 1 {
                            g.gen_sum_cast_expr(target_type, g.a.child(&node, 1))
                        } else {
                            g.write('(${ct})(')
                            for i in 1 .. node.children_count {
                                if i > 1 {
                                    g.write(', ')
                                }
                                g.gen_expr(g.a.child(&node, i))
                            }
                            g.write(')')
                        }
                        return
                    }
                    g.write(c_name(full_name))
                    g.write('(')
                    g.gen_call_args(full_name, node, 1)
                    g.write(')')
                    return
                } else if base.kind == .ident && !base_is_local
                    && g.static_method_fn_name(base.value, fn_node.value) != none {
                    // `Type.method(...)` where the base ident names a (possibly
                    // imported) type, not a value — e.g. `Animation.load(path)` inside
                    // the type's own module. Resolve to the module-qualified static fn.
                    static_fn := g.static_method_fn_name(base.value, fn_node.value) or { '' }
                    g.write(g.direct_call_name(static_fn))
                    g.write('(')
                    // Lower the arguments through the ordinary call path so a static method
                    // parameter that needs coercion — option/result wrapping, fn-pointer alias
                    // callbacks, sum variants, fixed-array decay, variadic/`@[params]` handling —
                    // is emitted against its expected type, not as the raw expression.
                    g.gen_call_args(static_fn, node, 1)
                    g.write(')')
                    return
                } else if base.kind == .selector {
                    inner := g.a.child_node(base, 0)
                    inner_is_local := if inner.kind == .ident {
                        (g.tc.cur_scope.lookup(inner.value) or { types.Type(types.void_) }) !is types.Void
                    } else {
                        false
                    }
                    if inner.kind == .ident && !inner_is_local {
                        if mod := g.import_alias_module(inner.value) {
                            full_name := '${mod}.${base.value}.${fn_node.value}'
                            g.write(c_name(full_name))
                            g.write('(')
                            g.gen_call_args(full_name, node, 1)
                            g.write(')')
                            return
                        }
                    }
                    {
                        base_type := g.tc.resolve_type(g.a.child(fn_node, 0))
                        clean_type := types.unwrap_pointer(base_type)
                        if g.gen_interface_method_call(node, fn_node, base_type) {
                            return
                        }
                        if g.gen_fn_field_call(node, fn_node, base_type) {
                            return
                        }
                        if arr := array_like_type(clean_type) {
                            g.gen_array_method_call(node, fn_node, arr)
                            return
                        }
                        if clean_type is types.ArrayFixed && fn_node.value == 'bytestr' {
                            g.write('u8__vstring_with_len((u8*)')
                            g.gen_expr(g.a.child(fn_node, 0))
                            len_expr := g.fixed_array_len_value(clean_type)
                            g.write(', ${len_expr})')
                            return
                        }
                        if clean_type is types.Map {
                            if fn_node.value == 'delete' {
                                g.gen_map_delete(node, fn_node, clean_type, base_type)
                                return
                            } else if fn_node.value == 'clone' {
                                g.write('map__clone(')
                                g.gen_map_ref_arg(g.a.child(fn_node, 0), base_type)
                                g.write(')')
                                return
                            } else if fn_node.value == 'clear' {
                                g.write('map__clear(')
                                g.gen_map_ref_arg(g.a.child(fn_node, 0), base_type)
                                g.write(')')
                                return
                            } else if fn_node.value == 'free' {
                                g.write('map__free(')
                                if base_type is types.Pointer {
                                    g.gen_expr(g.a.child(fn_node, 0))
                                } else {
                                    g.write('&')
                                    g.gen_expr(g.a.child(fn_node, 0))
                                }
                                g.write(')')
                                return
                            }
                        }
                        if clean_type is types.String {
                            method_name = 'string.${fn_node.value}'
                            if method_name in g.tc.fn_param_types {
                                is_method = true
                                base_id = g.a.child(fn_node, 0)
                                g.write_method_c_name(id, node, method_name)
                            } else {
                                g.write('string__${fn_node.value}(')
                                g.gen_expr(g.a.child(fn_node, 0))
                                for i in 1 .. node.children_count {
                                    g.write(', ')
                                    g.gen_expr(g.a.child(&node, i))
                                }
                                g.write(')')
                                return
                            }
                        }
                        if !is_method && (clean_type is types.Primitive
                            || clean_type is types.ISize || clean_type is types.USize
                            || clean_type is types.Rune) {
                            tname := clean_type.name()
                            prim_method := '${tname}.${fn_node.value}'
                            if prim_method in g.tc.fn_param_types {
                                is_method = true
                                base_id = g.a.child(fn_node, 0)
                                g.write(c_name(prim_method))
                            } else {
                                mut prim_found := false
                                if alias_method := g.find_alias_method(tname, fn_node.value) {
                                    is_method = true
                                    prim_found = true
                                    base_id = g.a.child(fn_node, 0)
                                    g.write(c_name(alias_method))
                                }
                                if !prim_found {
                                    alt_name := g.find_prim_method(fn_node.value)
                                    if alt_name.len > 0 {
                                        is_method = true
                                        base_id = g.a.child(fn_node, 0)
                                        g.write(alt_name)
                                    }
                                }
                            }
                        }
                        if !is_method {
                            mut struct_name := clean_type.name()
                            if clean_type is types.Struct {
                                struct_name = clean_type.name
                            }
                            method_name = g.resolve_method_name(struct_name, fn_node.value)
                            if method_name.len == 0 {
                                for alias, target in g.tc.type_aliases {
                                    if target == struct_name {
                                        alias_method := '${alias}.${fn_node.value}'
                                        if alias_method in g.tc.fn_param_types {
                                            method_name = alias_method
                                            break
                                        }
                                    }
                                }
                            }
                            if method_name.len > 0 && method_name in g.tc.fn_param_types {
                                is_method = true
                                base_id = g.a.child(fn_node, 0)
                                g.write_method_c_name(id, node, method_name)
                            } else {
                                str_method := 'string.${fn_node.value}'
                                if str_method in g.tc.fn_param_types {
                                    is_method = true
                                    method_name = str_method
                                    base_id = g.a.child(fn_node, 0)
                                    g.write(c_name(str_method))
                                } else if embedded_method := g.embedded_method_name_for_type(clean_type,
                                    fn_node.value)
                                {
                                    is_method = true
                                    method_name = embedded_method
                                    base_id = g.a.child(fn_node, 0)
                                    g.write(c_name(embedded_method))
                                } else if struct_name.len > 0 {
                                    is_method = true
                                    base_id = g.a.child(fn_node, 0)
                                    fallback_method := '${struct_name}.${fn_node.value}'
                                    g.write_method_c_name(id, node, fallback_method)
                                } else {
                                    g.gen_expr(g.a.child(&node, 0))
                                }
                            }
                        }
                    }
                } else if base.kind == .ident
                    && (base.value in g.tc.structs || base.value in g.tc.enum_names || g.tc.qualify_name(base.value) in g.tc.structs
                    || g.tc.qualify_name(base.value) in g.tc.enum_names) {
                    qname := if base.value in g.tc.structs || base.value in g.tc.enum_names {
                        base.value
                    } else {
                        g.tc.qualify_name(base.value)
                    }
                    static_name := '${qname}.${fn_node.value}'
                    g.write(c_name(static_name))
                    g.write('(')
                    for i in 1 .. node.children_count {
                        if i > 1 {
                            g.write(', ')
                        }
                        g.gen_expr(g.a.child(&node, i))
                    }
                    g.write(')')
                    return
                } else {
                    base_type := g.tc.resolve_type(g.a.child(fn_node, 0))
                    clean_type := types.unwrap_pointer(base_type)
                    if g.gen_interface_method_call(node, fn_node, base_type) {
                        return
                    }
                    if g.gen_fn_field_call(node, fn_node, base_type) {
                        return
                    }
                    if arr := array_like_type(clean_type) {
                        g.gen_array_method_call(node, fn_node, arr)
                        return
                    }
                    if clean_type is types.ArrayFixed && fn_node.value == 'bytestr' {
                        g.write('u8__vstring_with_len((u8*)')
                        g.gen_expr(g.a.child(fn_node, 0))
                        len_expr := g.fixed_array_len_value(clean_type)
                        g.write(', ${len_expr})')
                        return
                    }
                    if clean_type is types.Map {
                        if fn_node.value == 'delete' {
                            g.gen_map_delete(node, fn_node, clean_type, base_type)
                            return
                        } else if fn_node.value == 'clone' {
                            g.write('map__clone(')
                            g.gen_map_ref_arg(g.a.child(fn_node, 0), base_type)
                            g.write(')')
                            return
                        } else if fn_node.value == 'clear' {
                            g.write('map__clear(')
                            g.gen_map_ref_arg(g.a.child(fn_node, 0), base_type)
                            g.write(')')
                            return
                        } else if fn_node.value == 'free' {
                            g.write('map__free(')
                            if base_type is types.Pointer {
                                g.gen_expr(g.a.child(fn_node, 0))
                            } else {
                                g.write('&')
                                g.gen_expr(g.a.child(fn_node, 0))
                            }
                            g.write(')')
                            return
                        }
                    }
                    if clean_type is types.String {
                        method_name = 'string.${fn_node.value}'
                        if method_name in g.tc.fn_param_types {
                            is_method = true
                            base_id = g.a.child(fn_node, 0)
                            g.write_method_c_name(id, node, method_name)
                        } else {
                            g.write('string__${fn_node.value}(')
                            g.gen_expr(g.a.child(fn_node, 0))
                            for i in 1 .. node.children_count {
                                g.write(', ')
                                g.gen_expr(g.a.child(&node, i))
                            }
                            g.write(')')
                            return
                        }
                    }
                    if !is_method && (clean_type is types.Void || clean_type is types.Primitive)
                        && fn_node.value in ['vstring', 'vstring_with_len'] {
                        g.write('u8__${fn_node.value}((u8*)')
                        g.gen_expr(g.a.child(fn_node, 0))
                        for i in 1 .. node.children_count {
                            g.write(', ')
                            g.gen_expr(g.a.child(&node, i))
                        }
                        g.write(')')
                        return
                    }
                    if !is_method && clean_type is types.Struct && clean_type.name == 'IError' {
                        if fn_node.value == 'msg' {
                            g.gen_expr(g.a.child(fn_node, 0))
                            g.write('.message')
                            return
                        } else if fn_node.value == 'code' {
                            g.gen_expr(g.a.child(fn_node, 0))
                            g.write('.code')
                            return
                        }
                    }
                    if !is_method && clean_type is types.Struct && clean_type.name == 'array'
                        && fn_node.value == 'free' {
                        g.write('array__free(')
                        if base_type is types.Pointer {
                            g.gen_expr(g.a.child(fn_node, 0))
                        } else {
                            g.write('&')
                            g.gen_expr(g.a.child(fn_node, 0))
                        }
                        g.write(')')
                        return
                    }
                    if !is_method && (clean_type is types.Primitive
                        || clean_type is types.ISize || clean_type is types.USize
                        || clean_type is types.Rune) {
                        tname := clean_type.name()
                        prim_method := '${tname}.${fn_node.value}'
                        if prim_method in g.tc.fn_param_types {
                            is_method = true
                            base_id = g.a.child(fn_node, 0)
                            g.write(c_name(prim_method))
                        } else {
                            mut prim_found := false
                            if alias_method := g.find_alias_method(tname, fn_node.value) {
                                is_method = true
                                prim_found = true
                                base_id = g.a.child(fn_node, 0)
                                g.write(c_name(alias_method))
                            }
                            if !prim_found {
                                alt_name := g.find_prim_method(fn_node.value)
                                if alt_name.len > 0 {
                                    is_method = true
                                    base_id = g.a.child(fn_node, 0)
                                    g.write(alt_name)
                                }
                            }
                        }
                    }
                    if !is_method {
                        // Static method on a named type / type alias (e.g. `SimdFloat4.new(...)`,
                        // where `SimdFloat4` names a type, not a value). The base ident resolves to
                        // no value type, so handle it before the instance-method fallback.
                        base_node_s := g.a.child_node(fn_node, 0)
                        if base_node_s.kind == .ident {
                            if static_fn := g.static_method_fn_name(base_node_s.value,
                                fn_node.value)
                            {
                                g.write(g.direct_call_name(static_fn))
                                g.write('(')
                                for i in 1 .. node.children_count {
                                    if i > 1 {
                                        g.write(', ')
                                    }
                                    g.gen_expr(g.a.child(&node, i))
                                }
                                g.write(')')
                                return
                            }
                        }
                    }
                    if !is_method {
                        mut struct_name := clean_type.name()
                        if clean_type is types.Struct {
                            struct_name = clean_type.name
                        }
                        method_name = g.resolve_method_name(struct_name, fn_node.value)
                        if method_name.len == 0 {
                            for alias, target in g.tc.type_aliases {
                                if target == struct_name {
                                    alias_method := '${alias}.${fn_node.value}'
                                    if alias_method in g.tc.fn_param_types {
                                        method_name = alias_method
                                        break
                                    }
                                }
                            }
                        }
                        if method_name.len > 0 && method_name in g.tc.fn_param_types {
                            is_method = true
                            base_id = g.a.child(fn_node, 0)
                            g.write_method_c_name(id, node, method_name)
                        } else {
                            str_method := 'string.${fn_node.value}'
                            if str_method in g.tc.fn_param_types {
                                is_method = true
                                method_name = str_method
                                base_id = g.a.child(fn_node, 0)
                                g.write(c_name(str_method))
                            } else if embedded_method := g.embedded_method_name_for_type(clean_type,
                                fn_node.value)
                            {
                                is_method = true
                                method_name = embedded_method
                                base_id = g.a.child(fn_node, 0)
                                g.write(c_name(embedded_method))
                            } else if struct_name.len > 0 {
                                is_method = true
                                base_id = g.a.child(fn_node, 0)
                                fallback_method := '${struct_name}.${fn_node.value}'
                                g.write_method_c_name(id, node, fallback_method)
                            } else {
                                g.gen_expr(g.a.child(&node, 0))
                            }
                        }
                    }
                    // !is_method
                }
            } else {
                fn_id := g.a.child(&node, 0)
                fn_ident := g.a.nodes[int(fn_id)]
                if fn_ident.kind == .ident {
                    qname := g.tc.qualify_name(fn_ident.value)
                    if fn_ident.value in g.tc.type_aliases || qname in g.tc.type_aliases
                        || fn_ident.value in g.tc.structs || qname in g.tc.structs
                        || fn_ident.value in g.tc.enum_names || qname in g.tc.enum_names
                        || fn_ident.value in g.tc.sum_types || qname in g.tc.sum_types {
                        type_name := if fn_ident.value in g.tc.type_aliases
                            || fn_ident.value in g.tc.structs || fn_ident.value in g.tc.enum_names
                            || fn_ident.value in g.tc.sum_types {
                            fn_ident.value
                        } else {
                            qname
                        }
                        target_type := g.tc.parse_type(type_name)
                        ct := g.tc.c_type(target_type)
                        if target_type is types.SumType && node.children_count > 1 {
                            g.gen_sum_cast_expr(target_type, g.a.child(&node, 1))
                        } else {
                            g.write('(${ct})(')
                            for i in 1 .. node.children_count {
                                if i > 1 {
                                    g.write(', ')
                                }
                                g.gen_expr(g.a.child(&node, i))
                            }
                            g.write(')')
                        }
                        return
                    }
                    call_key := g.call_key(id, fn_ident.value)
                    looked_up := g.tc.cur_scope.lookup(fn_ident.value) or {
                        types.Type(types.void_)
                    }
                    if looked_up !is types.Void && fn_type_from(looked_up) != none {
                        g.write(c_name(fn_ident.value))
                    } else if call_key in g.tc.fn_ret_types || call_key in g.tc.fn_param_types {
                        g.write(g.direct_call_name_for_call(id, call_key))
                    } else {
                        g.write(c_name(fn_ident.value))
                    }
                } else {
                    g.gen_expr(fn_id)
                }
            }
            g.write('(')
            actual_fn := if is_method {
                method_name
            } else if target_name.contains('.') {
                g.call_key(id, target_name)
            } else {
                g.call_key(id, fn_name)
            }
            mut param_types := g.param_types_for(actual_fn, fn_name)
            if param_types.len == 0 && !is_method {
                // Calling through a function-typed value (a generic `f F` parameter or a
                // local fn variable): the callee is not a named function, so recover the
                // parameter types from the value's own function type. This lets `mut` /
                // pointer arguments receive their `&` exactly as a direct call would.
                if ft := fn_type_from(g.tc.resolve_type(g.a.child(&node, 0))) {
                    param_types = ft.params.clone()
                }
            }
            mut arg_start := 1
            if is_method {
                base_type := g.receiver_base_type(base_id)
                wants_ptr := param_types.len > 0 && param_types[0] is types.Pointer
                receiver_type_name := g.type_lookup_name(base_type)
                method_short := method_name.all_after_last('.').all_after_last('__')
                atomic_receiver_wants_ptr := method_name.starts_with('stdatomic.AtomicVal_')
                    || method_name.starts_with('stdatomic.AtomicVal.')
                    || method_name.starts_with('AtomicVal_')
                    || method_name.starts_with('AtomicVal.')
                    || (receiver_type_name.contains('AtomicVal')
                    && method_short in ['load', 'store', 'add', 'sub', 'swap', 'compare_and_swap'])
                if param_types.len > 0
                    && g.gen_embedded_method_receiver(base_id, base_type, param_types[0], wants_ptr) {
                    arg_start = 1
                } else {
                    mut is_ptr_base := base_type is types.Pointer
                    // A `string.*` method always takes its receiver by value. If the
                    // receiver mis-resolves to a char pointer (e.g. a `const x =
                    // os.getenv(..)` whose type was inferred as `&char`), the actual
                    // storage is still a `string`, so do not dereference it.
                    if is_ptr_base && method_name.starts_with('string.')
                        && base_type is types.Pointer && base_type.base_type is types.Char {
                        is_ptr_base = false
                    }
                    if (wants_ptr || atomic_receiver_wants_ptr) && !is_ptr_base {
                        g.write('&')
                    } else if !wants_ptr && !atomic_receiver_wants_ptr && is_ptr_base {
                        g.write('*')
                    }
                    g.gen_expr(base_id)
                    arg_start = 1
                }
            }
            num_call_args := node.children_count - arg_start
            is_variadic_fn := !is_method && !is_c_call && (g.tc.fn_variadic[actual_fn] or { false })
            variadic_idx := if is_variadic_fn && param_types.len > 0
                && param_types[param_types.len - 1] is types.Array {
                param_types.len - 1
            } else {
                -1
            }
            // A veb handler whose hidden `Context` parameter (param index 1, right
            // after the receiver) was omitted by the caller forwards the enclosing
            // handler's `ctx` in that slot so the remaining explicit arguments still
            // line up with their parameters.
            expected_non_ctx := if is_method { param_types.len - 1 } else { param_types.len }
            forward_ctx := param_types.len > 1 && g.is_implicit_veb_ctx_param(param_types[1])
                && num_call_args < expected_non_ctx && g.cur_scope_has_ctx()
            if forward_ctx && is_method {
                g.write(', ctx')
            }
            mut emitted_arg_count := 0
            for i in arg_start .. node.children_count {
                mut arg_idx := if is_method { i } else { i - 1 }
                if forward_ctx && (is_method || i - arg_start >= 1) {
                    arg_idx++
                }
                arg_id := g.a.child(&node, i)
                if int(arg_id) < 0 {
                    continue
                }
                arg_node := g.a.nodes[int(arg_id)]
                if is_method || emitted_arg_count > 0 {
                    g.write(', ')
                }
                emitted_arg_count++
                if arg_node.kind == .field_init && variadic_idx >= 0 && arg_idx == variadic_idx {
                    variadic_type := param_types[variadic_idx]
                    if variadic_type is types.Array {
                        if variadic_type.elem_type is types.Struct {
                            c_elem := g.tc.c_type(variadic_type.elem_type)
                            g.write('new_array_from_c_array(1, 1, sizeof(${c_elem}), (${c_elem}[]){')
                            g.gen_params_struct_arg(variadic_type.elem_type, node, i)
                            g.write('})')
                            break
                        }
                    }
                }
                if arg_node.kind == .field_init {
                    // `@[params]` struct argument: trailing `key: value` args form a struct literal
                    ptyp := if arg_idx < param_types.len {
                        param_types[arg_idx]
                    } else {
                        types.Type(types.void_)
                    }
                    g.gen_params_struct_arg(ptyp, node, i)
                    break
                }
                if fixed := array_fixed_type(g.tc.resolve_type(arg_id)) {
                    g.gen_fixed_array_data_arg(arg_id, fixed)
                    continue
                }
                if !is_c_call && arg_idx < param_types.len {
                    if fixed := array_fixed_type(param_types[arg_idx]) {
                        g.gen_fixed_array_data_arg(arg_id, fixed)
                        continue
                    }
                }
                if !is_c_call && arg_idx < param_types.len
                    && g.gen_pointer_arg_from_array_literal(arg_node, param_types[arg_idx]) {
                    continue
                }
                cb_param := if arg_idx >= 0 && arg_idx < param_types.len {
                    param_types[arg_idx]
                } else {
                    types.Type(types.void_)
                }
                if g.gen_special_c_callback_arg(target_name, arg_idx, arg_id, cb_param) {
                    continue
                }
                if variadic_idx >= 0 && arg_idx == variadic_idx {
                    variadic_type := param_types[variadic_idx]
                    if variadic_type is types.Array {
                        if num_call_args > param_types.len {
                            c_elem := g.tc.c_type(variadic_type.elem_type)
                            count := num_call_args - variadic_idx
                            g.write('new_array_from_c_array(${count}, ${count}, sizeof(${c_elem}), (${c_elem}[]){')
                            for j in i .. node.children_count {
                                if j > i {
                                    g.write(', ')
                                }
                                g.gen_expr_with_expected_type(g.a.child(&node, j),
                                    variadic_type.elem_type)
                            }
                            g.write('})')
                            break
                        }
                        arg_type := g.tc.resolve_type(arg_id)
                        if arg_type !is types.Array {
                            c_elem := g.tc.c_type(variadic_type.elem_type)
                            g.write('new_array_from_c_array(1, 1, sizeof(${c_elem}), (${c_elem}[]){')
                            g.gen_expr_with_expected_type(arg_id, variadic_type.elem_type)
                            g.write('})')
                            continue
                        }
                    }
                }
                mut needs_addr := false
                if !is_c_call && arg_idx < param_types.len && param_types[arg_idx] is types.Pointer
                    && !(arg_node.kind == .prefix && arg_node.op == .amp) {
                    arg_type := g.tc.resolve_type(arg_id)
                    if arg_type !is types.Pointer
                        && !c_string_literal_pointer_arg(arg_node, param_types[arg_idx]) {
                        needs_addr = true
                    }
                }
                if !is_c_call && arg_idx < param_types.len {
                    pt := param_types[arg_idx]
                    if pt is types.Enum {
                        g.expected_enum = pt.name
                    }
                }
                if !is_c_call && arg_idx < param_types.len {
                    if child_id := g.addressed_rvalue_arg(arg_node) {
                        pt := param_types[arg_idx]
                        if pt is types.Pointer {
                            ct := g.tc.c_type(types.unwrap_pointer(pt))
                            g.write('({${ct} _t${g.tmp_count} = ')
                            g.gen_expr_with_expected_type(child_id, types.unwrap_pointer(pt))
                            g.write('; &_t${g.tmp_count};})')
                            g.tmp_count++
                            g.expected_enum = ''
                            continue
                        }
                    }
                }
                is_rvalue := arg_node.kind == .call
                    || (arg_node.kind == .index && arg_node.value == 'range')
                if needs_addr && is_rvalue {
                    pt := param_types[arg_idx]
                    ct := g.tc.c_type(types.unwrap_pointer(pt))
                    g.write('({${ct} _t${g.tmp_count} = ')
                    g.gen_expr_with_expected_type(arg_id, types.unwrap_pointer(pt))
                    g.write('; &_t${g.tmp_count};})')
                    g.tmp_count++
                } else {
                    if needs_addr {
                        g.write('&')
                    }
                    emitted_variant := !needs_addr && !is_c_call && arg_idx < param_types.len
                        && g.gen_sum_variant_arg(arg_id, param_types[arg_idx])
                    if !emitted_variant {
                        if !is_c_call && arg_idx < param_types.len
                            && g.gen_optional_arg(arg_id, param_types[arg_idx]) {
                            // handled
                        } else if !is_c_call && arg_idx < param_types.len {
                            g.gen_expr_with_expected_type(arg_id, param_types[arg_idx])
                        } else {
                            g.gen_expr(arg_id)
                        }
                    }
                }
                g.expected_enum = ''
                // A no-arg delegation leaves the forwarded ctx as the final argument;
                // emit it here, right after the receiver, for the lowered free call.
                if forward_ctx && !is_method && i - arg_start == 0 {
                    g.write(', ctx')
                }
            }
            // Count the forwarded ctx (if any) as already supplied.
            actual_args := emitted_arg_count + (if forward_ctx { 1 } else { 0 })
            expected_args := if is_method {
                param_types.len - 1
            } else {
                param_types.len
            }
            if !is_c_call && expected_args > 0 && actual_args < expected_args {
                for pi in actual_args .. expected_args {
                    if is_method || pi > 0 {
                        g.write(', ')
                    }
                    pidx := if is_method { pi + 1 } else { pi }
                    pt := param_types[pidx]
                    // The implicit veb `Context` parameter is supplied from the
                    // enclosing handler's `ctx`, not a zero/default value.
                    if g.is_implicit_veb_ctx_param(pt) && g.cur_scope_has_ctx() {
                        g.write('ctx')
                    } else {
                        g.gen_default_value_for_type(pt)
                    }
                }
            }
            g.write(')')
        }
    }
}

// receiver_base_type supports receiver base type handling for FlatGen.
fn (g &FlatGen) receiver_base_type(base_id flat.NodeId) types.Type {
    if int(base_id) < 0 {
        return types.Type(types.void_)
    }
    base := g.a.nodes[int(base_id)]
    if base.kind == .ident {
        if typ := g.current_param_type(base.value) {
            return typ
        }
        if typ := g.cur_param_types[base.value] {
            return typ
        }
        if typ := g.tc.cur_scope.lookup(base.value) {
            return typ
        }
    }
    return g.tc.resolve_type(base_id)
}

fn (g &FlatGen) receiver_storage_type(base_id flat.NodeId) ?types.Type {
    if int(base_id) < 0 || int(base_id) >= g.a.nodes.len {
        return none
    }
    node := g.a.nodes[int(base_id)]
    if node.kind == .selector && node.children_count > 0 {
        parent_type := g.tc.resolve_type(g.a.child(&node, 0))
        return g.field_type(parent_type, node.value)
    }
    return none
}

fn (g &FlatGen) receiver_needs_address(base_id flat.NodeId, base_type types.Type) bool {
    if int(base_id) >= 0 && int(base_id) < g.a.nodes.len {
        node := g.a.nodes[int(base_id)]
        if node.kind == .selector {
            if storage_type := g.receiver_storage_type(base_id) {
                return storage_type !is types.Pointer
            }
        }
    }
    return base_type !is types.Pointer
}

fn (mut g FlatGen) gen_interface_method_call(node flat.Node, fn_node flat.Node, base_type types.Type) bool {
    clean0 := types.unwrap_pointer(base_type)
    mut clean := clean0
    if clean0 is types.Alias {
        clean = clean0.base_type
    }
    if clean !is types.Interface {
        return false
    }
    iface := clean as types.Interface
    if c_name(iface.name) == 'IError' {
        return false
    }
    if iface.name !in g.interfaces {
        return false
    }
    method_name := '${iface.name}.${fn_node.value}'
    param_types := g.interface_method_param_types(method_name) or { []types.Type{} }
    base_id := g.a.child(fn_node, 0)
    g.write(c_name(method_name))
    g.write('(')
    if g.receiver_needs_address(base_id, base_type) {
        g.write('&')
    }
    g.gen_expr(base_id)
    mut emitted_arg_count := 0
    for i in 1 .. node.children_count {
        arg_id := g.a.child(&node, i)
        if int(arg_id) < 0 {
            continue
        }
        arg_node := g.a.nodes[int(arg_id)]
        g.write(', ')
        emitted_arg_count++
        param_idx := i
        if param_idx < param_types.len {
            if fixed := array_fixed_type(param_types[param_idx]) {
                g.gen_fixed_array_data_arg(arg_id, fixed)
                continue
            }
            if g.gen_pointer_arg_from_array_literal(arg_node, param_types[param_idx]) {
                continue
            }
            if child_id := g.addressed_rvalue_arg(arg_node) {
                pt := param_types[param_idx]
                if pt is types.Pointer {
                    ct := g.tc.c_type(types.unwrap_pointer(pt))
                    g.write('({${ct} _t${g.tmp_count} = ')
                    g.gen_expr_with_expected_type(child_id, types.unwrap_pointer(pt))
                    g.write('; &_t${g.tmp_count};})')
                    g.tmp_count++
                    continue
                }
            }
            emitted_variant := g.gen_sum_variant_arg(arg_id, param_types[param_idx])
            if !emitted_variant {
                if g.gen_optional_arg(arg_id, param_types[param_idx]) {
                    // handled
                } else {
                    g.gen_expr_with_expected_type(arg_id, param_types[param_idx])
                }
            }
        } else {
            g.gen_expr(arg_id)
        }
    }
    expected_args := if param_types.len > 0 { param_types.len - 1 } else { 0 }
    if emitted_arg_count < expected_args {
        for pi in emitted_arg_count .. expected_args {
            g.write(', ')
            g.gen_default_value_for_type(param_types[pi + 1])
        }
    }
    g.write(')')
    return true
}

fn (g &FlatGen) call_target_name(id flat.NodeId) string {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return ''
    }
    node := g.a.nodes[int(id)]
    match node.kind {
        .ident {
            return node.value
        }
        .selector {
            if node.children_count == 0 {
                return node.value
            }
            base := g.a.child_node(&node, 0)
            if base.kind == .ident {
                if mod := g.import_alias_module(base.value) {
                    return '${mod}.${node.value}'
                }
                return '${base.value}.${node.value}'
            }
            return node.value
        }
        .index {
            if node.children_count > 0 {
                return g.call_target_name(g.a.child(&node, 0))
            }
            return node.value
        }
        else {
            return node.value
        }
    }
}

fn (g &FlatGen) call_has_selector_name(id flat.NodeId, name string) bool {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return false
    }
    node := g.a.nodes[int(id)]
    if node.kind == .selector && node.value == name {
        return true
    }
    for i in 0 .. node.children_count {
        if g.call_has_selector_name(g.a.child(&node, i), name) {
            return true
        }
    }
    return false
}

fn (g &FlatGen) is_veb_json_result_call(fn_node flat.Node) bool {
    if fn_node.kind == .ident {
        if fn_node.value in ['veb.Context.json', 'veb.Context.json_pretty'] {
            return true
        }
        if fn_node.value !in ['Context.json', 'Context.json_pretty'] {
            return false
        }
        if fn_node.value in g.tc.fn_param_types || fn_node.value in g.tc.fn_ret_types {
            return false
        }
        return g.type_name_known_in_current_module('Context')
            && g.type_embeds_veb_context(g.tc.parse_type('Context'))
    }
    if fn_node.kind != .selector || fn_node.children_count == 0 {
        return false
    }
    if fn_node.value !in ['json', 'json_pretty'] {
        return false
    }
    receiver_id := g.a.child(fn_node, 0)
    receiver_type := types.unwrap_pointer(g.tc.resolve_type(receiver_id))
    if receiver_type is types.Struct {
        receiver_name := receiver_type.name
        if receiver_name != 'veb.Context' {
            method_name := '${receiver_name}.${fn_node.value}'
            if method_name in g.tc.fn_param_types || method_name in g.tc.fn_ret_types {
                return false
            }
        }
    }
    if embedded_method := g.embedded_method_name_for_type(receiver_type, fn_node.value) {
        return embedded_method in ['veb.Context.json', 'veb.Context.json_pretty']
    }
    return g.is_veb_context_receiver(receiver_id)
}

fn (g &FlatGen) is_veb_context_receiver(id flat.NodeId) bool {
    typ := g.tc.resolve_type(id)
    return g.type_embeds_veb_context(typ)
}

fn (g &FlatGen) type_embeds_veb_context(typ types.Type) bool {
    clean := types.unwrap_pointer(typ)
    if clean is types.Alias {
        return g.type_embeds_veb_context(clean.base_type)
    }
    if clean !is types.Struct {
        return false
    }
    struct_name := clean.name()
    if struct_name == 'veb.Context' {
        return true
    }
    fields := g.struct_fields_for_type(struct_name) or { return false }
    for field in fields {
        embedded_type_name := g.embedded_field_type_name(field)
        if embedded_type_name == 'veb.Context' {
            return true
        }
        if embedded_type_name.len > 0
            && g.type_embeds_veb_context(g.tc.parse_type(embedded_type_name)) {
            return true
        }
    }
    return false
}

fn (g &FlatGen) is_missing_middleware_use_call(fn_node flat.Node) bool {
    if fn_node.kind == .ident {
        if !fn_node.value.ends_with('.use') {
            return false
        }
        if fn_node.value in g.tc.fn_param_types || fn_node.value in g.tc.fn_ret_types {
            return false
        }
        receiver := fn_node.value.all_before_last('.')
        return g.struct_has_middleware_receiver(receiver)
    }
    if fn_node.kind != .selector || fn_node.value != 'use' || fn_node.children_count == 0 {
        return false
    }
    base_type := g.tc.resolve_type(g.a.child(fn_node, 0))
    clean_type := types.unwrap_pointer(base_type)
    if clean_type !is types.Struct {
        return false
    }
    method_name := '${clean_type.name()}.use'
    if method_name in g.tc.fn_param_types || method_name in g.tc.fn_ret_types {
        return false
    }
    return g.struct_has_middleware_receiver(clean_type.name())
}

fn (g &FlatGen) struct_has_middleware_receiver(type_name string) bool {
    if is_middleware_type_name(type_name) {
        return true
    }
    fields := g.struct_fields_for_type(type_name) or { return false }
    for field in fields {
        embedded_type_name := g.embedded_field_type_name(field)
        if is_middleware_type_name(embedded_type_name) {
            return true
        }
    }
    return false
}

fn is_middleware_type_name(name string) bool {
    base := if name.contains('[') { name.all_before('[') } else { name }
    return base == 'veb.Middleware'
}

fn (g &FlatGen) call_default_return_type(id flat.NodeId) types.Type {
    if g.expected_expr_type is types.OptionType || g.expected_expr_type is types.ResultType {
        return g.expected_expr_type
    }
    if g.expected_expr_type is types.Struct && g.expected_expr_type.name.starts_with('Optional') {
        return g.expected_expr_type
    }
    if g.expected_expr_type is types.String {
        return g.expected_expr_type
    }
    if typ := g.tc.expr_type(id) {
        if typ !is types.Unknown && typ !is types.Void {
            return typ
        }
    }
    return g.tc.resolve_type(id)
}

fn (g &FlatGen) json_decode_result_type(callee_id flat.NodeId) ?types.Type {
    if int(callee_id) < 0 || int(callee_id) >= g.a.nodes.len {
        return none
    }
    callee := g.a.nodes[int(callee_id)]
    if callee.kind != .index || callee.children_count < 2 {
        return none
    }
    arg := g.a.child_node(&callee, 1)
    mut type_name := ''
    if arg.typ.len > 0 {
        type_name = arg.typ
    } else if arg.kind == .array_init && arg.value.len > 0 {
        type_name = '[]${arg.value}'
    } else if arg.value.len > 0 {
        type_name = arg.value
    }
    if type_name.len == 0 {
        return none
    }
    return types.Type(types.ResultType{
        base_type: g.tc.parse_type(type_name)
    })
}

fn (g &FlatGen) embedded_method_name_for_type(base_type types.Type, method string) ?string {
    type_name := g.type_lookup_name(base_type)
    if type_name.len == 0 || method.len == 0 {
        return none
    }
    return g.embedded_method_name_for_struct(type_name, method)
}

fn (g &FlatGen) embedded_method_name_for_struct(type_name string, method string) ?string {
    fields := g.struct_fields_for_type(type_name) or { return none }
    for field in fields {
        embedded_type_name := g.embedded_field_type_name(field)
        if embedded_type_name.len == 0 {
            continue
        }
        method_name := '${embedded_type_name}.${method}'
        if method_name in g.tc.fn_param_types {
            return method_name
        }
        if found := g.embedded_method_name_for_struct(embedded_type_name, method) {
            return found
        }
    }
    return none
}

fn (mut g FlatGen) gen_embedded_method_receiver(base_id flat.NodeId, base_type types.Type, expected_type types.Type, wants_ptr bool) bool {
    field := g.embedded_receiver_field_for_expected(base_type, expected_type) or { return false }
    field_is_ptr := field.typ is types.Pointer
    if wants_ptr && !field_is_ptr {
        g.write('&')
    } else if !wants_ptr && field_is_ptr {
        g.write('*')
    }
    needs_paren := g.a.nodes[int(base_id)].kind !in [.ident, .selector]
    if needs_paren {
        g.write('(')
    }
    g.gen_expr(base_id)
    if needs_paren {
        g.write(')')
    }
    first_op := if base_type is types.Pointer { '->' } else { '.' }
    g.write('${first_op}${c_name(field.name)}')
    return true
}

fn (g &FlatGen) embedded_receiver_field_for_expected(base_type types.Type, expected_type types.Type) ?types.StructField {
    base_name := g.type_lookup_name(base_type)
    expected_name := g.type_lookup_name(expected_type)
    if base_name.len == 0 || expected_name.len == 0 {
        return none
    }
    fields := g.struct_fields_for_type(base_name) or { return none }
    for field in fields {
        embedded_type_name := g.embedded_field_type_name(field)
        if embedded_type_name == expected_name {
            return field
        }
    }
    return none
}

// current_param_type returns current param type data for FlatGen.
fn (g &FlatGen) current_param_type(name string) ?types.Type {
    for i in 0 .. g.cur_param_names.len {
        if g.cur_param_names[i] == name {
            return g.cur_param_type_values[i]
        }
    }
    return none
}

// gen_enum_str_call emits an explicit `enum_val.str()` (with no user-defined `str`)
// by routing to the compiler-synthesized `<Enum>__autostr`, so it matches `${enum}`
// interpolation exactly — including `[flag]` enums' `Enum{.a | .b}` form, which the
// old inline single-value ternary chain could not render.
fn (mut g FlatGen) gen_enum_str_call(fn_node &flat.Node, enum_type types.Enum) {
    mut name := enum_type.name
    if name.starts_with('main.') {
        name = name[5..]
    }
    g.write('${c_name(name)}__autostr(')
    g.gen_expr(g.a.child(fn_node, 0))
    g.write(')')
}

// enum_receiver_method_name supports enum receiver method name handling for FlatGen.
fn (g &FlatGen) enum_receiver_method_name(enum_type types.Enum, method string) ?string {
    name := enum_type.name
    direct := '${name}.${method}'
    if direct in g.tc.fn_param_types {
        return direct
    }
    if name.contains('.') {
        return none
    }
    for candidate, _ in g.tc.fn_param_types {
        if candidate.ends_with('.${direct}') {
            return candidate
        }
    }
    return none
}

// gen_fn_field_call emits fn field call output for c.
fn (mut g FlatGen) gen_fn_field_call(node flat.Node, fn_node &flat.Node, base_type types.Type) bool {
    fn_type := g.fn_field_type(base_type, fn_node.value) or { return false }
    base_id := g.a.child(fn_node, 0)
    base := g.a.nodes[int(base_id)]
    needs_paren := base.kind !in [.ident, .selector, .call]
    if needs_paren {
        g.write('(')
    }
    g.gen_expr(base_id)
    if needs_paren {
        g.write(')')
    }
    if base_type is types.Pointer {
        g.write('->')
    } else {
        g.write('.')
    }
    g.write(c_name(fn_node.value))
    g.write('(')
    for i in 1 .. node.children_count {
        if i > 1 {
            g.write(', ')
        }
        arg_id := g.a.child(&node, i)
        arg_idx := i - 1
        if arg_idx < fn_type.params.len {
            g.gen_arg_for_expected_type(arg_id, fn_type.params[arg_idx])
        } else {
            g.gen_expr(arg_id)
        }
    }
    g.write(')')
    return true
}

// call_key updates call key state for FlatGen.
fn (g &FlatGen) call_key(id flat.NodeId, name string) string {
    if name.contains('.') {
        normalized := g.normalize_call_key(name)
        if normalized in g.tc.fn_param_types || normalized in g.tc.fn_ret_types {
            return normalized
        }
    }
    if resolved := g.tc.resolved_call_name(id) {
        return g.normalize_call_key(resolved)
    }
    return g.normalize_call_key(name)
}

// normalize_call_key transforms normalize call key data for c.
fn (g &FlatGen) normalize_call_key(name string) string {
    if name.starts_with('main.') {
        short_name := name.all_after_last('.')
        if short_name in g.tc.fn_param_types || short_name in g.tc.fn_ret_types {
            return short_name
        }
    }
    if !name.contains('.') && g.tc.cur_module.len > 0 && g.tc.cur_module != 'main'
        && g.tc.cur_module != 'builtin' {
        local := '${g.tc.cur_module}.${name}'
        if local in g.tc.fn_param_types || local in g.tc.fn_ret_types {
            return local
        }
    }
    if name in g.tc.fn_param_types || name in g.tc.fn_ret_types {
        return name
    }
    qname := g.tc.qualify_fn_name(name)
    if qname in g.tc.fn_param_types || qname in g.tc.fn_ret_types {
        return qname
    }
    for _, mod_name in g.tc.imports {
        imported := '${mod_name}.${name}'
        if imported in g.tc.fn_param_types || imported in g.tc.fn_ret_types {
            return imported
        }
    }
    return qname
}

// param_types_for supports param types for handling for FlatGen.
// param_types_for resolves the parameter types of a called function. It is invoked once
// per call site during codegen, and the slow path below scans every known function, so
// results are memoized: without this, generic/monomorphized call names that miss the
// direct lookups re-scan (and copy) the whole function table on every call (O(n^2)).
fn (mut g FlatGen) param_types_for(name string, fallback string) []types.Type {
    cache_key := '${name}\x01${fallback}'
    if cached := g.param_types_cache[cache_key] {
        return cached
    }
    result := g.param_types_for_uncached(name, fallback)
    g.param_types_cache[cache_key] = result
    return result
}

fn (mut g FlatGen) param_types_for_uncached(name string, fallback string) []types.Type {
    if generic_params := g.generic_receiver_method_param_types(name) {
        return generic_params
    }
    if interface_types := g.interface_method_param_types(name) {
        return interface_types
    }
    for candidate in [name, fallback] {
        if params := g.tc.fn_param_types[candidate] {
            return params
        }
        if candidate.starts_with('main.') {
            short_name := candidate.all_after_last('.')
            if params := g.tc.fn_param_types[short_name] {
                return params
            }
        }
    }
    decl_types := g.param_types_from_decl(name, fallback)
    if decl_types.len > 0 {
        return decl_types
    }
    if name.contains('.') {
        // O(1) lookup via the precomputed short-name index instead of scanning the whole
        // function table on every (cache-missing) call — this fallback ran ~3000× and was
        // a top cgen self-time cost (each scan is O(functions)).
        short_name := name.all_after_last('.')
        if params := g.param_types_by_short[short_name] {
            return params
        }
    }
    return []types.Type{}
}

fn (g &FlatGen) generic_receiver_method_param_types(name string) ?[]types.Type {
    if !name.contains('.') || !name.contains('[') || !name.contains(']') {
        return none
    }
    receiver := name.all_before_last('.')
    method := name.all_after_last('.')
    info := g.tc.resolve_generic_struct_method(receiver, method) or { return none }
    return info.params.clone()
}

// precompute_param_type_index builds short-name -> param-types, preserving the fallback's
// priority (fn_decl_param_types first, then the checker's fn_param_types; first match wins).
fn (mut g FlatGen) precompute_param_type_index() {
    for name, params in g.fn_decl_param_types {
        if name.contains('.') {
            short := name.all_after_last('.')
            if short !in g.param_types_by_short {
                g.param_types_by_short[short] = params
            }
        }
    }
    for name, params in g.tc.fn_param_types {
        if name.contains('.') {
            short := name.all_after_last('.')
            if short !in g.param_types_by_short {
                g.param_types_by_short[short] = params
            }
        }
    }
}

fn (g &FlatGen) interface_method_param_types(name string) ?[]types.Type {
    if !name.contains('.') {
        return none
    }
    iface_name := name.all_before_last('.')
    if iface_name !in g.interfaces {
        return none
    }
    method := name.all_after_last('.')
    if iface_name == 'IError' && method == 'str' {
        return none
    }
    decl_key := g.interface_method_signature_key(iface_name, method) or { return none }
    decl_params := g.tc.fn_param_types[decl_key] or { return none }
    mut params := []types.Type{cap: decl_params.len}
    params << types.Type(types.Pointer{
        base_type: types.Type(types.Interface{
            name: iface_name
        })
    })
    if decl_params.len > 1 {
        for i in 1 .. decl_params.len {
            params << decl_params[i]
        }
    }
    return params
}

// param_types_from_decl converts param types from decl data for c.
fn (mut g FlatGen) param_types_from_decl(name string, fallback string) []types.Type {
    if name.contains('.') {
        if ptypes := g.fn_decl_param_types[name] {
            return ptypes
        }
    } else {
        for candidate in [fallback, name] {
            if ptypes := g.fn_decl_param_types[candidate] {
                return ptypes
            }
        }
    }
    return []types.Type{}
}

// short_receiver_method_name supports short receiver method name handling for c.
fn short_receiver_method_name(name string) string {
    if !name.contains('.') {
        return ''
    }
    receiver := name.all_before_last('.')
    if !receiver.contains('.') {
        return ''
    }
    return '${receiver.all_after_last('.')}.${name.all_after_last('.')}'
}

// gen_arg_for_expected_type emits arg for expected type output for c.
fn (mut g FlatGen) gen_arg_for_expected_type(arg_id flat.NodeId, expected types.Type) {
    arg_node := g.a.nodes[int(arg_id)]
    mut needs_addr := false
    if expected is types.Pointer && !(arg_node.kind == .prefix && arg_node.op == .amp) {
        arg_type := g.tc.resolve_type(arg_id)
        if arg_type !is types.Pointer {
            needs_addr = true
        }
    }
    if needs_addr {
        g.write('&')
    }
    if !needs_addr && g.gen_sum_variant_arg(arg_id, expected) {
        return
    }
    if !needs_addr && g.gen_optional_arg(arg_id, expected) {
        return
    }
    g.gen_expr_with_expected_type(arg_id, expected)
}

fn (mut g FlatGen) gen_callback_fn_value_for_expected_type(arg_id flat.NodeId, expected types.Type) bool {
    return g.gen_callback_fn_value_for_expected_c_abi(arg_id, expected, '')
}

fn (mut g FlatGen) gen_callback_fn_value_for_expected_c_abi(arg_id flat.NodeId, expected types.Type, expected_c_abi string) bool {
    expected_fn := fn_type_from(expected) or { return false }
    actual_name := g.callback_fn_value_name(arg_id, expected) or { return false }
    actual_fn := g.callback_fn_value_type(actual_name) or { return false }
    wrapper := g.ensure_callback_userdata_wrapper(actual_name, actual_fn, expected_fn,
        expected_c_abi) or { return false }
    g.write(wrapper)
    return true
}

fn (mut g FlatGen) gen_callback_fn_value_for_field_c_abi(arg_id flat.NodeId, expected types.Type, expected_c_abi string) bool {
    if expected_c_abi.len == 0 {
        return false
    }
    if g.gen_callback_fn_value_for_expected_c_abi(arg_id, expected, expected_c_abi) {
        return true
    }
    if call_name := g.callback_direct_fn_value_name_for_c_abi(arg_id, expected, expected_c_abi) {
        g.write(g.callback_c_fn_name(call_name))
        return true
    }
    if _ := g.callback_fn_value_name(arg_id, expected) {
        g.gen_expr(arg_id)
        return true
    }
    return false
}

fn (mut g FlatGen) callback_fn_value_name(id flat.NodeId, expected types.Type) ?string {
    if name := g.tc.resolved_fn_value_name(id) {
        return name
    }
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return none
    }
    node := g.a.nodes[int(id)]
    if node.kind in [.cast_expr, .paren, .expr_stmt] && node.children_count > 0 {
        return g.callback_fn_value_name(g.a.child(&node, 0), expected)
    }
    return none
}

fn (mut g FlatGen) callback_direct_fn_value_name(id flat.NodeId, expected types.Type) ?string {
    return g.callback_direct_fn_value_name_for_c_abi(id, expected, '')
}

fn (mut g FlatGen) callback_direct_fn_value_name_for_c_abi(id flat.NodeId, expected types.Type, expected_c_abi string) ?string {
    expected_fn := fn_type_from(expected) or { return none }
    actual_name := g.callback_fn_value_name(id, expected) or { return none }
    actual_fn := g.callback_fn_value_type(actual_name) or { return none }
    if !g.callback_fn_types_direct_compatible(actual_fn, expected_fn, expected_c_abi) {
        return none
    }
    return actual_name
}

fn (mut g FlatGen) callback_fn_value_type(name string) ?types.FnType {
    params := g.tc.fn_param_types[name] or { return none }
    ret := g.tc.fn_ret_types[name] or { return none }
    return types.FnType{
        params:      params.clone()
        return_type: ret
    }
}

fn (mut g FlatGen) callback_fn_types_direct_compatible(actual types.FnType, expected types.FnType, expected_c_abi string) bool {
    if actual.params.len != expected.params.len {
        return false
    }
    if g.callback_c_type(actual.return_type) != g.callback_expected_return_c_type(expected.return_type,
        expected_c_abi) {
        return false
    }
    for i in 0 .. expected.params.len {
        if g.callback_c_type(fn_type_param(actual, i)) != g.callback_expected_param_c_type(expected,
            i, expected_c_abi) {
            return false
        }
    }
    return true
}

fn (mut g FlatGen) ensure_callback_userdata_wrapper(actual_name string, actual types.FnType, expected types.FnType, expected_c_abi string) ?string {
    if actual.params.len != expected.params.len {
        return none
    }
    actual_ret_ct := g.callback_c_type(actual.return_type)
    expected_ret_ct := g.callback_expected_return_c_type(expected.return_type, expected_c_abi)
    if actual_ret_ct != expected_ret_ct {
        return none
    }
    mut needs_wrapper := false
    mut param_decls := []string{}
    mut call_args := []string{}
    for i in 0 .. expected.params.len {
        expected_param := fn_type_param(expected, i)
        actual_param := fn_type_param(actual, i)
        expected_ct := g.callback_expected_param_c_type(expected, i, expected_c_abi)
        actual_ct := g.callback_c_type(actual_param)
        param_decls << '${expected_ct} arg${i}'
        if actual_ct == expected_ct {
            call_args << 'arg${i}'
            continue
        }
        if g.callback_can_cast_userdata_param(actual_param, expected_param) {
            call_args << '(${actual_ct})arg${i}'
            needs_wrapper = true
            continue
        }
        if callback_can_cast_const_abi_param(actual_ct, expected_ct) {
            call_args << '(${actual_ct})arg${i}'
            needs_wrapper = true
            continue
        }
        return none
    }
    if !needs_wrapper {
        return none
    }
    actual_c_name := g.callback_c_fn_name(actual_name)
    expected_key := if expected_c_abi.len > 0 {
        expected_c_abi
    } else {
        g.callback_fn_type_key(expected)
    }
    key := '${actual_c_name}|${g.callback_fn_type_key(actual)}|${expected_key}'
    if name := g.callback_wrapper_names[key] {
        return name
    }
    name := c_name('${actual_c_name}_callback_adapter_${callback_stable_key_hash(key)}')
    g.callback_wrapper_names[key] = name
    params := if param_decls.len == 0 { 'void' } else { param_decls.join(', ') }
    call := '${actual_c_name}(${call_args.join(', ')})'
    body := if expected_ret_ct == 'void' {
        'static void ${name}(${params}) { ${call}; }'
    } else {
        'static ${expected_ret_ct} ${name}(${params}) { return ${call}; }'
    }
    g.callback_wrapper_defs << body
    return name
}

fn (mut g FlatGen) callback_expected_return_c_type(typ types.Type, expected_c_abi string) string {
    if expected_c_abi.len > 0 {
        ret, _ := fn_ptr_typedef_parts(expected_c_abi)
        return ret.trim_space()
    }
    return g.callback_c_type(typ)
}

fn (mut g FlatGen) callback_expected_param_c_type(expected types.FnType, idx int, expected_c_abi string) string {
    if expected_c_abi.len > 0 {
        params := callback_fn_ptr_param_c_types(expected_c_abi)
        if idx < params.len {
            return params[idx]
        }
    }
    return g.callback_c_type(fn_type_param(expected, idx))
}

fn callback_fn_ptr_param_c_types(encoded string) []string {
    _, params := fn_ptr_typedef_parts(encoded)
    clean := params.trim_space()
    if clean.len == 0 || clean == 'void' {
        return []string{}
    }
    mut out := []string{}
    for param in clean.split(',') {
        out << param.trim_space()
    }
    return out
}

fn callback_can_cast_const_abi_param(actual_ct string, expected_ct string) bool {
    actual := actual_ct.trim_space()
    expected := expected_ct.trim_space()
    if !expected.starts_with('const ') || !expected.ends_with('*') {
        return false
    }
    return actual == expected['const '.len..].trim_space()
}

fn (mut g FlatGen) callback_c_type(typ types.Type) string {
    if typ is types.Void {
        return 'void'
    }
    mut ct := if typ is types.OptionType || typ is types.ResultType {
        g.optional_type_name(typ)
    } else {
        g.tc.c_type(typ)
    }
    if ct.starts_with('fn_ptr:') {
        ct = g.resolve_fn_ptr_type(ct)
    }
    return ct
}

fn (mut g FlatGen) callback_fn_type_key(typ types.FnType) string {
    mut parts := []string{}
    for i in 0 .. typ.params.len {
        parts << g.callback_c_type(fn_type_param(typ, i))
    }
    return '${g.callback_c_type(typ.return_type)}|${parts.join(',')}'
}

fn callback_stable_key_hash(key string) string {
    mut hash := u64(1469598103934665603)
    for b in key.bytes() {
        hash ^= u64(b)
        hash *= u64(1099511628211)
    }
    return '${hash}'
}

fn (g &FlatGen) callback_can_cast_userdata_param(actual types.Type, expected types.Type) bool {
    return (callback_is_voidptr_type(expected) && callback_is_nonvoid_pointer_type(actual))
        || (callback_is_nonvoid_pointer_type(expected) && callback_is_voidptr_type(actual))
}

fn callback_is_voidptr_type(typ types.Type) bool {
    clean := callback_unalias_type(typ)
    if clean is types.Pointer {
        base := callback_unalias_type(clean.base_type)
        return base is types.Void
    }
    return false
}

fn callback_is_nonvoid_pointer_type(typ types.Type) bool {
    clean := callback_unalias_type(typ)
    if clean is types.Pointer {
        base := callback_unalias_type(clean.base_type)
        return base !is types.Void
    }
    return false
}

fn callback_unalias_type(typ types.Type) types.Type {
    if typ is types.Alias {
        return callback_unalias_type(typ.base_type)
    }
    return typ
}

fn (g &FlatGen) callback_c_fn_name(name string) string {
    if name.starts_with('C.') {
        return c_name(name.all_after_last('.'))
    }
    if g.test_files.len > 0 && (name == 'main' || name == 'main.main') {
        return g.test_user_main_c_name()
    }
    if name.starts_with('main.') {
        return c_name(name.all_after_last('.'))
    }
    return c_name(name)
}

fn fn_type_param(typ types.FnType, idx int) types.Type {
    return typ.params[idx]
}

// gen_optional_arg emits optional arg output for c.
fn (mut g FlatGen) gen_optional_arg(arg_id flat.NodeId, expected types.Type) bool {
    mut base_type := types.Type(types.void_)
    if expected is types.OptionType {
        base_type = expected.base_type
    } else if expected is types.ResultType {
        base_type = expected.base_type
    } else {
        return false
    }
    if g.expr_is_optional_literal(arg_id, expected) {
        g.gen_expr_with_expected_type(g.collapsed_optional_literal(arg_id, expected), expected)
        return true
    }
    arg_type := g.usable_expr_type(arg_id)
    if arg_type is types.OptionType || arg_type is types.ResultType {
        if g.type_names_match(arg_type, expected) {
            g.gen_expr_with_expected_type(arg_id, expected)
            return true
        }
        arg_node := g.a.nodes[int(arg_id)]
        if arg_node.kind == .none_expr || g.expr_really_returns_optional(arg_id) {
            g.gen_expr_with_expected_type(arg_id, expected)
            return true
        }
    }
    ct := g.optional_type_name(expected)
    if base_type is types.Void {
        g.write('(${ct}){.ok = true}')
        return true
    }
    g.write('(${ct}){.ok = true, .value = ')
    g.gen_expr_with_expected_type(arg_id, base_type)
    g.write('}')
    return true
}

// expr_is_optional_literal supports expr is optional literal handling for FlatGen.
fn (mut g FlatGen) expr_is_optional_literal(id flat.NodeId, expected types.Type) bool {
    if int(id) < 0 {
        return false
    }
    node := g.a.nodes[int(id)]
    if node.kind != .struct_init && node.kind != .cast_expr {
        return false
    }
    return node.value.starts_with('?') || node.value.starts_with('!')
        || node.value == g.optional_type_name(expected) || node.value.starts_with('Optional')
}

// collapsed_optional_literal supports collapsed optional literal handling for FlatGen.
fn (mut g FlatGen) collapsed_optional_literal(id flat.NodeId, expected types.Type) flat.NodeId {
    mut current := id
    for _ in 0 .. 4 {
        value_id := g.optional_literal_value_id(current) or { break }
        if !g.expr_is_optional_literal(value_id, expected) {
            break
        }
        current = value_id
    }
    return current
}

// optional_literal_value_id supports optional literal value id handling for FlatGen.
fn (g &FlatGen) optional_literal_value_id(id flat.NodeId) ?flat.NodeId {
    if int(id) < 0 {
        return none
    }
    node := g.a.nodes[int(id)]
    if node.kind != .struct_init && node.kind != .cast_expr {
        return none
    }
    for i in 0 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.kind == .field_init && field.value == 'value' && field.children_count > 0 {
            return g.a.child(field, 0)
        }
    }
    return none
}

// fn_field_type supports fn field type handling for FlatGen.
fn (g &FlatGen) fn_field_type(base_type types.Type, field_name string) ?types.FnType {
    field_type := g.field_type(base_type, field_name) or { return none }
    return fn_type_from(field_type)
}

// field_type supports field type handling for FlatGen.
fn (g &FlatGen) field_type(base_type types.Type, field_name string) ?types.Type {
    clean0 := types.unwrap_pointer(base_type)
    mut clean := clean0
    if clean0 is types.Alias {
        clean = clean0.base_type
    }
    mut struct_name := ''
    if clean is types.Struct {
        struct_name = clean.name
    } else if clean is types.Array {
        struct_name = 'array'
    } else if clean is types.Map {
        struct_name = 'map'
    } else if clean is types.String {
        struct_name = 'string'
    }
    if struct_name.len == 0 {
        return none
    }
    fields := g.tc.structs[struct_name] or { return none }
    for field in fields {
        if field.name == field_name {
            return field.typ
        }
    }
    return none
}

// fn_type_from supports fn type from handling for c.
fn fn_type_from(t types.Type) ?types.FnType {
    if t is types.FnType {
        return t
    }
    if t is types.Alias {
        return fn_type_from(t.base_type)
    }
    return none
}

// gen_call_args emits call args output for c.
fn (mut g FlatGen) gen_call_args(fn_name string, node flat.Node, start int) {
    mut param_types := g.param_types_for(fn_name, fn_name.all_after_last('.'))
    // Retry with the bare method name only when the qualified name is genuinely unresolved —
    // not when it is a known function that simply takes no parameters. The short-name index
    // matches any same-named function, so retrying a real 0-param fn (e.g. a static method
    // `Type.build()`) would adopt an unrelated `build`'s parameters and append phantom args.
    if param_types.len == 0 && fn_name.contains('.') && fn_name !in g.tc.fn_param_types
        && c_name(fn_name) !in g.tc.fn_param_types {
        param_types = g.param_types_for(fn_name.all_after_last('.'), fn_name.all_after_last('.'))
    }
    is_c_variadic_fn := g.tc.c_variadic_fns[fn_name] or { false }
    is_variadic_fn := !is_c_variadic_fn && (g.tc.fn_variadic[fn_name] or { false })
    variadic_idx := if is_variadic_fn && param_types.len > 0
        && param_types[param_types.len - 1] is types.Array {
        param_types.len - 1
    } else {
        -1
    }
    typed_param_count := if is_c_variadic_fn && param_types.len > 0
        && param_types[param_types.len - 1] is types.Array {
        param_types.len - 1
    } else {
        param_types.len
    }
    num_args := node.children_count - start
    is_variadic := variadic_idx >= 0 && num_args > param_types.len
    for i in start .. node.children_count {
        if i > start {
            g.write(', ')
        }
        arg_idx := i - start
        arg_id := g.a.child(&node, i)
        arg_node := g.a.nodes[int(arg_id)]
        if arg_node.kind == .field_init && variadic_idx >= 0 && arg_idx == variadic_idx {
            variadic_type := param_types[variadic_idx]
            if variadic_type is types.Array {
                if variadic_type.elem_type is types.Struct {
                    c_elem := g.tc.c_type(variadic_type.elem_type)
                    g.write('new_array_from_c_array(1, 1, sizeof(${c_elem}), (${c_elem}[]){')
                    g.gen_params_struct_arg(variadic_type.elem_type, node, i)
                    g.write('})')
                    break
                }
            }
        }
        if arg_node.kind == .field_init {
            // `@[params]` struct argument: trailing `key: value` args form a struct literal
            ptyp := if arg_idx < typed_param_count {
                param_types[arg_idx]
            } else {
                types.Type(types.void_)
            }
            g.gen_params_struct_arg(ptyp, node, i)
            break
        }
        if fixed := array_fixed_type(g.tc.resolve_type(arg_id)) {
            g.gen_fixed_array_data_arg(arg_id, fixed)
            continue
        }
        if arg_idx < typed_param_count {
            if fixed := array_fixed_type(param_types[arg_idx]) {
                g.gen_fixed_array_data_arg(arg_id, fixed)
                continue
            }
        }
        if arg_idx < typed_param_count
            && g.gen_pointer_arg_from_array_literal(arg_node, param_types[arg_idx]) {
            continue
        }
        cb_param := if arg_idx >= 0 && arg_idx < param_types.len {
            param_types[arg_idx]
        } else {
            types.Type(types.void_)
        }
        if g.gen_special_c_callback_arg(fn_name, arg_idx, arg_id, cb_param) {
            continue
        }
        if is_variadic && arg_idx == variadic_idx {
            variadic_type := param_types[variadic_idx]
            if variadic_type is types.Array {
                c_elem := g.tc.c_type(variadic_type.elem_type)
                count := num_args - variadic_idx
                g.write('new_array_from_c_array(${count}, ${count}, sizeof(${c_elem}), (${c_elem}[]){')
                for j in i .. node.children_count {
                    if j > i {
                        g.write(', ')
                    }
                    g.gen_expr_with_expected_type(g.a.child(&node, j), variadic_type.elem_type)
                }
                g.write('})')
            }
            break
        }
        if variadic_idx >= 0 && arg_idx == variadic_idx && num_args == param_types.len {
            arg_type := g.tc.resolve_type(arg_id)
            if arg_type !is types.Array {
                variadic_type := param_types[variadic_idx]
                if variadic_type is types.Array {
                    c_elem := g.tc.c_type(variadic_type.elem_type)
                    g.write('new_array_from_c_array(1, 1, sizeof(${c_elem}), (${c_elem}[]){')
                    g.gen_expr_with_expected_type(arg_id, variadic_type.elem_type)
                    g.write('})')
                    continue
                }
            }
        }
        mut needs_addr := false
        if arg_idx < typed_param_count && param_types[arg_idx] is types.Pointer
            && !(arg_node.kind == .prefix && arg_node.op == .amp) {
            arg_type := g.tc.resolve_type(arg_id)
            if arg_type !is types.Pointer
                && !c_string_literal_pointer_arg(arg_node, param_types[arg_idx]) {
                needs_addr = true
            }
        }
        is_rvalue := arg_node.kind == .call
            || (arg_node.kind == .index && arg_node.value == 'range')
        if needs_addr && is_rvalue {
            pt := param_types[arg_idx]
            ct := g.tc.c_type(types.unwrap_pointer(pt))
            g.write('({${ct} _t${g.tmp_count} = ')
            g.gen_expr_with_expected_type(arg_id, types.unwrap_pointer(pt))
            g.write('; &_t${g.tmp_count};})')
            g.tmp_count++
        } else {
            if arg_idx < typed_param_count {
                if child_id := g.addressed_rvalue_arg(arg_node) {
                    pt := param_types[arg_idx]
                    if pt is types.Pointer {
                        ct := g.tc.c_type(types.unwrap_pointer(pt))
                        g.write('({${ct} _t${g.tmp_count} = ')
                        g.gen_expr_with_expected_type(child_id, types.unwrap_pointer(pt))
                        g.write('; &_t${g.tmp_count};})')
                        g.tmp_count++
                        continue
                    }
                }
            }
            if needs_addr {
                g.write('&')
            }
            emitted_variant := !needs_addr && arg_idx < typed_param_count
                && g.gen_sum_variant_arg(arg_id, param_types[arg_idx])
            if !emitted_variant {
                if arg_idx < typed_param_count && g.gen_optional_arg(arg_id, param_types[arg_idx]) {
                    // handled
                } else if arg_idx < typed_param_count {
                    g.gen_expr_with_expected_type(arg_id, param_types[arg_idx])
                } else {
                    g.gen_expr(arg_id)
                }
            }
        }
        if variadic_idx >= 0 && num_args == variadic_idx {
            if node.children_count > start {
                g.write(', ')
            }
            variadic_type := param_types[variadic_idx]
            if variadic_type is types.Array {
                c_elem := g.tc.c_type(variadic_type.elem_type)
                g.write('new_array_from_c_array(0, 0, sizeof(${c_elem}), (${c_elem}[]){0})')
            }
        }
    }
    num_provided := node.children_count - start
    if num_provided < typed_param_count {
        for i in num_provided .. typed_param_count {
            if num_provided > 0 || i > num_provided {
                g.write(', ')
            }
            g.gen_default_value_for_type(param_types[i])
        }
    }
}

// is_flag_enum_method reports whether is flag enum method applies in c.
fn (g &FlatGen) is_flag_enum_method(fn_node &flat.Node) bool {
    if fn_node.kind != .selector {
        return false
    }
    method := fn_node.value
    if method !in ['has', 'all', 'set', 'clear'] {
        return false
    }
    base_type := g.tc.resolve_type(g.a.child(fn_node, 0))
    clean := types.unwrap_pointer(base_type)
    if clean is types.Enum {
        return true
    } else if clean is types.Primitive {
        return clean.props.has(.integer)
    } else if clean is types.Unknown {
        return true
    }
    return false
}

// gen_flag_enum_call emits flag enum call output for c.
fn (mut g FlatGen) gen_flag_enum_call(node flat.Node) {
    fn_node := g.a.child_node(&node, 0)
    method := fn_node.value
    base_id := g.a.child(fn_node, 0)
    base_type := types.unwrap_pointer(g.tc.resolve_type(base_id))
    match method {
        'has' {
            g.write('((')
            g.gen_expr(base_id)
            g.write(' & ')
            if node.children_count > 1 {
                g.gen_flag_enum_arg(g.a.child(&node, 1), base_type)
            }
            g.write(') != 0)')
        }
        'all' {
            g.write('((')
            g.gen_expr(base_id)
            g.write(' & (')
            if node.children_count > 1 {
                g.gen_flag_enum_arg(g.a.child(&node, 1), base_type)
            }
            g.write(')) == (')
            if node.children_count > 1 {
                g.gen_flag_enum_arg(g.a.child(&node, 1), base_type)
            }
            g.write('))')
        }
        'set' {
            g.gen_expr(base_id)
            g.write(' |= ')
            if node.children_count > 1 {
                g.gen_flag_enum_arg(g.a.child(&node, 1), base_type)
            }
        }
        'clear' {
            g.gen_expr(base_id)
            g.write(' &= ~(')
            if node.children_count > 1 {
                g.gen_flag_enum_arg(g.a.child(&node, 1), base_type)
            }
            g.write(')')
        }
        else {}
    }
}

// gen_flag_enum_arg emits flag enum arg output for c.
fn (mut g FlatGen) gen_flag_enum_arg(arg_id flat.NodeId, base_type types.Type) {
    if base_type is types.Enum {
        g.gen_expr_with_expected_type(arg_id, base_type)
    } else {
        g.gen_expr(arg_id)
    }
}

// is_generic_type reports whether is generic type applies in c.
fn is_generic_type(typ string) bool {
    t := typ.trim_left('&?!')
    return t.len == 1 && t[0] >= `A` && t[0] <= `Z`
}

// has_generic_params reports whether has generic params applies in c.
fn (g &FlatGen) has_generic_params(node flat.Node) bool {
    for i in 0 .. node.children_count {
        child := g.a.child_node(&node, i)
        if child.kind == .param && is_generic_type(child.typ) {
            return true
        }
    }
    return is_generic_type(node.typ)
}

fn (g &FlatGen) addressed_rvalue_arg(arg_node flat.Node) ?flat.NodeId {
    if arg_node.kind != .prefix || arg_node.op != .amp || arg_node.children_count == 0 {
        return none
    }
    child_id := g.a.child(&arg_node, 0)
    child := g.a.nodes[int(child_id)]
    if child.kind == .call || (child.kind == .index && child.value == 'range') {
        return child_id
    }
    return none
}

// find_prim_method resolves find prim method information for c.
fn (g &FlatGen) find_prim_method(method string) string {
    if 'u8.${method}' in g.tc.fn_param_types {
        return c_name('u8.${method}')
    }
    if 'int.${method}' in g.tc.fn_param_types {
        return c_name('int.${method}')
    }
    if 'i64.${method}' in g.tc.fn_param_types {
        return c_name('i64.${method}')
    }
    if 'u32.${method}' in g.tc.fn_param_types {
        return c_name('u32.${method}')
    }
    if 'u64.${method}' in g.tc.fn_param_types {
        return c_name('u64.${method}')
    }
    return ''
}

// find_alias_method converts find alias method data for c.
fn (g &FlatGen) find_alias_method(target string, method string) ?string {
    mut fallback := ''
    for alias, alias_target in g.tc.type_aliases {
        if alias_target != target {
            continue
        }
        alias_method := '${alias}.${method}'
        if alias_method !in g.tc.fn_param_types {
            if alias.contains('.') {
                short_method := '${alias.all_after_last('.')}.${method}'
                if short_method in g.tc.fn_param_types {
                    return alias_method
                }
            }
            continue
        }
        if alias.contains('.') {
            return alias_method
        }
        if fallback.len == 0 {
            fallback = alias_method
        }
    }
    if fallback.len > 0 {
        return fallback
    }
    return none
}

// gen_sum_variant_arg emits sum variant arg output for c.
fn (mut g FlatGen) gen_sum_variant_arg(arg_id flat.NodeId, expected types.Type) bool {
    actual0 := types.unwrap_pointer(g.tc.resolve_type(arg_id))
    mut actual := actual0
    if actual0 is types.Alias {
        actual = actual0.base_type
    }
    expected0 := expected
    mut expected_type := expected0
    if expected0 is types.Alias {
        expected_type = expected0.base_type
    }
    if expected_type is types.SumType {
        return false
    }
    if actual !is types.SumType {
        return false
    }
    sum_type := actual as types.SumType
    sum_name := sum_type.name
    variant := g.resolve_variant(sum_name, expected_type.name())
    variants := g.tc.sum_types[sum_name] or { return false }
    if variant !in variants {
        return false
    }
    is_ptr_arg := g.tc.resolve_type(arg_id) is types.Pointer
    is_ref_variant := g.variant_references_sum(variant, sum_name)
    if is_ref_variant {
        g.write('(*')
    }
    g.gen_expr(arg_id)
    if is_ptr_arg {
        g.write('->')
    } else {
        g.write('.')
    }
    g.write(g.sum_field_name(variant))
    if is_ref_variant {
        g.write(')')
    }
    return true
}

// forward_decls supports forward decls handling for FlatGen.
fn (mut g FlatGen) forward_decls() {
    mut cur_module := ''
    mut cur_file := ''
    mut forwarded := map[string]bool{}
    for i in 0 .. g.a.nodes.len {
        node := g.a.nodes[i]
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_file = node.value
            g.tc.cur_file = cur_file
            cur_module = ''
            g.tc.cur_module = cur_module
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            continue
        }

        is_entry_main := is_main_fn_in_main_module(cur_module, node.value) && g.test_files.len == 0
        if kind_id == 61 && !is_entry_main {
            if !g.should_emit_fn_node_in_module(node, i, cur_module) {
                continue
            }
            qfn := g.fn_c_name_in_module(cur_module, node.value)
            if forwarded[qfn] {
                continue
            }
            forwarded[qfn] = true
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            ret_type := g.fn_node_return_type(node, cur_module)
            g.write(g.fn_return_type_name(ret_type))
            g.write(' ')
            g.write(qfn)
            g.write('(')
            g.write_fn_node_params(node)
            g.writeln(');')
            if export_name := g.export_fn_name_in_module(cur_module, node.value) {
                if !forwarded[export_name] {
                    forwarded[export_name] = true
                    g.write(g.fn_return_type_name(ret_type))
                    g.write(' ')
                    g.write(export_name)
                    g.write('(')
                    g.write_fn_node_params(node)
                    g.writeln(');')
                }
            }
        } else if kind_id == 76
            && (node.value.starts_with('C.v_filelock_') || node.value.starts_with('v_filelock_')) {
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            ret_type := g.tc.parse_type(node.typ)
            cfn := c_name(node.value)
            if forwarded[cfn] {
                continue
            }
            forwarded[cfn] = true
            g.write(g.optional_type_name(ret_type))
            g.write(' ')
            g.write(cfn)
            g.write('(')
            g.write_c_fn_node_params(node)
            g.writeln(');')
        }
    }
    g.writeln('')
}

fn (mut g FlatGen) insert_cur_implicit_veb_ctx_param(node flat.Node) {
    if !g.fn_needs_implicit_veb_ctx(node) {
        return
    }
    insert_idx := g.fn_implicit_veb_ctx_insert_index(node)
    ctx_type := g.implicit_veb_ctx_type()
    mut names := []string{cap: g.cur_param_names.len + 1}
    mut type_values := []types.Type{cap: g.cur_param_type_values.len + 1}
    for i, name in g.cur_param_names {
        if i == insert_idx {
            names << 'ctx'
            type_values << ctx_type
        }
        names << name
        type_values << g.cur_param_type_values[i]
    }
    if insert_idx >= g.cur_param_names.len {
        names << 'ctx'
        type_values << ctx_type
    }
    g.cur_param_names = names
    g.cur_param_type_values = type_values
    g.cur_param_types['ctx'] = ctx_type
    g.tc.cur_scope.insert('ctx', ctx_type)
}

fn (mut g FlatGen) fn_param_types_with_implicit_veb_ctx(node flat.Node, params []types.Type) []types.Type {
    if !g.fn_needs_implicit_veb_ctx(node) {
        return params
    }
    insert_idx := g.fn_implicit_veb_ctx_insert_index(node)
    ctx_type := g.implicit_veb_ctx_type()
    mut result := []types.Type{cap: params.len + 1}
    for i, param in params {
        if i == insert_idx {
            result << ctx_type
        }
        result << param
    }
    if insert_idx >= params.len {
        result << ctx_type
    }
    return result
}

fn (mut g FlatGen) fn_needs_implicit_veb_ctx(node flat.Node) bool {
    return g.fn_returns_veb_result(node) && g.fn_has_receiver_param(node)
        && !g.fn_receiver_type_is_context(node) && !g.fn_has_param(node, 'ctx')
        && g.type_name_known_in_current_module('Context')
}

// is_implicit_veb_ctx_param reports whether a callee parameter is the hidden
// veb `Context` pointer that callers do not supply explicitly.
fn (g &FlatGen) is_implicit_veb_ctx_param(pt types.Type) bool {
    if pt is types.Pointer {
        return pt.base_type.name().all_after_last('.') == 'Context'
    }
    return false
}

// cur_scope_has_ctx reports whether the current function exposes a `ctx`
// variable (the implicit veb context) that can be forwarded to delegated calls.
fn (g &FlatGen) cur_scope_has_ctx() bool {
    if _ := g.tc.cur_scope.lookup('ctx') {
        return true
    }
    return false
}

fn (g &FlatGen) type_name_known_in_current_module(name string) bool {
    qname := g.tc.qualify_name(name)
    return qname in g.struct_decl_infos || qname in g.tc.type_aliases || qname in g.tc.enum_names
        || qname in g.tc.sum_types || qname in g.tc.interface_names
}

fn (g &FlatGen) type_name_known(name string) bool {
    qname := g.tc.qualify_name(name)
    return name in g.struct_decl_infos || qname in g.struct_decl_infos || name in g.tc.type_aliases
        || qname in g.tc.type_aliases || name in g.tc.enum_names || qname in g.tc.enum_names
        || name in g.tc.sum_types || qname in g.tc.sum_types || name in g.tc.interface_names
        || qname in g.tc.interface_names
}

fn (mut g FlatGen) fn_returns_veb_result(node flat.Node) bool {
    if node.typ == 'veb.Result' {
        return true
    }
    ret := g.tc.parse_type(node.typ)
    return ret.name() == 'veb.Result'
}

fn (g &FlatGen) fn_has_param(node flat.Node, name string) bool {
    for i in 0 .. node.children_count {
        p := g.a.child_node(&node, i)
        if p.kind == .param && p.value == name {
            return true
        }
    }
    return false
}

fn (g &FlatGen) fn_implicit_veb_ctx_insert_index(node flat.Node) int {
    if g.fn_has_receiver_param(node) {
        return 1
    }
    return 0
}

fn (g &FlatGen) fn_has_receiver_param(node flat.Node) bool {
    if !node.value.contains('.') || node.children_count == 0 {
        return false
    }
    first := g.a.child_node(&node, 0)
    if first.kind != .param || first.typ.len == 0 {
        return false
    }
    receiver := node.value.all_before_last('.').all_after_last('.')
    param_type := first.typ.trim_left('&').all_after_last('.')
    return receiver == param_type
}

fn (g &FlatGen) fn_receiver_type_is_context(node flat.Node) bool {
    if !g.fn_has_receiver_param(node) {
        return false
    }
    first := g.a.child_node(&node, 0)
    return first.typ.trim_left('&').all_after_last('.') == 'Context'
}

fn (mut g FlatGen) implicit_veb_ctx_type() types.Type {
    return g.tc.parse_type('mut Context')
}

fn (mut g FlatGen) fn_node_return_type(node flat.Node, module_name string) types.Type {
    for candidate in g.fn_node_signature_names(node, module_name) {
        if rt := g.tc.fn_ret_types[candidate] {
            return rt
        }
    }
    if info := g.generic_receiver_method_call_info(node.value) {
        return info.return_type
    }
    return g.tc.parse_type(node.typ)
}

fn (mut g FlatGen) fn_node_param_types(node flat.Node, module_name string) []types.Type {
    if g.fn_needs_implicit_veb_ctx(node) {
        return []types.Type{}
    }
    mut explicit_params := 0
    for i in 0 .. node.children_count {
        if g.a.child_node(&node, i).kind == .param {
            explicit_params++
        }
    }
    for candidate in g.fn_node_signature_names(node, module_name) {
        if params := g.tc.fn_param_types[candidate] {
            if params.len == explicit_params {
                return params
            }
        }
    }
    if info := g.generic_receiver_method_call_info(node.value) {
        if info.params.len == explicit_params {
            return info.params.clone()
        }
    }
    return []types.Type{}
}

fn (g &FlatGen) generic_receiver_method_call_info(name string) ?types.CallInfo {
    if !name.contains('.') {
        return none
    }
    receiver := name.all_before_last('.')
    if !receiver.contains('[') || !receiver.contains(']') {
        return none
    }
    return g.tc.resolve_generic_struct_method(receiver, name.all_after_last('.'))
}

fn (mut g FlatGen) fn_node_signature_names(node flat.Node, module_name string) []string {
    dotted_name := qualify_name_in_module(module_name, node.value)
    cname := g.fn_c_name_in_module(module_name, node.value)
    mut names := []string{}
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin' {
        names << dotted_name
        names << c_name(dotted_name)
        names << cname
        names << node.value
        names << c_name(node.value)
    } else {
        names << node.value
        names << c_name(node.value)
        names << dotted_name
        names << c_name(dotted_name)
        names << cname
    }
    mut deduped := []string{cap: names.len}
    for name in names {
        if name.len > 0 && name !in deduped {
            deduped << name
        }
    }
    return deduped
}

// write_fn_node_params writes fn node params output for c.
fn (mut g FlatGen) write_fn_node_params(node flat.Node) {
    mut params_len := 0
    for i in 0 .. node.children_count {
        if g.a.child_node(&node, i).kind == .param {
            params_len++
        }
    }
    needs_implicit_ctx := g.fn_needs_implicit_veb_ctx(node)
    if needs_implicit_ctx {
        params_len++
    }
    if params_len == 0 {
        g.write('void')
        return
    }
    mut written := 0
    mut param_idx := 0
    mut implicit_ctx_written := false
    insert_implicit_ctx_after_first := needs_implicit_ctx && g.fn_has_receiver_param(node)
    typed_params := g.fn_node_param_types(node, g.tc.cur_module)
    concrete_optional_params := g.is_specialized_generic_fn_node(node)
    for i in 0 .. node.children_count {
        param_id := g.a.child(&node, i)
        p := g.a.node(param_id)
        if p.kind != .param {
            continue
        }
        pt := if param_idx < typed_params.len {
            typed_params[param_idx]
        } else {
            g.tc.parse_type(p.typ)
        }
        param_idx++
        ct := if concrete_optional_params && (pt is types.OptionType || pt is types.ResultType) {
            g.concrete_optional_type_name(pt)
        } else if pt is types.ArrayFixed {
            '${g.tc.c_type(pt.elem_type)}*'
        } else if pt is types.OptionType || pt is types.ResultType {
            g.optional_type_name(pt)
        } else {
            g.tc.c_type(pt)
        }
        if ct.starts_with('fn_ptr:') {
            g.write(g.resolve_fn_ptr_type(ct))
        } else {
            g.write(ct)
        }
        if p.value.len > 0 {
            g.write(' ')
            param_name := if p.value == '_' { '_${written}' } else { c_name(p.value) }
            g.write(param_name)
        }
        written++
        if insert_implicit_ctx_after_first && !implicit_ctx_written {
            if written < params_len {
                g.write(', ')
            }
            g.write_implicit_veb_ctx_param()
            written++
            implicit_ctx_written = true
        }
        if written < params_len {
            g.write(', ')
        }
    }
    if needs_implicit_ctx && !implicit_ctx_written {
        g.write_implicit_veb_ctx_param()
    }
}

fn (g &FlatGen) is_specialized_generic_fn_node(node flat.Node) bool {
    return node.value.contains('[') || node.value.contains('_T_')
}

fn (mut g FlatGen) concrete_optional_type_name(t types.Type) string {
    mut base_type := types.Type(types.void_)
    if t is types.OptionType {
        base_type = t.base_type
    } else if t is types.ResultType {
        base_type = t.base_type
    } else {
        return g.tc.c_type(t)
    }
    mut inner_ct := g.tc.c_type(base_type)
    if inner_ct.starts_with('fn_ptr:') {
        inner_ct = g.resolve_fn_ptr_type(inner_ct)
    }
    safe_name := inner_ct.replace('*', 'ptr').replace(' ', '_')
    opt_name := 'Optional_${safe_name}'
    g.needed_optional_types[opt_name] = inner_ct
    return opt_name
}

fn (mut g FlatGen) write_implicit_veb_ctx_param() {
    pt := g.implicit_veb_ctx_type()
    g.write(g.tc.c_type(pt))
    g.write(' ctx')
}

// write_c_fn_node_params writes c fn node params output for c.
fn (mut g FlatGen) write_c_fn_node_params(node flat.Node) {
    if node.children_count == 0 {
        g.write('void')
        return
    }
    mut written := 0
    for i in 0 .. node.children_count {
        param_id := g.a.child(&node, i)
        p := g.a.node(param_id)
        if p.kind != .param {
            continue
        }
        raw_typ := if p.typ.len > 0 { p.typ } else { p.value }
        if raw_typ.len == 0 {
            continue
        }
        pt := g.tc.parse_type(raw_typ)
        ct := if pt is types.OptionType || pt is types.ResultType {
            g.optional_type_name(pt)
        } else {
            g.tc.c_type(pt)
        }
        if written > 0 {
            g.write(', ')
        }
        if ct.starts_with('fn_ptr:') {
            g.write(g.resolve_fn_ptr_type(ct))
        } else {
            g.write(ct)
        }
        if p.typ.len > 0 && p.value.len > 0 {
            g.write(' ')
            param_name := if p.value == '_' { '_${written}' } else { c_name(p.value) }
            g.write(param_name)
        }
        written++
    }
    if written == 0 {
        g.write('void')
    }
}

// fn_ptr_typedefs supports fn ptr typedefs handling for FlatGen.
fn (mut g FlatGen) fn_ptr_typedefs() {
    mut emitted := map[string]bool{}
    for {
        mut pending_encoded := []string{}
        mut pending_name := []string{}
        for encoded, name in g.fn_ptr_types {
            if emitted[encoded] {
                continue
            }
            pending_encoded << encoded
            pending_name << name
        }
        if pending_encoded.len == 0 {
            break
        }
        for i in 0 .. pending_encoded.len {
            g.emit_fn_ptr_typedef(pending_encoded[i], pending_name[i], mut emitted)
        }
    }
    if emitted.len > 0 {
        g.writeln('')
    }
}

fn (mut g FlatGen) emit_fn_ptr_typedef(encoded string, name string, mut emitted map[string]bool) {
    if emitted[encoded] {
        return
    }
    emitted[encoded] = true
    ret, params := fn_ptr_typedef_parts(encoded)
    ret_ct := g.fn_ptr_return_ct(g.fn_ptr_typedef_type(ret, mut emitted))
    params_ct := g.fn_ptr_typedef_params(params, mut emitted)
    g.writeln('typedef ${ret_ct} (*${name})(${params_ct});')
}

fn fn_ptr_typedef_parts(encoded string) (string, string) {
    payload := if encoded.starts_with('fn_ptr:') { encoded['fn_ptr:'.len..] } else { encoded }
    if payload.starts_with('fn_ptr:') {
        first_pipe_idx := payload.index('|') or { return payload, 'void' }
        rest := payload[first_pipe_idx + 1..]
        second_pipe_idx := rest.index('|') or { return payload, 'void' }
        split_idx := first_pipe_idx + 1 + second_pipe_idx
        return payload[..split_idx], payload[split_idx + 1..]
    }
    pipe_idx := payload.index('|') or { return payload, 'void' }
    return payload[..pipe_idx], payload[pipe_idx + 1..]
}

fn (mut g FlatGen) fn_ptr_typedef_params(params string, mut emitted map[string]bool) string {
    clean := params.trim_space()
    if clean.len == 0 || clean == 'void' {
        return 'void'
    }
    mut out := []string{}
    for param in clean.split(',') {
        out << g.fn_ptr_typedef_type(param, mut emitted)
    }
    return out.join(', ')
}

fn (mut g FlatGen) fn_ptr_typedef_type(typ string, mut emitted map[string]bool) string {
    mut clean := typ.trim_space()
    if clean.len == 0 {
        return 'void'
    }
    if clean.starts_with('fn_ptr:') {
        clean = fn_ptr_typedef_normalized(clean)
        name := g.resolve_fn_ptr_type(clean)
        g.emit_fn_ptr_typedef(clean, name, mut emitted)
        return name
    }
    if clean == 'Optional' {
        return 'struct Optional'
    }
    if clean.starts_with('Optional_') {
        return 'struct ${clean}'
    }
    if fn_ptr_typedef_is_generic_placeholder(clean) {
        return 'int'
    }
    return clean
}

fn fn_ptr_typedef_normalized(typ string) string {
    clean := typ.trim_space()
    if !clean.starts_with('fn_ptr:') {
        return clean
    }
    payload := clean['fn_ptr:'.len..]
    if payload.contains('|') {
        return clean
    }
    return 'fn_ptr:${payload}|void'
}

fn fn_ptr_typedef_is_generic_placeholder(typ string) bool {
    mut clean := typ.trim_space()
    for clean.ends_with('*') {
        clean = clean[..clean.len - 1].trim_space()
    }
    if clean.starts_with('struct ') {
        clean = clean['struct '.len..].trim_space()
    }
    short := if clean.contains('__') {
        clean.all_after_last('__')
    } else if clean.contains('.') {
        clean.all_after_last('.')
    } else {
        clean
    }
    if short in ['T', 'U', 'V', 'K', 'R'] {
        return true
    }
    return short.len == 1 && short[0] >= `A` && short[0] <= `Z`
}

// multi_return_forward_decls forward-declares every multi-return struct that the
// generated C can reference by name. It must run before fn_ptr_typedefs(), because
// a function-pointer typedef may name a multi-return as its (by-value) return type
// — and a `typedef RET (*fp)(...)` only needs RET's tag declared, not its full
// layout. The full struct bodies are emitted later by multi_return_typedefs(),
// after the member struct definitions they depend on are available.
fn (mut g FlatGen) multi_return_forward_decls() {
    mut emitted := map[string]bool{}
    g.walk_multi_return_typedefs(mut emitted, true)
    // Also cover multi-returns reachable only as a fn-pointer return type: parallel
    // cgen preseeds fn-ptr types that the serial path never materializes, so their
    // return multi-returns may not appear among the function/expression types above.
    for encoded, _ in g.fn_ptr_types {
        ret, _ := fn_ptr_typedef_parts(encoded)
        if ret.starts_with('multi_return_') && ret !in emitted {
            emitted[ret] = true
            g.writeln('typedef struct ${ret} ${ret};')
        }
    }
    if emitted.len > 0 {
        g.writeln('')
    }
}

// multi_return_typedefs emits the full struct definitions for multi-return types.
fn (mut g FlatGen) multi_return_typedefs() {
    mut emitted := map[string]bool{}
    g.walk_multi_return_typedefs(mut emitted, false)
    if emitted.len > 0 {
        g.writeln('')
    }
}

// walk_multi_return_typedefs visits every multi-return type reachable from a
// function return type or an expression type and emits it via emit_multi_return_typedef.
// Shared by the forward-declaration and full-definition passes so both see the same
// set in the same (deterministic) order.
fn (mut g FlatGen) walk_multi_return_typedefs(mut emitted map[string]bool, forward_only bool) {
    for _, ret in g.tc.fn_ret_types {
        g.emit_multi_return_typedef(ret, mut emitted, forward_only)
    }
    mut cur_module := ''
    mut cur_file := ''
    for node in g.a.nodes {
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_file = node.value
            g.tc.cur_file = cur_file
            cur_module = ''
            g.tc.cur_module = cur_module
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            continue
        }
        g.tc.cur_file = cur_file
        g.tc.cur_module = cur_module
        // emit_multi_return_typedef only acts on (optionally `?`/`!`-wrapped) multi-return
        // types, whose string form always begins with `(`. Skip parse_type for everything
        // else — this ran on every node's type (~hundreds of thousands of parse_type calls).
        typ := node.typ
        if typ.len > 0 && (typ[0] == `(` || ((typ[0] == `?` || typ[0] == `!`) && typ.len > 1
            && typ[1] == `(`)) {
            g.emit_multi_return_typedef(g.tc.parse_type(typ), mut emitted, forward_only)
        }
    }
}

// emit_multi_return_typedef emits one multi-return type: a forward declaration
// (`typedef struct NAME NAME;`) when forward_only, otherwise the full struct body
// (`struct NAME { ... };`). The two forms are paired — the forward decl provides the
// typedef name, the body completes the tagged struct.
fn (mut g FlatGen) emit_multi_return_typedef(ret types.Type, mut emitted map[string]bool, forward_only bool) {
    if ret is types.OptionType {
        g.emit_multi_return_typedef(ret.base_type, mut emitted, forward_only)
        return
    }
    if ret is types.ResultType {
        g.emit_multi_return_typedef(ret.base_type, mut emitted, forward_only)
        return
    }
    if ret is types.MultiReturn {
        name := g.tc.c_type(ret)
        if name in emitted {
            return
        }
        emitted[name] = true
        if forward_only {
            g.writeln('typedef struct ${name} ${name};')
        } else {
            g.writeln('struct ${name} {')
            for i, typ in ret.types {
                g.writeln('\t${g.tc.c_type(typ)} arg${i};')
            }
            g.writeln('};')
        }
    }
}

// resolve_fn_ptr_type resolves resolve fn ptr type information for c.
fn (mut g FlatGen) resolve_fn_ptr_type(typ string) string {
    if typ in g.fn_ptr_types {
        return g.fn_ptr_types[typ]
    }
    name := '_fn_ptr_${g.fn_ptr_types.len}'
    g.fn_ptr_types[typ] = name
    return name
}