// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module c

import os
import term
import strings
import hash.fnv1a
import v.ast
import v.pref
import v.token
import v.util
import v.util.version
import v.depgraph
import v.type_resolver
import sync.pool

// Note: some of the words in c_reserved, are not reserved in C, but are
// in C++, or have special meaning in V
const c_reserved = ['asm', 'array', 'auto', 'bool', 'break', 'calloc', 'case', 'char', 'class',
    'complex', 'const', 'continue', 'default', 'delete', 'do', 'double', 'else', 'enum', 'error',
    'exit', 'export', 'extern', 'false', 'float', 'for', 'free', 'goto', 'if', 'inline', 'int',
    'long', 'malloc', 'namespace', 'new', 'nil', 'panic', 'register', 'restrict', 'return', 'short',
    'signed', 'sizeof', 'static', 'string', 'struct', 'switch', 'typedef', 'typename', 'typeof',
    'union', 'unix', 'unsigned', 'void', 'volatile', 'while', 'template', 'true', 'stdout', 'stdin',
    'stderr', 'errno', 'environ', 'requires']
const c_reserved_chk = token.new_keywords_matcher_from_array_trie(c_reserved)
// same order as in token.Kind
const cmp_str = ['eq', 'ne', 'gt', 'lt', 'ge', 'le']
// when operands are switched
const cmp_rev = ['eq', 'ne', 'lt', 'gt', 'le', 'ge']
const result_name = ast.result_name
const option_name = ast.option_name
const max_c_string_literal_segment_len = 12000

struct ScopeGcPin {
    post_stmt string
}

pub struct Gen {
    pref                &pref.Preferences = unsafe { nil }
    field_data_type     ast.Type // cache her to avoid map lookups
    enum_data_type      ast.Type // cache her to avoid map lookups
    variant_data_type   ast.Type // cache her to avoid map lookups
    module_built        string
    timers_should_print bool
mut:
    out        strings.Builder
    extern_out strings.Builder // extern declarations for -parallel-cc
    // line_nr                   int
    cheaders                             strings.Builder
    preincludes                          strings.Builder // allows includes to go before `definitions`
    postincludes                         strings.Builder // allows includes to go after all the rest of the code generation
    includes                             strings.Builder // all C #includes required by V modules
    typedefs                             strings.Builder
    enum_typedefs                        strings.Builder // enum types
    definitions                          strings.Builder // typedefs, defines etc (everything that goes to the top of the file)
    type_definitions                     strings.Builder // typedefs, defines etc (everything that goes to the top of the file)
    sort_fn_definitions                  strings.Builder // sort fns
    alias_definitions                    strings.Builder // alias fixed array of non-builtin
    hotcode_definitions                  strings.Builder // -live declarations & functions
    channel_definitions                  strings.Builder // channel related code
    thread_definitions                   strings.Builder // thread defines
    comptime_definitions                 strings.Builder // custom defines, given by -d/-define flags on the CLI
    type_default_vars                    strings.Builder // type_default() var declarations
    cleanup                              strings.Builder
    cleanups                             map[string]strings.Builder // contents of `void _vcleanup(){}`
    gowrappers                           strings.Builder            // all go callsite wrappers
    waiter_fn_definitions                strings.Builder            // waiter fns definitions
    auto_str_funcs                       strings.Builder            // function bodies of all auto generated _str funcs
    dump_funcs                           strings.Builder            // function bodies of all auto generated _str funcs
    pcs_declarations                     strings.Builder            // -prof profile counter declarations for each function
    cov_declarations                     strings.Builder            // -cov coverage
    embedded_data                        strings.Builder            // data to embed in the executable/binary
    shared_types                         strings.Builder            // shared/lock types
    shared_functions                     strings.Builder            // shared constructors
    out_options_forward                  strings.Builder            // forward `option_xxxx` types
    out_options                          strings.Builder            // `option_xxxx` types
    out_results_forward                  strings.Builder            // forward`result_xxxx` types
    out_results                          strings.Builder            // `result_xxxx` types
    json_forward_decls                   strings.Builder            // json type forward decls
    sql_buf                              strings.Builder            // for writing exprs to args via `sqlite3_bind_int()` etc
    global_const_defs                    map[string]GlobalConstDef
    vsafe_arithmetic_ops                 map[string]VSafeArithmeticOp // 'VSAFE_DIV_u8' -> {11, /}, 'VSAFE_MOD_u8' -> {11,%}, 'VSAFE_MOD_i64' -> the same but with 9
    sorted_global_const_names            []string
    file                                 &ast.File  = unsafe { nil }
    table                                &ast.Table = unsafe { nil }
    mods_with_c_includes                 map[string]bool
    styp_cache                           map[ast.Type]string
    no_eq_method_types                   map[ast.Type]bool // types that does not need to call its auto eq methods for optimization
    generic_parts_cache                  []i8              // type idx -> 0 unknown, 1 false, 2 true
    unwrap_generic_cache                 map[u64]ast.Type
    resolved_scope_var_type_cache        map[u64]ast.Type
    unique_file_path_hash                u64 // a hash of file.path, used for making auxiliary fn generation unique (like `compare_xyz`)
    fn_decl                              &ast.FnDecl = unsafe { nil } // pointer to the FnDecl we are currently inside otherwise 0
    last_fn_c_name                       string
    tmp_count                            int  // counter for unique tmp vars (_tmp1, _tmp2 etc); resets at the start of each fn.
    tmp_count_af                         int  // a separate tmp var counter for autofree fn calls
    tmp_count_declarations               int  // counter for unique tmp names (_d1, _d2 etc); does NOT reset, used for C declarations
    global_tmp_count                     int  // like tmp_count but global and not reset in each function
    discard_or_result                    bool // do not safe last ExprStmt of `or` block in tmp variable to defer ongoing expr usage
    is_direct_array_access               bool // inside a `[direct_array_access fn a() {}` function
    is_assign_lhs                        bool // inside left part of assign expr (for array_set(), etc)
    is_void_expr_stmt                    bool // ExprStmt whose result is discarded
    is_arraymap_set                      bool // map or array set value state
    is_amp                               bool // for `&Foo{}` to merge PrefixExpr `&` and StructInit `Foo{}`; also for `&u8(unsafe { nil })` etc
    is_sql                               bool // Inside `sql db{}` statement, generating sql instead of C (e.g. `and` instead of `&&` etc)
    is_shared                            bool // for initialization of hidden mutex in `[rw]shared` literals
    is_vlines_enabled                    bool // is it safe to generate #line directives when -g is passed
    is_autofree                          bool // false, inside the bodies of fns marked with [manualfree], otherwise === g.pref.autofree
    is_autofree_tmp                      bool // when generating autofree temporary variables
    is_builtin_mod                       bool
    is_json_fn                           bool // inside json.encode()
    is_js_call                           bool // for handling a special type arg #1 `json.decode(User, ...)`
    is_fn_index_call                     bool
    is_cc_msvc                           bool // g.pref.ccompiler == 'msvc'
    is_option_auto_heap                  bool
    vlines_path                          string            // set to the proper path for generating #line directives
    options_pos_forward                  int               // insertion point to forward
    options_forward                      []string          // to forward
    options                              map[string]string // to avoid duplicates
    results_forward                      []string          // to forward
    results                              map[string]string // to avoid duplicates
    done_options                         shared []string   // to avoid duplicates
    done_results                         shared []string   // to avoid duplicates
    array_typedefs                       []string          // to avoid duplicate array typedefs
    written_array_typedefs               int
    done_typedef_phase                   bool              // set after write_typedef_types() completes
    late_chan_types                      shared []string   // concrete channel cnames discovered during file generation
    emitted_chan_types                   map[string]bool   // concrete channel typedefs/helpers already emitted
    c_extern_signature_types             map[string]bool   // C signature-only type decls already emitted
    chan_pop_options                     map[string]string // types for `x := <-ch or {...}`
    chan_push_options                    map[string]string // types for `ch <- x or {...}`
    mtxs                                 string            // array of mutexes if the `lock` has multiple variables
    tmp_var_ptr                          map[string]bool   // indicates if the tmp var passed to or_block() is a ptr
    labeled_loops                        map[string]&ast.Stmt
    contains_ptr_cache                   map[ast.Type]bool
    boehm_keep_decl                      map[string]bool
    boehm_keep_gen                       map[string]bool
    boehm_keep_busy                      map[string]bool
    inner_loop                           &ast.Stmt = unsafe { nil }
    cur_indexexpr                        []int          // list of nested indexexpr which generates array_set/map_set
    shareds                              map[int]string // types with hidden mutex for which decl has been emitted
    coverage_files                       map[u64]&CoverageInfo
    inside_smartcast                     bool
    inside_ternary                       int  // ?: comma separated statements on a single line
    inside_map_postfix                   bool // inside map++/-- postfix expr
    inside_map_infix                     bool // inside map<</+=/-= infix expr
    wrote_windows_tcc_atomic_include     bool
    inside_left_shift                    bool // generating the left operand of `<<`
    inside_assign                        bool
    inside_map_index                     bool
    inside_array_index                   bool
    inside_array_fixed_struct            bool
    inside_opt_or_res                    bool
    inside_opt_data                      bool
    inside_if_option                     bool
    inside_if_result                     bool
    inside_match_option                  bool
    inside_match_result                  bool
    inside_veb_tmpl                      bool
    inside_return                        bool
    inside_return_expr                   bool
    inside_return_tmpl                   bool
    inside_struct_init                   bool
    inside_or_block                      bool
    inside_call                          bool
    inside_curry_call                    bool // inside foo()()!, foo()()?, foo()()
    inside_dump_fn                       bool
    inside_c_extern                      bool // inside `@[c_extern] fn C.somename(param1 int, param2 voidptr, param3 &char) &char`
    active_call_generic_names            []string
    active_call_concrete_types           []ast.Type
    expected_fixed_arr                   bool
    inside_for_c_stmt                    bool
    inside_cast_in_heap                  int // inside cast to interface type in heap (resolve recursive calls)
    inside_cast                          bool
    inside_sumtype_cast                  bool
    inside_selector                      bool
    inside_selector_lhs                  bool
    inside_selector_deref                bool // indicates if the inside selector was already dereferenced
    inside_memset                        bool
    inside_const                         bool
    inside_array_item                    bool
    inside_const_opt_or_res              bool
    inside_lambda                        bool
    inside_cinit                         bool
    inside_global_decl                   bool
    inside_interface_deref               bool
    inside_assign_fn_var                 bool
    outer_tmp_var                        string // tmp var from outer context (e.g. from stmts_with_tmp_var) to be used by nested if/match expressions
    last_tmp_call_var                    []string
    last_if_option_type                  ast.Type // stores the expected if type on nested if expr
    loop_depth                           int
    unsafe_level                         int
    ternary_names                        map[string]string
    ternary_level_names                  map[string][]string
    arraymap_set_pos                     int              // map or array set value position
    stmt_path_pos                        []int            // positions of each statement start, for inserting C statements before the current statement
    skip_stmt_pos                        bool             // for handling if expressions + autofree (since both prepend C statements)
    left_is_opt                          bool             // left hand side on assignment is an option
    right_is_opt                         bool             // right hand side on assignment is an option
    assign_ct_type                       map[int]ast.Type // left hand side resolved comptime type
    expected_rhs_type_by_pos             map[int]ast.Type // expected value type for local RHS expressions
    indent                               int
    empty_line                           bool
    assign_op                            token.Kind // *=, =, etc (for array_set)
    defer_stmts                          []ast.DeferStmt
    defer_ifdef                          string
    defer_profile_code                   string
    inside_defer_generation              bool
    defer_vars                           []string
    closure_structs                      []string
    str_types                            []StrType       // types that need automatic str() generation
    generated_str_fns                    []StrType       // types that already have a str() function
    str_fn_names                         shared []string // remove duplicate function names
    threaded_fns                         shared []string // for generating unique wrapper types and fns for `go xxx()`
    waiter_fns                           shared []string // functions that wait for `go xxx()` to finish
    needed_equality_fns                  []ast.Type
    generated_eq_fns                     []ast.Type
    needed_map_key_fns                   []ast.Type
    generated_map_key_fns                map[ast.Type]bool
    generated_array_interface_cast_fns   shared map[string]bool
    generated_array_interface_repeat_fns shared map[string]bool
    array_sort_fn                        shared []string
    array_sort_wrappers                  shared []string
    array_contains_types                 []ast.Type
    array_index_types                    []ast.Type
    array_last_index_types               []ast.Type
    array_get_types                      []ast.Type
    auto_fn_definitions                  []string // auto generated functions definition list
    sumtype_casting_fns                  []SumtypeCastingFn
    anon_fn_definitions                  []string        // anon generated functions definition list
    anon_fns                             shared []string // remove duplicate anon generated functions
    sumtype_definitions                  map[string]bool // `_TypeA_to_sumtype_TypeB()` fns that have been generated
    trace_fn_definitions                 []string
    json_types                           []ast.Type // to avoid json gen duplicates
    json_types_pos                       map[ast.Type]token.Pos
    json_gen_pos                         token.Pos
    pcs                                  []ProfileCounterMeta // -prof profile counter fn_names => fn counter name
    hotcode_fn_names                     []string
    hotcode_fpaths                       []string
    embedded_files                       []ast.EmbeddedFile
    sql_i                                int
    sql_stmt_name                        string
    sql_bind_name                        string
    sql_idents                           []string
    sql_idents_types                     []ast.Type
    sql_left_type                        ast.Type
    sql_table_name                       string
    sql_table_typ                        ast.Type // the table type, used for generic types lookup
    sql_fkey                             string
    sql_parent_id                        string
    sql_side                             SqlExprSide // left or right, to distinguish idents in `name == name`
    sql_last_stmt_out_len                int
    strs_to_free0                        []string // strings.Builder
    // strs_to_free          []string // strings.Builder
    // tmp_arg_vars_to_free  []string
    // autofree_pregen       map[string]string
    // autofree_pregen_buf   strings.Builder
    // autofree_tmp_vars     []string // to avoid redefining the same tmp vars in a single function
    // nr_vars_to_free       int
    // doing_autofree_tmp    bool
    type_resolver                    type_resolver.TypeResolver
    comptime                         &type_resolver.ResolverInfo = unsafe { nil }
    prevent_sum_type_unwrapping_once bool // needed for assign new values to sum type
    // used in match multi branch
    // TypeOne, TypeTwo {}
    // where an aggregate (at least two types) is generated
    // sum type deref needs to know which index to deref because unions take care of the correct field
    aggregate_type_idx  int
    arg_no_auto_deref   bool            // smartcast must not be dereferenced
    branch_parent_pos   int             // used in BranchStmt (continue/break) for autofree stop position
    returned_var_names  map[string]bool // to detect that vars doesn't need to be freed since it's being returned
    infix_left_var_name string          // a && if expr
    curr_var_name       []string        // curr var name on assignment
    called_fn_name      string
    timers              &util.Timers = util.get_timers()
    force_main_console  bool // true when @[console] used on fn main()
    uses_power          bool
    uses_power_u64      bool
    as_cast_type_names  map[string]string // table for type name lookup in runtime (for __as_cast)
    obf_table           map[string]string
    referenced_fns      shared map[string]bool // functions that have been referenced
    nr_closures         int
    expected_cast_type  ast.Type // for match expr of sumtypes
    expected_arg_mut    bool     // generating a mutable fn parameter
    or_expr_return_type ast.Type // or { 0, 1 } return type
    anon_fn             &ast.AnonFn
    tests_inited        bool
    has_main            bool
    // main_fn_decl_node  ast.FnDecl
    cur_mod                 ast.Module
    cur_concrete_types      []ast.Type // do not use table.cur_concrete_types because table is global, so should not be accessed by different threads
    cur_fn                  &ast.FnDecl = unsafe { nil } // same here
    cur_lock                ast.LockExpr
    cur_struct_init_typ     ast.Type
    zero_struct_init_stack  []ast.Type
    autofree_methods        map[ast.Type]string
    generated_free_methods  map[ast.Type]bool
    generated_free_fn_names map[string]bool
    autofree_scope_stmts    []string
    use_segfault_handler    bool = true
    test_function_names     []string
    /////////
    // out_parallel []strings.Builder
    // out_idx      int
    out_fn_start_pos     []int  // for generating multiple .c files, stores locations of all fn positions in `out` string builder
    static_modifier      string // for parallel_cc
    static_non_parallel  string // for non -parallel_cc
    has_reflection       bool   // v.reflection has been imported
    has_debugger         bool   // $dbg has been used in the code
    reflection_strings   &map[string]int
    defer_return_tmp_var string
    veb_filter_fn_name   string   // veb__filter, used by $veb.html() for escaping strings in templates
    export_funcs         []string // for .dll export function names
    //
    type_default_impl_level int
    preinclude_nodes        []&ast.HashStmtNode // allows hash stmts to go before `includes`
    include_nodes           []&ast.HashStmtNode // all hash stmts to go `includes`
    definition_nodes        []&ast.HashStmtNode // allows hash stmts to go `definitions`
    postinclude_nodes       []&ast.HashStmtNode // allows hash stmts to go after all the rest of the code generation
    curr_comptime_node      ast.Expr = ast.empty_expr // current `$if` expr
    is_builtin_overflow_mod bool
    do_int_overflow_checks  bool // outside a `@[ignore_overflow] fn abc() {}` or a function in `builtin.overflow`
    //
    tid string // the thread id of the file processor in the thread pool (log it to debug issues in parallel cgen)
    fid int    // the index of ast.File that is currently processed (log it to debug issues in parallel cgen)
}

