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
    c_flags                      []string
    libc_compat_fns              map[string]bool
    tc                           &types.TypeChecker = unsafe { nil }
    has_builtins                 bool
    has_stdatomic_header         bool
    has_stdatomic_compat_header  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
    runtime_inits                []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_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
}

// 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{}
        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{}
        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{}
        runtime_inits:                []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.runtime_inits = []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.c_flags = []string{}
    g.libc_compat_fns = map[string]bool{}
    g.has_stdatomic_header = false
    g.has_stdatomic_compat_header = false
    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.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()
    // 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.preamble()
    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.builtin_abi_decls()
    g.multi_return_typedefs()
    g.optional_typedefs()
    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.runtime_inits.len > 0 || g.module_init_fns.len > 0 || g.global_inits.len > 0 {
        g.writeln('void _vinit() {')
        for ri in g.runtime_inits {
            g.writeln(ri)
        }
        // Module-level init() functions run after const/global initialization.
        for init_fn in g.ordered_module_init_fns() {
            g.writeln('\t${init_fn}();')
        }
        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() {
    mut cur_module := ''
    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)
            g.tc.cur_file = cur_file
            cur_module = ''
            g.tc.cur_module = cur_module
            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' && node.typ.len > 0 {
            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.kind == .directive && node.value == 'pkgconfig' && node.typ.len > 0 {
            for flag in c_pkgconfig_flags(node.typ) {
                if flag.len > 0 && flag !in g.c_flags {
                    g.c_flags << flag
                }
            }
            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_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') {
            return true
        }
        if is_stdatomic_header(include_arg) {
            g.has_stdatomic_header = true
        }
        if is_stdatomic_compat_header(include_arg) {
            g.has_stdatomic_compat_header = true
        }
        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 is_stdatomic_header(include_arg string) bool {
    normalized := include_arg.replace('\\', '/')
    return normalized == '<stdatomic.h>' || normalized == '"stdatomic.h"'
        || normalized.ends_with('/stdatomic.h"') || is_stdatomic_compat_header(normalized)
}

fn is_stdatomic_compat_header(include_arg string) bool {
    normalized := include_arg.replace('\\', '/')
    return normalized.contains('/thirdparty/stdatomic/') && normalized.ends_with('/atomic.h"')
}

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 := ''
        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 {
    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
    }
    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
}

// 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{} } {
        g.visit_module_init(dep, 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 (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_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
}

// 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 _ := 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 {
        elem_type := if node.children_count > 0 {
            g.tc.resolve_type(g.a.child(&node, 0))
        } else {
            expected.elem_type
        }
        g.gen_array_literal_value(node, elem_type)
        g.expected_expr_type = old_expected
        g.expected_enum = old_expected_enum
        return
    }
    if expected !is types.Pointer && expected !is types.Void && 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)
    }
    t := g.tc.parse_type(type_name)
    return g.tc.c_type(t)
}

fn (mut g FlatGen) sizeof_target(value string) string {
    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..])
            }
        }
    }
    return g.type_name_c_type(value)
}

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 {
                g.write(v)
            }
        }
        .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 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 {
                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(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.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.tc.c_type(init_type)
                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 {
                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(', ')
                }
                g.gen_expr(g.a.child(&node, i))
            }
            g.write('}')
        }
        .nil_literal {
            g.write('NULL')
        }
        .none_expr {
            ct := g.optional_type_name(g.optional_none_type(id))
            g.write('(${ct}){.ok = false}')
        }
        .or_expr {
            g.gen_or_expr(node)
        }
        .block {
            if node.children_count > 1 {
                g.write('({')
                for bi in 0 .. node.children_count - 1 {
                    g.gen_node(g.a.child(&node, bi))
                }
                last_id := g.a.child(&node, node.children_count - 1)
                last := g.a.nodes[int(last_id)]
                if last.kind == .expr_stmt {
                    g.gen_expr(g.a.child(&last, 0))
                } else if last.kind == .if_expr {
                    g.gen_expr(last_id)
                } else {
                    g.gen_node(last_id)
                }
                g.write(';})')
            } else if node.children_count > 0 {
                last_id := g.a.child(&node, 0)
                last := g.a.nodes[int(last_id)]
                if last.kind == .expr_stmt {
                    g.gen_expr(g.a.child(&last, 0))
                } else {
                    g.gen_expr(last_id)
                }
            }
        }
        .is_expr {
            expr_id := g.a.child(&node, 0)
            expr_type := g.tc.resolve_type(expr_id)
            clean := types.unwrap_pointer(expr_type)
            if clean is types.SumType {
                idx := g.sum_type_index(clean.name, node.value)
                g.write('(')
                if expr_type.is_pointer() {
                    g.gen_expr(expr_id)
                    g.write('->typ == ${idx}')
                } else {
                    g.gen_expr(expr_id)
                    g.write('.typ == ${idx}')
                }
                g.write(')')
            } else {
                g.write('1')
            }
        }
        .as_expr {
            expr_id := g.a.child(&node, 0)
            expr_type := g.tc.resolve_type(expr_id)
            clean := types.unwrap_pointer(expr_type)
            if clean is types.SumType {
                qv := g.resolve_variant(clean.name, node.value)
                field := g.sum_field_name(qv)
                if g.variant_references_sum(qv, clean.name) {
                    g.write('(*')
                    if expr_type.is_pointer() {
                        g.gen_expr(expr_id)
                        g.write('->${field})')
                    } else {
                        g.gen_expr(expr_id)
                        g.write('.${field})')
                    }
                } else {
                    if expr_type.is_pointer() {
                        g.gen_expr(expr_id)
                        g.write('->${field}')
                    } else {
                        g.gen_expr(expr_id)
                        g.write('.${field}')
                    }
                }
            } else {
                g.gen_expr(expr_id)
            }
        }
        .sizeof_expr {
            g.write('sizeof(${g.sizeof_target(node.value)})')
        }
        .offsetof_expr {
            ct := g.type_name_c_type(node.value)
            g.write('offsetof(${ct}, ${c_name(node.typ)})')
        }
        .assoc {
            g.gen_assoc_expr(node)
        }
        .empty {
            g.write('0')
        }
        else {}
    }
}

fn (mut g FlatGen) gen_string_infix_fallback(node flat.Node, lhs_id flat.NodeId, rhs_id flat.NodeId) bool {
    match node.op {
        .plus {
            g.write('string__plus(')
            g.gen_expr(lhs_id)
            g.write(', ')
            g.gen_expr(rhs_id)
            g.write(')')
        }
        .eq {
            g.write('string__eq(')
            g.gen_expr(lhs_id)
            g.write(', ')
            g.gen_expr(rhs_id)
            g.write(')')
        }
        .ne {
            g.write('!string__eq(')
            g.gen_expr(lhs_id)
            g.write(', ')
            g.gen_expr(rhs_id)
            g.write(')')
        }
        .lt {
            g.write('string__lt(')
            g.gen_expr(lhs_id)
            g.write(', ')
            g.gen_expr(rhs_id)
            g.write(')')
        }
        .gt {
            g.write('string__lt(')
            g.gen_expr(rhs_id)
            g.write(', ')
            g.gen_expr(lhs_id)
            g.write(')')
        }
        .le {
            g.write('!string__lt(')
            g.gen_expr(rhs_id)
            g.write(', ')
            g.gen_expr(lhs_id)
            g.write(')')
        }
        .ge {
            g.write('!string__lt(')
            g.gen_expr(lhs_id)
            g.write(', ')
            g.gen_expr(rhs_id)
            g.write(')')
        }
        else {
            return false
        }
    }

    return true
}

fn array_membership_fn_name(elem_type types.Type, fixed bool) string {
    prefix := if fixed { 'fixed_array_contains_' } else { 'array_contains_' }
    elem_name := elem_type.name()
    suffix := match elem_name {
        'string' { 'string' }
        'u8', 'byte' { 'u8' }
        else { 'int' }
    }

    return prefix + suffix
}

fn (g &FlatGen) is_module_qualified_enum(base flat.Node) bool {
    if base.kind != .selector || base.children_count == 0 {
        return false
    }
    inner_base := g.a.child_node(&base, 0)
    if inner_base.kind != .ident || !g.has_import_alias(inner_base.value) {
        return false
    }
    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}'
    return qname in g.tc.enum_names || base.value in g.tc.enum_names
}

