module c

import os
import strings
import v3.flat
import v3.types

// FlatGen emits flat gen output used by c.
pub struct FlatGen {
mut:
    sb                           strings.Builder
    indent                       int
    a                            &flat.FlatAst = unsafe { nil }
    used_fns                     map[string]bool
    used_fn_names                []string
    test_files                   map[string]bool
    str_lits                     []string
    str_lit_ids                  map[string]int
    global_types                 map[string]types.Type
    enum_vals                    map[string]int
    defers                       []flat.NodeId
    fn_defers                    []flat.NodeId
    fn_defer_counts              map[int]string
    defer_capture_names          []string
    defer_capture_types          map[string]types.Type
    interfaces                   map[string][]string
    const_vals                   map[string]flat.NodeId
    const_modules                map[string]string
    const_init_order             []string
    global_modules               map[string]string
    global_inits                 map[string]flat.NodeId // qualified global name -> initializer value node
    global_init_order            []string               // qualified global names, in declaration order
    iface_impls                  map[string][]string    // interface name -> implementing concrete type names
    iface_type_ids               map[string]int         // "${iface}::${concrete}" -> 1-based type id
    module_init_fns              []string               // C names of module-level `init()` fns, in source order
    module_init_fn_modules       map[string]string      // C init fn name -> V module name
    module_imports               map[string][]string    // module -> imported modules
    c_directives                 []CDirective
    inlined_c_structs            map[string]bool
    inlined_c_fns                map[string]bool
    inlined_c_declared_fns       map[string]bool
    c_flags                      []string
    libc_compat_fns              map[string]bool
    tc                           &types.TypeChecker = unsafe { nil }
    has_builtins                 bool
    tmp_count                    int
    line_start                   bool
    field_name_set               map[string]bool   // every struct field's C name (lazy) — for const/field collision checks
    modules                      map[string]string // alias -> full module name
    fn_ptr_types                 map[string]string // fn_ptr:ret|params -> typedef name
    fixed_array_ret_wrappers     map[string]bool   // bare fixed-array c_type name -> has a return wrapper struct
    emitted_fixed_array_typedefs map[string]bool   // bare fixed-array typedefs already written (shared across passes)
    fn_decl_param_types          map[string][]types.Type
    fn_decl_ret_types            map[string]types.Type // fn decl name (and qualified variants) -> return type
    struct_decl_infos            map[string]StructDeclInfo
    struct_decl_short_infos      map[string]StructDeclInfo
    const_runtime_inits          []string
    const_runtime_init_modules   []string
    runtime_inits                []string
    runtime_init_modules         []string
    compiler_vroot               string
    c99_mode                     bool
    cur_fn_name                  string
    cur_param_names              []string
    cur_param_type_values        []types.Type
    cur_param_types              map[string]types.Type
    cur_mut_params               map[string]bool
    cur_fn_ret                   types.Type = types.Type(types.void_)
    cur_fn_ret_is_optional       bool
    cur_fn_ret_base              types.Type = types.Type(types.void_)
    // in_return is true only while generating a `return` statement's value, so a bare
    // generic literal (`return Box{...}`) may adopt `cur_fn_ret`'s concrete instance —
    // but a literal in a local decl / argument elsewhere in the body does not.
    in_return               bool
    expected_expr_type      types.Type = types.Type(types.void_)
    expected_enum           string
    needed_optional_types   map[string]string
    emitted_optional_types  map[string]bool
    emitted_fns             map[string]bool
    array_method_cache      map[string]string
    param_types_cache       map[string][]types.Type        // (name|fallback) -> resolved param types
    embedded_fields_by_type map[string][]types.StructField // type name -> its embedded fields (usually empty)
    param_types_by_short    map[string][]types.Type        // method short-name suffix -> param types (fallback index)
    spawn_wrapper_names     map[string]string
    spawn_wrapper_defs      []string
    callback_wrapper_names  map[string]string
    callback_wrapper_defs   []string
    parallel_used           bool
}

struct FixedArrayTypedefInfo {
    arr    types.ArrayFixed
    module string
}

struct CDirective {
    module        string
    text          string
    before_import bool
}

struct CInlineHeader {
    text                 string
    preserved_directives []string
    preserved_c_fns      []string
    preserved_c_structs  []string
}

// was_parallel reports whether the last fn codegen actually ran across threads.
pub fn (g &FlatGen) was_parallel() bool {
    return g.parallel_used
}

pub fn (g &FlatGen) c_flags() []string {
    return g.c_flags.clone()
}

// set_c99_mode configures whether generated C should support strict C99 builds.
pub fn (mut g FlatGen) set_c99_mode(enabled bool) {
    g.c99_mode = enabled
}

// new creates a FlatGen value for c.
pub fn FlatGen.new() FlatGen {
    return FlatGen{
        sb:                           strings.new_builder(4096)
        used_fns:                     map[string]bool{}
        test_files:                   map[string]bool{}
        str_lit_ids:                  map[string]int{}
        global_types:                 map[string]types.Type{}
        enum_vals:                    map[string]int{}
        interfaces:                   map[string][]string{}
        const_vals:                   map[string]flat.NodeId{}
        const_modules:                map[string]string{}
        const_init_order:             []string{}
        global_modules:               map[string]string{}
        global_inits:                 map[string]flat.NodeId{}
        global_init_order:            []string{}
        iface_impls:                  map[string][]string{}
        iface_type_ids:               map[string]int{}
        module_init_fns:              []string{}
        module_init_fn_modules:       map[string]string{}
        module_imports:               map[string][]string{}
        c_directives:                 []CDirective{}
        inlined_c_structs:            map[string]bool{}
        inlined_c_fns:                map[string]bool{}
        inlined_c_declared_fns:       map[string]bool{}
        c_flags:                      []string{}
        libc_compat_fns:              map[string]bool{}
        modules:                      map[string]string{}
        fn_ptr_types:                 map[string]string{}
        fixed_array_ret_wrappers:     map[string]bool{}
        emitted_fixed_array_typedefs: map[string]bool{}
        fn_decl_param_types:          map[string][]types.Type{}
        fn_decl_ret_types:            map[string]types.Type{}
        struct_decl_infos:            map[string]StructDeclInfo{}
        struct_decl_short_infos:      map[string]StructDeclInfo{}
        cur_param_names:              []string{}
        cur_param_type_values:        []types.Type{}
        cur_param_types:              map[string]types.Type{}
        cur_mut_params:               map[string]bool{}
        needed_optional_types:        map[string]string{}
        emitted_optional_types:       map[string]bool{}
        emitted_fns:                  map[string]bool{}
        array_method_cache:           map[string]string{}
        param_types_cache:            map[string][]types.Type{}
        embedded_fields_by_type:      map[string][]types.StructField{}
        param_types_by_short:         map[string][]types.Type{}
        spawn_wrapper_names:          map[string]string{}
        spawn_wrapper_defs:           []string{}
        callback_wrapper_names:       map[string]string{}
        callback_wrapper_defs:        []string{}
        str_lits:                     []string{}
        defers:                       []flat.NodeId{}
        fn_defers:                    []flat.NodeId{}
        fn_defer_counts:              map[int]string{}
        defer_capture_names:          []string{}
        defer_capture_types:          map[string]types.Type{}
        const_runtime_inits:          []string{}
        const_runtime_init_modules:   []string{}
        runtime_inits:                []string{}
        runtime_init_modules:         []string{}
        compiler_vroot:               ''
        line_start:                   true
    }
}

// gen supports gen handling for FlatGen.
pub fn (mut g FlatGen) gen(a &flat.FlatAst) string {
    tc := types.TypeChecker.new(a)
    return g.gen_with_used(a, map[string]bool{}, &tc)
}

// gen_with_used emits with used output for c.
pub fn (mut g FlatGen) gen_with_used(a &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker) string {
    return g.gen_with_used_options(a, used_fns, tc, false)
}

pub fn (mut g FlatGen) gen_with_used_test_options(a &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker, no_parallel bool, test_files []string) string {
    g.test_files = map[string]bool{}
    for file in test_files {
        g.test_files[file] = true
    }
    return g.gen_with_used_options(a, used_fns, tc, no_parallel)
}

// gen_with_used_options emits with used options output for c.
pub fn (mut g FlatGen) gen_with_used_options(a &flat.FlatAst, used_fns map[string]bool, tc &types.TypeChecker, no_parallel bool) string {
    g.a = a
    g.used_fns = used_fns.clone()
    g.used_fn_names = []string{}
    g.str_lits = []string{}
    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.const_runtime_inits = []string{}
    g.const_runtime_init_modules = []string{}
    g.runtime_inits = []string{}
    g.runtime_init_modules = []string{}
    g.compiler_vroot = ''
    g.str_lit_ids = map[string]int{}
    g.global_types = map[string]types.Type{}
    g.enum_vals = map[string]int{}
    g.interfaces = map[string][]string{}
    g.const_vals = map[string]flat.NodeId{}
    g.const_modules = map[string]string{}
    g.const_init_order = []string{}
    g.global_modules = map[string]string{}
    g.global_inits = map[string]flat.NodeId{}
    g.global_init_order = []string{}
    g.iface_impls = map[string][]string{}
    g.iface_type_ids = map[string]int{}
    g.module_init_fns = []string{}
    g.module_init_fn_modules = map[string]string{}
    g.module_imports = map[string][]string{}
    g.c_directives = []CDirective{}
    g.inlined_c_structs = map[string]bool{}
    g.inlined_c_fns = map[string]bool{}
    g.inlined_c_declared_fns = map[string]bool{}
    g.c_flags = []string{}
    g.libc_compat_fns = map[string]bool{}
    g.modules = map[string]string{}
    g.fn_ptr_types = map[string]string{}
    g.fixed_array_ret_wrappers = map[string]bool{}
    g.emitted_fixed_array_typedefs = map[string]bool{}
    g.fn_decl_param_types = map[string][]types.Type{}
    g.fn_decl_ret_types = map[string]types.Type{}
    g.struct_decl_infos = map[string]StructDeclInfo{}
    g.struct_decl_short_infos = map[string]StructDeclInfo{}
    g.cur_param_names = []string{}
    g.cur_param_type_values = []types.Type{}
    g.cur_param_types = map[string]types.Type{}
    g.cur_mut_params = map[string]bool{}
    g.needed_optional_types = map[string]string{}
    g.emitted_optional_types = map[string]bool{}
    g.emitted_fns = map[string]bool{}
    g.array_method_cache = map[string]string{}
    g.param_types_cache = map[string][]types.Type{}
    g.embedded_fields_by_type = map[string][]types.StructField{}
    g.param_types_by_short = map[string][]types.Type{}
    g.spawn_wrapper_names = map[string]string{}
    g.spawn_wrapper_defs = []string{}
    g.callback_wrapper_names = map[string]string{}
    g.callback_wrapper_defs = []string{}
    g.parallel_used = false
    g.tc = unsafe { tc }
    if g.tc.a == unsafe { nil } {
        g.tc.collect(a)
    }
    g.has_builtins = g.tc.has_builtins
    g.collect_gen_info()
    g.precompute_embedded_fields()
    g.precompute_param_type_index()
    g.collect_interface_impls()
    g.preseed_struct_fn_ptr_types()
    g.preseed_global_fn_ptr_types()
    g.preseed_c_extern_fn_ptr_types()
    // Decide fixed-array return wrappers before generating function bodies, so
    // signatures, returns and call sites all agree on the wrapped types.
    g.populate_fixed_array_ret_wrappers()
    const_code := g.precompute_consts()
    orig_sb := g.sb
    orig_line_start := g.line_start
    g.sb = strings.new_builder(4096)
    g.line_start = true
    g.gen_fns_dispatch(no_parallel)
    fn_code := g.sb.str()
    // `.str()` copies out of the builder; free the emptied backing array under -gc none.
    unsafe { g.sb.free() }
    g.sb = orig_sb
    g.line_start = orig_line_start
    g.c99_feature_test_macros()
    g.emit_preserved_c_directives()
    g.preamble()
    g.emit_c_directives()
    g.enum_decls()
    g.type_alias_decls()
    g.type_forward_decls()
    // Forward-declare multi-return structs before fn-ptr typedefs, which may name a
    // multi-return as a by-value return type (full bodies come after struct_decls).
    g.multi_return_forward_decls()
    // Bare typedefs for primitive-element fixed arrays and wrapper structs for
    // fixed-array return types, before fn-ptr typedefs (which may name a fixed
    // array in param or return position) and the function declarations.
    g.fixed_array_early_typedefs()
    g.fn_ptr_typedefs()
    g.struct_decls()
    g.fixed_array_typedefs()
    g.multi_return_typedefs()
    g.optional_typedefs()
    g.c_extern_forward_decls()
    g.builtin_abi_decls()
    g.global_decls()
    g.forward_decls()
    g.enum_str_forward_decls()
    g.callback_wrapper_decls()
    g.spawn_wrapper_decls()
    g.register_interface_strings()
    g.string_literals()
    g.interface_method_stubs()
    g.enum_str_defs()
    g.sb.write_string(const_code)
    // The final builder now owns a copy of the const code.
    unsafe { const_code.free() }
    if g.const_runtime_inits.len > 0 || g.runtime_inits.len > 0 || g.module_init_fns.len > 0
        || g.global_inits.len > 0 {
        g.writeln('void _vinit() {')
        mut emitted_const := []bool{len: g.const_runtime_inits.len}
        mut emitted_runtime := []bool{len: g.runtime_inits.len}
        init_fns := g.module_init_fn_map()
        for mod in g.ordered_startup_modules(init_fns) {
            g.emit_runtime_inits_for_module(mod, mut emitted_const, mut emitted_runtime)
            if init_fn := init_fns[mod] {
                g.writeln('\t${init_fn}();')
            }
        }
        g.emit_remaining_runtime_inits(mut emitted_const, mut emitted_runtime)
        g.writeln('}')
        g.writeln('')
    }
    g.sb.write_string(fn_code)
    // The final builder now owns a copy of the function code.
    unsafe { fn_code.free() }
    result := g.sb.str()
    // Keep only the returned C string, not the builder's copied backing array.
    unsafe { g.sb.free() }
    return result
}

// node_kind_id supports node kind id handling for c.
fn node_kind_id(node flat.Node) int {
    mut kind_id := node.kind_id
    if kind_id == 0 && int(node.kind) != 0 {
        kind_id = int(node.kind)
    }
    return kind_id
}