@[heap]
pub struct GenOutput {
pub:
    header           string          // produced output for out.h (-parallel-cc)
    res_builder      strings.Builder // produced output (complete)
    out_str          string          // produced output from g.out
    out0_str         string          // helpers output (auto fns, dump fns) for out_0.c (-parallel-cc)
    extern_str       string          // extern chunk for (-parallel-cc)
    out_fn_start_pos []int           // fn decl positions
}

pub fn gen(files []&ast.File, mut table ast.Table, pref_ &pref.Preferences) GenOutput {
    mut module_built := ''
    if pref_.build_mode == .build_module || pref_.is_o {
        for file in files {
            if pref_.build_mode == .build_module && file.path.contains(pref_.path)
                && file.mod.short_name == pref_.path.all_after_last(os.path_separator).trim_right(os.path_separator) {
                module_built = file.mod.name
                break
            } else if pref_.is_o && file.path.contains(pref_.path) {
                module_built = file.mod.name
                break
            }
        }
    }
    mut timers_should_print := false
    $if time_cgening ? {
        timers_should_print = true
    }
    mut reflection_strings := map[string]int{}
    mut global_g := Gen{
        fid:                           -1
        tid:                           v_gettid().hex()
        file:                          unsafe { nil }
        out:                           strings.new_builder(512000)
        cheaders:                      strings.new_builder(15000)
        includes:                      strings.new_builder(100)
        preincludes:                   strings.new_builder(100)
        postincludes:                  strings.new_builder(100)
        typedefs:                      strings.new_builder(100)
        enum_typedefs:                 strings.new_builder(100)
        type_definitions:              strings.new_builder(100)
        sort_fn_definitions:           strings.new_builder(100)
        alias_definitions:             strings.new_builder(100)
        hotcode_definitions:           strings.new_builder(100)
        channel_definitions:           strings.new_builder(100)
        thread_definitions:            strings.new_builder(100)
        comptime_definitions:          strings.new_builder(100)
        definitions:                   strings.new_builder(100)
        gowrappers:                    strings.new_builder(100)
        auto_str_funcs:                strings.new_builder(100)
        dump_funcs:                    strings.new_builder(100)
        pcs_declarations:              strings.new_builder(100)
        cov_declarations:              strings.new_builder(100)
        embedded_data:                 strings.new_builder(1000)
        out_options_forward:           strings.new_builder(100)
        out_options:                   strings.new_builder(100)
        out_results_forward:           strings.new_builder(100)
        out_results:                   strings.new_builder(100)
        shared_types:                  strings.new_builder(100)
        shared_functions:              strings.new_builder(100)
        json_forward_decls:            strings.new_builder(100)
        sql_buf:                       strings.new_builder(100)
        table:                         table
        mods_with_c_includes:          modules_with_c_includes(files)
        pref:                          pref_
        fn_decl:                       unsafe { nil }
        anon_fn:                       unsafe { nil }
        is_autofree:                   pref_.autofree
        indent:                        -1
        module_built:                  module_built
        timers_should_print:           timers_should_print
        timers:                        util.new_timers(
            should_print: timers_should_print
            label:        'global_cgen'
        )
        inner_loop:                    unsafe { &ast.empty_stmt }
        field_data_type:               table.find_type('FieldData')
        enum_data_type:                table.find_type('EnumData')
        variant_data_type:             table.find_type('VariantData')
        is_cc_msvc:                    pref_.ccompiler == 'msvc'
        use_segfault_handler:          pref_.should_use_segfault_handler()
        static_modifier:               if pref_.parallel_cc || pref_.is_o { 'static ' } else { '' }
        static_non_parallel:           if !pref_.parallel_cc { 'static ' } else { '' }
        has_reflection:                'v.reflection' in table.modules
        has_debugger:                  'v.debug' in table.modules
        reflection_strings:            &reflection_strings
        generated_map_key_fns:         map[ast.Type]bool{}
        c_extern_signature_types:      map[string]bool{}
        boehm_keep_decl:               map[string]bool{}
        boehm_keep_gen:                map[string]bool{}
        boehm_keep_busy:               map[string]bool{}
        generic_parts_cache:           []i8{len: table.type_symbols.len}
        unwrap_generic_cache:          map[u64]ast.Type{}
        resolved_scope_var_type_cache: map[u64]ast.Type{}
    }

    global_g.type_resolver = type_resolver.TypeResolver.new(table, global_g)
    global_g.comptime = &global_g.type_resolver.info
    // anon fn may include assert and thus this needs
    // to be included before any test contents are written
    if pref_.is_test {
        global_g.write_tests_definitions()
    }

    util.timing_start('cgen init')
    for mod in global_g.table.modules {
        global_g.cleanups[mod] = strings.new_builder(100)
    }
    global_g.init()
    util.timing_measure('cgen init')
    global_g.tests_inited = false
    global_g.file = files.last()
    if !pref_.no_parallel {
        util.timing_start('cgen parallel processing')
        mut pp := pool.new_pool_processor(callback: cgen_process_one_file_cb)
        pp.set_shared_context(global_g) // TODO: make global_g shared
        pp.work_on_items(files)
        util.timing_measure('cgen parallel processing')

        util.timing_start('cgen unification')
        for g in pp.get_results_ref[Gen]() {
            global_g.embedded_files << g.embedded_files
            global_g.out << g.out
            global_g.cheaders << g.cheaders
            global_g.preincludes << g.preincludes
            global_g.postincludes << g.postincludes
            global_g.includes << g.includes
            global_g.typedefs << g.typedefs
            global_g.type_definitions << g.type_definitions
            global_g.sort_fn_definitions << g.sort_fn_definitions
            global_g.alias_definitions << g.alias_definitions
            global_g.definitions << g.definitions
            global_g.gowrappers << g.gowrappers
            global_g.waiter_fn_definitions << g.waiter_fn_definitions
            global_g.auto_str_funcs << g.auto_str_funcs
            global_g.dump_funcs << g.auto_str_funcs
            global_g.comptime_definitions << g.comptime_definitions
            global_g.pcs_declarations << g.pcs_declarations
            global_g.cov_declarations << g.cov_declarations
            global_g.hotcode_definitions << g.hotcode_definitions
            global_g.embedded_data << g.embedded_data
            global_g.shared_types << g.shared_types
            global_g.shared_functions << g.shared_functions
            global_g.export_funcs << g.export_funcs

            global_g.force_main_console = global_g.force_main_console || g.force_main_console
            global_g.uses_power = global_g.uses_power || g.uses_power
            global_g.uses_power_u64 = global_g.uses_power_u64 || g.uses_power_u64

            // merge maps
            for k, v in g.vsafe_arithmetic_ops {
                global_g.vsafe_arithmetic_ops[k] = v
            }
            for k, v in g.global_const_defs {
                global_g.global_const_defs[k] = v
            }
            for k, v in g.shareds {
                global_g.shareds[k] = v
            }
            for k, v in g.chan_pop_options {
                global_g.chan_pop_options[k] = v
            }
            for k, v in g.chan_push_options {
                global_g.chan_push_options[k] = v
            }
            for k, v in g.options {
                global_g.options[k] = v
            }
            for k, v in g.results {
                global_g.results[k] = v
            }
            for k, v in g.as_cast_type_names {
                global_g.as_cast_type_names[k] = v
            }
            for k, v in g.sumtype_definitions {
                global_g.sumtype_definitions[k] = v
            }
            for k, v in g.coverage_files {
                global_g.coverage_files[k] = v
            }
            global_g.json_forward_decls << g.json_forward_decls
            global_g.enum_typedefs << g.enum_typedefs
            global_g.channel_definitions << g.channel_definitions
            global_g.thread_definitions << g.thread_definitions
            global_g.sql_buf << g.sql_buf
            global_g.cleanups[g.file.mod.name] << g.cleanup

            for str_type in g.str_types {
                global_g.str_types << str_type
            }
            for scf in g.sumtype_casting_fns {
                mut already_exists := false
                for existing in global_g.sumtype_casting_fns {
                    if existing.fn_name == scf.fn_name {
                        already_exists = true
                        break
                    }
                }
                if !already_exists {
                    global_g.sumtype_casting_fns << scf
                }
            }

            for at in g.array_typedefs {
                if at !in global_g.array_typedefs {
                    global_g.array_typedefs << at
                }
            }
            global_g.nr_closures += g.nr_closures
            global_g.has_main = global_g.has_main || g.has_main

            global_g.auto_fn_definitions << g.auto_fn_definitions
            global_g.anon_fn_definitions << g.anon_fn_definitions
            global_g.needed_equality_fns << g.needed_equality_fns // duplicates are resolved later in gen_equality_fns
            global_g.needed_map_key_fns << g.needed_map_key_fns
            global_g.array_contains_types << g.array_contains_types
            global_g.array_index_types << g.array_index_types
            global_g.array_last_index_types << g.array_last_index_types
            global_g.array_get_types << g.array_get_types
            global_g.pcs << g.pcs
            global_g.json_types << g.json_types
            for k, v in g.json_types_pos {
                if k !in global_g.json_types_pos || global_g.json_types_pos[k] == token.Pos{} {
                    global_g.json_types_pos[k] = v
                }
            }
            global_g.hotcode_fn_names << g.hotcode_fn_names
            global_g.hotcode_fpaths << g.hotcode_fpaths
            global_g.test_function_names << g.test_function_names
            for k, v in g.autofree_methods {
                global_g.autofree_methods[k] = v
            }
            for k, v in g.no_eq_method_types {
                global_g.no_eq_method_types[k] = v
            }
            unsafe { g.free_builders() } // free at the very end
        }
    } else {
        util.timing_start('cgen serial processing')
        for fid, file in files {
            global_g.fid = fid
            global_g.file = file
            global_g.gen_file()
            global_g.cleanups[file.mod.name].drain_builder(mut global_g.cleanup, 100)
            global_g.global_tmp_count = 0
            global_g.tmp_count = 0
        }
        util.timing_measure('cgen serial processing')
        global_g.fid = -1

        util.timing_start('cgen unification')
    }

    if !global_g.pref.new_generic_solver {
        global_g.post_process_generic_fns_for_files(files)
    }
    global_g.gen_jsons()
    global_g.dump_expr_definitions() // this uses global_g.get_str_fn, so it has to go before the below for loop
    // Pre-register auto-str types for interface implementing types that need str()
    // but don't have an explicit str() method. This must happen before final_gen_str
    // processing so all transitive str types are included.
    global_g.register_auto_str_for_interfaces()
    for i := 0; i < global_g.str_types.len; i++ {
        global_g.final_gen_str(global_g.str_types[i])
    }
    for sumtype_casting_fn in global_g.sumtype_casting_fns {
        global_g.write_sumtype_casting_fn(sumtype_casting_fn)
    }
    global_g.write_shareds()
    global_g.emit_late_chan_type_definitions()
    global_g.write_chan_pop_option_fns()
    global_g.write_chan_push_option_fns()
    global_g.gen_array_contains_methods()
    global_g.gen_array_index_methods(false) // .index()
    global_g.gen_array_index_methods(true) // .last_index()
    global_g.gen_array_get_methods()
    global_g.gen_equality_fns()
    global_g.gen_map_key_fns()
    global_g.gen_free_methods()
    global_g.register_iface_return_types()
    global_g.write_results()
    global_g.write_options()
    global_g.write_late_array_typedefs()
    global_g.sort_globals_consts()
    util.timing_measure('cgen unification')

    mut g := global_g
    util.timing_start('cgen common')

    // to make sure type idx's are the same in cached mods
    // Some distinct type symbols can still share a C name, for example repeated
    // C struct declarations. Emit one cache helper per cname to avoid duplicate
    // definitions when `-usecache` builds the main module.
    mut emitted_cache_type_idx_cnames := map[string]bool{}
    if g.pref.build_mode == .build_module {
        is_toml := g.pref.path.contains('/toml')
        for idx, sym in g.table.type_symbols {
            if idx in [0, 31] {
                continue
            }
            if is_toml && sym.cname.contains('map[string]') {
                // Temporary hack to make toml work with -usecache TODO remove
                continue
            }
            if sym.cname in emitted_cache_type_idx_cnames {
                continue
            }
            emitted_cache_type_idx_cnames[sym.cname] = true
            g.definitions.writeln('u32 _v_type_idx_${sym.cname}(); // 1build module ${g.pref.path}')
        }
    } else if g.pref.use_cache {
        is_toml := g.pref.path.contains('/toml')
        for idx, sym in g.table.type_symbols {
            if idx in [0, 31] {
                continue
            }
            if is_toml && sym.cname.contains('map[string]') {
                continue
            }
            if sym.cname in emitted_cache_type_idx_cnames {
                continue
            }
            emitted_cache_type_idx_cnames[sym.cname] = true
            g.definitions.writeln('u32 _v_type_idx_${sym.cname}() { return ${idx}; }; //lol ${g.pref.path}')
        }
    }

    // v files are finished, what remains is pure C code
    g.gen_vlines_reset()
    if g.pref.build_mode != .build_module {
        // no init in builtin.o
        g.write_init_function()
    }

    if g.pref.is_coverage {
        mut total_code_points := 0
        for k, cov in g.coverage_files {
            g.cheaders.writeln('#define _v_cov_file_offset_${k} ${total_code_points}')
            total_code_points += cov.points.len
        }
        g.cheaders.writeln('long int _v_cov[${total_code_points}] = {0};')
    }

    // insert for options forward
    if g.out_options_forward.len > 0 || g.out_results_forward.len > 0 {
        tail := g.type_definitions.cut_to(g.options_pos_forward)
        if g.out_options_forward.len > 0 {
            g.type_definitions.writeln('// #start V forward option_xxx definitions:')
            g.type_definitions.writeln(g.out_options_forward.str())
            g.type_definitions.writeln('// #end V forward option_xxx definitions\n')
        }
        if g.out_results_forward.len > 0 {
            g.type_definitions.writeln('// #start V forward result_xxx definitions:')
            g.type_definitions.writeln(g.out_results_forward.str())
            g.type_definitions.writeln('// #end V forward result_xxx definitions\n')
        }
        g.type_definitions.writeln(tail)
    }

    g.finish()

    mut b := strings.new_builder(g.out.len + 600_000)
    b.write_string(g.hashes())
    if g.use_segfault_handler || g.pref.is_prof {
        b.writeln('\n#define V_USE_SIGNAL_H')
    }
    b.write_string2('\n// V comptime_definitions:\n', g.comptime_definitions.str())
    b.write_string2('\n// V typedefs:\n', g.typedefs.str())
    b.write_string2('\n // V preincludes:\n', g.preincludes.str())
    b.write_string2('\n// V cheaders:\n', g.cheaders.str())
    if g.pcs_declarations.len > 0 {
        g.pcs_declarations.writeln('// V profile thread local:')
        g.pcs_declarations.writeln('#if defined(__cplusplus) && __cplusplus >= 201103L')
        g.pcs_declarations.writeln('\t#define PROF_THREAD_LOCAL thread_local')
        g.pcs_declarations.writeln('#elif defined(__GNUC__) && __GNUC__ < 5')
        g.pcs_declarations.writeln('\t#define PROF_THREAD_LOCAL __thread')
        g.pcs_declarations.writeln('#elif defined(_MSC_VER)')
        g.pcs_declarations.writeln('\t#define PROF_THREAD_LOCAL __declspec(thread)')
        g.pcs_declarations.writeln('#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)')
        g.pcs_declarations.writeln('\t#define PROF_THREAD_LOCAL _Thread_local')
        g.pcs_declarations.writeln('#endif')
        g.pcs_declarations.writeln('#ifndef PROF_THREAD_LOCAL')
        g.pcs_declarations.writeln('\t#if defined(__GNUC__)')
        g.pcs_declarations.writeln('\t\t#define PROF_THREAD_LOCAL __thread')
        g.pcs_declarations.writeln('\t#endif')
        g.pcs_declarations.writeln('#endif')
        g.pcs_declarations.writeln('#ifdef PROF_THREAD_LOCAL')
        g.pcs_declarations.writeln('\tstatic PROF_THREAD_LOCAL double prof_measured_time = 0.0;')
        g.pcs_declarations.writeln('#else')
        g.pcs_declarations.writeln('\tdouble prof_measured_time = 0.0; // multithreaded: wrong values for func times without its children')
        g.pcs_declarations.writeln('#endif')
        b.write_string2('\n// V profile counters:\n', g.pcs_declarations.str())
    }
    b.write_string2('\n// V includes:\n', g.includes.str())
    // Restore V's bool definition: system headers (e.g. macOS mach/vm_statistics.h)
    // may include <stdbool.h> which redefines bool to _Bool via a macro,
    // overriding V's `typedef u8 bool;` and causing type mismatches in clang.
    // In C23, bool is a keyword, so we must not redefine it.
    b.writeln('#if !defined(__cplusplus) && !defined(CUSTOM_DEFINE_no_bool)')
    b.writeln('#ifdef bool')
    b.writeln('#undef bool')
    b.writeln('#endif')
    b.writeln('#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 202311L')
    b.writeln('#ifdef CUSTOM_DEFINE_4bytebool')
    b.writeln('typedef int bool;')
    b.writeln('#else')
    b.writeln('typedef u8 bool;')
    b.writeln('#endif')
    b.writeln('#endif')
    b.writeln('#endif')
    b.writeln('\n// V global/const #define ... :')
    for var_name in g.sorted_global_const_names {
        if var := g.global_const_defs[var_name] {
            if var.def.starts_with('#define') {
                b.writeln(var.def)
            }
        }
    }
    if g.enum_typedefs.len > 0 {
        b.write_string2('\n// Enum definitions:\n', g.enum_typedefs.str())
    }
    if g.thread_definitions.len > 0 {
        b.write_string2('\n// Thread definitions:\n', g.thread_definitions.str())
    }
    if g.type_definitions.len > 0 {
        b.write_string2('\n// V type definitions:\n', g.type_definitions.str())
    }
    if g.alias_definitions.len > 0 {
        b.write_string2('\n// V alias definitions:\n', g.alias_definitions.str())
    }
    if g.shared_types.len > 0 {
        b.write_string2('\n// V shared types:\n', g.shared_types.str())
    }
    if g.out_options.len > 0 {
        b.write_string2('\n// V Option_xxx definitions:\n', g.out_options.str())
    }
    if g.out_results.len > 0 {
        b.write_string2('\n// V result_xxx definitions:\n', g.out_results.str())
    }
    b.write_string2('\n// V definitions:\n', g.definitions.str())
    if !pref_.parallel_cc {
        b.writeln('\n// V global/const non-precomputed definitions:')
        for var_name in g.sorted_global_const_names {
            if var := g.global_const_defs[var_name] {
                if !var.def.starts_with('#define') {
                    b.writeln(var.def)
                }
            }
        }
    }
    interface_table := g.interface_table()
    if interface_table.len > 0 {
        b.write_string2('\n// V interface table:\n', interface_table)
    }
    if g.sort_fn_definitions.len > 0 {
        b.write_string2('\n// V sort fn definitions:\n', g.sort_fn_definitions.str())
    }
    if g.hotcode_definitions.len > 0 {
        b.write_string2('\n// V hotcode definitions:\n', g.hotcode_definitions.str())
    }
    if g.shared_functions.len > 0 {
        b.writeln('\n// V shared type functions:\n')
        b.write_string2(g.shared_functions.str(), c_concurrency_helpers)
    }
    if g.channel_definitions.len > 0 {
        b.write_string2('\n// V channel code:\n', g.channel_definitions.str())
    }
    if g.vsafe_arithmetic_ops.len > 0 {
        for vsafe_fn_name, val in g.vsafe_arithmetic_ops {
            styp := g.styp(val.typ)
            if val.op == .div {
                if g.pref.no_builtin || g.pref.div_by_zero_is_zero {
                    b.writeln('static inline ${styp} ${vsafe_fn_name}(${styp} x, ${styp} y) { if (_unlikely_(0 == y)) { return 0; } else { return x / y; } }')
                } else {
                    b.writeln('static inline ${styp} ${vsafe_fn_name}(${styp} x, ${styp} y) { if (_unlikely_(0 == y)) { builtin___v_panic(_S("division by zero")); } return x / y; }')
                }
            } else {
                if g.pref.no_builtin || g.pref.div_by_zero_is_zero {
                    b.writeln('static inline ${styp} ${vsafe_fn_name}(${styp} x, ${styp} y) { if (_unlikely_(0 == y)) { return x; } else { return x % y; } }')
                } else {
                    b.writeln('static inline ${styp} ${vsafe_fn_name}(${styp} x, ${styp} y) { if (_unlikely_(0 == y)) { builtin___v_panic(_S("modulo by zero")); } return x % y; }')
                }
            }
        }
    }
    if g.uses_power {
        b.writeln('#include <math.h>')
        b.writeln('static inline i64 __v_pow_i64(i64 base, i64 exponent) {')
        b.writeln('\tif (exponent < 0) {')
        b.writeln('\t\tif (base == 0) {')
        b.writeln('\t\t\treturn -1;')
        b.writeln('\t\t}')
        b.writeln('\t\tif (base != 1 && base != -1) {')
        b.writeln('\t\t\treturn 0;')
        b.writeln('\t\t}')
        b.writeln('\t\treturn (exponent & 1) != 0 ? base : 1;')
        b.writeln('\t}')
        b.writeln('\ti64 value = 1;')
        b.writeln('\ti64 power = base;')
        b.writeln('\tfor (; exponent > 0; exponent >>= 1) {')
        b.writeln('\t\tif ((exponent & 1) != 0) {')
        b.writeln('\t\t\tvalue *= power;')
        b.writeln('\t\t}')
        b.writeln('\t\tpower *= power;')
        b.writeln('\t}')
        b.writeln('\treturn value;')
        b.writeln('}')
    }
    if g.uses_power_u64 {
        b.writeln('static inline u64 __v_pow_u64(u64 base, i64 exponent) {')
        b.writeln('\tif (exponent < 0) {')
        b.writeln('\t\tif (base == 0) {')
        b.writeln('\t\t\treturn ((u64)-1);')
        b.writeln('\t\t}')
        b.writeln('\t\treturn base == 1 ? 1 : 0;')
        b.writeln('\t}')
        b.writeln('\tu64 value = 1;')
        b.writeln('\tu64 power = base;')
        b.writeln('\tfor (; exponent > 0; exponent >>= 1) {')
        b.writeln('\t\tif ((exponent & 1) != 0) {')
        b.writeln('\t\t\tvalue *= power;')
        b.writeln('\t\t}')
        b.writeln('\t\tpower *= power;')
        b.writeln('\t}')
        b.writeln('\treturn value;')
        b.writeln('}')
    }
    if g.pref.is_coverage {
        b.write_string2('\n// V coverage:\n', g.cov_declarations.str())
    }
    b.writeln('\n// end of V out (header)')
    mut header := b.last_n(b.len)
    header = '#ifndef V_HEADER_FILE\n#define V_HEADER_FILE' + header
    header += '\n#endif\n'

    mut helpers := strings.new_builder(300_000)
    // Code added here (after the header) goes to out_0.c in parallel cc mode
    // Previously it went to the header which resulted in duplicated code and more code
    // to compile for the C compiler
    if g.embedded_data.len > 0 {
        helpers.write_string2('\n// V embedded data:\n', g.embedded_data.str())
    }
    if g.pref.parallel_cc {
        helpers.writeln('\n// V global/const non-precomputed definitions:')
        for var_name in g.sorted_global_const_names {
            if var := g.global_const_defs[var_name] {
                if !var.def.starts_with('#define') {
                    helpers.writeln(var.def)
                    if var.def.starts_with('/*') || var.def.starts_with('extern ') {
                        // skip C globals (comment-only placeholders) and
                        // already extern declarations (e.g. extern C globals)
                        g.extern_out.writeln(var.def)
                    } else if var.def.contains(' = ') {
                        g.extern_out.writeln('extern ${var.def.all_before(' = ')};')
                    } else {
                        g.extern_out.writeln('extern ${var.def}')
                    }
                }
            }
        }
    }
    if g.waiter_fn_definitions.len > 0 {
        if g.pref.parallel_cc {
            g.extern_out.write_string2('\n// V gowrappers waiter fns:\n',
                g.waiter_fn_definitions.bytestr())
        }
        helpers.write_string2('\n// V gowrappers waiter fns:\n', g.waiter_fn_definitions.str())
    }
    if g.auto_str_funcs.len > 0 {
        helpers.write_string2('\n// V auto str functions:\n', g.auto_str_funcs.str())
    }
    if g.auto_fn_definitions.len > 0 {
        helpers.writeln('\n// V auto functions:')
        for fn_def in g.auto_fn_definitions {
            helpers.writeln(fn_def)
        }
    }
    if g.json_forward_decls.len > 0 {
        helpers.write_string2('\n// V json forward decls:\n', g.json_forward_decls.bytestr())
        if g.pref.parallel_cc {
            g.extern_out.write_string2('\n// V json forward decls:\n', g.json_forward_decls.str())
        }
    }
    if g.gowrappers.len > 0 {
        helpers.write_string2('\n// V gowrappers:\n', g.gowrappers.str())
    }
    if g.dump_funcs.len > 0 {
        helpers.write_string2('\n// V dump functions:\n', g.dump_funcs.str())
    }
    if g.anon_fn_definitions.len > 0 {
        helpers.writeln('\n// V anon functions:')
        for fn_def in g.anon_fn_definitions {
            helpers.writeln(fn_def)
        }
    }

    if g.pref.is_shared && g.pref.os == .windows && g.export_funcs.len > 0 {
        // generate a .def for export function names, avoid function name mangle
        mut def_name := ''
        mut dll_name := ''
        if g.pref.out_name.ends_with('.dll') {
            def_name = g.pref.out_name[0..g.pref.out_name.len - 4] + '.def'
            dll_name = g.pref.out_name.all_after_last('\\')
        } else {
            def_name = g.pref.out_name + '.def'
            dll_name = g.pref.out_name.all_after_last('\\') + '.dll'
        }
        file_content := 'LIBRARY ${dll_name}\n\nEXPORTS\n' + g.export_funcs.join('\n')
        os.write_file('${def_name}', file_content) or { panic(err) }
    }

    // End of out_0.c

    shelpers := helpers.str()

    if !g.pref.parallel_cc {
        b.write_string(shelpers)
    }

    // The rest of the output
    out_str := g.out.str()
    extern_out_str := g.extern_out.str()
    b.write_string(out_str)
    b.writeln('// THE END.')

    postincludes_str := g.postincludes.str()
    if postincludes_str != '' {
        b.write_string2('\n // V postincludes:\n', postincludes_str)
    }

    util.timing_measure('cgen common')
    $if trace_all_generic_fn_keys ? {
        gkeys := g.table.fn_generic_types.keys()
        for gkey in gkeys {
            eprintln('>> g.table.fn_generic_types key: ${gkey}')
        }
    }
    out_fn_start_pos := g.out_fn_start_pos.clone()
    unsafe { helpers.free() }
    unsafe { g.free_builders() }

    return GenOutput{
        header:           header
        res_builder:      b
        out_str:          out_str
        out0_str:         shelpers
        extern_str:       extern_out_str
        out_fn_start_pos: out_fn_start_pos
    }
}