fn (mut g FlatGen) preamble() {
    g.c99_feature_test_macros()
    g.writeln('#include <stdio.h>')
    g.writeln('#include <stdlib.h>')
    g.writeln('#include <string.h>')
    g.writeln('#include <stddef.h>')
    g.writeln('#include <float.h>')
    g.writeln('#include <stdint.h>') // guarantees UINTPTR_MAX for the pointer-width atomic helpers
    g.writeln('#include <math.h>')
    g.writeln('#include <unistd.h>')
    g.c99_atomic_compat_decls()
    if g.has_builtins {
        g.writeln('#include <time.h>')
        g.writeln('#include <sys/time.h>')
        g.writeln('#include <errno.h>')
        g.writeln('#include <signal.h>')
        g.writeln('#include <execinfo.h>')
        g.writeln('#include <dirent.h>')
        g.writeln('#include <sys/stat.h>')
        g.writeln('#include <fcntl.h>')
        g.writeln('#include <sys/ioctl.h>')
        g.writeln('#include <sys/utsname.h>')
        g.writeln('#include <pthread.h>')
        g.writeln('#include <semaphore.h>')
        g.writeln('#include <termios.h>')
        g.writeln('#include <unistd.h>')
        g.writeln('#include <arpa/inet.h>')
        g.writeln('#include <netdb.h>')
        g.writeln('#include <netinet/in.h>')
        g.writeln('#include <netinet/tcp.h>')
        g.writeln('#include <sys/socket.h>')
        g.writeln('#ifdef __APPLE__')
        g.writeln('#define panic mach_panic')
        g.writeln('#include <mach/mach.h>')
        g.writeln('#include <mach/task.h>')
        g.writeln('#include <mach/mach_time.h>')
        g.writeln('#include <mach-o/dyld.h>')
        g.writeln('#undef panic')
        g.writeln('#ifndef PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP')
        g.writeln('#define PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 0')
        g.writeln('#define pthread_rwlockattr_setkind_np(attr, kind) 0')
        g.writeln('#endif')
        g.writeln('#endif')
    }
    if g.libc_compat_fns['gettid'] {
        g.writeln('#ifdef __linux__')
        g.writeln('#include <sys/syscall.h>')
        g.writeln('#endif')
    }
    for directive in g.ordered_c_directives() {
        g.writeln(directive)
    }
    g.writeln('')
    g.writeln('typedef signed char i8;')
    g.writeln('typedef short i16;')
    g.writeln('typedef int i32;')
    g.writeln('typedef long long i64;')
    g.writeln('typedef unsigned char u8;')
    g.writeln('typedef unsigned char byte;')
    g.writeln('typedef unsigned short u16;')
    g.writeln('typedef unsigned int u32;')
    g.writeln('typedef unsigned long long u64;')
    g.writeln('#ifndef __bool_true_false_are_defined')
    g.writeln('typedef int bool;')
    g.writeln('#endif')
    g.writeln('typedef void* voidptr;')
    g.writeln('typedef int int_literal;')
    g.writeln('typedef double float_literal;')
    g.writeln('struct sync__Channel;')
    g.writeln('typedef struct sync__Channel* chan;')
    g.writeln('#define true 1')
    g.writeln('#define false 0')
    g.write_arch_macros()
    g.writeln('')
    if !g.has_builtins {
        g.writeln('typedef struct {')
        g.writeln('\tchar* str;')
        g.writeln('\tint len;')
        g.writeln('\tint is_lit;')
        g.writeln('} string;')
        g.writeln('')
    }
    g.writeln('#define elem_size element_size')
    g.writeln('#define c_name types__c_name')
    if g.has_builtins {
        return
    }
    g.writeln('typedef struct Array { void* data; int len; int cap; int elem_size; } Array;')
    g.writeln('')
}

fn (mut g FlatGen) c99_feature_test_macros() {
    if !g.c99_mode {
        return
    }
    g.writeln('#if defined(__linux__) && !defined(_GNU_SOURCE)')
    g.writeln('#define _GNU_SOURCE')
    g.writeln('#endif')
    g.writeln('#if defined(__linux__) && !defined(_POSIX_C_SOURCE)')
    g.writeln('#define _POSIX_C_SOURCE 200809L')
    g.writeln('#endif')
}

fn (mut g FlatGen) c99_atomic_compat_decls() {
    if g.has_stdatomic_header {
        return
    }
    g.writeln('typedef volatile uintptr_t atomic_uintptr_t;')
    g.writeln('#ifndef memory_order_relaxed')
    g.writeln('#define memory_order_relaxed 0')
    g.writeln('#define memory_order_consume 1')
    g.writeln('#define memory_order_acquire 2')
    g.writeln('#define memory_order_release 3')
    g.writeln('#define memory_order_acq_rel 4')
    g.writeln('#define memory_order_seq_cst 5')
    g.writeln('#endif')
    g.writeln('#ifndef atomic_thread_fence')
    g.writeln('#define atomic_thread_fence(order) __sync_synchronize()')
    g.writeln('#endif')
}

fn (mut g FlatGen) write_arch_macros() {
    g.writeln('#ifndef __V_architecture')
    g.writeln('#define __V_architecture 0')
    g.writeln('#endif')
    g.writeln('#if defined(__x86_64__) || defined(_M_AMD64)')
    g.writeln('#define __V_amd64 1')
    g.writeln('#undef __V_architecture')
    g.writeln('#define __V_architecture 1')
    g.writeln('#endif')
    g.writeln('#if defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64)')
    g.writeln('#define __V_arm64 1')
    g.writeln('#undef __V_architecture')
    g.writeln('#define __V_architecture 2')
    g.writeln('#endif')
    g.writeln('#if defined(__arm__) || defined(_M_ARM)')
    g.writeln('#define __V_arm32 1')
    g.writeln('#undef __V_architecture')
    g.writeln('#define __V_architecture 3')
    g.writeln('#endif')
    g.writeln('#if defined(__riscv) && __riscv_xlen == 64')
    g.writeln('#define __V_rv64 1')
    g.writeln('#undef __V_architecture')
    g.writeln('#define __V_architecture 4')
    g.writeln('#endif')
    g.writeln('#if defined(__riscv) && __riscv_xlen == 32')
    g.writeln('#define __V_rv32 1')
    g.writeln('#undef __V_architecture')
    g.writeln('#define __V_architecture 5')
    g.writeln('#endif')
    g.writeln('#if defined(__i386__) || defined(_M_IX86)')
    g.writeln('#define __V_x86 1')
    g.writeln('#undef __V_architecture')
    g.writeln('#define __V_architecture 6')
    g.writeln('#endif')
}

fn (mut g FlatGen) libc_compat_decls() {
    if g.libc_compat_fns['gettid'] {
        g.writeln('#ifdef __linux__')
        g.writeln('#ifndef SYS_gettid')
        g.writeln('#define SYS_gettid __NR_gettid')
        g.writeln('#endif')
        g.writeln('static inline u32 v3_gettid(void) {')
        g.writeln('\treturn (u32)syscall(SYS_gettid);')
        g.writeln('}')
        g.writeln('#endif')
        g.writeln('')
    }
}

fn (mut g FlatGen) prealloc_atomic_compat_decls() {
    g.writeln('static inline int v_prealloc_atomic_add_i32(int *ptr, int delta) { return __atomic_add_fetch(ptr, delta, 5); }')
    g.writeln('static inline int v_prealloc_atomic_load_i32(int *ptr) { return __atomic_add_fetch(ptr, 0, 5); }')
    g.writeln('#ifdef __TINYC__')
    g.writeln('static inline int v_prealloc_atomic_store_i32(int *ptr, int val) { return (int)__atomic_exchange_4((u32*)ptr, (u32)val, 5); }')
    g.writeln('static inline int v_prealloc_atomic_cas_i32(int *ptr, int expected, int desired) { u32 e = (u32)expected; return __atomic_compare_exchange_4((u32*)ptr, &e, (u32)desired, 5, 5); }')
    g.writeln('#else')
    g.writeln('static inline int v_prealloc_atomic_store_i32(int *ptr, int val) { return __atomic_exchange_n(ptr, val, 5); }')
    g.writeln('static inline int v_prealloc_atomic_cas_i32(int *ptr, int expected, int desired) { return __atomic_compare_exchange_n(ptr, &expected, desired, 0, 5, 5); }')
    g.writeln('#endif')
}