// collect_gen_info updates collect gen info state for c.
fn (mut g FlatGen) collect_gen_info() {
    g.collect_c_flags_from_directives()
    mut cur_module := 'main'
    mut cur_file := ''
    mut seen_import_in_file := false
    for node_idx in 0 .. g.a.nodes.len {
        node := g.a.nodes[node_idx]
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_file = node.value
            g.note_compiler_source_file(node.value)
            cur_module = 'main'
            g.tc.cur_module = cur_module
            g.tc.cur_file = cur_file
            seen_import_in_file = false
            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 {
            full_name := qualify_name_in_module(cur_module, node.value)
            mut ptypes := []types.Type{}
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            for i in 0 .. node.children_count {
                child := g.a.child_node(&node, i)
                if node_kind_id(child) == 75 {
                    raw_pt := g.tc.parse_type(child.typ)
                    pt := raw_pt
                    ptypes << raw_pt
                    if pt is types.FnType {
                        ct := g.tc.c_type(raw_pt)
                        g.resolve_fn_ptr_type(ct)
                    }
                }
            }
            ptypes = g.fn_param_types_with_implicit_veb_ctx(node, ptypes)
            g.register_fn_decl_param_types(node.value, full_name, ptypes)
            g.register_fn_decl_ret_type(node.value, full_name, node.typ)
            // Module-level `init()` functions run once at startup. Collect their C
            // names so _vinit can invoke them (V semantics).
            if node.value == 'init' && ptypes.len == 0 {
                init_cname := qualified_fn_name_in_module(cur_module, 'init')
                if init_cname !in g.module_init_fns {
                    g.module_init_fns << init_cname
                }
                g.module_init_fn_modules[init_cname] = cur_module
            }
            continue
        }
        if g.collect_c_directive(cur_module, node, cur_file, !seen_import_in_file) {
            continue
        }
        if node.kind == .directive && node.value == 'flag' {
            continue
        }
        if node.kind == .directive && node.value == 'pkgconfig' {
            continue
        }
        if kind_id == 62 {
            full_name := qualify_name_in_module(cur_module, node.value)
            g.register_struct_decl_info(node.value, full_name, cur_module, node)
            continue
        }
        if kind_id == 64 {
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            for i in 0 .. node.children_count {
                f := g.a.child_node(&node, i)
                if f.value.starts_with('C.') {
                    continue
                }
                mut ft := g.tc.parse_type(f.typ)
                if ft is types.Void && f.children_count > 0 {
                    ft = g.tc.resolve_type(g.a.child(f, 0))
                }
                qname := qualify_name_in_module(cur_module, f.value)
                g.global_types[qname] = ft
                g.global_modules[f.value] = cur_module
                g.global_modules[qname] = cur_module
                if f.children_count > 0 {
                    val_id := g.a.child(f, 0)
                    if int(val_id) >= 0 {
                        g.global_inits[qname] = val_id
                        g.global_init_order << qname
                    }
                }
                g.tc.file_scope.insert(f.value, ft)
                if qname != f.value {
                    g.tc.file_scope.insert(qname, ft)
                }
            }
            continue
        }
        if kind_id == 67 {
            is_flag := node.typ == 'flag'
            mut val := 0
            enum_name := qualify_name_in_module(cur_module, node.value)
            for i in 0 .. node.children_count {
                f := g.a.child_node(&node, i)
                if f.children_count > 0 {
                    if enum_val := g.enum_field_expr_value(g.a.child(f, 0)) {
                        val = enum_val
                    }
                }
                if is_flag {
                    g.enum_vals['${enum_name}.${f.value}'] = 1 << val
                    val++
                } else {
                    g.enum_vals['${enum_name}.${f.value}'] = val
                    val++
                }
            }
            continue
        }
        if kind_id == 70 {
            iface_name := qualify_name_in_module(cur_module, node.value)
            g.interfaces[iface_name] = g.tc.interface_abstract_method_names(iface_name)
            continue
        }
        if kind_id == 65 {
            for i in 0 .. node.children_count {
                f := g.a.child_node(&node, i)
                if node_kind_id(f) == 66 && f.children_count > 0 {
                    qname := g.const_storage_name(cur_module, f.value)
                    g.const_vals[qname] = g.a.child(f, 0)
                    g.const_modules[qname] = cur_module
                    if (cur_module.len == 0 || cur_module == 'main' || cur_module == 'builtin')
                        && f.value !in g.const_vals {
                        g.const_vals[f.value] = g.a.child(f, 0)
                        g.const_modules[f.value] = cur_module
                    }
                }
            }
            continue
        }
        if kind_id == 72 {
            seen_import_in_file = true
            alias := node.typ.clone()
            mod_name := node.value.clone()
            if alias.len > 0 && mod_name.len > 0 {
                g.modules[alias] = mod_name
            }
            if cur_module.len > 0 && mod_name.len > 0 {
                dep_module := mod_name
                if cur_module !in g.module_imports {
                    g.module_imports[cur_module] = []string{}
                }
                if dep_module !in g.module_imports[cur_module] {
                    g.module_imports[cur_module] << dep_module
                }
            }
            continue
        }
    }
    g.modules['strings'] = 'strings'
    g.collect_const_init_order_from_files()
}

fn (mut g FlatGen) collect_c_flags_from_directives() {
    mut cur_file := ''
    for node in g.a.nodes {
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_file = node.value
            g.note_compiler_source_file(node.value)
            continue
        }
        if node.kind != .directive || node.typ.len == 0 {
            continue
        }
        if node.value == 'flag' {
            flag := c_flag_arg(node.typ, g.compiler_vroot, cur_file)
            if flag.len > 0 && flag !in g.c_flags {
                g.c_flags << flag
            }
            continue
        }
        if node.value == 'pkgconfig' {
            for flag in c_pkgconfig_flags(node.typ) {
                if flag.len > 0 && flag !in g.c_flags {
                    g.c_flags << flag
                }
            }
        }
    }
}

fn (mut g FlatGen) collect_c_directive(module_name string, node flat.Node, source_file string, before_import bool) bool {
    if node.kind != .directive {
        return false
    }
    if node.value in ['include', 'insert'] {
        if node.typ.len == 0 {
            return true
        }
        include_arg := c_include_arg(node.typ, g.compiler_vroot, source_file)
        if include_arg.len == 0 {
            return true
        }
        // These helper headers are superseded by the inline compiler helpers emitted in
        // builtin_abi_decls(); also including them would redefine the helpers.
        if include_arg.contains('prealloc_atomics.h') || include_arg.contains('filelock_helpers.h')
            || include_arg.contains('stdatomic') {
            return true
        }
        include_dirs := c_flag_include_dirs(g.c_flags)
        if header := c_inline_header_text(include_arg, g.compiler_vroot, source_file, include_dirs) {
            header_text := header.text
            g.collect_inlined_c_structs(header_text)
            g.collect_inlined_c_fns(header_text)
            g.collect_inlined_c_declared_fns(header_text)
            g.collect_preserved_c_fns(header.preserved_c_fns)
            g.collect_preserved_c_structs(header.preserved_c_structs)
            for directive in header.preserved_directives {
                g.add_c_directive(module_name, directive, before_import)
            }
            if header_text.len > 0 {
                g.add_c_directive(module_name, header_text, before_import)
            }
        } else if c_should_preserve_uninlined_include(include_arg) {
            g.collect_preserved_c_fns(c_preserved_system_include_declared_fns(include_arg))
            g.collect_preserved_c_structs(c_preserved_system_include_struct_names(include_arg))
            g.add_c_directive(module_name, '#include ${include_arg}', before_import)
        }
        return true
    }
    if node.value in ['define', 'undef', 'ifdef', 'ifndef', 'if', 'elif', 'else', 'endif', 'pragma',
        'error', 'warning'] {
        g.add_c_directive(module_name, c_preprocessor_directive_line(node.value, node.typ),
            before_import)
        return true
    }
    return false
}

fn c_inline_header_text(include_arg string, vroot string, source_file string, include_dirs []string) ?CInlineHeader {
    if replacement := c_system_include_replacement(include_arg) {
        return CInlineHeader{
            text: replacement
        }
    }
    mut seen := map[string]bool{}
    for path in c_include_file_paths(include_arg, vroot, source_file, include_dirs) {
        if header := c_inline_header_file(path, vroot, include_dirs, mut seen) {
            return header
        }
    }
    return none
}

fn c_inline_header_file(path string, vroot string, include_dirs []string, mut seen map[string]bool) ?CInlineHeader {
    if path.len == 0 || !os.exists(path) {
        return none
    }
    real_path := os.real_path(path)
    if seen[real_path] {
        return CInlineHeader{}
    }
    seen[real_path] = true
    text := os.read_file(real_path) or { return none }
    return c_inline_header_file_text(text, vroot, real_path, include_dirs, mut seen)
}

fn c_inline_header_file_text(text string, vroot string, source_file string, include_dirs []string, mut seen map[string]bool) CInlineHeader {
    mut lines := []string{}
    mut preserved_directives := []string{}
    mut preserved_c_fns := []string{}
    mut preserved_c_structs := []string{}
    mut include_context := []string{}
    mut include_prefix := []string{}
    for line in text.split_into_lines() {
        clean := line.trim_space()
        if c_directive_name(clean) == 'include' {
            include_arg := c_include_arg(c_directive_arg(clean), vroot, source_file)
            if replacement := c_system_include_replacement(include_arg) {
                lines << replacement
                continue
            }
            mut inlined := false
            for path in c_include_file_paths(include_arg, vroot, source_file, include_dirs) {
                if nested := c_inline_header_file(path, vroot, include_dirs, mut seen) {
                    if nested.text.len > 0 {
                        lines << nested.text
                    }
                    preserved_directives << nested.preserved_directives
                    preserved_c_fns << nested.preserved_c_fns
                    preserved_c_structs << nested.preserved_c_structs
                    inlined = true
                    break
                }
            }
            if !inlined && c_should_preserve_uninlined_include(include_arg) {
                preserved_directives << c_preserved_nested_include_directive(include_arg,
                    include_context, include_prefix)
                preserved_c_fns << c_preserved_system_include_declared_fns(include_arg)
                preserved_c_structs << c_preserved_system_include_struct_names(include_arg)
            }
            continue
        }
        lines << line
        c_update_nested_include_context(clean, line, mut include_context)
        c_update_nested_include_prefix(clean, line, mut include_prefix)
    }
    return CInlineHeader{
        text:                 lines.join('\n')
        preserved_directives: preserved_directives
        preserved_c_fns:      preserved_c_fns
        preserved_c_structs:  preserved_c_structs
    }
}

fn c_update_nested_include_context(clean string, line string, mut context []string) {
    match c_directive_name(clean) {
        'if', 'ifdef', 'ifndef', 'elif', 'else' {
            context << line
        }
        'endif' {
            for context.len > 0 {
                name := c_directive_name(context[context.len - 1].trim_space())
                context.delete_last()
                if name in ['if', 'ifdef', 'ifndef'] {
                    break
                }
            }
        }
        else {}
    }
}

fn c_update_nested_include_prefix(clean string, line string, mut prefix []string) {
    match c_directive_name(clean) {
        'define', 'undef' {
            prefix << line
        }
        else {
            prefix.clear()
        }
    }
}

fn c_preserved_nested_include_directive(include_arg string, context []string, prefix []string) string {
    if context.len == 0 && prefix.len == 0 {
        return '#include ${include_arg}'
    }
    mut lines := context.clone()
    lines << prefix
    lines << '#include ${include_arg}'
    for _ in 0 .. c_nested_include_context_depth(context) {
        lines << '#endif'
    }
    return lines.join('\n')
}

fn c_nested_include_context_depth(context []string) int {
    mut depth := 0
    for line in context {
        if c_directive_name(line.trim_space()) in ['if', 'ifdef', 'ifndef'] {
            depth++
        }
    }
    return depth
}

fn c_flag_include_dirs(flags []string) []string {
    mut dirs := []string{}
    for flag in flags {
        tokens := flag.fields()
        mut i := 0
        for i < tokens.len {
            tok := tokens[i]
            mut dir := ''
            if tok == '-I' {
                if i + 1 < tokens.len {
                    dir = tokens[i + 1]
                    i++
                }
            } else if tok.starts_with('-I') && tok.len > 2 {
                dir = tok[2..]
            }
            if dir.len > 0 && dir !in dirs {
                dirs << dir
            }
            i++
        }
    }
    return dirs
}

fn c_system_include_replacement(include_arg string) ?string {
    match include_arg.trim_space() {
        '<stdint.h>' {
            return c_stdint_header_text()
        }
        else {
            return none
        }
    }
}

fn c_should_preserve_uninlined_include(include_arg string) bool {
    clean := include_arg.trim_space()
    if clean.len == 0 {
        return false
    }
    if clean[0] == `<` {
        return !c_headerless_system_include_is_handled(clean)
    }
    return true
}

fn c_preserved_system_include_declared_fns(include_arg string) []string {
    match include_arg.trim_space() {
        '<bcrypt.h>' {
            return ['BCryptGenRandom']
        }
        '<dlfcn.h>' {
            return ['dlopen', 'dlsym', 'dlclose', 'dlerror']
        }
        '<mach/mach_time.h>' {
            return ['mach_absolute_time', 'mach_timebase_info']
        }
        else {
            return []string{}
        }
    }
}

fn c_preserved_system_include_struct_names(include_arg string) []string {
    match include_arg.trim_space() {
        '<mach/mach_time.h>' {
            return ['mach_timebase_info_data_t']
        }
        '<X11/Xlib.h>', '<X11/Xutil.h>', '<X11/Xresource.h>', '<X11/XKBlib.h>',
        '<X11/extensions/XInput2.h>', '<X11/Xcursor/Xcursor.h>' {
            return c_x11_preserved_struct_names.clone()
        }
        else {
            return []string{}
        }
    }
}

const c_x11_preserved_struct_names = [
    'Display',
    'Screen',
    'Visual',
    'XButtonEvent',
    'XClientMessageData',
    'XClientMessageEvent',
    'XCrossingEvent',
    'XcursorImage',
    'XDestroyWindowEvent',
    'XEvent',
    'XFocusChangeEvent',
    'XGenericEventCookie',
    'XIEventMask',
    'XIRawEvent',
    'XIValuatorState',
    'XkbDescRec',
    'XkbKeyAliasRec',
    'XkbKeyNameRec',
    'XkbNamesRec',
    'XKeyEvent',
    'XMotionEvent',
    'XPropertyEvent',
    'XrmValue',
    'XSelectionClearEvent',
    'XSelectionEvent',
    'XSelectionRequestEvent',
    'XSetWindowAttributes',
    'XSizeHints',
    'XVisualInfo',
    'XWindowAttributes',
]

fn c_headerless_system_include_is_handled(include_arg string) bool {
    if include_arg.len < 3 || include_arg[0] != `<` || include_arg[include_arg.len - 1] != `>` {
        return false
    }
    name := include_arg[1..include_arg.len - 1]
    return name in c_headerless_handled_system_headers
}

const c_headerless_handled_system_headers = {
    'arpa/inet.h':     true
    'conio.h':         true
    'dirent.h':        true
    'errno.h':         true
    'execinfo.h':      true
    'fcntl.h':         true
    'float.h':         true
    'io.h':            true
    'math.h':          true
    'netdb.h':         true
    'netinet/in.h':    true
    'netinet/tcp.h':   true
    'poll.h':          true
    'process.h':       true
    'pthread.h':       true
    'pthread_np.h':    true
    'semaphore.h':     true
    'signal.h':        true
    'stdarg.h':        true
    'stdatomic.h':     true
    'stdbool.h':       true
    'stddef.h':        true
    'stdint.h':        true
    'stdio.h':         true
    'stdlib.h':        true
    'string.h':        true
    'synchapi.h':      true
    'sys/epoll.h':     true
    'sys/event.h':     true
    'sys/file.h':      true
    'sys/ioctl.h':     true
    'sys/mman.h':      true
    'sys/ptrace.h':    true
    'sys/random.h':    true
    'sys/resource.h':  true
    'sys/select.h':    true
    'sys/sendfile.h':  true
    'sys/socket.h':    true
    'sys/stat.h':      true
    'sys/statvfs.h':   true
    'sys/syscall.h':   true
    'sys/sysctl.h':    true
    'sys/syslimits.h': true
    'sys/time.h':      true
    'sys/types.h':     true
    'sys/uio.h':       true
    'sys/utime.h':     true
    'sys/utsname.h':   true
    'sys/wait.h':      true
    'termios.h':       true
    'time.h':          true
    'unistd.h':        true
    'utime.h':         true
    'wchar.h':         true
    'windows.h':       true
    'winsock2.h':      true
    'ws2tcpip.h':      true
}