fn cgen_process_one_file_cb(mut p pool.PoolProcessor, idx int, wid int) voidptr {
    file := p.get_item[&ast.File](idx)
    timing_label_for_thread := 'C GEN thread ${wid}'
    util.timing_start(timing_label_for_thread)
    defer {
        util.timing_measure_cumulative(timing_label_for_thread)
    }
    mut global_g := unsafe { &Gen(p.get_shared_context()) }
    mut g := &Gen{
        fid:                                idx
        tid:                                v_gettid().hex()
        file:                               file
        out:                                strings.new_builder(512000)
        cheaders:                           strings.new_builder(15000)
        includes:                           strings.new_builder(100)
        typedefs:                           strings.new_builder(100)
        type_definitions:                   strings.new_builder(100)
        sort_fn_definitions:                strings.new_builder(100)
        alias_definitions:                  strings.new_builder(100)
        definitions:                        strings.new_builder(100)
        gowrappers:                         strings.new_builder(100)
        waiter_fn_definitions:              strings.new_builder(100)
        auto_str_funcs:                     strings.new_builder(100)
        comptime_definitions:               strings.new_builder(100)
        pcs_declarations:                   strings.new_builder(100)
        cov_declarations:                   strings.new_builder(100)
        hotcode_definitions:                strings.new_builder(100)
        embedded_data:                      strings.new_builder(1000)
        out_options_forward:                strings.new_builder(100)
        out_options:                        strings.new_builder(100)
        out_results_forward:                strings.new_builder(100)
        out_results:                        strings.new_builder(100)
        shared_types:                       strings.new_builder(100)
        shared_functions:                   strings.new_builder(100)
        channel_definitions:                strings.new_builder(100)
        thread_definitions:                 strings.new_builder(100)
        json_forward_decls:                 strings.new_builder(100)
        enum_typedefs:                      strings.new_builder(100)
        sql_buf:                            strings.new_builder(100)
        cleanup:                            strings.new_builder(100)
        table:                              global_g.table
        mods_with_c_includes:               global_g.mods_with_c_includes
        pref:                               global_g.pref
        fn_decl:                            unsafe { nil }
        anon_fn:                            unsafe { nil }
        indent:                             -1
        module_built:                       global_g.module_built
        static_non_parallel:                global_g.static_non_parallel
        static_modifier:                    global_g.static_modifier
        timers:                             util.new_timers(
            should_print: global_g.timers_should_print
            label:        'cgen_process_one_file_cb idx: ${idx}, wid: ${wid}'
        )
        inner_loop:                         &ast.empty_stmt
        field_data_type:                    global_g.table.find_type('FieldData')
        enum_data_type:                     global_g.table.find_type('EnumData')
        variant_data_type:                  global_g.table.find_type('VariantData')
        array_sort_fn:                      global_g.array_sort_fn
        array_sort_wrappers:                global_g.array_sort_wrappers
        generated_array_interface_cast_fns: global_g.generated_array_interface_cast_fns
        waiter_fns:                         global_g.waiter_fns
        threaded_fns:                       global_g.threaded_fns
        str_fn_names:                       global_g.str_fn_names
        anon_fns:                           global_g.anon_fns
        options_forward:                    global_g.options_forward
        results_forward:                    global_g.results_forward
        done_options:                       global_g.done_options
        done_results:                       global_g.done_results
        late_chan_types:                    global_g.late_chan_types
        is_autofree:                        global_g.pref.autofree
        obf_table:                          global_g.obf_table
        referenced_fns:                     global_g.referenced_fns
        is_cc_msvc:                         global_g.is_cc_msvc
        use_segfault_handler:               global_g.use_segfault_handler
        done_typedef_phase:                 global_g.done_typedef_phase
        array_typedefs:                     global_g.array_typedefs.clone()
        written_array_typedefs:             global_g.written_array_typedefs
        has_reflection:                     'v.reflection' in global_g.table.modules
        has_debugger:                       'v.debug' in global_g.table.modules
        reflection_strings:                 global_g.reflection_strings
        generated_map_key_fns:              map[ast.Type]bool{}
        c_extern_signature_types:           map[string]bool{}
        boehm_keep_decl:                    map[string]bool{}
        boehm_keep_gen:                     map[string]bool{}
        boehm_keep_busy:                    map[string]bool{}
        generic_parts_cache:                []i8{len: global_g.table.type_symbols.len}
        unwrap_generic_cache:               map[u64]ast.Type{}
        resolved_scope_var_type_cache:      map[u64]ast.Type{}
    }
    g.type_resolver = type_resolver.TypeResolver.new(global_g.table, g)
    g.comptime = &g.type_resolver.info
    g.gen_file()
    return voidptr(g)
}

// free_builders should be called only when a Gen would NOT be used anymore
// it frees the bulk of the memory that is private to the Gen instance
// (the various string builders)
@[unsafe]
pub fn (mut g Gen) free_builders() {
    unsafe {
        g.out.free()
        g.cheaders.free()
        g.includes.free()
        g.typedefs.free()
        g.type_definitions.free()
        g.sort_fn_definitions.free()
        g.alias_definitions.free()
        g.definitions.free()
        g.cleanup.free()
        g.gowrappers.free()
        g.waiter_fn_definitions.free()
        g.auto_str_funcs.free()
        g.dump_funcs.free()
        g.comptime_definitions.free()
        g.pcs_declarations.free()
        g.cov_declarations.free()
        g.hotcode_definitions.free()
        g.embedded_data.free()
        g.shared_types.free()
        g.shared_functions.free()
        g.channel_definitions.free()
        g.thread_definitions.free()
        g.out_options_forward.free()
        g.out_options.free()
        g.out_results_forward.free()
        g.out_results.free()
        g.json_forward_decls.free()
        g.enum_typedefs.free()
        g.sql_buf.free()
        for _, mut v in g.cleanups {
            v.free()
        }
    }
}

pub fn (mut g Gen) gen_file() {
    $if trace_cgen ? {
        eprintln('> ${@FILE}:${@LINE} | g.file.path: ${g.file.path} | g.tid: ${g.tid} | g.fid: ${g.fid:3}')
    }
    g.timers.start('cgen_file ${g.file.path}')
    g.unique_file_path_hash = fnv1a.sum64_string(g.file.path)
    if g.pref.is_vlines {
        g.vlines_path = util.vlines_escape_path(g.file.path, g.pref.ccompiler)
        g.is_vlines_enabled = true
        g.inside_ternary = 0
    }
    g.stmts(g.file.stmts)

    // after all other stmts executed, we got info about hash stmts in top,
    // write them to corresponding sections
    g.gen_hash_stmts_in_top()

    // Transfer embedded files
    for path in g.file.embedded_files {
        if path !in g.embedded_files {
            g.embedded_files << path
        }
    }
    g.timers.show('cgen_file ${g.file.path}')
}

pub fn (g &Gen) hashes() string {
    return c_commit_hash_default.replace('@@@', version.vhash())
}