fn (mut g FlatGen) atomic_builtin_compat_decls() {
    if g.has_stdatomic_compat_header {
        return
    }
    // Atomic helpers. We use compiler __atomic_* builtins (memory order 5 == __ATOMIC_SEQ_CST).
    // clang/gcc inline the generic _n / RMW builtins. tcc only implements the inline
    // __atomic_{add,sub,fetch}_* RMW builtins; for load/store/exchange/cas it has no generic
    // _n form, so we route those to the sized __atomic_*_N libcalls (resolved from libc).
    g.writeln('static inline u32 atomic_fetch_add_u32(void* ptr, u32 delta) { return __atomic_fetch_add((u32*)ptr, delta, 5); }')
    g.writeln('static inline u64 atomic_fetch_add_u64(void* ptr, u64 delta) { return __atomic_fetch_add((u64*)ptr, delta, 5); }')
    g.writeln('static inline u64 atomic_fetch_sub_u64(void* ptr, u64 delta) { return __atomic_fetch_sub((u64*)ptr, delta, 5); }')
    g.writeln('static inline byte atomic_load_byte(void* ptr) { return __atomic_fetch_add((byte*)ptr, 0, 5); }')
    g.writeln('static inline u16 atomic_load_u16(void* ptr) { return __atomic_fetch_add((u16*)ptr, 0, 5); }')
    g.writeln('static inline u32 atomic_load_u32(void* ptr) { return __atomic_fetch_add((u32*)ptr, 0, 5); }')
    g.writeln('static inline u64 atomic_load_u64(void* ptr) { return __atomic_fetch_add((u64*)ptr, 0, 5); }')
    g.writeln('static inline void* atomic_load_ptr(void* ptr) { return *(void* volatile*)ptr; }')
    g.writeln('#ifdef __TINYC__')
    g.writeln('static inline void atomic_store_byte(void* ptr, byte val) { __atomic_store_1((byte*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_u16(void* ptr, u16 val) { __atomic_store_2((u16*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_u32(void* ptr, u32 val) { __atomic_store_4((u32*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_u64(void* ptr, u64 val) { __atomic_store_8((u64*)ptr, val, 5); }')
    g.writeln('#if UINTPTR_MAX == 0xFFFFFFFF')
    g.writeln('static inline void atomic_store_ptr(void* ptr, void* val) { __atomic_store_4((u32*)ptr, (u32)(size_t)val, 5); }')
    g.writeln('#else')
    g.writeln('static inline void atomic_store_ptr(void* ptr, void* val) { __atomic_store_8((u64*)ptr, (u64)(size_t)val, 5); }')
    g.writeln('#endif')
    g.writeln('static inline bool atomic_compare_exchange_strong_u16(void* ptr, u16* expected, u16 desired) { return __atomic_compare_exchange_2((u16*)ptr, expected, desired, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_strong_u32(void* ptr, u32* expected, u32 desired) { return __atomic_compare_exchange_4((u32*)ptr, expected, desired, 5, 5); }')
    g.writeln('#if UINTPTR_MAX == 0xFFFFFFFF')
    g.writeln('static inline bool atomic_compare_exchange_strong_ptr(void* ptr, void* expected, ptrdiff_t desired) { return __atomic_compare_exchange_4((u32*)ptr, (u32*)expected, (u32)desired, 5, 5); }')
    g.writeln('#else')
    g.writeln('static inline bool atomic_compare_exchange_strong_ptr(void* ptr, void* expected, ptrdiff_t desired) { return __atomic_compare_exchange_8((u64*)ptr, (u64*)expected, (u64)desired, 5, 5); }')
    g.writeln('#endif')
    g.writeln('static inline bool atomic_compare_exchange_weak_byte(void* ptr, byte* expected, byte desired) { return __atomic_compare_exchange_1((byte*)ptr, expected, desired, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_u16(void* ptr, u16* expected, u16 desired) { return __atomic_compare_exchange_2((u16*)ptr, expected, desired, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_u32(void* ptr, u32* expected, u32 desired) { return __atomic_compare_exchange_4((u32*)ptr, expected, desired, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_u64(void* ptr, u64* expected, u64 desired) { return __atomic_compare_exchange_8((u64*)ptr, expected, desired, 5, 5); }')
    g.writeln('#else')
    g.writeln('static inline void atomic_store_byte(void* ptr, byte val) { __atomic_store_n((byte*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_u16(void* ptr, u16 val) { __atomic_store_n((u16*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_u32(void* ptr, u32 val) { __atomic_store_n((u32*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_u64(void* ptr, u64 val) { __atomic_store_n((u64*)ptr, val, 5); }')
    g.writeln('static inline void atomic_store_ptr(void* ptr, void* val) { __atomic_store_n((void**)ptr, val, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_strong_u16(void* ptr, u16* expected, u16 desired) { return __atomic_compare_exchange_n((u16*)ptr, expected, desired, 0, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_strong_u32(void* ptr, u32* expected, u32 desired) { return __atomic_compare_exchange_n((u32*)ptr, expected, desired, 0, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_strong_ptr(void* ptr, void* expected, ptrdiff_t desired) { return __atomic_compare_exchange_n((void**)ptr, (void**)expected, (void*)desired, 0, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_byte(void* ptr, byte* expected, byte desired) { return __atomic_compare_exchange_n((byte*)ptr, expected, desired, 1, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_u16(void* ptr, u16* expected, u16 desired) { return __atomic_compare_exchange_n((u16*)ptr, expected, desired, 1, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_u32(void* ptr, u32* expected, u32 desired) { return __atomic_compare_exchange_n((u32*)ptr, expected, desired, 1, 5, 5); }')
    g.writeln('static inline bool atomic_compare_exchange_weak_u64(void* ptr, u64* expected, u64 desired) { return __atomic_compare_exchange_n((u64*)ptr, expected, desired, 1, 5, 5); }')
    g.writeln('#endif')
    g.writeln('static inline bool atomic_compare_exchange_weak_ptr(void* ptr, void* expected, ptrdiff_t desired) { return atomic_compare_exchange_strong_ptr(ptr, expected, desired); }')
    g.writeln('static inline void cpu_relax(void) { __asm__ __volatile__("" ::: "memory"); }')
}