fn c_stdint_header_text() string {
    return '#if !defined(__V_HEADERLESS_STDINT_H) && !defined(_STDINT_H) && !defined(_STDINT_H_) && !defined(_STDINT) && !defined(_STDINT_H_INCLUDED) && !defined(_GCC_STDINT_H) && !defined(_MSC_STDINT_H_)
#define __V_HEADERLESS_STDINT_H
typedef signed char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767 - 1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647 - 1)
#endif
#ifndef INT64_MIN
#define INT64_MIN (-9223372036854775807LL - 1)
#endif
#ifndef INT8_MAX
#define INT8_MAX 127
#endif
#ifndef INT16_MAX
#define INT16_MAX 32767
#endif
#ifndef INT32_MAX
#define INT32_MAX 2147483647
#endif
#ifndef INT64_MAX
#define INT64_MAX 9223372036854775807LL
#endif
#ifndef UINT8_MAX
#define UINT8_MAX 255U
#endif
#ifndef UINT16_MAX
#define UINT16_MAX 65535U
#endif
#ifndef UINT32_MAX
#define UINT32_MAX 4294967295U
#endif
#ifndef UINT64_MAX
#define UINT64_MAX 18446744073709551615ULL
#endif
#ifndef INT32_C
#define INT32_C(c) c
#endif
#ifndef UINT32_C
#define UINT32_C(c) c ## U
#endif
#ifndef INT64_C
#define INT64_C(c) c ## LL
#endif
#ifndef UINT64_C
#define UINT64_C(c) c ## ULL
#endif
#endif'
}

fn (mut g FlatGen) collect_inlined_c_structs(text string) {
    for line in text.split_into_lines() {
        clean := line.trim_space()
        mut rest := ''
        if clean.starts_with('typedef struct ') {
            rest = clean['typedef struct '.len..]
        } else if clean.starts_with('typedef union ') {
            rest = clean['typedef union '.len..]
        } else if clean.starts_with('struct ') {
            rest = clean['struct '.len..]
        } else if clean.starts_with('union ') {
            rest = clean['union '.len..]
        } else {
            continue
        }
        tag := c_header_struct_tag(rest)
        if tag.len > 0 {
            g.inlined_c_structs[tag] = true
        }
    }
    for alias in c_typedef_struct_aliases(text) {
        g.inlined_c_structs[alias] = true
    }
    for alias in c_typedef_union_aliases(text) {
        g.inlined_c_structs[alias] = true
    }
}

fn (mut g FlatGen) collect_inlined_c_fns(text string) {
    mut pending_static := false
    for line in text.split_into_lines() {
        clean := line.trim_space()
        if clean.len == 0 {
            continue
        }
        if clean.starts_with('static ') {
            name := c_header_fn_name(clean)
            if name.len > 0 {
                g.inlined_c_fns[name] = true
                pending_static = false
            } else {
                pending_static = c_static_fn_prefix_can_continue(clean)
            }
            continue
        }
        if pending_static {
            name := c_header_fn_name(clean)
            if name.len > 0 {
                g.inlined_c_fns[name] = true
                pending_static = false
                continue
            }
            if clean.ends_with(';') || clean.contains('{') || clean.starts_with('#') {
                pending_static = false
            }
        }
    }
}

fn (mut g FlatGen) collect_inlined_c_declared_fns(text string) {
    for line in text.split_into_lines() {
        name := c_header_declared_fn_name(line.trim_space())
        if name.len > 0 {
            g.inlined_c_declared_fns[name] = true
        }
    }
}

fn (mut g FlatGen) collect_preserved_c_fns(names []string) {
    for name in names {
        g.inlined_c_declared_fns[name] = true
    }
}

fn (mut g FlatGen) collect_preserved_c_structs(names []string) {
    for name in names {
        g.inlined_c_structs[name] = true
    }
}

fn c_static_fn_prefix_can_continue(line string) bool {
    return line in ['static', 'static inline', 'static __inline', 'static __inline__']
        || line.starts_with('static inline ') || line.starts_with('static __inline ')
        || line.starts_with('static __inline__ ')
}