pub fn (mut g Gen) init() {
    if g.pref.custom_prelude != '' {
        g.cheaders.writeln(g.pref.custom_prelude)
    } else if !g.pref.no_preludes {
        g.cheaders.writeln('// Generated by the V compiler')
        if g.pref.relaxed_gcc14 {
            // See https://gcc.gnu.org/gcc-14/porting_to.html#c-code-generators:
            g.cheaders.writeln('
#if defined __GNUC__ && __GNUC__ >= 14
#pragma GCC diagnostic warning "-Wimplicit-function-declaration"
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#pragma GCC diagnostic warning "-Wint-conversion"
#pragma GCC diagnostic warning "-Wreturn-mismatch"
#endif
')
        }
        if g.pref.os == .linux {
            // For gettid() declaration (and other GNU-specific bits).
            // Must come before any C declarations that use GNU extensions.
            g.preincludes.writeln('#define _GNU_SOURCE')
        }
        if g.pref.os == .wasm32 {
            g.cheaders.writeln('#define VWASM 1')
            // Include <stdint.h> instead of <inttypes.h> for WASM target
            g.cheaders.writeln('#include <stdint.h>')
            g.cheaders.writeln('#include <stddef.h>')
        } else {
            tcc_undef_has_include := '
#if defined(__TINYC__) && defined(__has_include) // tcc does not support has_include properly yet, turn it off completely
#undef __has_include
#endif'
            g.preincludes.writeln(tcc_undef_has_include)
            g.cheaders.writeln(tcc_undef_has_include)
            g.includes.writeln(tcc_undef_has_include)
            if g.pref.os == .freebsd {
                g.cheaders.writeln('#include <inttypes.h>')
                g.cheaders.writeln('#include <stddef.h>')
            } else {
                install_compiler_msg := ' Please install the package `build-essential`.'
                // int64_t etc; allow a fallback to <stdint.h> for toolchains that do not ship <inttypes.h>.
                g.cheaders.writeln(get_inttypes_or_stdint_include_text('The C compiler can not find <stdint.h>.${install_compiler_msg}'))
                if g.pref.os == .ios {
                    g.cheaders.writeln(get_guarded_include_text('<stdbool.h>',
                        'The C compiler can not find <stdbool.h>.${install_compiler_msg}')) // bool, true, false
                }
                g.cheaders.writeln(get_guarded_include_text('<stddef.h>',
                    'The C compiler can not find <stddef.h>.${install_compiler_msg}')) // size_t, ptrdiff_t
            }
        }
        if g.pref.nofloat {
            g.cheaders.writeln('#define VNOFLOAT 1')
        }
        g.cheaders.writeln(c_builtin_types)
        g.cheaders.writeln(c_shift_helpers)
        if !g.pref.skip_unused || g.table.used_features.used_maps > 0 {
            g.cheaders.writeln(c_mapfn_callback_types)
        }
        if g.pref.is_bare {
            g.cheaders.writeln(c_bare_headers)
        } else {
            g.cheaders.writeln(c_headers)
        }
        g.cheaders.writeln(c_float_to_unsigned_conversion_functions)
        if !g.pref.skip_unused || g.table.used_features.safe_int {
            g.cheaders.writeln(c_unsigned_comparison_functions)
        }
        if !g.pref.skip_unused || g.table.used_features.used_attr_weak {
            g.cheaders.writeln(c_common_weak_attr)
        }
        if !g.pref.skip_unused || g.table.used_features.used_attr_hidden {
            g.cheaders.writeln(c_common_hidden_attr)
        }
        if !g.pref.skip_unused || g.table.used_features.used_attr_noreturn {
            g.cheaders.writeln(c_common_noreturn_attr)
            g.cheaders.writeln(c_common_unreachable_attr)
        }
        if !g.pref.skip_unused || g.table.used_features.used_maps > 0 {
            g.cheaders.writeln(c_wyhash_headers)
        }
    }
    if g.pref.os == .ios {
        g.cheaders.writeln('#define __TARGET_IOS__ 1')
        g.cheaders.writeln('#include <spawn.h>')
    }
    if g.pref.os == .linux {
        g.cheaders.writeln('#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 30')
        g.cheaders.writeln('#include <sys/syscall.h>')
        g.cheaders.writeln('#define gettid() syscall(SYS_gettid)')
        g.cheaders.writeln('#endif')
    }
    g.write_builtin_types()
    g.options_pos_forward = g.type_definitions.len
    g.write_typedef_types()
    g.written_array_typedefs = g.array_typedefs.len
    g.done_typedef_phase = true
    g.write_typeof_functions()
    g.write_sorted_types()
    g.write_array_fixed_return_types()
    g.write_multi_return_types()
    g.definitions.writeln('// end of definitions #endif')
    if g.pref.compile_defines_all.len > 0 {
        g.comptime_definitions.writeln('// V compile time defines by -d or -define flags:')
        g.comptime_definitions.writeln('//     All custom defines      : ' +
            g.pref.compile_defines_all.join(','))
        g.comptime_definitions.writeln('//     Turned ON custom defines: ' +
            g.pref.compile_defines.join(','))
        for cdefine in g.pref.compile_defines {
            g.comptime_definitions.writeln('#define CUSTOM_DEFINE_${cdefine}')
        }
        g.comptime_definitions.writeln('')
    }
    if g.table.gostmts > 0 {
        g.comptime_definitions.writeln('#define __VTHREADS__ (1)')
    }
    if g.pref.os in [.macos, .freebsd, .openbsd, .netbsd, .dragonfly] {
        // `#include bsd <...>` and any other code path that emits `defined(__BSD__)`
        // needs this; individual BSD/Darwin compilers do not predefine __BSD__.
        g.comptime_definitions.writeln('#define __BSD__ (1)')
    }
    if g.pref.gc_mode in [.boehm_full, .boehm_incr, .boehm_full_opt, .boehm_incr_opt, .boehm_leak] {
        g.comptime_definitions.writeln('#define _VGCBOEHM (1)')
    }
    if g.pref.is_debug {
        g.comptime_definitions.writeln('#define _VDEBUG (1)')
    }
    if g.pref.is_prod {
        g.comptime_definitions.writeln('#define _VPROD (1)')
    }
    if g.pref.is_test {
        g.comptime_definitions.writeln('#define _VTEST (1)')
    }
    if g.pref.is_prof {
        g.comptime_definitions.writeln('#define _VPROFILE (1)')
    }
    if g.pref.autofree {
        g.comptime_definitions.writeln('#define _VAUTOFREE (1)')
    }
    if g.pref.parallel_cc {
        g.comptime_definitions.writeln('#define _VPARALLELCC (1)')
    }
    if g.pref.prealloc {
        g.comptime_definitions.writeln('#define _VPREALLOC (1)')
    }
    if g.pref.use_cache {
        g.comptime_definitions.writeln('#define _VUSECACHE (1)')
    }
    if g.pref.build_mode == .build_module {
        g.comptime_definitions.writeln('#define _VBUILDMODULE (1)')
    }
    if g.pref.is_o {
        g.comptime_definitions.writeln('#define _VOBJECTFILE (1)')
    }
    if g.pref.is_livemain || g.pref.is_liveshared {
        g.generate_hotcode_reloading_declarations()
    }
    // we know that this is being called before the multi-threading starts
    // and this is being called in the main thread, so we can mutate the table
    mut muttable := unsafe { &ast.Table(g.table) }
    if g.use_segfault_handler {
        muttable.used_features.used_fns['v_segmentation_fault_handler'] = true
    }
    // muttable.used_features.used_fns['eprintln'] = true
    // muttable.used_features.used_fns['print_backtrace'] = true
    // muttable.used_features.used_fns['exit'] = true
}

fn (g &Gen) should_use_object_local_linkage(mod string) bool {
    return g.pref.is_o && g.module_built != '' && mod != g.module_built
}

pub fn (mut g Gen) finish() {
    if g.pref.is_prof && g.pref.build_mode != .build_module {
        g.gen_vprint_profile_stats()
    }
    if g.pref.is_livemain || g.pref.is_liveshared {
        g.generate_hotcode_reloader_code()
    }
    g.handle_embedded_files_finish()
    if g.pref.is_test {
        g.gen_c_main_for_tests()
    } else if (g.pref.is_shared || g.pref.is_liveshared) && g.pref.os == .windows
        && !g.has_user_defined_windows_dll_main() {
        // create DllMain() for windows .dll
        g.gen_dll_main()
    } else {
        g.gen_c_main()
    }
}

// get_sumtype_variant_type_name returns the variant type name according to its type
@[inline]
pub fn (mut g Gen) get_sumtype_variant_type_name(typ ast.Type, sym ast.TypeSymbol) string {
    return if typ.has_flag(.option) {
        '_option_${sym.cname}'
    } else if sym.is_c_struct() {
        g.cc_type(typ, true)
    } else {
        sym.cname
    }
}

// get_sumtype_variant_name returns the variant name according to its type
@[inline]
pub fn (mut g Gen) get_sumtype_variant_name(typ ast.Type, sym ast.TypeSymbol) string {
    return if typ.has_flag(.option) { '_option_${sym.cname}' } else { sym.cname }
}

@[inline]
fn (g &Gen) sumtype_runtime_variants(typ ast.Type) []ast.Type {
    return g.table.sumtype_matchable_variants(typ.idx_type())
}

// get_sumtype_casting_variant_name returns a helper-safe variant name that
// keeps pointer-depth distinctions for sumtype cast wrappers.
@[inline]
pub fn (mut g Gen) get_sumtype_casting_variant_name(typ ast.Type, sym ast.TypeSymbol) string {
    mut variant_name := g.get_sumtype_variant_name(typ, sym)
    if typ.nr_muls() > 0 {
        variant_name += '__ptr__'.repeat(typ.nr_muls())
    }
    return variant_name
}

pub fn (mut g Gen) write_typeof_functions() {
    g.writeln('')
    g.writeln('// >> typeof() support for sum types / interfaces')
    mut already_generated_ifaces := map[string]bool{}
    for ityp, sym in g.table.type_symbols {
        if sym.kind == .sum_type {
            if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
                continue
            }
            static_prefix := if g.pref.build_mode == .build_module || g.pref.is_o {
                'static '
            } else {
                ''
            }
            sum_info := sym.info as ast.SumType
            if sum_info.is_generic {
                continue
            }
            g.writeln('${static_prefix}char * v_typeof_sumtype_${sym.cname}(u32 sidx) {')
            g.definitions.writeln('${static_prefix}char * v_typeof_sumtype_${sym.cname}(u32);')
            runtime_variants := g.sumtype_runtime_variants(ast.idx_to_type(ityp))
            if g.pref.build_mode == .build_module {
                g.writeln('\t\tif( sidx == _v_type_idx_${sym.cname}() ) return "${util.strip_main_name(sym.name)}";')
                for v in runtime_variants {
                    subtype := g.table.sym(v)
                    g.writeln('\tif( sidx == _v_type_idx_${g.get_sumtype_variant_name(v, subtype)}() ) return "${util.strip_main_name(subtype.name)}";')
                }
                g.writeln('\treturn "unknown ${util.strip_main_name(sym.name)}";')
            } else {
                tidx := g.table.find_type_idx(sym.name)
                g.writeln('\tswitch(sidx) {')
                g.writeln('\t\tcase ${tidx}: return "${util.strip_main_name(sym.name)}";')
                mut idxs := []ast.Type{}
                for v in runtime_variants {
                    if v in idxs {
                        continue
                    }
                    subtype := g.table.sym(v)
                    g.writeln('\t\tcase ${u32(v)}: return "${util.strip_main_name(subtype.name)}";')
                    idxs << v
                }
                g.writeln('\t\tdefault: return "unknown ${util.strip_main_name(sym.name)}";')
                g.writeln('\t}')
            }
            g.writeln2('}', '')
            g.writeln('${static_prefix}u32 v_typeof_sumtype_idx_${sym.cname}(u32 sidx) {')
            if g.pref.build_mode == .build_module {
                g.writeln('\t\tif( sidx == _v_type_idx_${sym.cname}() ) return ${u32(ityp)};')
                for v in runtime_variants {
                    subtype := g.table.sym(v)
                    g.writeln('\tif( sidx == _v_type_idx_${subtype.cname}() ) return ${u32(v)};')
                }
                g.writeln('\treturn ${u32(ityp)};')
            } else {
                tidx := g.table.find_type_idx(sym.name)
                g.writeln2('\tswitch(sidx) {', '\t\tcase ${tidx}: return ${u32(ityp)};')
                mut idxs := []ast.Type{}
                for v in runtime_variants {
                    if v in idxs {
                        continue
                    }
                    g.writeln('\t\tcase ${u32(v)}: return ${u32(v)};')
                    idxs << v
                }
                g.writeln2('\t\tdefault: return ${u32(ityp)};', '\t}')
            }
            g.writeln('}')
        } else if sym.kind == .interface {
            if sym.info !is ast.Interface {
                continue
            }
            inter_info := sym.info as ast.Interface
            if inter_info.is_generic {
                continue
            }
            if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
                continue
            }
            if sym.cname in already_generated_ifaces {
                continue
            }
            already_generated_ifaces[sym.cname] = true
            impl_types := g.runtime_interface_variants(inter_info)
            g.definitions.writeln('${g.static_non_parallel}string v_typeof_interface_${sym.cname}(u32 sidx);')
            if g.pref.parallel_cc {
                g.extern_out.writeln('extern string v_typeof_interface_${sym.cname}(u32 sidx);')
            }
            g.writeln('${g.static_non_parallel}string v_typeof_interface_${sym.cname}(u32 sidx) {')
            for t in impl_types {
                sub_sym := g.table.sym(ast.mktyp(t))
                if sub_sym.kind == .interface {
                    continue
                }
                if sub_sym.info is ast.Struct && sub_sym.info.is_unresolved_generic() {
                    continue
                }
                if g.pref.skip_unused && sub_sym.kind == .struct
                    && sub_sym.idx !in g.table.used_features.used_syms {
                    continue
                }
                g.writeln('\tif (sidx == _${sym.cname}_${sub_sym.cname}_index) return _S("${util.strip_main_name(sub_sym.name)}");')
            }
            g.writeln2('\treturn _S("unknown ${util.strip_main_name(sym.name)}");', '}')
            // Avoid duplicate symbol '_v_typeof_interface_idx_IError' when using -usecache
            if g.pref.build_mode != .build_module {
                interface_idx_static_prefix := if g.pref.is_o { 'static ' } else { '' }
                g.definitions.writeln('${interface_idx_static_prefix}u32 v_typeof_interface_idx_${sym.cname}(u32 sidx);')
                g.writeln2('',
                    '${interface_idx_static_prefix}u32 v_typeof_interface_idx_${sym.cname}(u32 sidx) {')
                if g.pref.parallel_cc && interface_idx_static_prefix == '' {
                    g.extern_out.writeln('extern u32 v_typeof_interface_idx_${sym.cname}(u32 sidx);')
                }
                for t in impl_types {
                    sub_sym := g.table.sym(ast.mktyp(t))
                    if sub_sym.kind == .interface {
                        continue
                    }
                    if sub_sym.info is ast.Struct && sub_sym.info.is_unresolved_generic() {
                        continue
                    }
                    if g.pref.skip_unused && sub_sym.kind == .struct
                        && sub_sym.idx !in g.table.used_features.used_syms {
                        continue
                    }
                    g.writeln('\tif (sidx == _${sym.cname}_${sub_sym.cname}_index) return ${u32(t.set_nr_muls(0))};')
                }
                g.writeln2('\treturn ${u32(ityp)};', '}')
            }
        }
    }
    g.writeln2('// << typeof() support for sum types', '')
}

// V type to C typecc
@[inline]
fn (mut g Gen) styp(t ast.Type) string {
    if !t.has_option_or_result() {
        return g.base_type(t)
    } else if t.has_flag(.result) {
        return g.register_result(t)
    } else if t.has_flag(.option) {
        // Register an optional if it's not registered yet
        return g.register_option(t)
    } else {
        return g.base_type(t)
    }
}

fn (mut g Gen) base_type(_t ast.Type) string {
    mut t := g.unwrap_generic(_t)
    // Safeguard: if unwrap_generic didn't convert because the generic flag wasn't set,
    // but the symbol name is a generic name, force the conversion
    if g.cur_fn != unsafe { nil } && g.cur_fn.generic_names.len > 0 && g.cur_concrete_types.len > 0 {
        sym := g.table.sym(t)
        if sym.name in g.cur_fn.generic_names {
            if utyp := g.table.convert_generic_type(t.set_flag(.generic), g.cur_fn.generic_names,
                g.cur_concrete_types)
            {
                t = utyp
            }
        }
    }
    if styp := g.styp_cache[t] {
        // Ensure late array typedefs are emitted even for cached types
        if g.done_typedef_phase {
            g.ensure_array_typedef(styp.trim_right('*'))
        }
        return styp
    }
    if g.pref.nofloat {
        // TODO: compile time if for perf?
        if t == ast.f32_type {
            return 'u32'
        } else if t == ast.f64_type {
            return 'u64'
        }
    }
    share := t.share()
    mut styp := if share == .atomic_t { t.atomic_typename() } else { g.cc_type(t, true) }
    if t.has_flag(.shared_f) {
        styp = g.find_or_register_shared(t, styp)
    }
    // During generic codegen, array types resolved from generic parameters
    // (e.g. []?T → []?i8) may not have been registered in the type table
    // early enough for write_typedef_types(). Emit a late typedef if needed.
    if g.done_typedef_phase {
        g.ensure_array_typedef(styp)
    }
    nr_muls := t.nr_muls()
    if nr_muls > 0 {
        styp += strings.repeat(`*`, nr_muls)
    }
    g.styp_cache[t] = styp
    return styp
}