fn (mut g FlatGen) builtin_abi_decls() {
    if !g.has_builtins {
        return
    }
    g.libc_compat_decls()
    g.writeln('#define array_new(elem_size, len, cap) __new_array((len), (cap), (elem_size))')
    g.writeln('#define array_push array__push')
    g.writeln('void array__push_many(array* a, void* val, int size);')
    g.writeln('#define array_push_many_ptr(a, val, size) array__push_many((a), (void*)(val), (size))')
    g.writeln('#define array_get array__get')
    g.writeln('#define array_set(a, i, ...) array__set(&(a), (i), __VA_ARGS__)')
    g.writeln('array array__clone(array* a);')
    g.writeln('#define array_slice array__slice')
    g.writeln('#define array_delete array__delete')
    g.writeln('#define array_ensure_cap array__ensure_cap')
    g.writeln('#define map__get_or_set map__get_and_set')
    g.writeln('#ifndef V_COMMIT_HASH')
    g.writeln('#define V_COMMIT_HASH ""')
    g.writeln('#endif')
    // Weak fallbacks for the heap-tracking hooks. A program that provides real
    // implementations (e.g. a `vheap_alloc`/`vheap_free` from a linked C file, as
    // some projects do) overrides these without a redefinition/static-vs-non-static
    // clash against that file's own non-static prototype.
    g.writeln('__attribute__((weak)) void vheap_alloc(void* p, u64 n) { (void)p; (void)n; }')
    g.writeln('__attribute__((weak)) void vheap_free(void* p) { (void)p; }')
    g.filelock_compat_decls()
    g.prealloc_atomic_compat_decls()
    g.atomic_builtin_compat_decls()
    g.writeln('static inline double math__abs(double a) { return a < 0 ? -a : a; }')
    g.writeln('static inline double math__min(double a, double b) { return a < b ? a : b; }')
    g.writeln('static const u64 _wyp[4] = {0x2d358dccaa6c78a5ull, 0x8bb84b93962eacc9ull, 0x4b33a62ed433d4a3ull, 0x4d5a2da51de1aa47ull};')
    g.writeln('static inline u64 _wymix(u64 a, u64 b) { u64 ha = a >> 32, hb = b >> 32, la = (u32)a, lb = (u32)b, hi, lo; u64 rh = ha * hb, rm0 = ha * lb, rm1 = hb * la, rl = la * lb, t = rl + (rm0 << 32), c = t < rl; lo = t + (rm1 << 32); c += lo < t; hi = rh + (rm0 >> 32) + (rm1 >> 32) + c; return lo ^ hi; }')
    g.writeln('static inline u64 wyhash64(u64 a, u64 b) { a ^= _wyp[0]; b ^= _wyp[1]; a *= 0xa0761d6478bd642full; b *= 0xe7037ed1a0b428dbull; return (a ^ (a >> 32)) ^ (b ^ (b >> 32)); }')
    g.writeln('static inline u64 wyhash(const void* key, size_t len, u64 seed, const u64* secret) { const unsigned char* p = (const unsigned char*)key; u64 h = seed ^ secret[0] ^ (u64)len; for (size_t i = 0; i < len; i++) h = wyhash64(h ^ (u64)p[i], secret[(i + 1) & 3]); return h; }')
    g.writeln('#define v_signal_with_handler_cast(sig, handler) signal((sig), ((void (*)(int))(handler)))')
    g.writeln('string string__clone(string a);')
    g.writeln('void string__free(string* s);')
    g.writeln('static inline int array_index_int(Array a, int val) { for (int i = 0; i < a.len; i++) if (((int*)a.data)[i] == val) return i; return -1; }')
    g.writeln('static inline bool array_contains_int(Array a, int val) { return array_index_int(a, val) >= 0; }')
    g.writeln('static inline int array_index_u8(Array a, u8 val) { for (int i = 0; i < a.len; i++) if (((u8*)a.data)[i] == val) return i; return -1; }')
    g.writeln('static inline bool array_contains_u8(Array a, u8 val) { return array_index_u8(a, val) >= 0; }')
    g.writeln('static inline int array_index_string(Array a, string val) { string* data = (string*)a.data; for (int i = 0; i < a.len; i++) if (data[i].len == val.len && memcmp(data[i].str, val.str, val.len) == 0) return i; return -1; }')
    g.writeln('static inline bool array_contains_string(Array a, string val) { return array_index_string(a, val) >= 0; }')
    g.writeln('static inline bool array_eq_raw(Array a, Array b, int elem_size) { return a.len == b.len && (a.len == 0 || memcmp(a.data, b.data, (size_t)a.len * elem_size) == 0); }')
    g.writeln('static inline bool array_eq_string(Array a, Array b) { if (a.len != b.len) return false; string* ad = (string*)a.data; string* bd = (string*)b.data; for (int i = 0; i < a.len; i++) if (ad[i].len != bd[i].len || memcmp(ad[i].str, bd[i].str, ad[i].len) != 0) return false; return true; }')
    g.writeln('static inline bool fixed_array_contains_string(const string* a, int len, string val) { for (int i = 0; i < len; i++) if (a[i].len == val.len && memcmp(a[i].str, val.str, val.len) == 0) return true; return false; }')
    g.writeln('static inline bool fixed_array_contains_u8(const u8* a, int len, u8 val) { for (int i = 0; i < len; i++) if (a[i] == val) return true; return false; }')
    g.writeln('static inline bool fixed_array_contains_int(const int* a, int len, int val) { for (int i = 0; i < len; i++) if (a[i] == val) return true; return false; }')
    g.writeln('static inline string Array_str(Array a) { if (a.element_size == 1) { u8* buf = (u8*)malloc((size_t)a.len + 1); if (a.len > 0) memcpy(buf, a.data, (size_t)a.len); buf[a.len] = 0; return (string){buf, a.len, 0}; } return (string){(u8*)"[]", 2, 1}; }')
    g.writeln('#ifndef max_int')
    g.writeln('#define max_int max_i32')
    g.writeln('#endif')
    g.writeln('#ifndef min_int')
    g.writeln('#define min_int min_i32')
    g.writeln('#endif')
    g.writeln('')
}

fn (mut g FlatGen) filelock_compat_decls() {
    g.writeln('#ifdef _WIN32')
    g.writeln('#include <windows.h>')
    g.writeln('int v_filelock_lock(void* handle, int exclusive, int immediate, u64 start, u64 len) {')
    g.writeln('\tOVERLAPPED overlap;')
    g.writeln('\tmemset(&overlap, 0, sizeof(overlap));')
    g.writeln('\toverlap.Offset = (DWORD)(start & 0xffffffffULL);')
    g.writeln('\toverlap.OffsetHigh = (DWORD)(start >> 32);')
    g.writeln('\tDWORD flags = immediate ? LOCKFILE_FAIL_IMMEDIATELY : 0;')
    g.writeln('\tif (exclusive) { flags |= LOCKFILE_EXCLUSIVE_LOCK; }')
    g.writeln('\tDWORD low = len == 0 ? MAXDWORD : (DWORD)(len & 0xffffffffULL);')
    g.writeln('\tDWORD high = len == 0 ? MAXDWORD : (DWORD)(len >> 32);')
    g.writeln('\treturn LockFileEx((HANDLE)handle, flags, 0, low, high, &overlap) ? 0 : -1;')
    g.writeln('}')
    g.writeln('int v_filelock_unlock(void* handle, u64 start, u64 len) {')
    g.writeln('\tOVERLAPPED overlap;')
    g.writeln('\tmemset(&overlap, 0, sizeof(overlap));')
    g.writeln('\toverlap.Offset = (DWORD)(start & 0xffffffffULL);')
    g.writeln('\toverlap.OffsetHigh = (DWORD)(start >> 32);')
    g.writeln('\tDWORD low = len == 0 ? MAXDWORD : (DWORD)(len & 0xffffffffULL);')
    g.writeln('\tDWORD high = len == 0 ? MAXDWORD : (DWORD)(len >> 32);')
    g.writeln('\treturn UnlockFileEx((HANDLE)handle, 0, low, high, &overlap) ? 0 : -1;')
    g.writeln('}')
    g.writeln('#else')
    g.writeln('int v_filelock_lock(i32 fd, i32 exclusive, i32 immediate, u64 start, u64 len) {')
    g.writeln('\tstruct flock fl;')
    g.writeln('\tmemset(&fl, 0, sizeof(fl));')
    g.writeln('\tfl.l_type = exclusive ? F_WRLCK : F_RDLCK;')
    g.writeln('\tfl.l_whence = SEEK_SET;')
    g.writeln('\tfl.l_start = (off_t)start;')
    g.writeln('\tfl.l_len = len == 0 ? 0 : (off_t)len;')
    g.writeln('\treturn fcntl(fd, immediate ? F_SETLK : F_SETLKW, &fl);')
    g.writeln('}')
    g.writeln('int v_filelock_unlock(i32 fd, u64 start, u64 len) {')
    g.writeln('\tstruct flock fl;')
    g.writeln('\tmemset(&fl, 0, sizeof(fl));')
    g.writeln('\tfl.l_type = F_UNLCK;')
    g.writeln('\tfl.l_whence = SEEK_SET;')
    g.writeln('\tfl.l_start = (off_t)start;')
    g.writeln('\tfl.l_len = len == 0 ? 0 : (off_t)len;')
    g.writeln('\treturn fcntl(fd, F_SETLK, &fl);')
    g.writeln('}')
    g.writeln('#endif')
}