fn c_header_struct_tag(rest string) string {
    mut end := 0
    for end < rest.len {
        c := rest[end]
        if (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`) || (c >= `0` && c <= `9`) || c == `_` {
            end++
            continue
        }
        break
    }
    return rest[..end]
}

fn c_typedef_struct_aliases(text string) []string {
    return c_typedef_aggregate_aliases(text, 'struct')
}

fn c_typedef_union_aliases(text string) []string {
    return c_typedef_aggregate_aliases(text, 'union')
}

fn c_typedef_aggregate_aliases(text string, kind string) []string {
    mut aliases := []string{}
    prefix := 'typedef ${kind}'
    mut start := 0
    for start < text.len {
        rel_idx := text[start..].index(prefix) or { break }
        idx := start + rel_idx
        mut pos := idx + prefix.len
        if pos < text.len && c_ident_char(text[pos]) {
            start = pos + 1
            continue
        }
        for pos < text.len && text[pos].is_space() {
            pos++
        }
        if pos < text.len && text[pos] != `{` {
            tag := c_header_struct_tag(text[pos..])
            if tag.len == 0 {
                start = pos + 1
                continue
            }
            pos += tag.len
            for pos < text.len && text[pos].is_space() {
                pos++
            }
        }
        if pos >= text.len || text[pos] != `{` {
            start = pos + 1
            continue
        }
        close_idx := c_matching_brace_end(text, pos)
        if close_idx < 0 {
            break
        }
        semi_rel_idx := text[close_idx + 1..].index_u8(`;`)
        if semi_rel_idx < 0 {
            break
        }
        semi_idx := close_idx + 1 + semi_rel_idx
        for alias in c_typedef_declarator_aliases(text[close_idx + 1..semi_idx]) {
            aliases << alias
        }
        start = semi_idx + 1
    }
    return aliases
}

fn c_matching_brace_end(text string, open_idx int) int {
    mut depth := 0
    for i in open_idx .. text.len {
        if text[i] == `{` {
            depth++
        } else if text[i] == `}` {
            depth--
            if depth == 0 {
                return i
            }
        }
    }
    return -1
}

fn c_typedef_declarator_aliases(decl string) []string {
    mut aliases := []string{}
    for part in decl.split(',') {
        alias := c_last_ident(part)
        if alias.len > 0 {
            aliases << alias
        }
    }
    return aliases
}

fn c_last_ident(text string) string {
    mut end := text.len
    for end > 0 && !c_ident_char(text[end - 1]) {
        end--
    }
    mut start := end
    for start > 0 && c_ident_char(text[start - 1]) {
        start--
    }
    if start == end {
        return ''
    }
    return text[start..end]
}

fn c_header_fn_name(line string) string {
    paren := line.index_u8(`(`)
    if paren < 0 {
        return ''
    }
    mut end := paren
    for end > 0 && line[end - 1].is_space() {
        end--
    }
    mut start := end
    for start > 0 && c_ident_char(line[start - 1]) {
        start--
    }
    if start == end {
        return ''
    }
    name := line[start..end]
    if name in ['if', 'for', 'while', 'switch'] {
        return ''
    }
    return name
}

fn c_header_declared_fn_name(line string) string {
    if line.len == 0 || line[0] == `#` || !line.ends_with(';') || !line.contains('(') {
        return ''
    }
    if line.starts_with('typedef ') || line.contains('(*') || line.contains('=')
        || line.contains('{') || line.contains('}') {
        return ''
    }
    for prefix in ['return ', 'if ', 'if(', 'for ', 'for(', 'while ', 'while(', 'switch ', 'switch(',
        'case ', 'do ', 'else '] {
        if line.starts_with(prefix) {
            return ''
        }
    }
    paren := line.index_u8(`(`)
    mut end := paren
    for end > 0 && line[end - 1].is_space() {
        end--
    }
    mut start := end
    for start > 0 && c_ident_char(line[start - 1]) {
        start--
    }
    if start == 0 {
        return ''
    }
    return c_header_fn_name(line)
}

fn c_ident_char(ch u8) bool {
    return (ch >= `a` && ch <= `z`) || (ch >= `A` && ch <= `Z`)
        || (ch >= `0` && ch <= `9`) || ch == `_`
}

fn c_include_file_path(include_arg string, vroot string, source_file string) string {
    clean := include_arg.trim_space()
    if clean.len < 2 {
        return ''
    }
    if clean[0] == `<` {
        return ''
    }
    mut path := ''
    if clean[0] == `"` && clean[clean.len - 1] == `"` {
        path = clean[1..clean.len - 1]
    } else {
        path = clean
    }
    path = c_resolve_pseudo_paths(path, vroot, source_file)
    if path.len == 0 || os.is_abs_path(path) {
        return path
    }
    if source_file.len == 0 {
        return path
    }
    return os.join_path_single(os.dir(source_file), path)
}

fn c_include_file_paths(include_arg string, vroot string, source_file string, include_dirs []string) []string {
    clean := include_arg.trim_space()
    if clean.len < 2 {
        return []string{}
    }
    mut raw_path := clean
    mut search_source_dir := true
    if clean[0] == `"` && clean[clean.len - 1] == `"` {
        raw_path = clean[1..clean.len - 1]
    } else if clean[0] == `<` && clean[clean.len - 1] == `>` {
        raw_path = clean[1..clean.len - 1]
        search_source_dir = false
    }
    mut paths := []string{}
    if search_source_dir {
        first := c_include_file_path(include_arg, vroot, source_file)
        if first.len > 0 {
            paths << first
        }
    }
    resolved_path := c_resolve_pseudo_paths(raw_path, vroot, source_file)
    if os.is_abs_path(resolved_path) {
        if resolved_path !in paths {
            paths << resolved_path
        }
        return paths
    }
    for dir in include_dirs {
        if dir.len == 0 {
            continue
        }
        path := os.join_path_single(dir, resolved_path)
        if path !in paths {
            paths << path
        }
    }
    return paths
}

fn (mut g FlatGen) add_c_directive(module_name string, text string, before_import bool) {
    if text.len == 0 {
        return
    }
    g.c_directives << CDirective{
        module:        module_name
        text:          text
        before_import: before_import
    }
}

fn c_preprocessor_directive_line(name string, raw string) string {
    clean := raw.trim_space()
    if clean.len == 0 {
        return '#${name}'
    }
    return '#${name} ${clean}'
}

// note_compiler_source_file supports note compiler source file handling for FlatGen.
fn (mut g FlatGen) note_compiler_source_file(path string) {
    if g.compiler_vroot.len > 0 || path.len == 0 {
        return
    }
    mut full_path := path
    if !os.is_abs_path(full_path) {
        full_path = os.abs_path(full_path)
    }
    full_path = os.real_path(full_path)
    normalized := full_path.replace('\\', '/')
    suffix := '/cmd/v/v.v'
    if normalized.ends_with(suffix) {
        g.compiler_vroot = normalized[..normalized.len - suffix.len]
        return
    }
    vlib_idx := normalized.index('/vlib/') or { return }
    if vlib_idx > 0 {
        g.compiler_vroot = normalized[..vlib_idx]
    }
}

// collect_const_init_order_from_files converts collect const init order from files data for c.
fn (mut g FlatGen) collect_const_init_order_from_files() {
    mut seen := map[string]bool{}
    g.const_init_order = []string{}
    for node in g.a.nodes {
        if node_kind_id(node) != 77 || node.children_count == 0 {
            continue
        }
        mut cur_module := 'main'
        for i in 0 .. node.children_count {
            child := g.a.child_node(&node, i)
            kind_id := node_kind_id(child)
            if kind_id == 73 {
                cur_module = child.value
                continue
            }
            if kind_id != 65 {
                continue
            }
            for j in 0 .. child.children_count {
                field := g.a.child_node(child, j)
                if node_kind_id(field) != 66 || field.children_count == 0 {
                    continue
                }
                qname := g.const_storage_name(cur_module, field.value)
                if qname in g.const_vals && !seen[qname] {
                    seen[qname] = true
                    g.const_init_order << qname
                }
            }
        }
    }
}

// ordered_module_init_fns supports ordered module init fns handling for FlatGen.
fn (g &FlatGen) ordered_module_init_fns() []string {
    module_to_init := g.module_init_fn_map()
    mut result := []string{}
    mut visiting := map[string]bool{}
    mut visited := map[string]bool{}
    for init_fn in g.module_init_fns {
        mod := g.module_init_fn_modules[init_fn] or { '' }
        g.visit_module_init(mod, module_to_init, mut visiting, mut visited, mut result)
    }
    return result
}

fn (g &FlatGen) module_init_fn_map() map[string]string {
    mut module_to_init := map[string]string{}
    for init_fn in g.module_init_fns {
        mod := g.module_init_fn_modules[init_fn] or { '' }
        module_to_init[mod] = init_fn
    }
    return module_to_init
}

fn (g &FlatGen) ordered_startup_modules(module_to_init map[string]string) []string {
    mut module_order := []string{}
    for init_fn in g.module_init_fns {
        mod := g.module_init_fn_modules[init_fn] or { '' }
        if mod !in module_order {
            module_order << mod
        }
    }
    for mod in g.const_runtime_init_modules {
        if mod !in module_order {
            module_order << mod
        }
    }
    for mod in g.runtime_init_modules {
        if mod !in module_order {
            module_order << mod
        }
    }
    mut startup_modules := map[string]bool{}
    for mod in module_order {
        startup_modules[mod] = true
    }
    for mod, _ in module_to_init {
        startup_modules[mod] = true
    }
    mut result := []string{}
    mut visiting := map[string]bool{}
    mut visited := map[string]bool{}
    for mod in module_order {
        g.visit_startup_module(mod, startup_modules, mut visiting, mut visited, mut result)
    }
    return result
}

fn (g &FlatGen) visit_startup_module(mod string, startup_modules map[string]bool, mut visiting map[string]bool, mut visited map[string]bool, mut result []string) {
    if mod in visited || mod in visiting {
        return
    }
    visiting[mod] = true
    for dep in g.module_imports[mod] or { []string{} } {
        dep_module := g.startup_dependency_module(dep, startup_modules)
        g.visit_startup_module(dep_module, startup_modules, mut visiting, mut visited, mut result)
    }
    visiting.delete(mod)
    visited[mod] = true
    if mod in startup_modules {
        result << mod
    }
}

fn (g &FlatGen) startup_dependency_module(dep string, startup_modules map[string]bool) string {
    if dep in startup_modules || dep in g.module_imports {
        return dep
    }
    short := startup_module_key(dep)
    if short in startup_modules || short in g.module_imports {
        return short
    }
    return dep
}

fn (mut g FlatGen) emit_runtime_inits_for_module(mod string, mut emitted_const []bool, mut emitted_runtime []bool) {
    for i, ri in g.const_runtime_inits {
        if !emitted_const[i] && i < g.const_runtime_init_modules.len
            && g.const_runtime_init_modules[i] == mod {
            g.writeln(ri)
            emitted_const[i] = true
        }
    }
    for i, ri in g.runtime_inits {
        if !emitted_runtime[i] && i < g.runtime_init_modules.len && g.runtime_init_modules[i] == mod {
            g.writeln(ri)
            emitted_runtime[i] = true
        }
    }
}

fn (mut g FlatGen) emit_remaining_runtime_inits(mut emitted_const []bool, mut emitted_runtime []bool) {
    for i, ri in g.const_runtime_inits {
        if !emitted_const[i] {
            g.writeln(ri)
            emitted_const[i] = true
        }
    }
    for i, ri in g.runtime_inits {
        if !emitted_runtime[i] {
            g.writeln(ri)
            emitted_runtime[i] = true
        }
    }
}

fn (mut g FlatGen) queue_const_runtime_init(line string) {
    g.const_runtime_inits << line
    g.const_runtime_init_modules << g.tc.cur_module
}

fn (mut g FlatGen) queue_runtime_init(line string) {
    g.runtime_inits << line
    g.runtime_init_modules << g.tc.cur_module
}

// visit_module_init updates visit module init state for FlatGen.
fn (g &FlatGen) visit_module_init(mod string, module_to_init map[string]string, mut visiting map[string]bool, mut visited map[string]bool, mut result []string) {
    if mod in visited || mod in visiting {
        return
    }
    visiting[mod] = true
    for dep in g.module_imports[mod] or { []string{} } {
        dep_module := startup_module_key(dep)
        g.visit_module_init(dep_module, module_to_init, mut visiting, mut visited, mut result)
    }
    visiting.delete(mod)
    visited[mod] = true
    if init_fn := module_to_init[mod] {
        result << init_fn
    }
}

fn (g &FlatGen) ordered_c_directives() []string {
    mut directives_by_module := map[string][]CDirective{}
    mut module_order := []string{}
    for directive in g.c_directives {
        if directive.module !in directives_by_module {
            directives_by_module[directive.module] = []CDirective{}
            module_order << directive.module
        }
        directives_by_module[directive.module] << directive
    }
    mut result := []string{}
    mut visiting := map[string]bool{}
    mut visited := map[string]bool{}
    for mod in module_order {
        g.visit_c_directive_module(mod, directives_by_module, mut visiting, mut visited, mut result)
    }
    return dedupe_top_level_c_includes(result)
}

fn (mut g FlatGen) emit_c_directives() {
    mut emitted := false
    for directive in g.ordered_c_directives() {
        if c_contains_preserved_system_include_directive(directive) {
            continue
        }
        g.writeln(directive)
        emitted = true
    }
    if emitted {
        g.writeln('')
    }
}

fn (mut g FlatGen) emit_preserved_c_directives() {
    mut emitted := false
    directives := g.ordered_c_directives()
    for i, directive in directives {
        if !c_contains_preserved_system_include_directive(directive) {
            continue
        }
        if directive.contains('\n') {
            g.emit_preserved_c_directive(directive)
            emitted = true
            continue
        }
        prefix := c_lifted_include_context_prefix(directives, i)
        for line in prefix {
            g.writeln(line)
            emitted = true
        }
        g.emit_preserved_c_directive(directive)
        emitted = true
        for _ in 0 .. c_lifted_include_context_depth(prefix) {
            g.writeln('#endif')
        }
    }
    if emitted {
        g.writeln('')
    }
}

fn (mut g FlatGen) emit_preserved_c_directive(directive string) {
    if c_preserved_directive_needs_mach_panic_alias(directive) {
        g.writeln('#define panic mach_panic')
        g.writeln(directive)
        g.writeln('#undef panic')
        return
    }
    g.writeln(directive)
}

fn c_preserved_directive_needs_mach_panic_alias(directive string) bool {
    for line in directive.split_into_lines() {
        clean := line.trim_space()
        if clean == '#include <mach/mach.h>' || clean == '#include <mach/mach_time.h>' {
            return true
        }
    }
    return false
}

fn c_lifted_include_context_prefix(directives []string, include_index int) []string {
    mut prefix := []string{}
    for i := include_index - 1; i >= 0; i-- {
        clean := directives[i].trim_space()
        if c_is_preserved_system_include_directive(clean) {
            continue
        }
        if !c_is_liftable_include_context_directive(clean) {
            break
        }
        prefix << directives[i]
    }
    prefix.reverse_in_place()
    return prefix
}

fn c_lifted_include_context_depth(prefix []string) int {
    mut depth := 0
    for directive in prefix {
        clean := directive.trim_space()
        if clean.starts_with('#ifdef') || clean.starts_with('#ifndef') || clean.starts_with('#if ') {
            depth++
        }
    }
    return depth
}

fn c_is_liftable_include_context_directive(directive string) bool {
    clean := directive.trim_space()
    if clean.len == 0 || clean.contains('\n') || clean.starts_with('#endif') {
        return false
    }
    return clean.starts_with('#define') || clean.starts_with('#undef')
        || clean.starts_with('#ifdef') || clean.starts_with('#ifndef') || clean.starts_with('#if ')
        || clean.starts_with('#elif') || clean.starts_with('#else')
}

fn c_is_preserved_system_include_directive(directive string) bool {
    clean := directive.trim_space()
    return clean.starts_with('#include <') && clean.ends_with('>') && !clean.contains('\n')
}

fn c_contains_preserved_system_include_directive(directive string) bool {
    if c_is_preserved_system_include_directive(directive) {
        return true
    }
    for line in directive.split_into_lines() {
        if c_is_preserved_system_include_directive(line) {
            return true
        }
    }
    return false
}

fn (g &FlatGen) visit_c_directive_module(mod string, directives_by_module map[string][]CDirective, mut visiting map[string]bool, mut visited map[string]bool, mut result []string) {
    if mod in visited || mod in visiting {
        return
    }
    visiting[mod] = true
    directives := directives_by_module[mod] or { []CDirective{} }
    for directive in directives {
        if directive.before_import {
            result << directive.text
        }
    }
    for dep in g.module_imports[mod] or { []string{} } {
        if dep in directives_by_module {
            g.visit_c_directive_module(dep, directives_by_module, mut visiting, mut visited, mut
                result)
        }
    }
    visiting.delete(mod)
    visited[mod] = true
    for directive in directives {
        if !directive.before_import {
            result << directive.text
        }
    }
}

fn dedupe_top_level_c_includes(directives []string) []string {
    mut result := []string{}
    mut seen_includes := map[string]bool{}
    mut depth := 0
    for directive in directives {
        clean := directive.trim_space()
        if depth == 0 && c_directive_name(clean) == 'include' {
            if clean in seen_includes {
                continue
            }
            seen_includes[clean] = true
        }
        result << directive
        name := c_directive_name(clean)
        if name in ['if', 'ifdef', 'ifndef'] {
            depth++
        } else if name == 'endif' && depth > 0 {
            depth--
        }
    }
    return result
}

fn c_directive_name(text string) string {
    if text.len == 0 || text[0] != `#` {
        return ''
    }
    body := text[1..].trim_space()
    if body.len == 0 {
        return ''
    }
    idx := body.index_u8(` `)
    if idx < 0 {
        return body
    }
    return body[..idx]
}

fn c_directive_arg(text string) string {
    if text.len == 0 || text[0] != `#` {
        return ''
    }
    body := text[1..].trim_space()
    mut idx := 0
    for idx < body.len && !body[idx].is_space() {
        idx++
    }
    if idx >= body.len {
        return ''
    }
    return body[idx..].trim_space()
}

fn c_include_arg(raw string, vroot string, source_file string) string {
    mut clean := c_directive_arg_for_target(raw.trim_space()) or { return '' }
    clean = c_resolve_pseudo_paths(clean.trim_space(), vroot, source_file)
    if clean.len == 0 {
        return ''
    }
    if clean[0] == `<` {
        end := clean.index_u8(`>`)
        if end > 0 {
            return clean[..end + 1]
        }
        return clean
    }
    if clean[0] == `"` {
        mut i := 1
        for i < clean.len {
            if clean[i] == `"` {
                return clean[..i + 1]
            }
            i++
        }
    }
    hash := clean.index_u8(`#`)
    if hash > 0 {
        return clean[..hash].trim_space()
    }
    return clean
}

fn c_flag_arg(raw string, vroot string, source_file string) string {
    clean := c_directive_arg_for_target(raw.trim_space()) or { return '' }
    if clean.len == 0 {
        return ''
    }
    resolved := c_resolve_pseudo_paths(clean, vroot, source_file)
    return c_resolve_relative_flag_paths(resolved, source_file)
}

// c_resolve_relative_flag_paths rewrites relative path arguments in a `#flag`
// directive (e.g. `-I ./thirdparty`, or a bare `./foo.c`) to absolute paths,
// resolved against the directory of the source file that carried the directive.
// V1 does the same: a project's `#flag` paths are relative to its own module dir,
// not to the compiler's build/working directory.
fn c_resolve_relative_flag_paths(flag string, source_file string) string {
    if source_file.len == 0 || !flag.contains('/') {
        return flag
    }
    base_dir := os.dir(source_file)
    if base_dir.len == 0 {
        return flag
    }
    mut out := []string{}
    for tok in flag.fields() {
        out << c_resolve_flag_path_token(tok, base_dir)
    }
    return out.join(' ')
}

fn c_resolve_flag_path_token(tok string, base_dir string) string {
    for prefix in ['-I', '-L'] {
        if tok.starts_with(prefix) && tok.len > prefix.len {
            path := tok[prefix.len..]
            if c_flag_path_is_relative(path) {
                return prefix + os.real_path(os.join_path_single(base_dir, path))
            }
            return tok
        }
    }
    if !tok.starts_with('-') && c_flag_path_is_relative(tok) {
        return os.real_path(os.join_path_single(base_dir, tok))
    }
    return tok
}

fn c_flag_path_is_relative(p string) bool {
    if p.len == 0 || os.is_abs_path(p) {
        return false
    }
    return p.starts_with('./') || p.starts_with('../') || p.contains('/')
}

fn c_directive_arg_for_target(raw string) ?string {
    parts := raw.fields()
    if parts.len == 0 {
        return none
    }
    if c_flag_has_target_prefix(parts[0]) {
        if !c_flag_target_enabled(parts[0]) || parts.len < 2 {
            return none
        }
        return parts[1..].join(' ')
    }
    return raw
}

fn c_resolve_pseudo_paths(raw string, vroot string, source_file string) string {
    mut result := raw
    if result.contains('@VEXEROOT') && vroot.len > 0 {
        result = result.replace('@VEXEROOT', vroot)
    }
    if result.contains('@VROOT') {
        result = result.replace('@VROOT', '@VMODROOT')
    }
    if result.contains('@VMODROOT') {
        result = result.replace('@VMODROOT', c_vmod_root_for_file(source_file))
    }
    if result.contains('@DIR') {
        dir := if source_file.len > 0 { os.dir(source_file) } else { os.getwd() }
        result = result.replace('@DIR', os.real_path(dir))
    }
    return result
}

fn c_vmod_root_for_file(source_file string) string {
    mut dir := if source_file.len > 0 { os.dir(source_file) } else { os.getwd() }
    if dir.len == 0 {
        dir = os.getwd()
    }
    for {
        if os.exists(os.join_path(dir, 'v.mod')) {
            return os.real_path(dir)
        }
        parent := os.dir(dir)
        if parent == dir || parent.len == 0 {
            return os.real_path(dir)
        }
        dir = parent
    }
    return os.real_path(dir)
}

fn c_pkgconfig_flags(raw string) []string {
    name := raw.trim_space()
    if name.len == 0 {
        return []string{}
    }
    // The package name comes straight from source text and is interpolated into a
    // shell command, so reject anything that is not a plain pkg-config name/flag to
    // avoid command injection (e.g. `#pkgconfig foo; touch /tmp/pwned`).
    if !c_pkgconfig_arg_is_safe(name) {
        return []string{}
    }
    result := os.execute('pkg-config --cflags --libs ${name}')
    if result.exit_code != 0 {
        return []string{}
    }
    return result.output.trim_space().fields()
}

fn c_pkgconfig_arg_is_safe(raw string) bool {
    for ch in raw {
        if (ch >= `a` && ch <= `z`) || (ch >= `A` && ch <= `Z`) || (ch >= `0` && ch <= `9`) {
            continue
        }
        if ch in [` `, `\t`, `_`, `-`, `.`, `+`, `:`, `/`] {
            continue
        }
        return false
    }
    return true
}

fn c_flag_has_target_prefix(target string) bool {
    return target in ['darwin', 'macos', 'linux', 'windows', 'freebsd', 'openbsd', 'netbsd',
        'solaris', 'wasm32_emscripten']
}

fn c_flag_target_enabled(target string) bool {
    match target {
        'darwin', 'macos' {
            $if macos {
                return true
            }
            return false
        }
        'linux' {
            $if linux {
                return true
            }
            return false
        }
        'windows' {
            $if windows {
                return true
            }
            return false
        }
        'freebsd' {
            $if freebsd {
                return true
            }
            return false
        }
        'openbsd' {
            $if openbsd {
                return true
            }
            return false
        }
        'netbsd' {
            $if netbsd {
                return true
            }
            return false
        }
        'solaris' {
            $if solaris {
                return true
            }
            return false
        }
        'wasm32_emscripten' {
            $if wasm32_emscripten {
                return true
            }
            return false
        }
        else {
            return true
        }
    }
}

// register_fn_decl_param_types updates register fn decl param types state for c.
fn (mut g FlatGen) register_fn_decl_param_types(name string, full_name string, ptypes []types.Type) {
    if name !in g.fn_decl_param_types {
        g.fn_decl_param_types[name] = ptypes.clone()
    }
    if g.tc.cur_module.len > 0 && g.tc.cur_module != 'main' && g.tc.cur_module != 'builtin' {
        dotted_name := '${g.tc.cur_module}.${name}'
        if dotted_name !in g.fn_decl_param_types {
            g.fn_decl_param_types[dotted_name] = ptypes.clone()
        }
    }
    if full_name !in g.fn_decl_param_types {
        g.fn_decl_param_types[full_name] = ptypes.clone()
    }
}

// register_fn_decl_ret_type indexes a fn decl's return type by its name (and qualified
// variants), so the return type can be looked up in O(1) instead of scanning all AST
// nodes per call (see fn_decl_return_type_for_call_name).
fn (mut g FlatGen) register_fn_decl_ret_type(name string, full_name string, ret_typ string) {
    rt := g.tc.parse_type(ret_typ)
    if name !in g.fn_decl_ret_types {
        g.fn_decl_ret_types[name] = rt
    }
    if g.tc.cur_module.len > 0 && g.tc.cur_module != 'main' && g.tc.cur_module != 'builtin' {
        dotted_name := '${g.tc.cur_module}.${name}'
        if dotted_name !in g.fn_decl_ret_types {
            g.fn_decl_ret_types[dotted_name] = rt
        }
    }
    if full_name !in g.fn_decl_ret_types {
        g.fn_decl_ret_types[full_name] = rt
    }
    cname := c_name(name)
    if cname != name && cname !in g.fn_decl_ret_types {
        g.fn_decl_ret_types[cname] = rt
    }
}

// register_struct_decl_info updates register struct decl info state for c.
fn (mut g FlatGen) register_struct_decl_info(name string, full_name string, module_name string, node flat.Node) {
    info := StructDeclInfo{
        node:      node
        module:    module_name
        full_name: full_name
    }
    g.struct_decl_infos[full_name] = info
    if name !in g.struct_decl_short_infos {
        g.struct_decl_short_infos[name] = info
    }
}

// enum_value_for_type supports enum value for type handling for FlatGen.
fn (g &FlatGen) enum_value_for_type(type_name string, field_name string) ?int {
    if type_name.len == 0 || field_name.len == 0 {
        return none
    }
    key := '${type_name}.${field_name}'
    if val := g.enum_vals[key] {
        return val
    }
    if !type_name.contains('.') && g.tc.cur_module.len > 0 && g.tc.cur_module != 'main'
        && g.tc.cur_module != 'builtin' {
        qkey := '${g.tc.cur_module}.${type_name}.${field_name}'
        if val := g.enum_vals[qkey] {
            return val
        }
    }
    if !type_name.contains('.') {
        mut found := 0
        mut ok := false
        for ename, val in g.enum_vals {
            if !ename.ends_with('.${type_name}.${field_name}') {
                continue
            }
            if ok {
                return none
            }
            found = val
            ok = true
        }
        if ok {
            return found
        }
    }
    return none
}

fn (g &FlatGen) enum_selector_base_name(name string) ?string {
    if name in g.tc.enum_names || name in g.tc.flag_enums {
        return name
    }
    qname := g.tc.qualify_name(name)
    if qname in g.tc.enum_names || qname in g.tc.flag_enums {
        return qname
    }
    if name.contains('.') || g.tc.cur_file.len == 0 {
        return none
    }
    candidates := g.tc.file_selective_imports['${g.tc.cur_file}\n${name}'] or { return none }
    for candidate in candidates {
        if candidate in g.tc.enum_names || candidate in g.tc.flag_enums {
            return candidate
        }
    }
    return none
}

// expr_to_string converts expr to string data for c.
fn (mut g FlatGen) expr_to_string(id flat.NodeId) string {
    orig := g.sb
    orig_line_start := g.line_start
    g.sb = strings.new_builder(64)
    g.line_start = true
    g.gen_expr(id)
    result := g.sb.str()
    g.sb = orig
    g.line_start = orig_line_start
    return result
}

// interface_value_to_string captures, as a string, the boxed interface value the direct return
// path emits (`(Iface){._typ = N, ._object = ...}`) — so a deferred return can save it into a
// temp without dropping `_typ`/`_object`. Mirrors that path: box a concrete value, else (already
// boxed by the transform) emit it as-is.
fn (mut g FlatGen) interface_value_to_string(id flat.NodeId, expected types.Type) string {
    orig := g.sb
    orig_line_start := g.line_start
    g.sb = strings.new_builder(64)
    // Box mid-statement (no leading indent), matching the direct return path.
    g.line_start = false
    if !g.gen_interface_value_expr(id, expected) {
        g.gen_expr(id)
    }
    result := g.sb.str()
    g.sb = orig
    g.line_start = orig_line_start
    return result
}

// fixed_array_copy_source_string captures gen_fixed_array_copy_source as a string, so a deferred
// optional/fixed-array return can embed the memcpy source when saving the value into a temp.
fn (mut g FlatGen) fixed_array_copy_source_string(value_id flat.NodeId, field_type types.Type) string {
    orig := g.sb
    orig_line_start := g.line_start
    g.sb = strings.new_builder(64)
    // Emit mid-statement (no leading indent), matching the direct return path.
    g.line_start = false
    g.gen_fixed_array_copy_source(value_id, field_type)
    result := g.sb.str()
    g.sb = orig
    g.line_start = orig_line_start
    return result
}

// expr_to_string_with_expected_type converts expr to string with expected type data for c.
fn (mut g FlatGen) expr_to_string_with_expected_type(id flat.NodeId, expected types.Type) string {
    orig := g.sb
    orig_line_start := g.line_start
    g.sb = strings.new_builder(64)
    g.line_start = true
    g.gen_expr_with_expected_type(id, expected)
    result := g.sb.str()
    g.sb = orig
    g.line_start = orig_line_start
    return result
}

fn (mut g FlatGen) gen_amp_c_string_literal(id flat.NodeId, node flat.Node) bool {
    if node.kind == .char_literal && node.value.starts_with('c:') {
        g.gen_expr(id)
        return true
    }
    if node.kind != .char_literal && node.kind != .string_literal {
        return false
    }
    expr := g.expr_to_string(id)
    if expr.len >= 2 && expr[0] == `"` && expr[expr.len - 1] == `"` {
        g.write(expr)
        return true
    }
    return false
}

fn (mut g FlatGen) gen_expr_as_string(id flat.NodeId) {
    typ := g.usable_expr_type(id)
    if g.gen_map_str_expr(id, typ) {
        return
    }
    g.gen_expr(id)
}

fn (mut g FlatGen) gen_map_str_expr(id flat.NodeId, typ types.Type) bool {
    clean := map_str_clean_type(typ)
    if clean !is types.Map {
        return false
    }
    node := g.a.nodes[int(id)]
    if node.kind == .map_init && typ !is types.Pointer {
        tmp := '__map_str_tmp_${g.tmp_count}'
        g.tmp_count++
        g.write('({ map ${tmp} = ')
        g.gen_expr_with_expected_type(id, clean)
        g.write(';')
        key_kind := map_str_kind(g.tc, clean.key_type)
        val_kind := map_str_kind(g.tc, clean.value_type)
        fixed_len := map_str_fixed_len(clean.value_type)
        g.write(' v3_map_str(${tmp}, ${key_kind}, ${val_kind}, ${fixed_len}); })')
        return true
    }
    g.write('v3_map_str(')
    if typ is types.Pointer {
        needs_paren := g.a.nodes[int(id)].kind !in [.ident, .selector, .call]
        g.write('*')
        if needs_paren {
            g.write('(')
        }
        g.gen_expr(id)
        if needs_paren {
            g.write(')')
        }
    } else {
        g.gen_expr(id)
    }
    key_kind := map_str_kind(g.tc, clean.key_type)
    val_kind := map_str_kind(g.tc, clean.value_type)
    fixed_len := map_str_fixed_len(clean.value_type)
    g.write(', ${key_kind}, ${val_kind}, ${fixed_len})')
    return true
}

fn map_str_clean_type(typ types.Type) types.Type {
    clean := types.unwrap_pointer(typ)
    if clean is types.Alias {
        return clean.base_type
    }
    return clean
}

fn map_str_kind(tc &types.TypeChecker, typ types.Type) int {
    clean := if typ is types.Alias { typ.base_type } else { typ }
    if clean is types.String {
        return 1
    }
    if clean is types.Rune {
        return 4
    }
    if clean is types.ISize || clean is types.Char {
        return 2
    }
    if clean is types.USize {
        return 3
    }
    if clean is types.Primitive {
        if clean.props.has(.float) {
            return if tc.c_type(types.Type(clean)) == 'float' { 8 } else { 5 }
        }
        name := types.Type(clean).name()
        if name in ['i8', 'i16', 'i32', 'i64', 'int'] {
            return 2
        }
        if name in ['u8', 'byte'] {
            return 3
        }
        if name in ['u16', 'u32', 'u64'] {
            return 3
        }
        if name == 'bool' {
            return 7
        }
    }
    if fixed := array_fixed_type(clean) {
        elem := if fixed.elem_type is types.Alias {
            fixed.elem_type.base_type
        } else {
            fixed.elem_type
        }
        if elem is types.Primitive && elem.props.has(.float) {
            return if tc.c_type(types.Type(elem)) == 'float' { 9 } else { 6 }
        }
    }
    return 0
}

fn map_str_fixed_len(typ types.Type) int {
    if fixed := array_fixed_type(typ) {
        if fixed.len > 0 {
            return fixed.len
        }
        if fixed.len_expr.len > 0 && fixed.len_expr.int().str() == fixed.len_expr {
            return fixed.len_expr.int()
        }
    }
    return 0
}

// gen_cast_from_mut_param_address emits pointer casts for `¶m` where `param`
// is a mutable V parameter already represented as a C pointer.
fn (mut g FlatGen) gen_cast_from_mut_param_address(id flat.NodeId, ct string) bool {
    node := g.a.nodes[int(id)]
    if node.kind != .prefix || node.op != .amp || node.children_count != 1 {
        return false
    }
    child_id := g.a.child(&node, 0)
    child := g.a.nodes[int(child_id)]
    if child.kind != .ident || !g.current_param_is_mut(child.value) {
        return false
    }
    param_type := g.current_param_type(child.value) or { return false }
    if param_type !is types.Pointer {
        return false
    }
    g.write('(${ct})(')
    g.gen_expr(child_id)
    g.write(')')
    return true
}

// gen_expr_with_expected_type emits expr with expected type output for c.
fn (mut g FlatGen) gen_expr_with_expected_type(id flat.NodeId, expected types.Type) {
    old_expected := g.expected_expr_type
    old_expected_enum := g.expected_enum
    g.expected_expr_type = expected
    if expected is types.Enum {
        g.expected_enum = expected.name
    }
    node := g.a.nodes[int(id)]
    if node.kind == .dump_expr {
        if node.children_count > 0 {
            g.gen_expr_with_expected_type(g.a.child(&node, 0), expected)
        } else {
            g.write('0')
        }
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    mut actual := g.usable_expr_type(id)
    if node.kind == .ident {
        if param_type := g.current_param_type(node.value) {
            actual = param_type
        }
    }
    if expected is types.String && g.gen_map_str_expr(id, actual) {
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    if _ := fn_type_from(expected) {
        if g.gen_callback_fn_value_for_expected_type(id, expected) {
            g.expected_expr_type = old_expected
            g.expected_enum = old_expected_enum
            return
        }
        if call_name := g.callback_direct_fn_value_name(id, expected) {
            g.write(g.callback_c_fn_name(call_name))
            g.expected_expr_type = old_expected
            g.expected_enum = old_expected_enum
            return
        }
    }
    if expected is types.Array && node.kind == .array_literal {
        g.gen_array_literal_value(node, expected.elem_type)
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    if expected !is types.Pointer && expected !is types.Void && expected !is types.OptionType
        && expected !is types.ResultType && actual is types.Pointer
        && g.type_names_match(actual.base_type, expected) {
        needs_paren := node.kind !in [.ident, .selector, .call, .index]
        g.write('*')
        if needs_paren {
            g.write('(')
        }
        g.gen_expr(id)
        if needs_paren {
            g.write(')')
        }
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    if g.gen_interface_value_expr(id, expected) {
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    if g.gen_sum_value_expr(id, expected) {
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    g.gen_expr(id)
    g.expected_expr_type = old_expected
    g.expected_enum = old_expected_enum
}

// gen_sum_value_expr emits sum value expr output for c.
fn (mut g FlatGen) gen_sum_value_expr(id flat.NodeId, expected types.Type) bool {
    sum_type0 := if expected is types.Alias { expected.base_type } else { expected }
    if sum_type0 !is types.SumType {
        return false
    }
    sum_type := sum_type0 as types.SumType
    raw_actual0 := g.sum_cast_actual_type(id)
    raw_actual_type := if raw_actual0 is types.Alias { raw_actual0.base_type } else { raw_actual0 }
    if raw_actual_type is types.SumType {
        return false
    }
    if declared := g.selector_declared_type(id) {
        declared0 := if declared is types.Alias { declared.base_type } else { declared }
        if declared0 is types.SumType && g.type_names_match(declared0, sum_type0) {
            return false
        }
    }
    actual0 := raw_actual0
    actual_type := if actual0 is types.Alias { actual0.base_type } else { actual0 }
    if actual_type is types.SumType {
        return false
    }
    sum_name := g.resolve_sum_name(sum_type.name)
    variant := g.resolve_variant(sum_name, actual_type.name())
    variants := g.tc.sum_types[sum_name] or { return false }
    if variant !in variants {
        return false
    }
    ct := g.tc.c_type(sum_type0)
    idx := g.sum_type_index(sum_name, variant)
    field := g.sum_field_name(variant)
    if g.variant_references_sum(variant, sum_name) {
        inner_ct := g.tc.c_type(g.tc.parse_type(variant))
        g.write('(${ct}){.typ = ${idx}, .${field} = (${inner_ct}*)memdup((${inner_ct}[]){')
        g.gen_expr(id)
        g.write('}, sizeof(${inner_ct}))}')
        return true
    }
    g.write('(${ct}){.typ = ${idx}, .${field} = ')
    g.gen_expr(id)
    g.write('}')
    return true
}

fn (g &FlatGen) sum_cast_actual_type(id flat.NodeId) types.Type {
    mut actual_type := g.tc.resolve_type(id)
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return actual_type
    }
    node := g.a.nodes[int(id)]
    if node.kind == .ident {
        if param_type := g.current_param_type(node.value) {
            return param_type
        }
        if param_type := g.cur_param_types[node.value] {
            return param_type
        }
    }
    return actual_type
}

// gen_sum_cast_expr emits sum cast expr output for c.
fn (mut g FlatGen) gen_sum_cast_expr(target_type types.SumType, inner_id flat.NodeId) {
    inner := g.a.nodes[int(inner_id)]
    actual_type := g.sum_cast_actual_type(inner_id)
    actual_clean := types.unwrap_pointer(actual_type)
    variant_name0 := if inner.kind == .struct_init {
        inner.value
    } else {
        actual_clean.name()
    }
    variant_name := g.resolve_variant(target_type.name, variant_name0)
    idx := g.sum_type_index(target_type.name, variant_name)
    field := g.sum_field_name(variant_name)
    ct := g.tc.c_type(target_type)
    variant_type := g.tc.parse_type(variant_name)
    variant_is_pointer_arg := actual_type is types.Pointer
        && g.type_names_match(actual_type.base_type, variant_type)
    if g.variant_references_sum(variant_name, target_type.name) {
        inner_ct := g.tc.c_type(variant_type)
        if variant_is_pointer_arg {
            g.write('(${ct}){.typ = ${idx}, .${field} = ')
            if g.pointer_variant_arg_needs_heap_copy(inner) {
                g.write('(${inner_ct}*)memdup(')
                g.gen_expr(inner_id)
                g.write(', sizeof(${inner_ct}))')
            } else {
                g.gen_expr(inner_id)
            }
            g.write('}')
        } else if inner.kind == .struct_init
            && g.resolve_sum_name(inner.value) == g.resolve_sum_name(target_type.name) {
            g.write('(${ct}){')
            for si in 0 .. inner.children_count {
                sf := g.a.child_node(&inner, si)
                if si > 0 {
                    g.write(', ')
                }
                g.write('.${c_name(sf.value)} = ')
                g.gen_lowered_sum_field_value(target_type.name, sf)
            }
            g.write('}')
        } else if inner.kind == .struct_init {
            g.write('(${ct}){.typ = ${idx}, .${field} = (${inner_ct}*)memdup(&(${inner_ct}){')
            for si in 0 .. inner.children_count {
                sf := g.a.child_node(&inner, si)
                if si > 0 {
                    g.write(', ')
                }
                g.write('.${c_name(sf.value)} = ')
                g.gen_expr(g.a.child(sf, 0))
            }
            g.write('}, sizeof(${inner_ct}))}')
        } else {
            g.write('(${ct}){.typ = ${idx}, .${field} = (${inner_ct}*)memdup((${inner_ct}[]){')
            g.gen_expr(inner_id)
            g.write('}, sizeof(${inner_ct}))}')
        }
    } else {
        g.write('(${ct}){.typ = ${idx}, .${field} = ')
        if variant_is_pointer_arg {
            g.write('*')
        }
        g.gen_expr(inner_id)
        g.write('}')
    }
}

// pointer_variant_arg_needs_heap_copy supports pointer_variant_arg_needs_heap_copy handling in c.
fn (g &FlatGen) pointer_variant_arg_needs_heap_copy(node flat.Node) bool {
    if node.kind != .prefix || node.op != .amp || node.children_count == 0 {
        return false
    }
    child_id := g.a.child(&node, 0)
    child := g.a.nodes[int(child_id)]
    if child.kind != .ident {
        return false
    }
    if _ := g.current_param_type(child.value) {
        return true
    }
    if child.value in g.cur_param_types {
        return true
    }
    if _ := g.tc.cur_scope.lookup(child.value) {
        return true
    }
    return false
}

// selector_declared_type supports selector declared type handling for FlatGen.
fn (g &FlatGen) selector_declared_type(id flat.NodeId) ?types.Type {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return none
    }
    node := g.a.nodes[int(id)]
    if node.kind != .selector || node.children_count == 0 {
        return none
    }
    base_id := g.a.child(&node, 0)
    base_type0 := types.unwrap_pointer(g.tc.resolve_type(base_id))
    base_type := if base_type0 is types.Alias { base_type0.base_type } else { base_type0 }
    if base_type is types.Struct {
        return g.struct_field_type(base_type.name, node.value)
    }
    return none
}

fn (g &FlatGen) c_typedef_cast_call_name(node flat.Node) string {
    if node.kind != .call || node.children_count == 0 {
        return ''
    }
    callee := g.a.child_node(&node, 0)
    match callee.kind {
        .ident {
            if callee.value.contains('__') {
                return callee.value
            }
        }
        .selector {
            if callee.children_count > 0 {
                base := g.a.child_node(callee, 0)
                if base.kind == .ident && base.value == 'C' {
                    return callee.value
                }
            }
        }
        else {}
    }

    return ''
}

// gen_expr_with_possible_enum_type emits expr with possible enum type output for c.
fn (mut g FlatGen) gen_expr_with_possible_enum_type(id flat.NodeId, expected types.Type) {
    if expected is types.Enum {
        g.gen_expr_with_expected_type(id, expected)
        return
    }
    g.gen_expr(id)
}

fn (g &FlatGen) expected_expr_is_optional_struct() bool {
    if g.expected_expr_type is types.Struct {
        return g.expected_expr_type.name.starts_with('Optional')
    }
    return false
}

fn (mut g FlatGen) type_name_c_type(type_name string) string {
    if _ := g.tc.cur_scope.lookup(type_name) {
        return c_name(type_name)
    }
    if type_name.starts_with('fn_ptr:') {
        return g.resolve_fn_ptr_type(type_name)
    }
    t := g.tc.parse_type(type_name)
    return g.tc.c_type(t)
}

fn (mut g FlatGen) sizeof_target(value string) string {
    if value.starts_with('fn_ptr:') {
        return g.resolve_fn_ptr_type(value)
    }
    if fixed_target := c_fixed_array_typedef_sizeof_target(value) {
        return fixed_target
    }
    if value.contains('.') {
        parts := value.split('.')
        if parts.len > 1 {
            if g.cur_scope_has_local_name(parts[0]) {
                return sizeof_selector_target(parts[0], parts[1..])
            }
            if global := g.sizeof_global_selector_base(parts[0]) {
                return sizeof_selector_target(global, parts[1..])
            }
        }
    }
    if fixed := array_fixed_type(g.tc.parse_type(value)) {
        c_elem, dims := g.fixed_array_decl_parts(fixed)
        return '${c_elem}${dims}'
    }
    return g.type_name_c_type(value)
}

fn c_fixed_array_typedef_sizeof_target(value string) ?string {
    if !value.starts_with('Array_fixed_') {
        return none
    }
    payload := value['Array_fixed_'.len..]
    if !payload.contains('_') {
        return none
    }
    elem := payload.all_before_last('_')
    len := payload.all_after_last('_')
    if elem.len == 0 || len.len == 0 {
        return none
    }
    return '${elem}[${len}]'
}

fn sizeof_selector_target(base string, fields []string) string {
    mut expr := c_name(base)
    for field in fields {
        expr += '.${c_field_name(field)}'
    }
    return expr
}

fn (g &FlatGen) cur_scope_has_local_name(name string) bool {
    mut scope := g.tc.cur_scope
    for scope != unsafe { nil } && scope != g.tc.file_scope {
        for existing in scope.names {
            if existing == name {
                return true
            }
        }
        scope = scope.parent
    }
    return false
}

fn (g &FlatGen) sizeof_global_selector_base(name string) ?string {
    if name.len == 0 || name.contains('.') {
        return none
    }
    current_qname := qualify_name_in_module(g.tc.cur_module, name)
    if current_qname in g.global_types {
        return current_qname
    }
    if mod := g.global_modules[name] {
        if mod.len == 0 || mod == 'main' || mod == 'builtin' || mod == g.tc.cur_module {
            return if mod.len > 0 && mod != 'main' && mod != 'builtin' {
                '${mod}.${name}'
            } else {
                name
            }
        }
    }
    return none
}

// optional_none_type supports optional none type handling for FlatGen.
fn (mut g FlatGen) optional_none_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 typ := g.tc.expr_type(id) {
        if typ is types.OptionType || typ is types.ResultType {
            return typ
        }
    }
    if g.cur_fn_ret_is_optional {
        return g.cur_fn_ret
    }
    return types.Type(types.OptionType{
        base_type: types.Type(types.void_)
    })
}

// array_index_info supports array index info handling for c.
fn array_index_info(t types.Type) (bool, bool, types.Array) {
    if t is types.Array {
        return true, false, t
    }
    if t is types.Alias {
        base := t.base_type
        if base is types.Array {
            return true, false, base
        }
    }
    if t is types.Pointer {
        base := t.base_type
        if base is types.Array {
            return true, true, base
        }
        if base is types.Alias {
            alias_base := base.base_type
            if alias_base is types.Array {
                return true, true, alias_base
            }
        }
    }
    return false, false, types.Array{}
}

// valid_node_id supports valid node id handling for FlatGen.
fn (g &FlatGen) valid_node_id(id flat.NodeId) bool {
    return g.a != unsafe { nil } && int(id) >= 0 && int(id) < g.a.nodes.len
}

// const_storage_name supports const storage name handling for FlatGen.
fn (g &FlatGen) const_storage_name(module_name string, name string) string {
    if module_name.len > 0 && module_name != 'main' && module_name != 'builtin'
        && !name.contains('.') {
        return '${module_name}.${name}'
    }
    return name
}

// const_primary_name supports const primary name handling for FlatGen.
fn (g &FlatGen) const_primary_name(name string) string {
    mod := if name in g.const_modules { g.const_modules[name] } else { '' }
    qname := g.const_storage_name(mod, name)
    if qname != name && qname in g.const_vals {
        return qname
    }
    return name
}

// is_const_alias_name reports whether is const alias name applies in c.
fn (g &FlatGen) is_const_alias_name(name string) bool {
    return g.const_primary_name(name) != name
}

// const_ref_name supports const ref name handling for FlatGen.
fn (g &FlatGen) const_ref_name(name string) string {
    if !name.contains('.') && !name.contains('__') {
        cur_qname := g.const_storage_name(g.tc.cur_module, name)
        if cur_qname in g.const_vals {
            return cur_qname
        }
        if name in g.const_vals {
            mod := g.const_modules[name] or { '' }
            if mod.len == 0 || mod == g.tc.cur_module
                || (g.tc.cur_module in ['', 'main', 'builtin'] && mod in ['', 'main', 'builtin']) {
                return g.const_primary_name(name)
            }
        }
        return ''
    }
    if name in g.const_vals {
        return g.const_primary_name(name)
    }
    if name.contains('.') {
        if name in g.const_vals {
            return g.const_primary_name(name)
        }
    }
    sep := if name.contains('.') {
        '.'
    } else if name.contains('__') {
        '__'
    } else {
        return ''
    }
    short_name := name.all_after_last(sep)
    if short_name !in g.const_vals {
        return ''
    }
    resolved := g.const_primary_name(short_name)
    mod := if resolved in g.const_modules { g.const_modules[resolved] } else { '' }
    if mod.len == 0 {
        return resolved
    }
    ref_mod := name.all_before_last(sep)
    if ref_mod == mod || ref_mod == mod.all_after_last('.') {
        return resolved
    }
    return ''
}

// const_ref_name_from_node converts const ref name from node data for c.
fn (g &FlatGen) const_ref_name_from_node(node flat.Node) string {
    if node.kind == .ident {
        return g.const_ref_name(node.value)
    }
    if node.kind == .selector && node.children_count > 0 {
        base := g.a.child_node(&node, 0)
        if base.kind == .ident {
            return g.const_ref_name('${base.value}.${node.value}')
        }
    }
    return ''
}

// const_expr_to_string converts const expr to string data for c.
fn (mut g FlatGen) const_expr_to_string(id flat.NodeId, seen []string) string {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return '0'
    }
    node := g.a.nodes[int(id)]
    return match node.kind {
        .ident, .selector {
            const_name := g.const_ref_name_from_node(node)
            if const_name.len > 0 && const_name !in seen {
                mut next_seen := seen.clone()
                next_seen << const_name
                old_module := g.tc.cur_module
                if mod := g.const_modules[const_name] {
                    g.tc.cur_module = mod
                }
                dep_expr := g.const_expr_to_string(g.const_vals[const_name], next_seen)
                g.tc.cur_module = old_module
                if dep_expr.trim_space().len > 0 {
                    return dep_expr
                }
            }
            g.expr_to_string(id)
        }
        .infix {
            lhs := g.const_expr_to_string(g.a.child(&node, 0), seen)
            rhs := g.const_expr_to_string(g.a.child(&node, 1), seen)
            '(${lhs}) ${g.op_str(node.op)} (${rhs})'
        }
        .prefix {
            child := g.const_expr_to_string(g.a.child(&node, 0), seen)
            '${g.op_str(node.op)}(${child})'
        }
        .paren {
            child := g.const_expr_to_string(g.a.child(&node, 0), seen)
            '(${child})'
        }
        .cast_expr {
            target_type := g.tc.parse_type(node.value)
            mut ct := g.tc.c_type(target_type)
            if ct.starts_with('fn_ptr:') {
                ct = g.resolve_fn_ptr_type(ct)
            }
            if node.value in g.interfaces || g.tc.qualify_name(node.value) in g.interfaces {
                return '(${ct}){0}'
            }
            if target_type is types.SumType {
                inner_id := g.a.child(&node, 0)
                inner := g.a.nodes[int(inner_id)]
                variant_name0 := if inner.kind == .struct_init {
                    inner.value
                } else {
                    g.tc.resolve_type(inner_id).name()
                }
                variant_name := g.resolve_variant(target_type.name, variant_name0)
                idx := g.sum_type_index(target_type.name, variant_name)
                field := g.sum_field_name(variant_name)
                inner_val := g.const_expr_to_string(inner_id, seen)
                inner_ct := g.tc.c_type(g.tc.parse_type(variant_name))
                payload := if inner_val.trim_space().len == 0 { '0' } else { inner_val }
                return '(${ct}){.typ = ${idx}, .${field} = (${inner_ct}[]){${payload}}}'
            }
            if target_type !is types.Primitive && target_type !is types.Char
                && target_type !is types.Rune && target_type !is types.ISize
                && target_type !is types.USize && target_type !is types.Pointer
                && target_type !is types.Enum {
                return g.expr_to_string(id)
            }
            child0 := g.const_expr_to_string(g.a.child(&node, 0), seen)
            child := if child0.trim_space().len == 0 { '0' } else { child0 }
            '(${ct})(${child})'
        }
        .array_literal {
            mut parts := []string{}
            for i in 0 .. node.children_count {
                parts << g.const_expr_to_string(g.a.child(&node, i), seen)
            }
            '{${parts.join(', ')}}'
        }
        .struct_init {
            ct := g.struct_init_c_type_name(node.value)
            sum_name := g.resolve_sum_name(node.value)
            is_sum_literal := sum_name in g.tc.sum_types
            mut parts := []string{}
            for i in 0 .. node.children_count {
                field := g.a.child_node(&node, i)
                if field.kind == .field_init && field.children_count > 0 {
                    val_id := g.a.child(field, 0)
                    val_node := g.a.nodes[int(val_id)]
                    val := if field.value.len == 0 {
                        const_val := g.const_expr_to_string(val_id, seen)
                        if const_val.trim_space().len > 0 {
                            const_val
                        } else {
                            if ftyp := g.struct_field_type_at(node.value, i) {
                                g.expr_to_string_with_expected_type(val_id, ftyp)
                            } else {
                                g.expr_to_string(val_id)
                            }
                        }
                    } else if is_sum_literal && field.value != 'typ' {
                        mut variant := ''
                        if field.typ.starts_with('&') {
                            variant = field.typ[1..]
                        } else if field.typ.len > 0 {
                            variant = field.typ
                        } else {
                            for v in g.tc.sum_types[sum_name] {
                                if g.sum_field_name(v) == field.value {
                                    variant = v
                                    break
                                }
                            }
                        }
                        variant = g.resolve_variant(sum_name, variant)
                        inner_ct := g.tc.c_type(g.tc.parse_type(variant))
                        const_val := g.const_expr_to_string(val_id, seen)
                        payload := if const_val.trim_space().len > 0 {
                            const_val
                        } else {
                            g.expr_to_string_with_expected_type(val_id, g.tc.parse_type(variant))
                        }
                        '(${inner_ct}[]){${payload}}'
                    } else if ftyp := g.struct_field_type(node.value, field.value) {
                        if val_node.kind == .enum_val {
                            g.expr_to_string_with_expected_type(val_id, ftyp)
                        } else {
                            const_val := g.const_expr_to_string(val_id, seen)
                            if const_val.trim_space().len > 0 {
                                const_val
                            } else {
                                g.expr_to_string_with_expected_type(val_id, ftyp)
                            }
                        }
                    } else {
                        const_val := g.const_expr_to_string(val_id, seen)
                        if const_val.trim_space().len > 0 {
                            const_val
                        } else {
                            g.expr_to_string(val_id)
                        }
                    }
                    if field.value.len == 0 {
                        parts << val
                    } else {
                        parts << '.${c_name(field.value)} = ${val}'
                    }
                } else {
                    parts << g.const_expr_to_string(g.a.child(&node, i), seen)
                }
            }
            '(${ct}){${parts.join(', ')}}'
        }
        .string_literal {
            '{"${c_escape(node.value)}", ${node.value.len}, 1}'
        }
        .int_literal, .float_literal, .bool_literal, .char_literal, .enum_val, .sizeof_expr {
            g.expr_to_string(id)
        }
        .offsetof_expr {
            ct := g.sizeof_target(node.value)
            'offsetof(${ct}, ${c_name(node.typ)})'
        }
        else {
            g.expr_to_string(id)
        }
    }
}

// const_ident_c_name converts const ident c name data for c.
fn (g &FlatGen) const_ident_c_name(name string) string {
    if name.contains('.') {
        return c_name(name)
    }
    mod := if name in g.const_modules { g.const_modules[name] } else { '' }
    if mod.len > 0 && mod != 'main' && mod != 'builtin' {
        return c_name('${mod}.${name}')
    }
    if (mod == '' || mod == 'main') && name in g.const_modules {
        return c_name('main.${name}')
    }
    return c_name(name)
}

// fixed_array_len_expr supports fixed array len expr handling for FlatGen.
fn (mut g FlatGen) fixed_array_len_expr(type_name string, fallback int) string {
    if type_name.len > 0 {
        typ := g.tc.parse_type(type_name)
        if typ is types.ArrayFixed {
            return g.fixed_array_len_value(typ)
        }
    }
    mut raw_len := ''
    if type_name.starts_with('[') {
        idx := type_name.index_u8(`]`)
        if idx > 1 {
            raw_len = type_name[1..idx]
        }
    } else if type_name.contains('[') && type_name.ends_with(']') {
        idx := type_name.index_u8(`[`)
        if idx >= 0 && idx < type_name.len - 1 {
            raw_len = type_name[idx + 1..type_name.len - 1]
        }
    }
    return g.fixed_array_len_raw(raw_len, fallback)
}

// fixed_array_len_value supports fixed array len value handling for FlatGen.
fn (mut g FlatGen) fixed_array_len_value(arr types.ArrayFixed) string {
    // Prefer the evaluated integer length: a const-expression size (`[segs + 1]f32`)
    // otherwise reaches the raw fallback and is c_name-mangled into garbage.
    if v := g.tc.fixed_array_len_value(arr) {
        return v.str()
    }
    return g.fixed_array_len_raw(arr.len_expr, arr.len)
}

// fixed_array_len_is_zero supports fixed array len is zero handling for FlatGen.
fn (mut g FlatGen) fixed_array_len_is_zero(arr types.ArrayFixed) bool {
    if value := g.tc.fixed_array_len_value(arr) {
        return value == 0
    }
    return g.fixed_array_len_value(arr).trim_space() == '0'
}

// fixed_array_len_raw supports fixed array len raw handling for FlatGen.
fn (mut g FlatGen) fixed_array_len_raw(raw_len string, fallback int) string {
    if raw_len.len == 0 {
        return '${fallback}'
    }
    // A literal or const-expression size (`8`, `SEGS + 1`, `1 << 2`, `8 >>> 1`) folds to an
    // integer; emit that literal so the C dimension is always valid — `>>>` has no C form,
    // so a digit-leading expression like `8 >>> 1` must not be passed through raw — and a
    // non-numeric expr isn't c_name-mangled (`SEGS_+_1`) into an undeclared identifier.
    if v := g.tc.const_int_value(raw_len, []string{}) {
        return v.str()
    }
    clean_len := raw_len.replace('_', '')
    if clean_len.len > 0 && clean_len[0] >= `0` && clean_len[0] <= `9` {
        return clean_len
    }
    const_name := g.const_ref_name(raw_len)
    if const_name.len > 0 {
        expr := g.const_expr_to_string(g.const_vals[const_name], []string{})
        if expr.trim_space().len > 0 {
            return expr
        }
        return g.const_ident_c_name(const_name)
    }
    return c_name(raw_len)
}

fn (mut g FlatGen) fixed_array_decl_parts(arr types.ArrayFixed) (string, string) {
    len_expr := g.fixed_array_len_value(arr)
    if arr.elem_type is types.ArrayFixed {
        base_ct, suffix := g.fixed_array_decl_parts(arr.elem_type)
        return base_ct, '[${len_expr}]${suffix}'
    }
    return g.tc.c_type(arr.elem_type), '[${len_expr}]'
}

// infix_can_skip_child_parens reports whether a child infix operand needs no
// surrounding parentheses. For associative logical chains (`||`, `&&`) a child of
// the same operator is safe unparenthesised; this keeps long lowered chains (e.g.
// a `match` over hundreds of enum values → `a || b || c || ...`) from nesting
// parentheses past the C compiler's bracket-depth limit.
fn infix_can_skip_child_parens(parent_op flat.Op, child_op flat.Op) bool {
    return (parent_op == .logical_or && child_op == .logical_or)
        || (parent_op == .logical_and && child_op == .logical_and)
}

// assoc_infix_chain_len counts how many same-operator infix nodes hang off the left
// spine of `node` (its nesting depth). Capped early since only "very deep" matters.
fn (g &FlatGen) assoc_infix_chain_len(node flat.Node) int {
    op := node.op
    mut cur := node
    mut depth := 0
    for {
        if cur.children_count < 1 {
            break
        }
        lhs_id := g.a.child(&cur, 0)
        if !g.valid_node_id(lhs_id) {
            break
        }
        lhs := g.a.nodes[int(lhs_id)]
        if lhs.kind == .infix && lhs.op == op {
            depth++
            if depth > 101 {
                break
            }
            cur = lhs
        } else {
            break
        }
    }
    return depth
}

// gen_assoc_infix_chain emits a left-nested `||`/`&&` chain iteratively, producing the
// same flat `a || b || c …` C as the recursive path but without growing the stack per
// link (a big match's condition chain can be hundreds deep).
fn (mut g FlatGen) gen_assoc_infix_chain(node flat.Node) {
    op := node.op
    op_s := g.op_str(op)
    mut operands := []flat.NodeId{cap: 256}
    mut cur := node
    for {
        operands << g.a.child(&cur, 1)
        lhs_id := g.a.child(&cur, 0)
        lhs := g.a.nodes[int(lhs_id)]
        if lhs.kind == .infix && lhs.op == op && g.valid_node_id(g.a.child(&lhs, 0)) {
            cur = lhs
        } else {
            operands << lhs_id
            break
        }
    }
    for i := operands.len - 1; i >= 0; i-- {
        if i != operands.len - 1 {
            g.write(' ${op_s} ')
        }
        oid := operands[i]
        onode := g.a.nodes[int(oid)]
        if onode.kind == .infix && !infix_can_skip_child_parens(op, onode.op) {
            g.write('(')
            g.gen_expr(oid)
            g.write(')')
        } else {
            g.gen_expr(oid)
        }
    }
}

// gen_expr emits expr output for c.
fn (mut g FlatGen) gen_expr(id flat.NodeId) {
    if int(id) < 0 {
        g.write('0')
        return
    }
    node := g.a.nodes[int(id)]
    match node.kind {
        .int_literal {
            v := node.value.replace('_', '')
            if v.starts_with('0o') {
                g.write('0${v[2..]}')
            } else {
                g.write(v)
            }
        }
        .float_literal {
            g.write(node.value.replace('_', ''))
        }
        .bool_literal {
            g.write(node.value)
        }
        .char_literal {
            v := node.value
            if v.starts_with('c:') {
                cv := v[2..]
                g.write('"${cv}"')
            } else if v.len == 0 {
                g.write("' '")
            } else if v.len == 1 {
                if v[0] == `\\` {
                    g.write("'\\\\'")
                } else if v[0] == `'` {
                    g.write("'\\''")
                } else {
                    g.write("'${v}'")
                }
            } else if v.starts_with('\\') {
                g.write("'${v}'")
            } else {
                runes := v.runes()
                if runes.len == 0 {
                    g.write('0')
                } else {
                    g.write(int(runes[0]).str())
                }
            }
        }
        .string_literal {
            sid := g.intern_string(node.value)
            g.write('_str_${sid}')
        }
        .string_interp {
            g.gen_string_interp(node)
        }
        .dump_expr {
            if node.children_count > 0 {
                g.gen_expr(g.a.child(&node, 0))
            } else {
                g.write('0')
            }
        }
        .ident {
            if c_fn_name := g.test_user_main_fn_value_c_name(id, node) {
                g.write(c_fn_name)
                return
            }
            looked_up := g.tc.cur_scope.lookup(node.value) or { types.Type(types.void_) }
            is_local := looked_up !is types.Void
            const_name := if !is_local { g.const_ref_name(node.value) } else { '' }
            if const_name.len > 0 {
                g.write(g.const_ident_c_name(const_name))
            } else if node.value in g.global_modules {
                mod := g.global_modules[node.value]
                if mod.len > 0 && mod != 'main' && mod != 'builtin' {
                    g.write(c_name('${mod}.${node.value}'))
                } else {
                    g.write(c_name(node.value))
                }
            } else {
                g.write(c_name(node.value))
            }
        }
        .enum_val {
            if node.value in g.enum_vals {
                eval := g.enum_vals[node.value]
                g.write('${eval}')
                return
            }
            if node.typ.len > 0 {
                short_name := node.value.trim_left('.').all_after_last('.')
                if eval := g.enum_value_for_type(node.typ, short_name) {
                    g.write('${eval}')
                    return
                }
            }
            if g.expected_enum.len > 0 {
                ekey := '${g.expected_enum}.${node.value}'
                if ekey in g.enum_vals {
                    eval := g.enum_vals[ekey]
                    g.write('${eval}')
                    return
                }
                if !g.expected_enum.contains('.') && g.tc.cur_module.len > 0
                    && g.tc.cur_module != 'main' && g.tc.cur_module != 'builtin' {
                    qkey := '${g.tc.cur_module}.${g.expected_enum}.${node.value}'
                    if qkey in g.enum_vals {
                        eval := g.enum_vals[qkey]
                        g.write('${eval}')
                        return
                    }
                }
            }
            for ename, eval in g.enum_vals {
                if ename.ends_with('.${node.value}') {
                    g.write('${eval}')
                    return
                }
            }
            g.write('0')
        }
        .call {
            // A call to a fixed-array-returning function yields the wrapper struct;
            // unwrap `.ret_arr` so the result behaves as the array value everywhere
            // (indexing, arg passing, memcpy into a destination).
            ret_t := g.declared_call_return_type(id)
            if ret_t is types.ArrayFixed && g.tc.c_type(ret_t) in g.fixed_array_ret_wrappers {
                g.write('(')
                g.gen_call(id, node)
                g.write(').ret_arr')
            } else {
                g.gen_call(id, node)
            }
        }
        .spawn_expr {
            g.gen_spawn_expr(node)
        }
        .infix {
            // A very long left-nested `||`/`&&` chain (e.g. from a big match condition or
            // a `!in [...]` over many values) would recurse once per link and overflow the
            // stack; emit those iteratively. Only pathologically long chains take this path,
            // so ordinary code keeps the existing per-node generation unchanged.
            if (node.op == .logical_or || node.op == .logical_and)
                && g.assoc_infix_chain_len(node) > 100 {
                g.gen_assoc_infix_chain(node)
                return
            }
            lhs_id := g.a.child(&node, 0)
            rhs_id := g.a.child(&node, 1)
            old_expected_enum := g.expected_enum
            lhs_type := g.usable_expr_type(lhs_id)
            rhs_type := g.usable_expr_type(rhs_id)
            if node.op == .arrow && lhs_type is types.Channel {
                elem_ct := g.tc.c_type(lhs_type.elem_type)
                g.write('sync__Channel__push(')
                g.gen_expr(lhs_id)
                g.write(', &(${elem_ct}[]){')
                g.gen_expr_with_expected_type(rhs_id, lhs_type.elem_type)
                g.write('})')
                g.expected_enum = old_expected_enum
                return
            }
            if g.gen_array_infix_eq(node, lhs_id, rhs_id, lhs_type, rhs_type) {
                g.expected_enum = old_expected_enum
                return
            }
            if lhs_type is types.String || rhs_type is types.String {
                if g.gen_string_infix_fallback(node, lhs_id, rhs_id) {
                    g.expected_enum = old_expected_enum
                    return
                }
            }
            if lhs_type is types.Enum {
                g.expected_enum = lhs_type.name
            } else if rhs_type is types.Enum {
                g.expected_enum = rhs_type.name
            }
            if lhs_type is types.Struct {
                op_name := match node.op {
                    .minus { '__minus' }
                    .plus { '__plus' }
                    .eq { '__eq' }
                    .ne { '__ne' }
                    .lt { '__lt' }
                    .gt { '__gt' }
                    .le { '__le' }
                    .ge { '__ge' }
                    else { '' }
                }

                if op_name.len > 0 {
                    method_name := '${lhs_type.name}${op_name}'
                    if method_name in g.tc.fn_param_types {
                        panic('internal error: struct operator overload reached C backend after transform: ${lhs_type.name} op=${node.op}')
                    }
                }
                g.gen_expr(lhs_id)
                g.write(' ${g.op_str(node.op)} ')
                g.gen_expr_with_possible_enum_type(rhs_id, lhs_type)
            } else {
                lhs_node := g.a.nodes[int(lhs_id)]
                rhs_node := g.a.nodes[int(rhs_id)]
                if lhs_node.kind == .infix && !infix_can_skip_child_parens(node.op, lhs_node.op) {
                    g.write('(')
                    g.gen_expr_with_possible_enum_type(lhs_id, rhs_type)
                    g.write(')')
                } else {
                    g.gen_expr_with_possible_enum_type(lhs_id, rhs_type)
                }
                g.write(' ${g.op_str(node.op)} ')
                if rhs_node.kind == .infix && !infix_can_skip_child_parens(node.op, rhs_node.op) {
                    g.write('(')
                    g.gen_expr_with_possible_enum_type(rhs_id, lhs_type)
                    g.write(')')
                } else {
                    g.gen_expr_with_possible_enum_type(rhs_id, lhs_type)
                }
            }
            g.expected_enum = old_expected_enum
        }
        .prefix {
            child_id := g.a.child(&node, 0)
            child := g.a.nodes[int(child_id)]
            if node.op == .arrow {
                child_type := g.usable_expr_type(child_id)
                if child_type is types.Channel {
                    elem_ct := g.tc.c_type(child_type.elem_type)
                    tmp := g.tmp_name()
                    g.write('({${elem_ct} ${tmp} = (${elem_ct}){0}; sync__Channel__pop(')
                    g.gen_expr(child_id)
                    g.write(', &${tmp}); ${tmp};})')
                    return
                }
            }
            if node.op == .mul && child.kind == .ident {
                if typ := g.current_param_type(child.value) {
                    if typ !is types.Pointer {
                        g.gen_expr(child_id)
                        return
                    }
                } else if typ := g.cur_param_types[child.value] {
                    if typ !is types.Pointer {
                        g.gen_expr(child_id)
                        return
                    }
                }
            }
            if node.op == .amp && g.gen_amp_c_string_literal(child_id, child) {
                return
            } else if node.op == .amp && child.kind == .struct_init {
                g.gen_heap_struct_init(child)
            } else if node.op == .amp && child.kind == .assoc {
                g.gen_heap_assoc_expr(child)
            } else if node.op == .amp && child.kind == .cast_expr {
                target_type := g.tc.parse_type(child.value)
                ct := g.cast_c_type(target_type)
                cast_arg := g.a.child_node(&child, 0)
                if cast_arg.kind == .nil_literal {
                    g.write('(${ct}*)NULL')
                    return
                }
                if target_type is types.SumType {
                    g.write('(${ct}*)memdup(&')
                    g.gen_sum_cast_expr(target_type, g.a.child(&child, 0))
                    g.write(', sizeof(${ct}))')
                    return
                }
                g.write('(${ct}*)(')
                g.gen_expr(g.a.child(&child, 0))
                g.write(')')
            } else if node.op == .amp && child.kind == .call {
                fn_child := g.a.child_node(&child, 0)
                if fn_child.kind == .selector {
                    base_child := g.a.child_node(fn_child, 0)
                    if base_child.kind == .ident && base_child.value == 'C' {
                        c_struct_prefix := if fn_child.value.len > 0 && fn_child.value[0] >= `a`
                            && fn_child.value[0] <= `z` && !fn_child.value.ends_with('_t') {
                            'struct '
                        } else {
                            ''
                        }
                        g.write('(${c_struct_prefix}${fn_child.value}*)(')
                        if child.children_count > 1 {
                            g.gen_expr(g.a.child(&child, 1))
                        } else {
                            g.write('0')
                        }
                        g.write(')')
                    } else {
                        g.write(g.op_str(node.op))
                        g.gen_expr(child_id)
                    }
                } else {
                    g.write(g.op_str(node.op))
                    g.gen_expr(child_id)
                }
            } else {
                g.write(g.op_str(node.op))
                g.gen_expr(child_id)
            }
        }
        .in_expr {
            // NOTE: range membership, inline-array-literal membership, dynamic- and
            // fixed-array membership, and `!in` negation are lowered by the
            // transformer (transform.transform_in_expr). Map membership stays as an
            // in_expr so each backend can lower it directly.
            lhs_id := g.a.child(&node, 0)
            rhs_id := g.a.child(&node, 1)
            rhs := g.a.nodes[int(rhs_id)]
            rhs_type := g.usable_expr_type(rhs_id)
            clean_rhs := types.unwrap_pointer(rhs_type)
            if clean_rhs is types.Map {
                c_key := g.tc.c_type(clean_rhs.key_type)
                is_ptr := rhs_type is types.Pointer
                if is_ptr {
                    g.write('map__exists(')
                } else {
                    g.write('map__exists(&')
                }
                g.gen_expr(rhs_id)
                g.write(', &(${c_key}[]){')
                g.gen_expr(lhs_id)
                g.write('})')
            } else if rhs.kind == .array_literal {
                if rhs.children_count == 0 {
                    g.write('false')
                } else {
                    lhs_type := g.usable_expr_type(lhs_id)
                    g.write('(')
                    for i in 0 .. rhs.children_count {
                        if i > 0 {
                            g.write(' || ')
                        }
                        elem_id := g.a.child(&rhs, i)
                        elem_type := g.usable_expr_type(elem_id)
                        if lhs_type is types.String || elem_type is types.String {
                            g.write('string__eq(')
                            g.gen_expr(lhs_id)
                            g.write(', ')
                            g.gen_expr(elem_id)
                            g.write(')')
                        } else {
                            g.gen_expr(lhs_id)
                            g.write(' == ')
                            g.gen_expr(elem_id)
                        }
                    }
                    g.write(')')
                }
            } else if clean_rhs is types.Array {
                fn_name := array_membership_fn_name(clean_rhs.elem_type, false)
                g.write('${fn_name}(')
                // A `mut []T` param (or any `&[]T`) is a pointer in C; the membership
                // helper takes the array by value, so dereference it first.
                if rhs_type is types.Pointer {
                    g.write('*')
                }
                g.gen_expr(rhs_id)
                g.write(', ')
                g.gen_expr(lhs_id)
                g.write(')')
            } else if clean_rhs is types.ArrayFixed {
                fn_name := array_membership_fn_name(clean_rhs.elem_type, true)
                len_expr := g.fixed_array_len_value(clean_rhs)
                g.write('${fn_name}(')
                g.gen_expr(rhs_id)
                g.write(', ${len_expr}, ')
                g.gen_expr(lhs_id)
                g.write(')')
            } else if clean_rhs is types.Struct && clean_rhs.name == 'array' {
                lhs_type := g.usable_expr_type(lhs_id)
                fn_name := array_membership_fn_name(lhs_type, false)
                g.write('${fn_name}(')
                g.gen_expr(rhs_id)
                g.write(', ')
                g.gen_expr(lhs_id)
                g.write(')')
            } else {
                panic('internal error: non-map membership reached C backend in ${g.cur_fn_name}: rhs=${rhs_type.name()} kind=${rhs.kind} value=${rhs.value}')
            }
        }
        .postfix {
            g.gen_expr(g.a.child(&node, 0))
            g.write(g.op_str(node.op))
        }
        .paren {
            g.write('(')
            g.gen_expr(g.a.child(&node, 0))
            g.write(')')
        }
        .selector {
            base_id := g.a.child(&node, 0)
            base := g.a.nodes[int(base_id)]
            base_type0 := g.tc.resolve_type(base_id)
            if base_type0 is types.Channel && node.value in ['closed', 'len'] {
                if node.value == 'closed' {
                    g.write('(atomic_load_u16(&')
                    g.gen_expr(base_id)
                    g.write('->closed) != 0)')
                } else {
                    g.write('sync__Channel__len(')
                    g.gen_expr(base_id)
                    g.write(')')
                }
                return
            }
            base_is_local := if base.kind == .ident {
                (g.tc.cur_scope.lookup(base.value) or { types.Type(types.void_) }) !is types.Void
            } else {
                false
            }
            // A method used as a value (e.g. `game.draw` passed as a callback) rather
            // than a field access — bind the receiver and yield a wrapper function.
            if g.gen_method_value_closure(base_id, base_type0, node.value) {
                return
            }
            enum_selector_qbase := if base.kind == .ident && base.value != 'C' && !base_is_local {
                g.enum_selector_base_name(base.value) or { '' }
            } else {
                ''
            }
            if base.kind == .ident && base.value == 'C' {
                g.write(c_winapi_wide_export_name(node.value))
            } else if enum_selector_qbase.len > 0 {
                ekey := '${enum_selector_qbase}.${node.value}'
                if eval := g.enum_vals[ekey] {
                    g.write('${eval}')
                } else {
                    g.write('0')
                }
            } else if base_type0 is types.String && node.value == 'len' {
                g.gen_expr(base_id)
                g.write('.len')
            } else if types.unwrap_pointer(base_type0) is types.Array && node.value == 'len' {
                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_type0 is types.Pointer {
                    g.write('->len')
                } else {
                    g.write('.len')
                }
            } else if base.kind == .call && base.children_count == 2
                && g.c_typedef_cast_call_name(base).len > 0 {
                cast_name := g.c_typedef_cast_call_name(base)
                cast_arg_id := g.a.child(&base, 1)
                g.write('((${c_name(cast_name)}*)')
                g.gen_expr(cast_arg_id)
                g.write(')->${c_name(node.value)}')
            } else if base.kind == .cast_expr && base.children_count > 0
                && (base.value.starts_with('C.') || base.value.contains('__')) {
                cast_child_id := g.a.child(&base, 0)
                cast_name := if base.value.starts_with('C.') { base.value[2..] } else { base.value }
                g.write('((${c_name(cast_name)}*)')
                g.gen_expr(cast_child_id)
                g.write(')->${c_name(node.value)}')
            } else if base.kind == .cast_expr && base.children_count > 0 {
                needs_paren := base.kind !in [.ident, .selector]
                if needs_paren {
                    g.write('(')
                }
                g.gen_expr(base_id)
                if needs_paren {
                    g.write(')')
                }
                if node.op == .arrow || base_type0 is types.Pointer {
                    g.write('->')
                } else {
                    g.write('.')
                }
                g.write(c_name(node.value))
            } else if node.value == 'len' && base.kind == .ident {
                base_type := g.tc.resolve_type(base_id)
                if base_type is types.ArrayFixed {
                    g.write(g.fixed_array_len_value(base_type))
                } else {
                    raw_type := g.tc.cur_scope.lookup(base.value) or { base_type }
                    g.gen_expr(base_id)
                    if raw_type is types.Pointer {
                        g.write('->len')
                    } else {
                        g.write('.len')
                    }
                }
            } else if base.kind == .ident && !base_is_local && g.has_import_alias(base.value) {
                mod := g.import_alias_module(base.value) or { '' }
                short_mod := if mod.contains('.') {
                    mod.all_after_last('.')
                } else {
                    mod
                }
                // A module-level const is stored under the importing module's full path
                // (e.g. `v3.gen.wasm`), matching its function naming. Reference it by that
                // exact storage name rather than the short alias, otherwise we'd emit an
                // undeclared `wasm__x` for a const defined as `v3__gen__wasm__x`.
                full_qname := g.const_storage_name(mod, node.value)
                if full_qname in g.const_vals {
                    g.write(c_name(full_qname))
                } else {
                    g.write(c_name('${short_mod}.${node.value}'))
                }
            } else if base.kind == .selector && base.children_count > 0
                && g.is_module_qualified_enum(base) {
                inner_base := g.a.child_node(&base, 0)
                mod := g.import_alias_module(inner_base.value) or { inner_base.value }
                short_mod := if mod.contains('.') {
                    mod.all_after_last('.')
                } else {
                    mod
                }
                qname := '${short_mod}.${base.value}'
                if qname in g.tc.enum_names || base.value in g.tc.enum_names {
                    ekey := '${qname}.${node.value}'
                    ekey2 := '${base.value}.${node.value}'
                    if ekey in g.enum_vals {
                        eval := g.enum_vals[ekey]
                        g.write('${eval}')
                    } else if ekey2 in g.enum_vals {
                        eval := g.enum_vals[ekey2]
                        g.write('${eval}')
                    } else {
                        g.write(c_name('${qname}.${node.value}'))
                    }
                } else {
                    g.write(c_name('${qname}.${node.value}'))
                }
            } else if embedded := g.direct_embedded_field_for_selector(base_type0, node.value) {
                needs_paren := base.kind !in [.ident, .selector]
                if needs_paren {
                    g.write('(')
                }
                g.gen_expr(base_id)
                if needs_paren {
                    g.write(')')
                }
                if node.op == .arrow || base_type0 is types.Pointer {
                    g.write('->')
                } else {
                    g.write('.')
                }
                g.write(c_name(embedded.name))
            } else if embedded_path := g.embedded_field_path_for_promoted_selector(base_type0,
                node.value)
            {
                needs_paren := base.kind !in [.ident, .selector]
                if needs_paren {
                    g.write('(')
                }
                g.gen_expr(base_id)
                if needs_paren {
                    g.write(')')
                }
                mut is_ptr := node.op == .arrow || base_type0 is types.Pointer
                for embedded in embedded_path {
                    op := if is_ptr { '->' } else { '.' }
                    g.write('${op}${c_name(embedded.name)}')
                    is_ptr = embedded.typ is types.Pointer
                }
                final_op := if is_ptr { '->' } else { '.' }
                g.write('${final_op}${c_name(node.value)}')
            } else {
                needs_paren := base.kind !in [.ident, .selector]
                if needs_paren {
                    g.write('(')
                }
                g.gen_expr(base_id)
                if needs_paren {
                    g.write(')')
                }
                mut is_ptr := false
                if base.kind == .ident {
                    if typ := g.tc.cur_scope.lookup(base.value) {
                        is_ptr = typ is types.Pointer
                    }
                } else if base.kind == .selector {
                    if declared := g.selector_declared_type(base_id) {
                        is_ptr = declared is types.Pointer
                    } else {
                        resolved := g.tc.resolve_type(base_id)
                        is_ptr = resolved is types.Pointer
                    }
                } else {
                    resolved := g.tc.resolve_type(base_id)
                    is_ptr = resolved is types.Pointer
                }
                if node.op == .arrow || is_ptr {
                    g.write('->')
                } else {
                    g.write('.')
                }
                g.write(c_name(node.value))
            }
        }
        .index {
            base_id := g.a.child(&node, 0)
            base_type := g.tc.resolve_type(base_id)
            if node.value == 'range' {
                g.gen_slice_expr(node, base_id, base_type)
            } else if base_type is types.Map {
                c_key := g.value_c_type(base_type.key_type)
                c_val := g.value_c_type(base_type.value_type)
                g.write('(*(${c_val}*)map__get(&')
                g.gen_expr(base_id)
                g.write(', &(${c_key}[]){')
                g.gen_expr(g.a.child(&node, 1))
                g.write('}, &(${c_val}[]){0}))')
            } else {
                is_fixed_array_index, fixed_is_ptr, _ := fixed_array_index_info(base_type)
                if is_fixed_array_index {
                    if fixed_is_ptr {
                        g.write('(*')
                        g.gen_expr(base_id)
                        g.write(')')
                    } else {
                        g.gen_expr(base_id)
                    }
                    g.write('[')
                    g.gen_expr(g.a.child(&node, 1))
                    g.write(']')
                } else {
                    is_array_index, is_ptr, arr_type := array_index_info(base_type)
                    if is_array_index {
                        index_type := if g.expected_expr_type is types.OptionType
                            || g.expected_expr_type is types.ResultType
                            || g.expected_expr_is_optional_struct() {
                            g.expected_expr_type
                        } else if node.typ.starts_with('?') || node.typ.starts_with('!') {
                            g.tc.parse_type(node.typ)
                        } else {
                            arr_type.elem_type
                        }
                        c_elem := g.value_c_type(index_type)
                        g.write('(*(${c_elem}*)array_get(')
                        if is_ptr {
                            g.write('*')
                        }
                        g.gen_expr(base_id)
                        g.write(', ')
                        g.gen_expr(g.a.child(&node, 1))
                        g.write('))')
                    } else if base_type is types.String {
                        // Parenthesize the base: a smartcast sum variant yields a deref
                        // like `*v._string`, and `*v._string.str[i]` would bind as
                        // `*(v._string.str[i])`. `(*v._string).str[i]` is what we want.
                        g.write('(')
                        g.gen_expr(base_id)
                        g.write(').str[')
                        g.gen_expr(g.a.child(&node, 1))
                        g.write(']')
                    } else if base_type is types.Pointer {
                        ptr_type := base_type
                        if ptr_type.base_type is types.Void {
                            g.write('((u8*)')
                            g.gen_expr(base_id)
                            g.write(')[')
                            g.gen_expr(g.a.child(&node, 1))
                            g.write(']')
                        } else {
                            g.gen_expr(base_id)
                            g.write('[')
                            g.gen_expr(g.a.child(&node, 1))
                            g.write(']')
                        }
                    } else {
                        g.gen_expr(base_id)
                        g.write('[')
                        g.gen_expr(g.a.child(&node, 1))
                        g.write(']')
                    }
                }
            }
        }
        .array_init {
            raw_init_type := g.tc.parse_type(node.value)
            init_type := raw_init_type
            if init_type is types.ArrayFixed {
                ct := g.tc.c_type(raw_init_type)
                g.write('(${ct}){0}')
            } else {
                c_elem := g.sizeof_target(node.value)
                g.write('array_new(sizeof(${c_elem}), 0, 0)')
            }
        }
        .map_init {
            g.gen_map_init(id, node)
        }
        .sql_expr {
            panic('internal error: SQL expression reached C backend after transform')
        }
        .cast_expr {
            target_type := g.tc.parse_type(node.value)
            mut ct := g.cast_c_type(target_type)
            if ct.starts_with('fn_ptr:') {
                ct = g.resolve_fn_ptr_type(ct)
            }
            if node.value in g.interfaces || g.tc.qualify_name(node.value) in g.interfaces {
                g.write('(${ct}){0}')
            } else if target_type is types.SumType {
                g.gen_sum_cast_expr(target_type, g.a.child(&node, 0))
            } else if target_type is types.Pointer
                && g.gen_cast_from_mut_param_address(g.a.child(&node, 0), ct) {
                return
            } else {
                g.write('(${ct})(')
                g.gen_expr(g.a.child(&node, 0))
                g.write(')')
            }
        }
        .struct_init {
            g.gen_struct_init(node)
        }
        .if_expr {
            g.gen_if_expr(node)
        }
        .array_literal {
            g.write('{')
            for i in 0 .. node.children_count {
                if i > 0 {
                    g.write(', ')