fn (mut g Gen) can_write_interface_typesymbol_declaration(sym ast.TypeSymbol) bool {
    if sym.info !is ast.Interface {
        return false
    }
    info := sym.info as ast.Interface
    if !info.is_generic {
        return true
    }
    return !info.fields.any(it.typ.has_flag(.generic) || g.type_has_unresolved_generic_parts(it.typ))
}

fn (mut g Gen) generic_fn_name(types []ast.Type, before string) string {
    if types.len == 0 {
        return before
    }
    // Using _T_ to differentiate between get[string] and get_string
    // `foo[int]()` => `foo_T_int()`
    mut name := before + '_T'
    for typ in types {
        normalized_typ := ast.mktyp(typ)
        mut typ_name := g.styp(normalized_typ.set_nr_muls(0))
        // Normalize named function types to their anonymous form for consistent naming.
        // E.g. `neg` (a specific fn) should produce the same name as `fn(int) int`.
        sym := g.table.sym(normalized_typ)
        if sym.info is ast.FnType && sym.kind == .function {
            mut anon_cname := 'anon_fn_${g.table.fn_type_signature(sym.info.func)}'
            if normalized_typ.has_flag(.option) {
                anon_cname = '${option_name}_${anon_cname}'
            } else if normalized_typ.has_flag(.result) {
                anon_cname = '${result_name}_${anon_cname}'
            }
            if normalized_typ.has_flag(.shared_f) {
                anon_cname = '__shared__${anon_cname}'
            } else if normalized_typ.has_flag(.atomic_f) {
                anon_cname = 'atomic_${anon_cname}'
            }
            if anon_cname != typ_name {
                typ_name = anon_cname
            }
        }
        name += '_' + strings.repeat_string('__ptr__', normalized_typ.nr_muls()) +
            typ_name.replace(' ', '_')
    }
    return name
}

fn (mut g Gen) expr_string(expr ast.Expr) string {
    pos := g.out.len
    // pos2 :=     g.out_parallel[g.out_idx].len
    g.expr(expr)
    // g.out_parallel[g.out_idx].cut_to(pos2)
    return g.out.cut_to(pos).trim_space()
}

fn (mut g Gen) expr_string_opt(typ ast.Type, expr ast.Expr) string {
    expr_str := g.expr_string(expr)
    if expr is ast.None {
        return '(${g.styp(typ)}){.state=2, .err=${expr_str}, .data={E_STRUCT}}'
    }
    return expr_str
}

fn (mut g Gen) expr_string_with_cast(expr ast.Expr, typ ast.Type, exp ast.Type) string {
    pos := g.out.len
    // pos2 :=     g.out_parallel[g.out_idx].len
    g.expr_with_cast(expr, typ, exp)
    // g.out_parallel[g.out_idx].cut_to(pos2)
    return g.out.cut_to(pos).trim_space()
}

// Surround a potentially multi-statement expression safely with `prepend` and `append`.
// (and create a statement)
fn (mut g Gen) expr_string_surround(prepend string, expr ast.Expr, append string) string {
    pos := g.out.len
    // pos2 :=     g.out_parallel[g.out_idx].len
    g.stmt_path_pos << pos
    defer {
        g.stmt_path_pos.delete_last()
    }
    g.write(prepend)
    g.expr(expr)
    g.write(append)
    // g.out_parallel[g.out_idx].cut_to(pos2)
    return g.out.cut_to(pos)
}

// TODO: this really shouldn't be separate from typ
// but I(emily) would rather have this generation
// all unified in one place so that it doesn't break
// if one location changes
fn (mut g Gen) option_type_name(t ast.Type) (string, string) {
    option_typ := if t.has_flag(.option_mut_param_t) && t.is_ptr() {
        t.deref().clear_flag(.option_mut_param_t)
    } else {
        t
    }
    mut base := g.base_type(option_typ)
    mut styp := ''
    sym := g.table.sym(option_typ)
    // If this is a type alias to an option type, use the parent type's option name
    // This ensures that ?int and MaybeInt (where MaybeInt = ?int) generate the same C type
    if sym.kind == .alias && sym.info is ast.Alias && sym.info.parent_type.has_flag(.option) {
        return g.option_type_name(sym.info.parent_type)
    }
    if sym.info is ast.FnType {
        base = 'anon_fn_${g.table.fn_type_signature(sym.info.func)}'
    }
    if sym.language == .c && sym.kind == .struct {
        styp = '${option_name}_${base.replace(' ', '_')}'
    } else {
        styp = '${option_name}_${base}'
    }
    if option_typ.has_flag(.generic) || option_typ.is_ptr() {
        styp = styp.replace('*', '_ptr')
    }
    return styp, base
}

fn (mut g Gen) type_has_unresolved_generic_parts(typ ast.Type) bool {
    if typ == 0 {
        return false
    }
    if typ.has_flag(.generic) {
        return true
    }
    idx := typ.idx()
    if idx <= ast.nil_type_idx {
        return false
    }
    if idx < g.generic_parts_cache.len {
        cached := g.generic_parts_cache[idx]
        if cached != 0 {
            return cached == 2
        }
    } else if idx < g.table.type_symbols.len {
        g.generic_parts_cache << []i8{len: idx - g.generic_parts_cache.len + 1}
    }
    resolved := g.type_has_unresolved_generic_parts_uncached(typ)
    if idx < g.generic_parts_cache.len {
        g.generic_parts_cache[idx] = if resolved { i8(2) } else { i8(1) }
    }
    return resolved
}

fn (mut g Gen) type_has_unresolved_generic_parts_uncached(typ ast.Type) bool {
    sym := g.table.sym(typ)
    if sym.kind == .placeholder || (sym.kind == .any && !sym.is_builtin()) {
        return true
    }
    match sym.info {
        ast.Array {
            return g.type_has_unresolved_generic_parts(sym.info.elem_type)
        }
        ast.ArrayFixed {
            return g.type_has_unresolved_generic_parts(sym.info.elem_type)
        }
        ast.Chan {
            return g.type_has_unresolved_generic_parts(sym.info.elem_type)
        }
        ast.Thread {
            return g.type_has_unresolved_generic_parts(sym.info.return_type)
        }
        ast.Map {
            return g.type_has_unresolved_generic_parts(sym.info.key_type)
                || g.type_has_unresolved_generic_parts(sym.info.value_type)
        }
        ast.FnType {
            return g.type_has_unresolved_generic_parts(sym.info.func.return_type)
                || sym.info.func.params.any(g.type_has_unresolved_generic_parts(it.typ))
        }
        ast.MultiReturn {
            return sym.info.types.any(g.type_has_unresolved_generic_parts(it))
        }
        ast.Struct {
            if sym.info.concrete_types.len > 0 {
                return sym.info.concrete_types.any(g.type_has_unresolved_generic_parts(it))
            }
            if sym.generic_types.len == sym.info.generic_types.len
                && sym.generic_types != sym.info.generic_types {
                return sym.generic_types.any(g.type_has_unresolved_generic_parts(it))
            }
            return sym.info.generic_types.len > 0
        }
        ast.Interface {
            if sym.info.concrete_types.len > 0 {
                return sym.info.concrete_types.any(g.type_has_unresolved_generic_parts(it))
            }
            if sym.generic_types.len == sym.info.generic_types.len
                && sym.generic_types != sym.info.generic_types {
                return sym.generic_types.any(g.type_has_unresolved_generic_parts(it))
            }
            return sym.info.is_generic
        }
        ast.SumType {
            if sym.info.concrete_types.len > 0 {
                return sym.info.concrete_types.any(g.type_has_unresolved_generic_parts(it))
            }
            if sym.generic_types.len == sym.info.generic_types.len
                && sym.generic_types != sym.info.generic_types {
                return sym.generic_types.any(g.type_has_unresolved_generic_parts(it))
            }
            return sym.info.is_generic
        }
        ast.GenericInst {
            return sym.info.concrete_types.any(g.type_has_unresolved_generic_parts(it))
        }
        ast.UnknownTypeInfo {
            if sym.name.contains('[') && sym.name.contains(']') {
                args := sym.name.all_after('[').trim_right(']').split(',').map(it.trim_space())
                return args.any(util.is_generic_type_name(it))
            }
            return false
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) result_type_name(t ast.Type) (string, string) {
    mut base := g.base_type(t)
    mut styp := ''
    sym := g.table.sym(t)
    // If this is a type alias to a result type, use the parent type's result name
    if sym.kind == .alias && sym.info is ast.Alias && sym.info.parent_type.has_flag(.result) {
        return g.result_type_name(sym.info.parent_type)
    }
    if t.has_flag(.option) {
        g.register_option(t)
        base = '_option_' + base
    }
    if sym.info is ast.FnType {
        base = 'anon_fn_${g.table.fn_type_signature(sym.info.func)}'
    }
    if sym.language == .c && sym.kind == .struct {
        styp = '${result_name}_${base.replace(' ', '_')}'
    } else {
        styp = '${result_name}_${base}'
    }
    if t.has_flag(.generic) || t.is_ptr() {
        styp = styp.replace('*', '_ptr')
    }
    return styp, base
}

fn (g &Gen) option_type_text(styp string, base string) string {
    // replace void with something else
    size := if base == 'void' {
        'u8'
    } else if base == 'int' {
        ast.int_type_name
    } else if base.starts_with('anon_fn') {
        'void*'
    } else if base.starts_with('_option_') {
        base.replace('*', '')
    } else {
        if base.starts_with('struct ') && !base.ends_with('*') { '${base}*' } else { base }
    }
    ret := 'struct ${styp} {
    byte state;
    IError err;
    byte data[sizeof(${size}) > 1 ? sizeof(${size}) : 1];
}'
    return ret
}

fn (g &Gen) result_type_text(styp string, base string) string {
    // replace void with something else
    size := if base == 'void' {
        'u8'
    } else if base == 'int' {
        ast.int_type_name
    } else if base.starts_with('anon_fn') {
        'void*'
    } else if base.starts_with('_option_') {
        base.replace('*', '')
    } else {
        if base.starts_with('struct ') && !base.ends_with('*') { '${base}*' } else { base }
    }
    ret := 'struct ${styp} {
    bool is_error;
    IError err;
    byte data[sizeof(${size}) > 1 ? sizeof(${size}) : 1];
}'
    return ret
}

fn (mut g Gen) register_option(t ast.Type) string {
    resolved_t := g.unwrap_generic(t)
    styp, base := g.option_type_name(resolved_t)
    // Only skip registration if the computed base is still an unresolved generic type name
    // (base_type should have resolved generics, but check to be safe)
    is_unresolved_generic := (g.cur_fn != unsafe { nil } && base in g.cur_fn.generic_names)
        || g.type_has_unresolved_generic_parts(resolved_t)
    if !is_unresolved_generic {
        g.options[base] = styp
    }
    return if !t.has_flag(.option_mut_param_t) { styp } else { '${styp}*' }
}

fn (mut g Gen) register_result(t ast.Type) string {
    resolved_t := g.unwrap_generic(t)
    styp, base := g.result_type_name(resolved_t)
    // Only skip registration if the computed base is still an unresolved generic type name
    is_unresolved_generic := (g.cur_fn != unsafe { nil } && base in g.cur_fn.generic_names)
        || g.type_has_unresolved_generic_parts(resolved_t)
    if !is_unresolved_generic {
        g.results[base] = styp
    }
    return styp
}

fn (mut g Gen) write_options() {
    mut done := []string{}
    rlock g.done_options {
        done = g.done_options.clone()
    }
    for base, styp in g.options {
        if base in done {
            continue
        }
        done << base
        g.typedefs.writeln('typedef struct ${styp} ${styp};')
        g.ensure_array_typedef(base)
        if base in g.options_forward {
            g.out_options_forward.write_string(g.option_type_text(styp, base) + ';\n\n')
        } else {
            g.out_options.write_string(g.option_type_text(styp, base) + ';\n\n')
        }
    }
}

fn (mut g Gen) write_results() {
    mut done := []string{}
    rlock g.done_results {
        done = g.done_results.clone()
    }
    for base, styp in g.results {
        if base in done {
            continue
        }
        done << base
        g.typedefs.writeln('typedef struct ${styp} ${styp};')
        g.ensure_array_typedef(base)
        if base in g.results_forward {
            g.out_results_forward.write_string(g.result_type_text(styp, base) + ';\n\n')
        } else {
            g.out_results.write_string(g.result_type_text(styp, base) + ';\n\n')
        }
    }
    for k, _ in g.table.anon_struct_names {
        ck := c_name(k)
        g.typedefs.writeln('typedef struct ${ck} ${ck};')
    }
    for k, _ in g.table.anon_union_names {
        ck := c_name(k)
        g.typedefs.writeln('typedef union ${ck} ${ck};')
    }
}

fn (mut g Gen) find_or_register_shared(t ast.Type, base string) string {
    g.shareds[t.idx()] = base
    return '__shared__${base}'
}

fn (mut g Gen) write_shareds() {
    mut done_types := []int{}
    for typ, base in g.shareds {
        if typ in done_types {
            continue
        }
        done_types << typ
        sh_typ := '__shared__${base}'
        mtx_typ := 'sync__RwMutex'
        g.shared_types.writeln('struct ${sh_typ} {')
        g.shared_types.writeln('\t${mtx_typ} mtx;')
        g.shared_types.writeln('\t${base} val;')
        g.shared_types.writeln('};')
        g.shared_functions.writeln('static inline voidptr __dup${sh_typ}(voidptr src, ${ast.int_type_name} sz) {')
        g.shared_functions.writeln('\t${sh_typ}* dest = builtin__memdup(src, sz);')
        g.shared_functions.writeln('\tsync__RwMutex_init(&dest->mtx);')
        g.shared_functions.writeln('\treturn dest;')
        g.shared_functions.writeln('}')
        g.typedefs.writeln('typedef struct ${sh_typ} ${sh_typ};')
    }
}

fn (mut g Gen) register_thread_void_wait_call() {
    lock g.waiter_fns {
        if '__v_thread_wait' in g.waiter_fns {
            return
        }
        g.waiter_fns << '__v_thread_wait'
        g.waiter_fn_definitions.writeln('void __v_thread_wait(__v_thread thread);')
    }
    g.gowrappers.writeln('void __v_thread_wait(__v_thread thread) {')
    if g.pref.os == .windows {
        g.gowrappers.writeln('\tu32 stat = WaitForSingleObject(thread, INFINITE);')
        g.gowrappers.writeln('\tif (stat != WAIT_OBJECT_0) { builtin___v_panic(_S("error waiting thread")); }')
    } else {
        g.gowrappers.writeln('\tint stat = pthread_join(thread, (void **)NULL);')
        g.gowrappers.writeln('\tif (stat != 0) { builtin___v_panic(_S("error waiting thread")); }')
    }
    g.gowrappers.writeln('}')
}

fn (mut g Gen) register_thread_wait_call(eltyp string) {
    thread_typ := '__v_thread_${eltyp}'
    fn_name := '${thread_typ}_wait'
    lock g.waiter_fns {
        if fn_name in g.waiter_fns {
            return
        }
        g.waiter_fns << fn_name
        g.waiter_fn_definitions.writeln('${eltyp} ${fn_name}(${thread_typ} thread);')
    }
    g.gowrappers.writeln('${eltyp} ${fn_name}(${thread_typ} thread) {')
    g.gowrappers.writeln('\t${eltyp} res;')
    if g.pref.os == .windows {
        g.gowrappers.writeln('\tu32 stat = WaitForSingleObject(thread.handle, INFINITE);')
        g.gowrappers.writeln('\tif (stat != WAIT_OBJECT_0) { builtin___v_panic(_S("error waiting thread")); }')
        g.gowrappers.writeln('\tCloseHandle(thread.handle);')
        g.gowrappers.writeln('\tres = *(${eltyp}*)(thread.ret_ptr);')
        if g.pref.prealloc {
            g.gowrappers.writeln('\tfree(thread.ret_ptr);')
        } else {
            g.gowrappers.writeln('\tbuiltin___v_free(thread.ret_ptr);')
        }
    } else {
        g.gowrappers.writeln('\tvoid* ret_val;')
        g.gowrappers.writeln('\tint stat = pthread_join(thread, &ret_val);')
        g.gowrappers.writeln('\tif (stat != 0) { builtin___v_panic(_S("error waiting thread")); }')
        g.gowrappers.writeln('\tres = *(${eltyp}*)ret_val;')
        if g.pref.prealloc {
            g.gowrappers.writeln('\tfree(ret_val);')
        } else {
            g.gowrappers.writeln('\tbuiltin___v_free(ret_val);')
        }
    }
    g.gowrappers.writeln('\treturn res;')
    g.gowrappers.writeln('}')
}