fn (mut g FlatGen) collect_fixed_array_typedefs_needed() map[string]FixedArrayTypedefInfo {
    mut needed := map[string]FixedArrayTypedefInfo{}
    old_module := g.tc.cur_module
    for name, ret_type in g.tc.fn_ret_types {
        g.tc.cur_module = module_from_qualified_name(name)
        g.collect_fixed_array_typedef(ret_type, mut needed)
    }
    for name, param_types in g.tc.fn_param_types {
        g.tc.cur_module = module_from_qualified_name(name)
        for param_type in param_types {
            g.collect_fixed_array_typedef(param_type, mut needed)
        }
    }
    for name, fields in g.tc.structs {
        g.tc.cur_module = g.fixed_array_typedef_type_module(name, old_module)
        for field in fields {
            g.collect_fixed_array_typedef(field.typ, mut needed)
        }
    }
    for name, fields in g.tc.interface_fields {
        g.tc.cur_module = module_from_qualified_name(name)
        for field in fields {
            g.collect_fixed_array_typedef(field.typ, mut needed)
        }
    }
    for name, typ in g.global_types {
        g.tc.cur_module = g.global_modules[name] or { old_module }
        g.collect_fixed_array_typedef(typ, mut needed)
    }
    for _, typ in g.tc.c_globals {
        g.tc.cur_module = old_module
        g.collect_fixed_array_typedef(typ, mut needed)
    }
    for name, typ in g.tc.const_types {
        g.tc.cur_module = g.const_modules[name] or { old_module }
        g.collect_fixed_array_typedef(typ, mut needed)
    }
    g.tc.cur_module = old_module
    return needed
}

fn (mut g FlatGen) fixed_array_typedefs() {
    needed := g.collect_fixed_array_typedefs_needed()
    old_len := g.emitted_fixed_array_typedefs.len
    for name, info in needed {
        g.emit_fixed_array_typedef(name, info, needed, mut g.emitted_fixed_array_typedefs)
    }
    // Return wrappers for non-early element types (struct/`string`/nested fixed array):
    // their bare typedef (above) and element definitions are available now, so a C
    // function returning `[N]Foo`/`[N]string` can return the wrapper struct instead of the
    // raw array type C rejects. Sorted for deterministic output.
    mut wrapper_names := []string{}
    for name, _ in needed {
        wrapper_names << name
    }
    wrapper_names.sort()
    mut emitted_wrapper := false
    for name in wrapper_names {
        if name !in g.fixed_array_ret_wrappers {
            continue
        }
        info := needed[name] or { continue }
        if fixed_array_typedef_is_early(info.arr) {
            continue
        }
        // Completes the struct forward-declared in fixed_array_early_typedefs().
        g.emit_fixed_array_ret_wrapper(name, info, true)
        emitted_wrapper = true
    }
    if g.emitted_fixed_array_typedefs.len > old_len || emitted_wrapper {
        g.writeln('')
    }
}

// fixed_array_typedef_is_early reports whether a fixed array's bare typedef can be
// emitted before struct definitions: its element chain must bottom out in a
// primitive/pointer/enum (not a struct or `string`, whose definitions come later).
fn fixed_array_typedef_is_early(arr types.ArrayFixed) bool {
    elem := arr.elem_type
    if elem is types.ArrayFixed {
        return fixed_array_typedef_is_early(elem)
    }
    return fixed_array_elem_is_early_complete(elem)
}

// populate_fixed_array_ret_wrappers records which fixed-array types get a return
// wrapper struct. It must run before function bodies are generated, so that fn
// signatures, return statements and call sites all agree on whether a given
// fixed-array return is wrapped. EVERY fixed-array type is wrapped, because C
// functions and fn pointers cannot return a raw array type regardless of the element:
// primitive/pointer/enum element wrappers are emitted early (before structs), while
// struct/`string`/nested element wrappers are emitted by fixed_array_typedefs(), after
// the element type is defined.
fn (mut g FlatGen) populate_fixed_array_ret_wrappers() {
    needed := g.collect_fixed_array_typedefs_needed()
    for name, _ in needed {
        g.fixed_array_ret_wrappers[name] = true
    }
}

// emit_fixed_array_ret_wrapper writes the one-field `struct { T ret_arr[N]; }` wrapper
// for a fixed-array return type. The element type's C definition must already be emitted.
// `tagged` completes a previously forward-declared named struct (`struct X { ... };`),
// used for non-early element types whose wrapper is referenced by an fn-pointer typedef
// emitted earlier; otherwise a fresh anonymous typedef is written.
fn (mut g FlatGen) emit_fixed_array_ret_wrapper(name string, info FixedArrayTypedefInfo, tagged bool) {
    arr := info.arr
    old_module := g.tc.cur_module
    g.tc.cur_module = info.module
    elem_ct := g.tc.c_type(arr.elem_type)
    len_expr := g.fixed_array_len_value(arr)
    g.tc.cur_module = old_module
    wname := fixed_array_ret_wrapper_name(name)
    if tagged {
        g.writeln('struct ${wname} { ${elem_ct} ret_arr[${len_expr}]; };')
    } else {
        g.writeln('typedef struct { ${elem_ct} ret_arr[${len_expr}]; } ${wname};')
    }
}

// emit_fixed_array_ret_wrapper_forward forward-declares a named return-wrapper struct so an
// fn-pointer typedef can name it as a (by-value) return type before the wrapper's element
// type is defined; the struct body is completed later by emit_fixed_array_ret_wrapper.
fn (mut g FlatGen) emit_fixed_array_ret_wrapper_forward(name string) {
    wname := fixed_array_ret_wrapper_name(name)
    g.writeln('typedef struct ${wname} ${wname};')
}

// fixed_array_early_typedefs emits, before the fn-ptr typedef block, the bare
// typedefs for fixed arrays whose element chain is a primitive/pointer/enum, plus
// a one-field struct wrapper `struct { T ret_arr[N]; }` for each fixed-array
// return type. fn-ptr typedefs may name a fixed array in param position (bare
// typedef) or return position (wrapper); both must therefore be defined first. C
// functions cannot return raw array types, hence the wrapper (as V1 does). Bare
// typedefs of struct/`string`-element fixed arrays are deferred to
// fixed_array_typedefs(), after the struct definitions.
fn (mut g FlatGen) fixed_array_early_typedefs() {
    needed := g.collect_fixed_array_typedefs_needed()
    mut names := []string{}
    for name, _ in needed {
        names << name
    }
    names.sort()
    mut emitted_any := false
    for name in names {
        info := needed[name] or { continue }
        if !fixed_array_typedef_is_early(info.arr) {
            continue
        }
        g.emit_fixed_array_typedef(name, info, needed, mut g.emitted_fixed_array_typedefs)
        emitted_any = true
    }
    // Wrapper structs for fixed-array return types. Primitive/pointer/enum element wrappers
    // are fully defined here. Struct/`string`/nested element wrappers can't be defined yet
    // (their element type comes later), but an fn-pointer typedef in the next block may name
    // one as a return type, so forward-declare the named struct now and complete it in
    // fixed_array_typedefs(), after the element definitions.
    for name in names {
        if name !in g.fixed_array_ret_wrappers {
            continue
        }
        info := needed[name] or { continue }
        if fixed_array_typedef_is_early(info.arr) {
            g.emit_fixed_array_ret_wrapper(name, info, false)
        } else {
            g.emit_fixed_array_ret_wrapper_forward(name)
        }
        emitted_any = true
    }
    if emitted_any {
        g.writeln('')
    }
}

// fixed_array_ret_wrapper_name is the struct name wrapping a fixed-array return.
fn fixed_array_ret_wrapper_name(bare_c_name string) string {
    return '_v_ret_${bare_c_name}'
}

// fixed_array_elem_is_early_complete reports whether a fixed-array element type's
// C definition is available before the fn_ptr/return-wrapper typedef block (i.e.
// it is a primitive, pointer, or enum — not a struct or nested fixed array, whose
// bare typedefs/definitions are emitted later).
fn fixed_array_elem_is_early_complete(elem types.Type) bool {
    return elem is types.Primitive || elem is types.Pointer || elem is types.Enum
}

// fn_return_type_name is the C type to write for a function/fn-ptr return type,
// substituting the fixed-array wrapper struct when one exists.
fn (mut g FlatGen) fn_return_type_name(t types.Type) string {
    if t is types.ArrayFixed {
        bare := g.tc.c_type(t)
        if bare in g.fixed_array_ret_wrappers {
            return fixed_array_ret_wrapper_name(bare)
        }
    }
    ct := g.optional_type_name(t)
    // A function/fn-ptr-valued return (`fn f() fn () int`) has the internal `fn_ptr:...`
    // encoding for its C type; map it to the shared `_fn_ptr_N` typedef, since a C function
    // cannot be declared returning that raw encoding (it would emit invalid C).
    if ct.starts_with('fn_ptr:') {
        return g.resolve_fn_ptr_type(ct)
    }
    return ct
}