fn (mut g Gen) thread_array_wait_return_type(thread_ret_type ast.Type) ast.Type {
    payload_type := thread_ret_type.clear_option_and_result()
    if payload_type == ast.void_type {
        return thread_ret_type
    }
    mut return_type := ast.idx_to_type(g.table.find_or_register_array(payload_type))
    if thread_ret_type.has_flag(.option) {
        return_type = return_type.set_flag(.option)
    }
    if thread_ret_type.has_flag(.result) {
        return_type = return_type.set_flag(.result)
    }
    return return_type
}

fn (mut g Gen) register_thread_array_wait_call(thread_ret_type ast.Type) string {
    payload_type := thread_ret_type.clear_option_and_result()
    is_plain_void := thread_ret_type == ast.void_type
    is_void_payload := payload_type == ast.void_type
    thread_typ := g.gen_gohandle_name(thread_ret_type)
    waiter_fn_name := '${thread_typ}_wait'
    ret_type := g.thread_array_wait_return_type(thread_ret_type)
    ret_styp := g.styp(ret_type)
    thread_arr_typ := 'Array_${thread_typ}'
    fn_name := '${thread_arr_typ}_wait'
    mut should_register := false
    lock g.waiter_fns {
        if fn_name !in g.waiter_fns {
            g.waiter_fns << fn_name
            should_register = true
        }
    }
    if should_register {
        thread_ret_styp := g.styp(thread_ret_type)
        g.create_waiter_handler(thread_ret_type, thread_ret_styp, thread_typ)
        g.waiter_fn_definitions.writeln('${ret_styp} ${fn_name}(${thread_arr_typ} a);')
        g.gowrappers.writeln('
${ret_styp} ${fn_name}(${thread_arr_typ} a) {')
        if !is_void_payload {
            payload_arr_styp := g.base_type(ret_type.clear_option_and_result())
            payload_styp := g.styp(payload_type)
            g.gowrappers.writeln('\t${payload_arr_styp} res = builtin____new_array_with_default(a.len, a.len, sizeof(${payload_styp}), 0);')
        }
        if thread_ret_type.has_option_or_result() {
            g.gowrappers.writeln('\tbool has_failure = false;')
            g.gowrappers.writeln('\t${thread_ret_styp} first_failure = {0};')
        }
        g.gowrappers.writeln('\tfor (${ast.int_type_name} i = 0; i < a.len; ++i) {')
        g.gowrappers.writeln('\t\t${thread_typ} t = ((${thread_typ}*)a.data)[i];')
        if g.pref.os == .windows {
            if is_plain_void {
                g.gowrappers.writeln('\t\tif (t == 0) continue;')
            } else {
                g.gowrappers.writeln('\t\tif (t.handle == 0) continue;')
            }
        } else {
            g.gowrappers.writeln('\t\tif (t == 0) continue;')
        }
        if thread_ret_type.has_flag(.option) {
            payload_arr_styp := if is_void_payload {
                ''
            } else {
                g.base_type(ret_type.clear_option_and_result())
            }
            payload_styp := if is_void_payload { '' } else { g.styp(payload_type) }
            g.gowrappers.writeln('\t\t${thread_ret_styp} waited = ${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t\tif (waited.state != 0) {')
            g.gowrappers.writeln('\t\t\tif (!has_failure) {')
            g.gowrappers.writeln('\t\t\t\thas_failure = true;')
            g.gowrappers.writeln('\t\t\t\tfirst_failure = waited;')
            g.gowrappers.writeln('\t\t\t}')
            g.gowrappers.writeln('\t\t\tcontinue;')
            g.gowrappers.writeln('\t\t}')
            if !is_void_payload {
                g.gowrappers.writeln('\t\t((${payload_styp}*)res.data)[i] = *((${payload_styp}*)waited.data);')
            }
            g.gowrappers.writeln('\t}')
            g.gowrappers.writeln('\tif (has_failure) {')
            if !is_void_payload {
                g.gowrappers.writeln('\t\tbuiltin__array_free(&res);')
            }
            if is_void_payload {
                g.gowrappers.writeln('\t\treturn first_failure;')
            } else {
                g.gowrappers.writeln('\t\treturn (${ret_styp}){ .state = first_failure.state, .err = first_failure.err, .data = {E_STRUCT} };')
            }
            g.gowrappers.writeln('\t}')
            if is_void_payload {
                g.gowrappers.writeln('\treturn (${ret_styp}){0};')
            } else {
                g.gowrappers.writeln('\t${ret_styp} waited_all = {0};')
                g.gowrappers.writeln('\tbuiltin___option_ok(&(${payload_arr_styp}[]) { res }, (${option_name}*)(&waited_all), sizeof(${payload_arr_styp}));')
                g.gowrappers.writeln('\treturn waited_all;')
            }
        } else if thread_ret_type.has_flag(.result) {
            payload_arr_styp := if is_void_payload {
                ''
            } else {
                g.base_type(ret_type.clear_option_and_result())
            }
            payload_styp := if is_void_payload { '' } else { g.styp(payload_type) }
            g.gowrappers.writeln('\t\t${thread_ret_styp} waited = ${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t\tif (waited.is_error) {')
            g.gowrappers.writeln('\t\t\tif (!has_failure) {')
            g.gowrappers.writeln('\t\t\t\thas_failure = true;')
            g.gowrappers.writeln('\t\t\t\tfirst_failure = waited;')
            g.gowrappers.writeln('\t\t\t}')
            g.gowrappers.writeln('\t\t\tcontinue;')
            g.gowrappers.writeln('\t\t}')
            if !is_void_payload {
                g.gowrappers.writeln('\t\t((${payload_styp}*)res.data)[i] = *((${payload_styp}*)waited.data);')
            }
            g.gowrappers.writeln('\t}')
            g.gowrappers.writeln('\tif (has_failure) {')
            if !is_void_payload {
                g.gowrappers.writeln('\t\tbuiltin__array_free(&res);')
            }
            if is_void_payload {
                g.gowrappers.writeln('\t\treturn first_failure;')
            } else {
                g.gowrappers.writeln('\t\treturn (${ret_styp}){ .is_error = true, .err = first_failure.err, .data = {E_STRUCT} };')
            }
            g.gowrappers.writeln('\t}')
            if is_void_payload {
                g.gowrappers.writeln('\treturn (${ret_styp}){0};')
            } else {
                g.gowrappers.writeln('\t${ret_styp} waited_all = {0};')
                g.gowrappers.writeln('\tbuiltin___result_ok(&(${payload_arr_styp}[]) { res }, (${result_name}*)(&waited_all), sizeof(${payload_arr_styp}));')
                g.gowrappers.writeln('\treturn waited_all;')
            }
        } else if is_void_payload {
            g.gowrappers.writeln('\t\t${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t}')
        } else {
            payload_styp := g.styp(payload_type)
            g.gowrappers.writeln('\t\t((${payload_styp}*)res.data)[i] = ${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t}')
            g.gowrappers.writeln('\treturn res;')
        }
        g.gowrappers.writeln('}')
    }
    return fn_name
}

fn (mut g Gen) register_thread_fixed_array_wait_call(node ast.CallExpr, thread_ret_type ast.Type) string {
    payload_type := thread_ret_type.clear_option_and_result()
    is_plain_void := thread_ret_type == ast.void_type
    is_void_payload := payload_type == ast.void_type
    thread_typ := g.gen_gohandle_name(thread_ret_type)
    waiter_fn_name := '${thread_typ}_wait'
    ret_type := g.thread_array_wait_return_type(thread_ret_type)
    ret_styp := g.styp(ret_type)
    rec_sym := g.table.sym(node.receiver_type)
    len := (rec_sym.info as ast.ArrayFixed).size
    thread_arr_typ := rec_sym.cname
    fn_name := '${thread_arr_typ}_wait'
    mut should_register := false
    lock g.waiter_fns {
        if fn_name !in g.waiter_fns {
            g.waiter_fns << fn_name
            should_register = true
        }
    }
    if should_register {
        thread_ret_styp := g.styp(thread_ret_type)
        g.create_waiter_handler(thread_ret_type, thread_ret_styp, thread_typ)
        g.waiter_fn_definitions.writeln('${ret_styp} ${fn_name}(${thread_arr_typ} a);')
        g.gowrappers.writeln('
${ret_styp} ${fn_name}(${thread_arr_typ} a) {')
        if !is_void_payload {
            payload_arr_styp := g.base_type(ret_type.clear_option_and_result())
            payload_styp := g.styp(payload_type)
            g.gowrappers.writeln('\t${payload_arr_styp} res = builtin____new_array_with_default(${len}, ${len}, sizeof(${payload_styp}), 0);')
        }
        if thread_ret_type.has_option_or_result() {
            g.gowrappers.writeln('\tbool has_failure = false;')
            g.gowrappers.writeln('\t${thread_ret_styp} first_failure = {0};')
        }
        g.gowrappers.writeln('\tfor (${ast.int_type_name} i = 0; i < ${len}; ++i) {')
        g.gowrappers.writeln('\t\t${thread_typ} t = a[i];')
        if g.pref.os == .windows {
            if is_plain_void {
                g.gowrappers.writeln('\t\tif (t == 0) continue;')
            } else {
                g.gowrappers.writeln('\t\tif (t.handle == 0) continue;')
            }
        } else {
            g.gowrappers.writeln('\t\tif (t == 0) continue;')
        }
        if thread_ret_type.has_flag(.option) {
            payload_arr_styp := if is_void_payload {
                ''
            } else {
                g.base_type(ret_type.clear_option_and_result())
            }
            payload_styp := if is_void_payload { '' } else { g.styp(payload_type) }
            g.gowrappers.writeln('\t\t${thread_ret_styp} waited = ${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t\tif (waited.state != 0) {')
            g.gowrappers.writeln('\t\t\tif (!has_failure) {')
            g.gowrappers.writeln('\t\t\t\thas_failure = true;')
            g.gowrappers.writeln('\t\t\t\tfirst_failure = waited;')
            g.gowrappers.writeln('\t\t\t}')
            g.gowrappers.writeln('\t\t\tcontinue;')
            g.gowrappers.writeln('\t\t}')
            if !is_void_payload {
                g.gowrappers.writeln('\t\t((${payload_styp}*)res.data)[i] = *((${payload_styp}*)waited.data);')
            }
            g.gowrappers.writeln('\t}')
            g.gowrappers.writeln('\tif (has_failure) {')
            if !is_void_payload {
                g.gowrappers.writeln('\t\tbuiltin__array_free(&res);')
            }
            if is_void_payload {
                g.gowrappers.writeln('\t\treturn first_failure;')
            } else {
                g.gowrappers.writeln('\t\treturn (${ret_styp}){ .state = first_failure.state, .err = first_failure.err, .data = {E_STRUCT} };')
            }
            g.gowrappers.writeln('\t}')
            if is_void_payload {
                g.gowrappers.writeln('\treturn (${ret_styp}){0};')
            } else {
                g.gowrappers.writeln('\t${ret_styp} waited_all = {0};')
                g.gowrappers.writeln('\tbuiltin___option_ok(&(${payload_arr_styp}[]) { res }, (${option_name}*)(&waited_all), sizeof(${payload_arr_styp}));')
                g.gowrappers.writeln('\treturn waited_all;')
            }
        } else if thread_ret_type.has_flag(.result) {
            payload_arr_styp := if is_void_payload {
                ''
            } else {
                g.base_type(ret_type.clear_option_and_result())
            }
            payload_styp := if is_void_payload { '' } else { g.styp(payload_type) }
            g.gowrappers.writeln('\t\t${thread_ret_styp} waited = ${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t\tif (waited.is_error) {')
            g.gowrappers.writeln('\t\t\tif (!has_failure) {')
            g.gowrappers.writeln('\t\t\t\thas_failure = true;')
            g.gowrappers.writeln('\t\t\t\tfirst_failure = waited;')
            g.gowrappers.writeln('\t\t\t}')
            g.gowrappers.writeln('\t\t\tcontinue;')
            g.gowrappers.writeln('\t\t}')
            if !is_void_payload {
                g.gowrappers.writeln('\t\t((${payload_styp}*)res.data)[i] = *((${payload_styp}*)waited.data);')
            }
            g.gowrappers.writeln('\t}')
            g.gowrappers.writeln('\tif (has_failure) {')
            if !is_void_payload {
                g.gowrappers.writeln('\t\tbuiltin__array_free(&res);')
            }
            if is_void_payload {
                g.gowrappers.writeln('\t\treturn first_failure;')
            } else {
                g.gowrappers.writeln('\t\treturn (${ret_styp}){ .is_error = true, .err = first_failure.err, .data = {E_STRUCT} };')
            }
            g.gowrappers.writeln('\t}')
            if is_void_payload {
                g.gowrappers.writeln('\treturn (${ret_styp}){0};')
            } else {
                g.gowrappers.writeln('\t${ret_styp} waited_all = {0};')
                g.gowrappers.writeln('\tbuiltin___result_ok(&(${payload_arr_styp}[]) { res }, (${result_name}*)(&waited_all), sizeof(${payload_arr_styp}));')
                g.gowrappers.writeln('\treturn waited_all;')
            }
        } else if is_void_payload {
            g.gowrappers.writeln('\t\t${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t}')
        } else {
            payload_styp := g.styp(payload_type)
            g.gowrappers.writeln('\t\t((${payload_styp}*)res.data)[i] = ${waiter_fn_name}(t);')
            g.gowrappers.writeln('\t}')
            g.gowrappers.writeln('\treturn res;')
        }
        g.gowrappers.writeln('}')
    }
    return fn_name
}

fn (mut g Gen) register_chan_pop_option_call(opt_el_type string, styp string) {
    g.chan_pop_options[opt_el_type] = styp
}

fn (mut g Gen) note_chan_type_definition(chan_typ ast.Type) {
    mut concrete_chan_typ := g.unwrap_generic(g.recheck_concrete_type(chan_typ))
    if concrete_chan_typ == 0 {
        return
    }
    sym := g.table.final_sym(concrete_chan_typ)
    if sym.kind != .chan || sym.name == 'chan' {
        return
    }
    lock g.late_chan_types {
        if sym.cname in g.late_chan_types {
            return
        }
        g.late_chan_types << sym.cname
    }
}

fn (mut g Gen) ensure_chan_type_definition(chan_typ ast.Type) {
    mut concrete_chan_typ := g.unwrap_generic(g.recheck_concrete_type(chan_typ))
    if concrete_chan_typ == 0 {
        return
    }
    sym := g.table.final_sym(concrete_chan_typ)
    if sym.kind != .chan || sym.name == 'chan' {
        return
    }
    if sym.cname in g.emitted_chan_types {
        return
    }
    g.emitted_chan_types[sym.cname] = true
    chan_inf := sym.chan_info()
    chan_elem_type := g.unwrap_generic(g.recheck_concrete_type(chan_inf.elem_type))
    esym := g.table.sym(chan_elem_type)
    g.type_definitions.writeln('typedef chan ${sym.cname};')
    is_fixed_arr := esym.kind == .array_fixed
    if !chan_elem_type.has_flag(.generic) {
        el_stype := if is_fixed_arr { '_v_' } else { '' } + g.styp(chan_elem_type)
        val_arg_pop := if is_fixed_arr { '&val.ret_arr' } else { '&val' }
        val_arg_push := if is_fixed_arr { 'val' } else { '&val' }
        push_arg := el_stype + if is_fixed_arr { '*' } else { '' }
        g.channel_definitions.writeln('
static inline ${el_stype} __${sym.cname}_popval(${sym.cname} ch) {
    ${el_stype} val = {0};
    sync__Channel_try_pop_priv(ch, ${val_arg_pop}, false);
    return val;
}')
        g.channel_definitions.writeln('
static inline void __${sym.cname}_pushval(${sym.cname} ch, ${push_arg} val) {
    sync__Channel_try_push_priv(ch, ${val_arg_push}, false);
}')
    }
}

fn (mut g Gen) emit_late_chan_type_definitions() {
    mut late_chan_cnames := []string{}
    lock g.late_chan_types {
        late_chan_cnames = g.late_chan_types.clone()
    }
    for cname in late_chan_cnames {
        for idx, sym in g.table.type_symbols {
            if sym.cname == cname {
                g.ensure_chan_type_definition(ast.new_type(idx))
                break
            }
        }
    }
}

fn (mut g Gen) write_chan_pop_option_fns() {
    mut done := []string{}
    for opt_el_type, styp in g.chan_pop_options {
        if opt_el_type in done {
            continue
        }
        if g.pref.skip_unused {
            if sym := g.table.find_sym(opt_el_type) {
                if sym.idx !in g.table.used_features.used_syms {
                    continue
                }
            }
        }
        done << opt_el_type
        // Ensure the option type is registered for typedef generation
        // Only add if this styp is not already registered (to avoid duplicates with different bases)
        option_prefix := option_name + '_'
        if opt_el_type.starts_with(option_prefix) {
            already_registered := opt_el_type in g.options.values()
            if !already_registered {
                base := opt_el_type[option_prefix.len..]
                g.options[base] = opt_el_type
            }
        }
        g.channel_definitions.writeln('
static inline ${opt_el_type} __Option_${styp}_popval(${styp} ch) {
    ${opt_el_type} _tmp = {0};
    if (sync__Channel_try_pop_priv(ch, _tmp.data, false)) {
        return (${opt_el_type}){ .state = 2, .err = sync__Channel_closed_error(ch), .data = {E_STRUCT} };
    }
    return _tmp;
}')
    }
}

fn (mut g Gen) register_chan_push_option_fn(el_type string, styp string) {
    g.chan_push_options[styp] = el_type
}

fn (mut g Gen) write_chan_push_option_fns() {
    mut done := []string{}
    for styp, el_type in g.chan_push_options {
        if styp in done {
            continue
        }
        if g.pref.skip_unused {
            if sym := g.table.find_sym(el_type) {
                if sym.idx !in g.table.used_features.used_syms {
                    continue
                }
            }
        }
        done << styp
        g.register_option(ast.void_type.set_flag(.option))
        g.channel_definitions.writeln('
static inline ${option_name}_void __Option_${styp}_pushval(${styp} ch, ${el_type} e) {
    if (sync__Channel_try_push_priv(ch, &e, false)) {
        return (${option_name}_void){ .state = 2, .err = builtin___v_error(_S("channel closed")), .data = {E_STRUCT} };
    }
    return (${option_name}_void){0};
}')
    }
}

// cc_type whether to prefix 'struct' or not (C__Foo -> struct Foo)
fn (mut g Gen) cc_type(typ ast.Type, is_prefix_struct bool) string {
    mut resolved_typ := g.unwrap_generic(typ)
    // For generic_inst types with aliased concrete types, resolve to the unaliased
    // version so that e.g. MiddlewareOptions[AliasContext] uses the same C type as
    // MiddlewareOptions[Context].
    rsym := g.table.sym(resolved_typ)
    if rsym.kind == .generic_inst {
        info := rsym.info as ast.GenericInst
        mut has_alias := false
        mut unaliased_cts := info.concrete_types.clone()
        for i, ct in info.concrete_types {
            ua := g.table.unaliased_type(ct)
            if ua != ct {
                unaliased_cts[i] = ua.derive_add_muls(ct)
                has_alias = true
            }
        }
        if has_alias {
            // see comment at top of vlib/v/gen/c/utils.v
            mut muttable := unsafe { &ast.Table(g.table) }
            idx := muttable.find_or_register_generic_inst(ast.new_type(info.parent_idx),
                unaliased_cts)
            if idx > 0 {
                resolved_typ = ast.new_type(idx).derive_add_muls(resolved_typ)
            }
        }
    }
    sym := g.table.sym(resolved_typ)
    if g.pref.no_preludes {
        match sym.kind {
            .voidptr {
                return 'void*'
            }
            .charptr {
                return 'char*'
            }
            .byteptr {
                return 'unsigned char*'
            }
            else {}
        }
    }
    mut styp := sym.scoped_cname()
    // TODO: this needs to be removed; cgen shouldn't resolve generic types (job of checker)
    match sym.info {
        ast.Struct, ast.Interface, ast.SumType {
            if sym.info.is_generic && sym.generic_types.len == 0 && sym.kind != .interface {
                mut sgtyps := ''
                for gt in sym.info.generic_types {
                    gts := g.table.sym(g.unwrap_generic(gt))
                    sgtyps += '_T_${gts.scoped_cname()}'
                }
                styp += sgtyps
            }
        }
        else {}
    }

    if is_prefix_struct && sym.language == .c {
        styp = styp[3..]
        if sym.kind == .struct {
            info := sym.info as ast.Struct
            if info.is_anon {
                styp = 'C__' + styp
            } else if !info.is_typedef {
                styp = 'struct ${styp}'
            }
        }
    }
    return styp
}

@[inline]
fn (g &Gen) type_sidx(t ast.Type) string {
    if g.pref.build_mode == .build_module {
        sym := g.table.sym(t)
        return '_v_type_idx_${sym.cname}()'
    }
    return u32(t).str()
}

fn (g &Gen) unalias_type_keep_muls(typ ast.Type) ast.Type {
    mut resolved := typ
    for {
        sym := g.table.sym(resolved)
        if sym.info is ast.Alias {
            resolved = sym.info.parent_type.derive_add_muls(resolved)
            continue
        }
        if sym.info !is ast.Alias {
            break
        }
    }
    return resolved
}

fn (mut g Gen) exposed_smartcast_type(orig_type ast.Type, smartcast_type ast.Type, is_mut bool) ast.Type {
    if is_mut || orig_type == 0 || smartcast_type == 0 || orig_type.is_ptr() {
        return smartcast_type
    }
    orig_sym := g.table.final_sym(orig_type)
    resolved_smartcast_type := g.unwrap_generic(smartcast_type)
    smartcast_sym := g.table.final_sym(resolved_smartcast_type)
    if orig_sym.kind == .interface && smartcast_sym.kind != .interface {
        if smartcast_sym.kind in [.struct, .aggregate] && !smartcast_sym.is_builtin() {
            return if smartcast_type.is_ptr() { smartcast_type } else { smartcast_type.ref() }
        }
        if smartcast_type.is_ptr() {
            return smartcast_type.deref()
        }
    }
    return smartcast_type
}

fn (mut g Gen) concrete_interface_cast_type(typ ast.Type) ast.Type {
    unwrapped_typ := g.unwrap_generic(typ)
    sym := g.table.final_sym(unwrapped_typ)
    if sym.kind != .aggregate {
        return typ
    }
    variant_typ := sym.aggregate_variant_type(g.aggregate_type_idx)
    if variant_typ == 0 {
        return typ
    }
    return variant_typ.derive_add_muls(typ)
}

fn (g &Gen) runtime_interface_variants(info ast.Interface) []ast.Type {
    mut variants := []ast.Type{cap: info.types.len + info.mut_types.len}
    for typ in info.implementor_types(true) {
        if g.table.sym(typ).kind == .aggregate {
            continue
        }
        variants << typ
    }
    return variants
}

// ensure_array_typedef emits a `typedef array <cname>;` if the base type
// name looks like an array type that might not have been typedef'd yet.
// This is needed because option/result wrapper structs reference the base
// type in sizeof(), but the array typedef might have been skipped
// (e.g. for builtin nested array types like Array_Array_string).
fn (mut g Gen) ensure_array_typedef(base_ string) {
    base := base_.trim_right('*')
    if base.starts_with('Array_') && !base.starts_with('Array_fixed_') {
        if base !in g.array_typedefs {
            // Only track if write_typedef_types() already emitted at least
            // one array typedef, which means the `array` struct is defined.
            if g.written_array_typedefs > 0 || !g.done_typedef_phase {
                g.array_typedefs << base
            }
        }
    }
}

fn (mut g Gen) write_late_array_typedefs() {
    for i := g.written_array_typedefs; i < g.array_typedefs.len; i++ {
        g.type_definitions.writeln('typedef array ${g.array_typedefs[i]};')
    }
}

fn (g &Gen) fixed_array_base_elem_sym(typ ast.Type) &ast.TypeSymbol {
    mut sym := g.table.final_sym(typ)
    for {
        match sym.info {
            ast.ArrayFixed {
                sym = g.table.final_sym(sym.info.elem_type)
            }
            else {
                return sym
            }
        }
    }
    return sym
}

pub fn (mut g Gen) write_typedef_types() {
    type_symbols := g.table.type_symbols.filter(!it.is_builtin
        && it.kind in [.array, .array_fixed, .chan, .map])
    for sym in type_symbols {
        if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
            continue
        }
        match sym.kind {
            .array {
                info := sym.info as ast.Array
                elem_sym := g.table.sym(info.elem_type)
                if !g.pref.no_preludes && elem_sym.kind != .placeholder
                    && !info.elem_type.has_flag(.generic) {
                    g.type_definitions.writeln('typedef array ${sym.cname};')
                    g.array_typedefs << sym.cname
                }
            }
            .array_fixed {
                info := sym.info as ast.ArrayFixed
                base_elem_sym := g.fixed_array_base_elem_sym(info.elem_type)
                if base_elem_sym.kind != .struct && base_elem_sym.is_builtin() {
                    styp := sym.cname
                    len := info.size
                    if len > 0 {
                        fixed_elem_type := g.unalias_type_keep_muls(info.elem_type)
                        resolved_elem_sym := g.table.sym(fixed_elem_type)
                        mut fixed := g.styp(fixed_elem_type)
                        if resolved_elem_sym.info is ast.FnType {
                            pos := g.out.len
                            // pos2:=g.out_parallel[g.out_idx].len
                            g.write_fn_ptr_decl(&resolved_elem_sym.info, '')
                            fixed = g.out.cut_to(pos)
                            // g.out_parallel[g.out_idx].cut_to(pos2)
                            mut def_str := 'typedef ${fixed};'
                            def_str = def_str.replace_once('(*)', '(*${styp}[${len}])')
                            g.type_definitions.writeln(def_str)
                        } else if !info.is_fn_ret {
                            base := g.styp(info.elem_type.clear_option_and_result())
                            if info.elem_type.has_flag(.option) && base !in g.options_forward {
                                styp_elem, elem_base := g.option_type_name(info.elem_type)
                                lock g.done_options {
                                    if base !in g.done_options {
                                        g.done_options << elem_base
                                        g.typedefs.writeln('typedef struct ${styp_elem} ${styp_elem};')
                                        g.type_definitions.writeln('${g.option_type_text(styp_elem,
                                            elem_base)};')
                                    }
                                    if styp !in g.done_options {
                                        g.type_definitions.writeln('typedef ${fixed} ${styp} [${len}];')
                                        g.done_options << styp
                                    }
                                }
                            } else {
                                g.type_definitions.writeln('typedef ${fixed} ${styp} [${len}];')
                                if info.elem_type.has_flag(.result) && base !in g.results_forward {
                                    g.results_forward << base
                                }
                            }
                        }
                    }
                }
            }
            .chan {
                g.ensure_chan_type_definition(ast.new_type(sym.idx))
            }
            .map {
                g.type_definitions.writeln('typedef map ${sym.cname};')
            }
            else {
                continue
            }
        }
    }
    for sym in g.table.type_symbols {
        if sym.kind == .alias && !sym.is_builtin && sym.name !in ['byte', 'i32'] {
            if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
                continue
            }
            g.write_alias_typesymbol_declaration(sym)
        }
    }
    g.write_sorted_fn_typesymbol_declaration()
    // Generating interfaces after all the common types have been defined
    // to prevent generating interface struct before definition of field types

    interfaces := g.table.type_symbols.filter(it.info is ast.Interface && !it.is_builtin)
    mut interface_declaration_syms := []&ast.TypeSymbol{cap: interfaces.len}
    for sym in interfaces {
        g.write_interface_typedef(sym)
        if g.can_write_interface_typesymbol_declaration(sym) {
            interface_declaration_syms << sym
        }
    }
    mut already_generated_ifaces := map[string]bool{}
    for sym in interface_declaration_syms {
        if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
            continue
        }
        if sym.cname !in already_generated_ifaces {
            g.write_interface_typesymbol_declaration(sym)
            already_generated_ifaces[sym.cname] = true
        }
    }
}

pub fn (mut g Gen) write_alias_typesymbol_declaration(sym ast.TypeSymbol) {
    mut levels := 0
    parent := g.table.type_symbols[sym.parent_idx]
    is_c_parent := parent.name.len > 2 && parent.name[0] == `C` && parent.name[1] == `.`
    mut is_fixed_array_of_non_builtin := false
    mut parent_styp := parent.cname
    if is_c_parent {
        if sym.info is ast.Alias {
            parent_styp = g.styp(sym.info.parent_type)
        }
    } else {
        if sym.info is ast.Alias {
            parent_styp = g.styp(sym.info.parent_type)
            parent_sym := g.table.sym(sym.info.parent_type)
            if parent_sym.info is ast.ArrayFixed {
                mut elem_sym := g.table.sym(parent_sym.info.elem_type)
                base_elem_sym := g.fixed_array_base_elem_sym(parent_sym.info.elem_type)

                mut parent_elem_info := parent_sym.info as ast.ArrayFixed
                mut parent_elem_styp := g.styp(sym.info.parent_type)
                mut out := strings.new_builder(50)
                for {
                    if mut elem_sym.info is ast.ArrayFixed {
                        old := out.str()
                        out.clear()
                        out.writeln('typedef ${elem_sym.cname} ${parent_elem_styp} [${parent_elem_info.size}];')
                        out.writeln(old)
                        parent_elem_styp = elem_sym.cname
                        parent_elem_info = elem_sym.info as ast.ArrayFixed
                        elem_sym = g.table.sym(elem_sym.info.elem_type)
                        levels++
                    } else {
                        break
                    }
                }
                // Determine based on the base element type (after walking
                // through all nesting levels) whether the fixed array
                // contains non-builtin types. For non-builtins (structs,
                // enums), write_sorted_types handles the typedefs after
                // struct definitions, so skip emitting them here.
                if !base_elem_sym.is_builtin() {
                    is_fixed_array_of_non_builtin = true
                    out.clear()
                }
                if out.len != 0 {
                    g.type_definitions.writeln(out.str())
                }
            }
        }
    }
    if parent_styp == 'byte' && sym.cname == 'u8' {
        // TODO: remove this check; it is here just to fix V rebuilding in -cstrict mode with clang-12
        return
    }
    if sym.name.starts_with('C.') {
        // `pub type C.HINSTANCE = voidptr` means that `HINSTANCE` should be treated as a voidptr by V.
        // The C type itself however already exists on the C side, so just treat C__HINSTANCE as a macro for it:
        g.type_definitions.writeln('#define ${sym.cname} ${sym.cname#[3..]}')
        return
    }
    if is_fixed_array_of_non_builtin {
        g.alias_definitions.writeln('typedef ${parent_styp} ${sym.cname};')
    } else {
        g.type_definitions.writeln('typedef ${parent_styp} ${sym.cname};')
    }
}

pub fn (mut g Gen) write_interface_typedef(sym ast.TypeSymbol) {
    struct_name := c_name(sym.cname)
    g.typedefs.writeln('typedef struct ${struct_name} ${struct_name};')
}

pub fn (mut g Gen) write_interface_typesymbol_declaration(sym ast.TypeSymbol) {
    info := sym.info as ast.Interface
    struct_name := c_name(sym.cname)
    impl_types := info.implementor_types(true)
    g.type_definitions.writeln('struct ${struct_name} {')
    g.type_definitions.writeln('\tunion {')
    g.type_definitions.writeln('\t\tvoid* _object;')
    for variant in impl_types {
        mk_typ := ast.mktyp(variant)
        if mk_typ != variant && mk_typ in impl_types {
            continue
        }
        vsym := g.table.sym(mk_typ)
        if vsym.kind == .aggregate {
            continue
        }
        if g.pref.skip_unused && vsym.idx !in g.table.used_features.used_syms {
            continue
        }
        vcname := vsym.cname
        if vsym.info is ast.FnType {
            g.type_definitions.writeln('\t\t${g.fn_ptr_decl_str(vsym.info as ast.FnType,
                '_${vcname}')};')
        } else {
            g.type_definitions.writeln('\t\t${vcname}* _${vcname};')
        }
    }
    g.type_definitions.writeln('\t};')
    g.type_definitions.writeln('\tu32 _typ;')
    g.type_definitions.writeln('\tvoid* _methods;')
    for field in info.fields {
        styp := g.styp(field.typ)
        cname := c_name(field.name)
        g.type_definitions.writeln('\t${styp}* ${cname};')
    }
    g.type_definitions.writeln('};')
}

fn (mut g Gen) interface_methods_struct_name(typ ast.Type) string {
    interface_sym := g.table.final_sym(g.table.unaliased_type(g.unwrap_generic(typ)))
    return 'struct _${interface_sym.cname}_interface_methods'
}

fn (mut g Gen) shared_interface_mtx_helper_name(typ ast.Type) string {
    interface_typ := g.table.unaliased_type(g.unwrap_generic(typ.clear_flags(.shared_f, .atomic_f)))
    interface_sym := g.table.final_sym(interface_typ)
    return '__shared__${interface_sym.cname}_mtx'
}

pub fn (mut g Gen) write_fn_typesymbol_declaration(sym ast.TypeSymbol) {
    info := sym.info as ast.FnType
    func := info.func
    is_fn_sig := func.name == ''
    not_anon := !info.is_anon
    mut has_generic_arg := false

    if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
        return
    }

    for param in func.params {
        if g.type_has_unresolved_generic_parts(param.typ) {
            has_generic_arg = true
            break
        }
    }
    if !info.has_decl && (not_anon || is_fn_sig)
        && !g.type_has_unresolved_generic_parts(func.return_type) && !has_generic_arg {
        fn_name := sym.cname
        mut call_conv_attr := ''
        for attr in func.attrs {
            match attr.name {
                'callconv' {
                    call_conv_attr = call_convention_attribute(attr.arg)
                }
                else {}
            }
        }
        ret_typ :=
            if !func.return_type.has_flag(.option) && !func.return_type.has_flag(.result) && g.table.sym(func.return_type).kind == .array_fixed { '_v_' } else { '' } +
            g.styp(func.return_type)
        g.type_definitions.write_string('typedef ${ret_typ} (${call_conv_attr}*${fn_name})(')
        for i, param in func.params {
            const_prefix := if param.typ.is_any_kind_of_pointer() && !param.is_mut
                && param.name.starts_with('const_') {
                'const '
            } else {
                ''
            }
            if const_prefix != '' {
                styp := g.styp(param.typ)
                g.type_definitions.write_string(const_prefix +
                    g.const_pointer_param_type_name(param.typ, styp))
            } else {
                g.type_definitions.write_string(g.fn_param_type_decl(param.typ, ''))
            }
            if i < func.params.len - 1 {
                g.type_definitions.write_string(',')
            }
        }
        g.type_definitions.writeln(');')
    }
}

// fn_param_type_decl emits fixed-array parameters as direct C array declarators so
// function type definitions do not depend on later fixed-array typedef ordering.
fn (mut g Gen) fn_param_type_decl(typ ast.Type, name string) string {
    styp := g.styp(typ)
    if typ.is_ptr() || typ.has_flag(.option) || typ.has_flag(.result) {
        return if name == '' { styp } else { '${styp} ${name}' }
    }
    mut current_typ := g.table.unaliased_type(typ)
    mut current_sym := g.table.sym(current_typ)
    if current_sym.kind != .array_fixed {
        return if name == '' { styp } else { '${styp} ${name}' }
    }
    mut dims := []string{}
    for current_sym.kind == .array_fixed {
        info := current_sym.info as ast.ArrayFixed
        dims << '[${info.size}]'
        if info.elem_type.is_ptr() || info.elem_type.has_flag(.option)
            || info.elem_type.has_flag(.result) {
            base_styp := g.styp(info.elem_type)
            decl := if name == '' { dims.join('') } else { '${name}${dims.join('')}' }
            return '${base_styp} ${decl}'
        }
        current_typ = g.table.unaliased_type(info.elem_type)
        current_sym = g.table.sym(current_typ)
    }
    if current_sym.info is ast.FnType {
        return if name == '' { styp } else { '${styp} ${name}' }
    }
    decl := if name == '' { dims.join('') } else { '${name}${dims.join('')}' }
    return '${g.styp(current_typ)} ${decl}'
}

pub fn (mut g Gen) write_array_fixed_return_types() {
    fixed_arr_wrappers := g.table.type_symbols.filter(it.info is ast.ArrayFixed
        && !it.info.elem_type.has_flag(.generic))
    if fixed_arr_wrappers.len == 0 {
        return
    }

    g.typedefs.writeln('\n// BEGIN_array_fixed_return_typedefs')
    g.type_definitions.writeln('\n// BEGIN_array_fixed_return_structs')
    mut generated_wrappers := map[string]bool{}

    for sym in fixed_arr_wrappers {
        if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
            continue
        }
        info := sym.info as ast.ArrayFixed
        if info.size <= 0 {
            // unresolved sizes e.g. [unknown_const]int
            continue
        }
        // Skip if element type is a non-builtin struct that isn't marked as used
        // This prevents generating wrapper structs that reference undefined types
        resolved_elem_type := g.unalias_type_keep_muls(info.elem_type)
        resolved_elem_sym := g.table.sym(resolved_elem_type)
        if g.pref.skip_unused && resolved_elem_sym.kind == .struct
            && !resolved_elem_sym.is_builtin()
            && resolved_elem_sym.idx !in g.table.used_features.used_syms {
            continue
        }
        wrapper_name := '_v_${sym.cname}'
        if wrapper_name in generated_wrappers {
            continue
        }
        generated_wrappers[wrapper_name] = true
        g.typedefs.writeln('typedef struct ${wrapper_name} ${wrapper_name};')
        g.type_definitions.writeln('struct ${wrapper_name} {')
        if resolved_elem_sym.info is ast.FnType {
            pos := g.out.len
            g.write_fn_ptr_decl(&resolved_elem_sym.info, 'ret_arr[${info.size}]')
            field_decl := g.out.cut_to(pos)
            g.type_definitions.writeln('\t${field_decl};')
        } else {
            mut fixed_elem_name := g.styp(resolved_elem_type.set_nr_muls(0))
            if resolved_elem_type.is_ptr() {
                fixed_elem_name += '*'.repeat(resolved_elem_type.nr_muls())
            }
            g.type_definitions.writeln('\t${fixed_elem_name} ret_arr[${info.size}];')
        }
        g.type_definitions.writeln('};')
    }

    g.typedefs.writeln('// END_array_fixed_return_typedefs\n')
    g.type_definitions.writeln('// END_array_fixed_return_structs\n')
}

pub fn (mut g Gen) write_multi_return_types() {
    start_pos := g.type_definitions.len
    g.typedefs.writeln('\n// BEGIN_multi_return_typedefs')
    g.type_definitions.writeln('\n// BEGIN_multi_return_structs')
    multi_rets := g.table.type_symbols.filter(it.kind == .multi_return && !it.cname.contains('['))
    for sym in multi_rets {
        info := sym.mr_info()
        if info.types.any(it.has_flag(.generic)) {
            continue
        }
        if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
            continue
        }
        g.typedefs.writeln('typedef struct ${sym.cname} ${sym.cname};')
        g.type_definitions.writeln('struct ${sym.cname} {')
        for i, mr_typ in info.types {
            type_name := g.styp(mr_typ)
            if mr_typ.has_flag(.option) {
                // option in multi_return
                // Dont use g.styp() here because it will register
                // option and we dont want that
                styp, base := g.option_type_name(mr_typ)
                lock g.done_options {
                    if base !in g.done_options {
                        g.done_options << base
                        last_text := g.type_definitions.after(start_pos).clone()
                        g.type_definitions.go_back_to(start_pos)
                        g.typedefs.writeln('typedef struct ${styp} ${styp};')
                        g.type_definitions.writeln('${g.option_type_text(styp, base)};')
                        g.type_definitions.write_string(last_text)
                    }
                }
            }
            if mr_typ.has_flag(.result) {
                // result in multi_return
                // Dont use g.styp() here because it will register
                // result and we dont want that
                styp, base := g.result_type_name(mr_typ)
                lock g.done_results {
                    if base !in g.done_results {
                        g.done_results << base
                        last_text := g.type_definitions.after(start_pos).clone()
                        g.type_definitions.go_back_to(start_pos)
                        g.typedefs.writeln('typedef struct ${styp} ${styp};')
                        g.type_definitions.writeln('${g.result_type_text(styp, base)};')
                        g.type_definitions.write_string(last_text)
                    }
                }
            }
            g.type_definitions.writeln('\t${type_name} arg${i};')
        }
        g.type_definitions.writeln('};\n')
    }
    g.typedefs.writeln('// END_multi_return_typedefs\n')
    g.type_definitions.writeln('// END_multi_return_structs\n')
}

@[inline]
fn prefix_with_counter(prefix string, counter int) string {
    mut sb := strings.new_builder(prefix.len + 5)
    sb.write_string(prefix)
    sb.write_decimal(counter)
    return sb.str()
}

pub fn (mut g Gen) new_tmp_var() string {
    g.tmp_count++
    return prefix_with_counter('_t', g.tmp_count)
}

pub fn (mut g Gen) new_global_tmp_var() string {
    g.global_tmp_count++
    return prefix_with_counter('_t', g.global_tmp_count)
}

pub fn (mut g Gen) current_tmp_var() string {
    return prefix_with_counter('_t', g.tmp_count)
}

pub fn (mut g Gen) reset_tmp_count() int {
    old := g.tmp_count
    g.tmp_count = 0
    return old
}

fn (mut g Gen) decrement_inside_ternary() {
    key := g.inside_ternary.str()
    for name in g.ternary_level_names[key] {
        g.ternary_names.delete(name)
    }
    g.ternary_level_names.delete(key)
    g.inside_ternary--
}

fn (mut g Gen) stmts(stmts []ast.Stmt) {
    g.stmts_with_tmp_var(stmts, '')
}

fn is_noreturn_callexpr(expr ast.Expr) bool {
    if expr is ast.CallExpr {
        return expr.is_noreturn
    }
    return false
}