// fn_ptr_return_ct maps a fixed-array return c_type name (string form, used by the
// fn-ptr typedef machinery) to its wrapper struct name when one exists.
fn (g &FlatGen) fn_ptr_return_ct(ct string) string {
    if ct.starts_with('Array_fixed_') && ct in g.fixed_array_ret_wrappers {
        return fixed_array_ret_wrapper_name(ct)
    }
    return ct
}

// emit_ready_fixed_array_typedefs emits, during the topological struct emission,
// any fixed-array bare typedef whose element type is now fully defined (i.e. its
// element struct has been emitted). Struct fields reference the typedef name
// (`Array_fixed_vec__Vec4_f32 x`), so the typedef must precede any struct that
// uses it — which a single later pass cannot guarantee.
fn (mut g FlatGen) emit_ready_fixed_array_typedefs(needed map[string]FixedArrayTypedefInfo, emitted_structs map[string]bool) {
    for name, info in needed {
        if g.emitted_fixed_array_typedefs[name] {
            continue
        }
        if g.fixed_array_elem_defined(info.arr, emitted_structs) {
            g.emit_fixed_array_typedef(name, info, needed, mut g.emitted_fixed_array_typedefs)
        }
    }
}

// fixed_array_elem_defined reports whether a fixed array's element type is fully
// available: a primitive/pointer/enum (always), or a struct/`string` already
// emitted. Aliases are unwrapped to their underlying type first (`SimdFloat4` ->
// `vec.Vec4[f32]` struct), so an alias to a not-yet-emitted struct is not treated
// as ready.
fn (g &FlatGen) fixed_array_elem_defined(arr types.ArrayFixed, emitted_structs map[string]bool) bool {
    return g.fixed_array_type_defined(arr.elem_type, emitted_structs)
}

fn (g &FlatGen) fixed_array_type_defined(typ0 types.Type, emitted_structs map[string]bool) bool {
    mut typ := typ0
    for typ is types.Alias {
        typ = typ.base_type
    }
    if typ is types.ArrayFixed {
        return g.fixed_array_type_defined(typ.elem_type, emitted_structs)
    }
    if typ is types.Struct {
        return g.tc.c_type(typ) in emitted_structs
    }
    if typ is types.String {
        return 'string' in emitted_structs
    }
    return true
}

fn (mut g FlatGen) fixed_array_typedef_type_module(name string, fallback string) string {
    if info := g.struct_decl_infos[name] {
        return info.module
    }
    mod := module_from_qualified_name(name)
    if mod.len > 0 {
        return mod
    }
    return fallback
}

fn module_from_qualified_name(name string) string {
    if name.contains('.') {
        return name.all_before_last('.')
    }
    if name.contains('__') {
        return name.all_before_last('__').replace('__', '.')
    }
    return ''
}

fn fixed_array_typedef_module_priority(module_name string) int {
    if module_name.len == 0 || module_name == 'C' {
        return 0
    }
    if module_name == 'main' || module_name == 'builtin' {
        return 1
    }
    return 2
}

fn (mut g FlatGen) collect_fixed_array_typedef(typ types.Type, mut needed map[string]FixedArrayTypedefInfo) {
    if typ is types.ArrayFixed {
        name := g.tc.c_type(typ)
        existing_priority := if name in needed {
            fixed_array_typedef_module_priority(needed[name].module)
        } else {
            -1
        }
        current_priority := fixed_array_typedef_module_priority(g.tc.cur_module)
        if name !in needed || current_priority > existing_priority {
            needed[name] = FixedArrayTypedefInfo{
                arr:    typ
                module: g.tc.cur_module
            }
        }
        g.collect_fixed_array_typedef(typ.elem_type, mut needed)
    } else if typ is types.Pointer {
        g.collect_fixed_array_typedef(typ.base_type, mut needed)
    } else if typ is types.Alias {
        g.collect_fixed_array_typedef(typ.base_type, mut needed)
    } else if typ is types.OptionType {
        g.collect_fixed_array_typedef(typ.base_type, mut needed)
    } else if typ is types.ResultType {
        g.collect_fixed_array_typedef(typ.base_type, mut needed)
    } else if typ is types.Array {
        g.collect_fixed_array_typedef(typ.elem_type, mut needed)
    } else if typ is types.Map {
        g.collect_fixed_array_typedef(typ.key_type, mut needed)
        g.collect_fixed_array_typedef(typ.value_type, mut needed)
    } else if typ is types.FnType {
        for param in typ.params {
            g.collect_fixed_array_typedef(param, mut needed)
        }
        g.collect_fixed_array_typedef(typ.return_type, mut needed)
    } else if typ is types.MultiReturn {
        for item in typ.types {
            g.collect_fixed_array_typedef(item, mut needed)
        }
    }
}

fn (mut g FlatGen) emit_fixed_array_typedef(name string, info FixedArrayTypedefInfo, needed map[string]FixedArrayTypedefInfo, mut emitted map[string]bool) {
    if emitted[name] {
        return
    }
    arr := info.arr
    old_module := g.tc.cur_module
    g.tc.cur_module = info.module
    if arr.elem_type is types.ArrayFixed {
        inner_name := g.tc.c_type(arr.elem_type)
        if inner := needed[inner_name] {
            g.emit_fixed_array_typedef(inner_name, inner, needed, mut emitted)
        }
    }
    elem_ct := g.tc.c_type(arr.elem_type)
    len_expr := g.fixed_array_len_value(arr)
    g.writeln('typedef ${elem_ct} ${name}[${len_expr}];')
    g.tc.cur_module = old_module
    emitted[name] = true
}

fn (mut g FlatGen) global_decls() {
    old_module := g.tc.cur_module
    for name, typ in g.global_types {
        if mod := g.global_modules[name] {
            g.tc.cur_module = mod
        } else {
            g.tc.cur_module = old_module
        }
        if typ is types.ArrayFixed {
            c_elem, dims := g.fixed_array_decl_parts(typ)
            init := if g.has_zero_sized_leading_init_slot(typ) { '' } else { ' = {0}' }
            g.writeln('${c_elem} ${c_name(name)}${dims}${init};')
            continue
        }
        ct := g.tc.c_type(typ)
        if ct == 'void' {
            continue
        }
        if name.starts_with('C.') {
            continue
        }
        init := if g.can_use_global_brace_zero_init(typ, ct) { ' = {0}' } else { '' }
        g.writeln('${ct} ${c_name(name)}${init};')
    }
    g.tc.cur_module = old_module
    if g.global_types.len > 0 {
        g.writeln('')
    }
    g.emit_global_inits()
}

// emit_global_inits queues assignments for `__global x = expr` declarations into
// _vinit. The C globals are emitted zero-initialized above; their initializer
// expressions (often function calls like `new_timers(...)`) cannot be C static
// initializers, so they must run at startup. Without this, such globals stay
// NULL/zero and the first access segfaults.
//
// Plain initializers are emitted as `name = expr;`. Fixed-array globals are
// copied from a generated compound literal with `memmove`, since C arrays are
// not assignable. `&Struct{}` is emitted as a self-contained heap allocation
// (`(T*)memdup(&(T){...}, sizeof(T))`), so it is safe. Other prefix/array
// initializers that would need a dropped temporary are skipped, leaving the
// global zero/NULL -- no regression versus never initializing globals at all.
fn (mut g FlatGen) emit_global_inits() {
    old_module := g.tc.cur_module
    for qname in g.global_init_order {
        val_id := g.global_inits[qname] or { continue }
        if int(val_id) < 0 {
            continue
        }
        // g_main_argc/g_main_argv are filled in by main's preamble (from argc/argv)
        // *before* _vinit runs, and are zero by default in C anyway. Re-emitting their
        // `= 0` initializer here would clobber the real argv, leaving os.args empty.
        cqname := c_name(qname)
        if cqname == 'g_main_argc' || cqname == 'g_main_argv' {
            continue
        }
        if mod := g.global_modules[qname] {
            g.tc.cur_module = mod
        } else {
            g.tc.cur_module = old_module
        }
        if typ := g.global_types[qname] {
            if typ is types.ArrayFixed {
                target := c_name(qname)
                g.queue_fixed_array_runtime_init(target, val_id, typ)
                continue
            }
        }
        if !g.is_safe_global_init(val_id) {
            continue
        }
        tmp_sb := g.sb
        tmp_line_start := g.line_start
        g.sb = strings.new_builder(64)
        g.line_start = true
        g.gen_expr(val_id)
        expr_str := g.sb.str()
        g.sb = tmp_sb
        g.line_start = tmp_line_start
        if expr_str.trim_space().len == 0 {
            continue
        }
        target := c_name(qname)
        g.runtime_inits << '\t${target} = ${expr_str};'
        if typ := g.global_types[qname] {
            if typ is types.Map {
                g.queue_map_literal_sets(target, val_id, typ)
            }
        }
    }
    g.tc.cur_module = old_module
}

// is_safe_global_init reports whether a global initializer can be emitted as a
// self-contained `name = expr;` assignment in _vinit, i.e. without auxiliary
// declarations/temporaries that the global context cannot host.
fn (g &FlatGen) is_safe_global_init(val_id flat.NodeId) bool {
    if int(val_id) < 0 {
        return false
    }
    node := g.a.nodes[int(val_id)]
    if node.kind == .prefix {
        // `&Struct{}` becomes an inline `(T*)memdup(&(T){...}, sizeof(T))`, which is
        // self-contained; allow it. Other prefixes (e.g. `&local`) would need a
        // dropped temporary, so skip them.
        if node.op == .amp && node.children_count > 0 {
            child := g.a.nodes[int(g.a.child(&node, 0))]
            return child.kind == .struct_init || child.kind == .assoc
        }
        return false
    }
    return match node.kind {
        .array_literal, .array_init {
            // Array literals need a backing temp the transformer drops for globals;
            // leave them zero/NULL instead of emitting a reference to an undeclared
            // symbol.
            false
        }
        else {
            true
        }
    }
}

fn (g &FlatGen) const_get_deps(val_id flat.NodeId) []string {
    mut deps := []string{}
    g.const_collect_deps(val_id, mut deps)
    return deps
}

fn (g &FlatGen) const_collect_deps(val_id flat.NodeId, mut deps []string) {
    if int(val_id) < 0 || int(val_id) >= g.a.nodes.len {
        return
    }
    node := g.a.nodes[int(val_id)]
    if node.kind == .ident || node.kind == .selector {
        const_name := g.const_ref_name_from_node(node)
        if const_name.len > 0 {
            deps << const_name
        }
    }
    for i in 0 .. node.children_count {
        g.const_collect_deps(g.a.child(&node, i), mut deps)
    }
}

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

fn (mut g FlatGen) emit_const(name string, val_id flat.NodeId) {
    old_module := g.tc.cur_module
    if name in g.const_modules {
        g.tc.cur_module = g.const_modules[name]
    }
    val_node := g.a.nodes[int(val_id)]
    if val_node.kind == .empty {
        g.tc.cur_module = old_module
        return
    }
    expr_str := if g.is_const_expr(val_id) {
        g.const_expr_to_string(val_id, []string{})
    } else {
        g.expr_to_string(val_id)
    }
    if expr_str.trim_space().len == 0 {
        g.tc.cur_module = old_module
        return
    }
    v_type := if val_node.kind == .offsetof_expr {
        types.Type(types.usize_)
    } else {
        g.tc.resolve_type(val_id)
    }
    ct := g.tc.c_type(v_type)
    qname := g.const_ident_c_name(name)
    mut is_static_const := g.is_const_expr(val_id) && !g.const_expr_needs_runtime_storage(expr_str)
    if v_type is types.ArrayFixed && v_type.elem_type is types.ArrayFixed {
        is_static_const = false
    }
    if !is_static_const {
        if v_type is types.ArrayFixed {
            c_elem, dims := g.fixed_array_decl_parts(v_type)
            g.writeln('${c_elem} ${qname}${dims};')
            g.queue_fixed_array_runtime_init(qname, val_id, v_type)
        } else if ct != 'void' {
            g.writeln('${ct} ${qname};')
            // The initializer is not a compile-time constant (e.g. `os.args =
            // arguments()`), so it cannot be a C static initializer. Run it at startup
            // in _vinit; otherwise the const stays zero/empty and first use is wrong.
            g.runtime_inits << '\t${qname} = ${expr_str};'
            if v_type is types.Map {
                g.queue_map_literal_sets(qname, val_id, v_type)
            }
        }
        g.tc.cur_module = old_module
        return
    }
    if v_type is types.String {
        g.writeln('string ${qname} = ${expr_str};')
    } else if v_type is types.ArrayFixed {
        c_elem, dims := g.fixed_array_decl_parts(v_type)
        g.writeln('const ${c_elem} ${qname}${dims} = ${expr_str};')
    } else if v_type is types.Primitive || v_type is types.Char || v_type is types.Rune
        || v_type is types.ISize || v_type is types.USize || v_type is types.Enum
        || ct in ['bool', 'char', 'i8', 'i16', 'i32', 'int', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'float', 'double', 'isize', 'usize'] {
        if qname == 'max_len' && ct == 'int' {
            g.writeln('enum { ${qname} = ${expr_str} };')
        } else if g.name_collides_with_struct_field(qname) {
            // A `#define` whose name matches a struct field would wrongly expand every
            // `.field` access; emit a real `const` variable instead (C keeps member and
            // ordinary-identifier namespaces separate, so there is no collision).
            g.writeln('static const ${ct} ${qname} = ${expr_str};')
        } else {
            g.writeln('#define ${qname} (${expr_str})')
        }
    } else {
        g.writeln('const ${ct} ${qname} = ${expr_str};')
    }
    g.tc.cur_module = old_module
}

// name_collides_with_struct_field reports whether a name is the C name of any struct
// field, building the set lazily on first use.
fn (mut g FlatGen) name_collides_with_struct_field(name string) bool {
    if g.field_name_set.len == 0 {
        for _, fields in g.tc.structs {
            for f in fields {
                g.field_name_set[c_field_name(f.name)] = true
            }
        }
        // Guard against an all-fieldless program re-scanning every call.
        g.field_name_set[''] = true
    }
    return name in g.field_name_set
}

fn (g &FlatGen) const_expr_needs_runtime_storage(expr string) bool {
    return expr.contains('array_new(') || expr.contains('new_map(') || expr.contains('({')
        || expr.contains('__map_')
}

fn (mut g FlatGen) queue_map_literal_sets(target string, val_id flat.NodeId, map_type types.Map) {
    if int(val_id) < 0 || int(val_id) >= g.a.nodes.len {
        return
    }
    node := g.a.nodes[int(val_id)]
    if node.kind != .map_init {
        return
    }
    c_key := g.tc.c_type(map_type.key_type)
    c_val := g.tc.c_type(map_type.value_type)
    for i := 0; i + 1 < node.children_count; i += 2 {
        key := g.expr_to_string_with_expected_type(g.a.child(&node, i), map_type.key_type)
        val := g.expr_to_string_with_expected_type(g.a.child(&node, i + 1), map_type.value_type)
        g.runtime_inits << '\tmap__set(&${target}, &(${c_key}[]){${key}}, &(${c_val}[]){${val}});'
    }
}

fn (mut g FlatGen) queue_fixed_array_runtime_init(target string, val_id flat.NodeId, fixed types.ArrayFixed) bool {
    expr := g.fixed_array_compound_literal_expr(val_id, fixed)
    if expr.trim_space().len == 0 {
        return false
    }
    g.runtime_inits << '\tmemmove(${target}, ${expr}, sizeof(${target}));'
    return true
}

fn (mut g FlatGen) fixed_array_compound_literal_expr(val_id flat.NodeId, fixed types.ArrayFixed) string {
    init := g.fixed_array_initializer_string(val_id, fixed)
    if init.trim_space().len == 0 {
        return ''
    }
    c_elem, dims := g.fixed_array_decl_parts(fixed)
    return '(${c_elem}${dims})${init}'
}