// stmts_with_tmp_var is used in `if` or `match` branches.
// It returns true, if the last statement was a `return` or `branch`
fn (mut g Gen) stmts_with_tmp_var(stmts []ast.Stmt, tmp_var string) bool {
    g.indent++
    if g.inside_ternary > 0 {
        g.write('(')
    }
    expected_cast_type := g.expected_cast_type
    // Track if last statement was return or branch (for autofree, both skip scope cleanup)
    mut last_stmt_was_return := false
    for i, stmt in stmts {
        if i == stmts.len - 1 {
            g.expected_cast_type = expected_cast_type
            if stmt is ast.Return {
                last_stmt_was_return = true
            } else if stmt is ast.BranchStmt {
                last_stmt_was_return = true
            }
        }
        if i == stmts.len - 1 && tmp_var != '' {
            // Handle if expressions, set the value of the last expression to the temp var.
            if g.inside_if_option || g.inside_match_option {
                g.set_current_pos_as_last_stmt_pos()
                g.skip_stmt_pos = true
                if stmt is ast.ExprStmt {
                    if stmt.typ == ast.error_type_idx || stmt.expr is ast.None {
                        g.writeln('${tmp_var}.state = 2;')
                        g.write('${tmp_var}.err = ')
                        g.expr(stmt.expr)
                        g.writeln(';')
                    } else {
                        mut styp := g.base_type(stmt.typ)
                        $if tinyc && x32 && windows {
                            if stmt.typ == ast.int_literal_type {
                                styp = ast.int_type_name
                            } else if stmt.typ == ast.float_literal_type {
                                styp = 'f64'
                            }
                        }
                        if stmt.typ.has_flag(.option)
                            || (g.inside_if_option && stmt.expr is ast.IfExpr) {
                            g.writeln('')
                            g.write('${tmp_var} = ')
                            g.expr(stmt.expr)
                            g.writeln(';')
                        } else {
                            // on assignment or struct field initialization
                            inside_assign_context := g.inside_struct_init
                                || g.inside_assign
                                || (!g.inside_return && g.inside_match_option)
                            ret_expr_typ := if inside_assign_context {
                                stmt.typ
                            } else {
                                g.fn_decl.return_type
                            }
                            ret_typ := if inside_assign_context {
                                stmt.typ
                            } else {
                                g.fn_decl.return_type.clear_flag(.option)
                            }
                            styp = g.base_type(ret_typ)
                            if stmt.expr is ast.CallExpr && stmt.expr.is_noreturn {
                                g.writeln(';')
                            } else if !ret_expr_typ.has_option_or_result()
                                && !stmt.typ.has_option_or_result() && g.last_if_option_type != 0
                                && !g.last_if_option_type.has_option_or_result() {
                                g.write('${tmp_var} = ')
                                g.expr_with_cast(stmt.expr, stmt.typ, ret_typ)
                                g.writeln(';')
                            } else {
                                g.write('builtin___option_ok(&(${styp}[]) { ')
                                g.expr_with_cast(stmt.expr, stmt.typ, ret_typ)
                                g.writeln(' }, (${option_name}*)(&${tmp_var}), sizeof(${styp}));')
                            }
                        }
                    }
                } else if stmt is ast.Return {
                    g.stmt(stmt)
                }
            } else if g.inside_if_result || g.inside_match_result {
                g.set_current_pos_as_last_stmt_pos()
                g.skip_stmt_pos = true
                if stmt is ast.ExprStmt {
                    if stmt.typ == ast.error_type_idx {
                        g.writeln('${tmp_var}.is_error = true;')
                        g.write('${tmp_var}.err = ')
                        g.expr(stmt.expr)
                        g.writeln(';')
                    } else {
                        mut styp := g.base_type(stmt.typ)
                        $if tinyc && x32 && windows {
                            if stmt.typ == ast.int_literal_type {
                                styp = ast.int_type_name
                            } else if stmt.typ == ast.float_literal_type {
                                styp = 'f64'
                            }
                        }
                        if stmt.typ.has_flag(.result) {
                            g.writeln('')
                            g.write('${tmp_var} = ')
                            g.expr(stmt.expr)
                            g.writeln(';')
                        } else {
                            // on assignment or struct field initialization
                            inside_assign_context := g.inside_struct_init
                                || g.inside_assign
                                || (!g.inside_return && g.inside_match_result)
                            ret_typ := if inside_assign_context {
                                stmt.typ
                            } else {
                                g.fn_decl.return_type.clear_flag(.result)
                            }
                            styp = g.base_type(ret_typ)
                            if stmt.expr is ast.CallExpr && stmt.expr.is_noreturn {
                                g.expr(ast.Expr(stmt.expr))
                                g.writeln(';')
                            } else {
                                g.write('builtin___result_ok(&(${styp}[]) { ')
                                g.expr_with_cast(stmt.expr, stmt.typ, ret_typ)
                                g.writeln(' }, (${result_name}*)(&${tmp_var}), sizeof(${styp}));')
                            }
                        }
                    }
                } else if stmt is ast.Return {
                    g.stmt(stmt)
                }
            } else {
                mut is_array_fixed_init := false
                mut ret_type := ast.void_type

                g.set_current_pos_as_last_stmt_pos()
                g.skip_stmt_pos = true
                mut is_noreturn := false
                mut is_if_expr_with_tmp := false
                if stmt in [ast.Return, ast.BranchStmt] {
                    is_noreturn = true
                } else if stmt is ast.ExprStmt {
                    is_noreturn = is_noreturn_callexpr(stmt.expr)
                    if stmt.expr is ast.ArrayInit && stmt.expr.is_fixed {
                        is_array_fixed_init = true
                        ret_type = stmt.expr.typ
                    }
                    if stmt.expr is ast.IfExpr && g.is_autofree && !g.inside_if_option
                        && !g.inside_if_result {
                        is_if_expr_with_tmp = true
                        g.outer_tmp_var = tmp_var
                    }
                }
                if !is_noreturn && !is_if_expr_with_tmp {
                    if is_array_fixed_init {
                        g.write('memcpy(${tmp_var}, (${g.styp(ret_type)})')
                    } else {
                        g.write('${tmp_var} = ')
                    }
                }
                g.stmt(stmt)
                // Reset outer_tmp_var after processing
                if is_if_expr_with_tmp {
                    g.outer_tmp_var = ''
                }
                if is_array_fixed_init {
                    lines := g.go_before_last_stmt().trim_right('; \n')
                    g.writeln('${lines}, sizeof(${tmp_var}));')
                }
                if !g.out.last_n(2).contains(';') {
                    g.writeln(';')
                }
            }
        } else {
            if i > 0 && stmt is ast.Return {
                last_stmt := stmts[i - 1]
                if last_stmt is ast.ExprStmt && last_stmt.expr is ast.CallExpr
                    && !g.out.last_n(2).contains(';') {
                    g.writeln(';')
                }
            }
            g.stmt(stmt)
            if stmt is ast.ExprStmt && (g.inside_if_option || g.inside_if_result
                || g.inside_match_option || g.inside_match_result
                || (stmt.expr is ast.IndexExpr && stmt.expr.or_expr.kind != .absent)) {
                g.writeln(';')
            }
        }
        g.skip_stmt_pos = false
        if g.inside_ternary > 0 && i < stmts.len - 1 {
            g.write(',')
        }
    }
    g.indent--
    if g.inside_ternary > 0 {
        g.write2('', ')')
    }
    if g.needs_scope_cleanup() && !g.inside_veb_tmpl && stmts.len > 0 && !last_stmt_was_return {
        // use the first stmt to get the scope
        stmt := stmts[0]
        if stmt !is ast.FnDecl && g.inside_ternary == 0 {
            // g.trace_autofree('// autofree scope')
            // g.trace_autofree('// autofree_scope_vars(${stmt.pos.pos}) | ${typeof(stmt)}')
            // go back 1 position is important so we dont get the
            // internal scope of for loops and possibly other nodes
            // g.autofree_scope_vars(stmt.pos.pos - 1)
            mut stmt_pos := stmt.pos
            if stmt_pos.pos == 0 {
                // Do not autofree if the position is 0, since the correct scope won't be found.
                // Report a bug, since position shouldn't be 0 for most nodes.
                if stmt is ast.Module {
                    return last_stmt_was_return
                }
                if stmt is ast.ExprStmt {
                    // For some reason ExprStmt.pos is 0 when ExprStmt.expr is comp if expr
                    // Extract the pos. TODO figure out why and fix.
                    stmt_pos = stmt.expr.pos()
                }
                if stmt_pos.pos == 0 {
                    $if trace_autofree ? {
                        println('autofree: first stmt pos = 0. ${stmt.type_name()}')
                    }
                    return last_stmt_was_return
                }
            }
            g.autofree_scope_vars(stmt_pos.pos - 1, stmt_pos.line_nr, false)
        }
    }
    return last_stmt_was_return
}

// expr_with_tmp_var is used in assign expr to `option` or `result` type.
// applicable to situations where the expr_typ does not have `option` and `result`,
// e.g. field default: "foo ?int = 1", field assign: "foo = 1", field init: "foo: 1"
fn (mut g Gen) gen_option_payload_ref(expr ast.PrefixExpr, ret_typ ast.Type, tmp_var string) bool {
    if expr.op != .amp || !expr.right_type.has_flag(.option) {
        return false
    }
    mut right_expr := expr.right
    right_expr = right_expr.remove_par()
    match right_expr {
        ast.Ident, ast.IndexExpr, ast.SelectorExpr {}
        else { return false }
    }

    opt_ptr_var := g.new_tmp_var()
    opt_styp := g.styp(expr.right_type).replace('*', '')