fn (mut g FlatGen) fixed_array_initializer_string(val_id flat.NodeId, fixed types.ArrayFixed) string {
    if int(val_id) < 0 || int(val_id) >= g.a.nodes.len {
        return ''
    }
    node := g.a.nodes[int(val_id)]
    if node.kind == .postfix && node.children_count > 0 {
        return g.fixed_array_initializer_string(g.a.child(&node, 0), fixed)
    }
    if node.kind == .array_init && node.children_count == 0 {
        return '{0}'
    }
    if node.kind != .array_literal {
        return ''
    }
    mut parts := []string{}
    for i in 0 .. node.children_count {
        child_id := g.a.child(&node, i)
        if fixed.elem_type is types.ArrayFixed {
            parts << g.fixed_array_initializer_string(child_id, fixed.elem_type)
        } else {
            parts << g.fixed_array_elem_initializer_string(child_id, fixed.elem_type)
        }
    }
    return '{${parts.join(', ')}}'
}

fn (mut g FlatGen) fixed_array_elem_initializer_string(val_id flat.NodeId, elem_type types.Type) string {
    if int(val_id) < 0 || int(val_id) >= g.a.nodes.len {
        return '0'
    }
    node := g.a.nodes[int(val_id)]
    if g.is_const_expr(val_id) && !(node.kind == .prefix && node.op == .amp) {
        const_val := g.const_expr_to_string(val_id, []string{})
        if const_val.trim_space().len > 0 {
            return const_val
        }
    }
    expr := g.expr_to_string_with_expected_type(val_id, elem_type)
    if expr.trim_space().len > 0 {
        return expr
    }
    return '0'
}

fn (mut g FlatGen) precompute_consts() string {
    old_sb := g.sb
    old_line_start := g.line_start
    g.sb = strings.new_builder(1024)
    g.line_start = true
    mut emitted := map[string]bool{}
    mut deferred := []string{}
    mut names := g.const_init_order.clone()
    for name, _ in g.const_vals {
        if g.is_const_alias_name(name) || name in names {
            continue
        }
        names << name
    }
    for name in names {
        val_id := g.const_vals[name] or { continue }
        if g.is_const_alias_name(name) {
            continue
        }
        if int(val_id) < 0 || int(val_id) >= g.a.nodes.len {
            continue
        }
        old_module := g.tc.cur_module
        if name in g.const_modules {
            g.tc.cur_module = g.const_modules[name]
        }
        deps := g.const_get_deps(val_id)
        g.tc.cur_module = old_module
        mut all_met := true
        for dep in deps {
            if dep !in emitted {
                all_met = false
                break
            }
        }
        if !all_met {
            deferred << name
        } else {
            g.emit_const(name, val_id)
            emitted[name] = true
        }
    }
    for _ in 0 .. 20 {
        if deferred.len == 0 {
            break
        }
        mut remaining := []string{}
        for name in deferred {
            val_id := g.const_vals[name]
            deps := g.const_get_deps(val_id)
            mut all_met := true
            for dep in deps {
                if dep !in emitted {
                    all_met = false
                    break
                }
            }
            if all_met {
                g.emit_const(name, val_id)
                emitted[name] = true
            } else {
                remaining << name
            }
        }
        deferred = remaining.clone()
    }
    for name in deferred {
        g.emit_const(name, g.const_vals[name])
    }
    if g.const_vals.len > 0 {
        g.writeln('')
    }
    result := g.sb.str()
    // `.str()` copies out of the temporary const builder.
    unsafe { g.sb.free() }
    g.sb = old_sb
    g.line_start = old_line_start
    return result
}

fn (g &FlatGen) is_const_expr(id flat.NodeId) bool {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return false
    }
    node := g.a.nodes[int(id)]
    return match node.kind {
        .int_literal, .float_literal, .bool_literal, .char_literal, .string_literal, .enum_val,
        .sizeof_expr, .offsetof_expr {
            true
        }
        .prefix {
            if node.op == .amp {
                false
            } else {
                g.is_const_expr(g.a.child(&node, 0))
            }
        }
        .infix {
            g.is_const_expr(g.a.child(&node, 0)) && g.is_const_expr(g.a.child(&node, 1))
        }
        .paren {
            g.is_const_expr(g.a.child(&node, 0))
        }
        .cast_expr {
            g.is_const_expr(g.a.child(&node, 0))
        }
        .ident {
            g.const_ref_name(node.value).len > 0
        }
        .selector {
            const_name := g.const_ref_name_from_node(node)
            if const_name.len > 0 {
                true
            } else if node.children_count > 0 {
                base := g.a.child_node(&node, 0)
                base.kind == .ident && base.value == 'C'
            } else {
                false
            }
        }
        .array_literal {
            mut all_const := true
            for ci in 0 .. node.children_count {
                if !g.is_const_expr(g.a.child(&node, ci)) {
                    all_const = false
                    break
                }
            }
            all_const
        }
        .struct_init {
            mut all_const := true
            for ci in 0 .. node.children_count {
                child := g.a.child_node(&node, ci)
                if child.kind == .field_init {
                    if ftyp := g.struct_field_type(node.value, child.value) {
                        if ftyp is types.Array || ftyp is types.Map {
                            all_const = false
                            break
                        }
                    }
                }
                if child.children_count > 0 && !g.is_const_expr(g.a.child(child, 0)) {
                    all_const = false
                    break
                }
            }
            all_const
        }
        else {
            false
        }
    }
}

fn (g &FlatGen) is_runtime_assignable(id flat.NodeId) bool {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return false
    }
    node := g.a.nodes[int(id)]
    return match node.kind {
        .string_literal, .string_interp {
            true
        }
        .call {
            g.is_runtime_assignable_call(&node)
        }
        .ident {
            true
        }
        .or_expr {
            true
        }
        .infix {
            if node.children_count >= 2 {
                lhs_type := g.tc.resolve_type(g.a.child(&node, 0))
                rhs_type := g.tc.resolve_type(g.a.child(&node, 1))
                lhs_type is types.String || rhs_type is types.String
            } else {
                false
            }
        }
        .cast_expr, .prefix, .struct_init, .map_init {
            true
        }
        else {
            false
        }
    }
}

fn (g &FlatGen) is_runtime_assignable_call(node &flat.Node) bool {
    if node.children_count == 0 {
        return false
    }
    callee_id := g.a.child(node, 0)
    if int(callee_id) < 0 {
        return false
    }
    callee := g.a.nodes[int(callee_id)]
    return callee.kind == .ident || callee.kind == .selector
}

fn (g &FlatGen) op_str(op flat.Op) string {
    return match op {
        .plus { '+' }
        .minus { '-' }
        .mul { '*' }
        .div { '/' }
        .mod { '%' }
        .eq { '==' }
        .ne { '!=' }
        .lt { '<' }
        .gt { '>' }
        .le { '<=' }
        .ge { '>=' }
        .amp { '&' }
        .pipe { '|' }
        .xor { '^' }
        .left_shift { '<<' }
        .right_shift { '>>' }
        .right_shift_unsigned { '>>' }
        .logical_and { '&&' }
        .logical_or { '||' }
        .not { '!' }
        .bit_not { '~' }
        .assign { '=' }
        .plus_assign { '+=' }
        .minus_assign { '-=' }
        .mul_assign { '*=' }
        .div_assign { '/=' }
        .mod_assign { '%=' }
        .amp_assign { '&=' }
        .pipe_assign { '|=' }
        .xor_assign { '^=' }
        .left_shift_assign { '<<=' }
        .right_shift_assign { '>>=' }
        .right_shift_unsigned_assign { '>>=' }
        .inc { '++' }
        .dec { '--' }
        .dot { '.' }
        .arrow { '->' }
        .none { '' }
    }
}

fn (mut g FlatGen) write(s string) {
    if g.line_start {
        g.write_indent()
    }
    if s.len == 0 {
        if g.indent > 0 {
            g.line_start = false
        }
        return
    }
    g.sb.write_string(s)
    g.line_start = s[s.len - 1] == `\n`
}

fn (mut g FlatGen) writeln(s string) {
    if s.len > 0 {
        if g.line_start {
            g.write_indent()
        }
        g.sb.write_string(s)
    }
    g.sb.write_string('\n')
    g.line_start = true
}

fn (mut g FlatGen) write_indent() {
    for _ in 0 .. g.indent {
        g.sb.write_string('\t')
    }
}