// 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('*', '')
    ret_styp := g.styp(ret_typ).replace('*', '')
    styp := g.base_type(ret_typ)
    opt_expr := g.expr_string(expr.right)
    g.writeln('${opt_styp}* ${opt_ptr_var} = &(${opt_expr});')
    g.writeln('if (${opt_ptr_var}->state != 0) {')
    g.writeln('\t${tmp_var} = (${ret_styp}){ .state = ${opt_ptr_var}->state, .err = ${opt_ptr_var}->err, .data = {E_STRUCT} };')
    g.writeln('} else {')
    g.writeln('\tbuiltin___option_ok(&(${styp}[]) { (${styp})${opt_ptr_var}->data }, (${option_name}*)(&${tmp_var}), sizeof(${styp}));')
    g.writeln('}')
    return true
}

fn (mut g Gen) expr_with_tmp_var(expr ast.Expr, expr_typ ast.Type, ret_typ ast.Type, tmp_var string, use_at_once bool) {
    if !ret_typ.has_option_or_result() {
        panic('cgen: parameter `ret_typ` of function `expr_with_tmp_var()` must be an Option or Result')
    }

    assign_op := g.assign_op
    defer {
        g.assign_op = assign_op
    }
    g.assign_op = .unknown
    stmt_str := if g.inside_ternary > 0 {
        g.go_before_ternary().trim_space()
    } else {
        g.go_before_last_stmt().trim_space()
    }
    // mut styp := g.base_type(ret_typ)
    unwrapped_ret_typ := g.unwrap_generic(ret_typ)
    mut styp := g.base_type(unwrapped_ret_typ)
    g.empty_line = true
    final_expr_sym := g.table.final_sym(g.unwrap_generic(expr_typ))
    mut expected_type := ret_typ
    if final_expr_sym.kind == .none {
        error_target_type := if unwrapped_ret_typ.has_flag(.option_mut_param_t) {
            unwrapped_ret_typ.clear_flag(.option_mut_param_t)
        } else {
            unwrapped_ret_typ
        }
        tmp_styp := g.styp(error_target_type)
        g.write('${tmp_styp} ${tmp_var} = ')
        g.gen_option_error(error_target_type, expr)
        g.writeln(';')
    } else if expr is ast.Ident && expr_typ == ast.error_type {
        g.writeln('${g.styp(unwrapped_ret_typ)} ${tmp_var} = {.state=2, .err=${expr.name}};')
    } else {
        mut simple_assign := false
        unwrapped_expr_typ := g.unwrap_generic(expr_typ)
        expr_typ_is_option := unwrapped_expr_typ.has_flag(.option)
        ret_typ_is_option := unwrapped_ret_typ.has_flag(.option)
        if ret_typ.has_flag(.generic) {
            if expr is ast.SelectorExpr && g.cur_concrete_types.len == 0 {
                // resolve generic struct on selectorExpr inside non-generic function
                if expr.expr is ast.Ident {
                    if expr.expr.obj is ast.Var {
                        if expr.expr.obj.expr is ast.StructInit {
                            struct_info := g.table.sym(expr.expr.obj.typ).info
                            if struct_info is ast.Struct && struct_info.concrete_types.len > 0 {
                                save_cur_concrete_types := g.cur_concrete_types
                                g.cur_concrete_types = struct_info.concrete_types
                                g.clear_type_resolution_caches()
                                defer {
                                    g.cur_concrete_types = save_cur_concrete_types
                                    g.clear_type_resolution_caches()
                                }
                            }
                        }
                    }
                }
            }
            ret_styp := g.styp(unwrapped_ret_typ).replace('*', '_ptr')
            g.writeln('${ret_styp} ${tmp_var};')
        } else {
            if unwrapped_ret_typ.has_flag(.option_mut_param_t) {
                ret_styp := g.styp(unwrapped_ret_typ).replace('*', '')
                g.writeln('${ret_styp} ${tmp_var};')
            } else {
                g.writeln('${g.styp(unwrapped_ret_typ)} ${tmp_var};')
            }
        }
        if ret_typ_is_option && expr is ast.PrefixExpr
            && g.gen_option_payload_ref(expr, unwrapped_ret_typ, tmp_var) {
            g.set_current_pos_as_last_stmt_pos()
            g.write2(stmt_str, ' ')
            if use_at_once {
                g.write(tmp_var)
            }
            return
        }
        mut expr_is_fixed_array_var := false
        mut fn_option_clone := false
        mut already_generated := false
        if ret_typ_is_option {
            if !expr_typ_is_option {
                expected_type = ret_typ.clear_flag(.option)
            }
            if expr_typ_is_option && expr in [ast.StructInit, ast.ArrayInit, ast.MapInit] {
                simple_assign = expr is ast.StructInit && !expr.typ.has_flag(.generic)
                if simple_assign {
                    g.write('${tmp_var} = ')
                } else {
                    if expr is ast.StructInit && expr.typ.has_flag(.generic) {
                        // T{}
                        g.write('builtin___option_ok(&(${styp}[]) { ')
                        already_generated = true
                        g.expr(ast.StructInit{
                            ...expr
                            typ: g.unwrap_generic(expr.typ).clear_flag(.option)
                        })
                    } else {
                        g.write('builtin___option_none(&(${styp}[]) { ')
                    }
                }
            } else {
                simple_assign =
                    ((expr is ast.SelectorExpr || (expr is ast.Ident && !expr.is_auto_heap()))
                    && ret_typ.is_ptr() && expr_typ.is_ptr() && expr_typ_is_option)
                    || (expr_typ == ret_typ && !(expr_typ.has_option_or_result()
                    && (expr_typ.is_ptr() || expr is ast.LambdaExpr)))
                // option ptr assignment simplification
                if simple_assign {
                    g.write('${tmp_var} = ')
                } else if expr_typ_is_option && expr is ast.PrefixExpr
                    && expr.right is ast.StructInit
                    && (expr.right as ast.StructInit).init_fields.len == 0 {
                    g.write('builtin___option_none(&(${styp}[]) { ')
                } else if final_expr_sym.kind == .array_fixed {
                    expr_is_fixed_array_var = true
                    info := final_expr_sym.array_fixed_info()
                    mut no_cast := false
                    if expr in [ast.CastExpr, ast.CallExpr, ast.Ident, ast.SelectorExpr] {
                        no_cast = true
                    }
                    elem_sym := g.table.sym(info.elem_type)
                    if elem_sym.kind == .struct {
                        expr_is_fixed_array_var = false
                        g.write('builtin___option_ok(&(${styp}[]) { ')
                    } else if no_cast {
                        g.write('builtin___option_ok(')
                    } else {
                        g.write('builtin___option_ok((${g.styp(final_expr_sym.idx)})')
                    }
                } else {
                    g.write('builtin___option_ok(&(${styp}[]) { ')
                    if final_expr_sym.info is ast.FnType {
                        final_ret_sym := g.table.final_sym(ret_typ)
                        if final_ret_sym.info is ast.FnType {
                            g.write('(')
                            g.write_fn_ptr_decl(&final_ret_sym.info, '')
                            g.write(')')
                            fn_option_clone = expr is ast.SelectorExpr && expr_typ.has_flag(.option)
                        }
                    }
                }
                // For @[heap] variables, the C-level variable is already a pointer
                // even though the V-level type is a value type, so account for
                // that extra indirection when computing how many '&' to add.
                extra_muls := if expr is ast.Ident && g.resolved_ident_is_auto_heap(expr)
                    && !expr_typ.is_ptr() {
                    1
                } else {
                    0
                }
                if !expr.is_literal() && expr_typ != ast.nil_type
                    && ret_typ.nr_muls() > expr_typ.nr_muls() + extra_muls
                    && !ret_typ.has_flag(.option_mut_param_t) {
                    g.write('&'.repeat(ret_typ.nr_muls() - expr_typ.nr_muls() - extra_muls))
                } else if ret_typ.has_flag(.option_mut_param_t) {
                    if expr_typ.is_ptr() {
                        if ret_typ.nr_muls() < expr_typ.nr_muls() {
                            g.write('*')
                        }
                    } else {
                        if expr_typ.has_flag(.option) {
                            fn_option_clone = true
                            g.write('(${styp})')
                        }
                        g.write('&')
                    }
                }
            }
        } else {
            if final_expr_sym.kind == .array_fixed {
                expr_is_fixed_array_var = true
                info := final_expr_sym.array_fixed_info()
                mut no_cast := false
                if expr in [ast.CastExpr, ast.CallExpr, ast.Ident, ast.SelectorExpr] {
                    no_cast = true
                }
                elem_sym := g.table.sym(info.elem_type)
                if elem_sym.kind == .struct {
                    expr_is_fixed_array_var = false
                    g.write('builtin___result_ok(&(${styp}[]) { ')
                } else if no_cast {
                    g.write('builtin___result_ok(')
                } else {
                    g.write('builtin___result_ok((${g.styp(final_expr_sym.idx)})')
                }
            } else {
                g.write('builtin___result_ok(&(${styp}[]) { ')
                expected_type = ret_typ.clear_flag(.result)
            }
        }
        if !already_generated {
            g.expr_with_cast(expr, expr_typ, expected_type)
        }

        if fn_option_clone {
            g.write('.data')
        }
        if ret_typ_is_option {
            if simple_assign {
                g.writeln(';')
            } else if expr_is_fixed_array_var {
                g.writeln(', (${option_name}*)(&${tmp_var}), sizeof(${styp}));')
            } else {
                g.writeln(' }, (${option_name}*)(&${tmp_var}), sizeof(${styp}));')
            }
        } else {
            if expr_is_fixed_array_var {
                g.writeln(', (${result_name}*)(&${tmp_var}), sizeof(${styp}));')
            } else {
                g.writeln(' }, (${result_name}*)(&${tmp_var}), sizeof(${styp}));')
            }
        }
        g.set_current_pos_as_last_stmt_pos()
    }

    g.write2(stmt_str, ' ')
    if use_at_once {
        g.write(tmp_var)
    }
}

@[inline]
fn (mut g Gen) write_v_source_line_info_pos(pos token.Pos) {
    if g.inside_ternary == 0 && g.pref.is_vlines && g.is_vlines_enabled {
        nline := pos.line_nr + 1
        lineinfo := '\n#line ${nline} "${g.vlines_path}"'
        $if trace_gen_source_line_info ? {
            eprintln('> lineinfo: ${lineinfo.replace('\n', '')}')
        }
        g.writeln(lineinfo)
    }
}

@[inline]
fn (mut g Gen) write_v_source_line_info(node ast.Node) {
    g.write_v_source_line_info_pos(node.pos())
    if g.inside_ternary == 0 && g.pref.is_coverage
        && node !in [ast.MatchBranch, ast.IfBranch, ast.InfixExpr] {
        g.write_coverage_point(node.pos())
    }
}

@[inline]
fn (mut g Gen) write_v_source_line_info_stmt(stmt ast.Stmt) {
    g.write_v_source_line_info_pos(stmt.pos)
    if g.inside_ternary == 0 && g.pref.is_coverage && !g.inside_for_c_stmt
        && stmt !in [ast.FnDecl, ast.ForCStmt, ast.ForInStmt, ast.ForStmt] {
        if stmt is ast.AssertStmt {
            if stmt.expr !in [ast.InfixExpr, ast.MatchExpr] {
                g.write_coverage_point(stmt.pos)
            }
        } else {
            g.write_coverage_point(stmt.pos)
        }
    }
}

fn (g &Gen) should_autofree_discarded_call_result(typ ast.Type) bool {
    if typ == 0 || typ == ast.void_type || typ.has_option_or_result() {
        return false
    }
    sym := g.table.final_sym(typ)
    if sym.kind in [.array, .string] {
        return true
    }
    if sym.has_method('free') {
        return true
    }
    sym_name := sym.name.after('.')
    is_user_ref := typ.is_ptr() && sym_name.len > 0 && sym_name[0].is_capital()
    if is_user_ref && g.pref.experimental {
        return true
    }
    return false
}

fn (mut g Gen) stmt(node ast.Stmt) {
    $if trace_cgen_stmt ? {
        ntype := typeof(node).replace('v.ast.', '')
        if g.file == unsafe { nil } {
            eprintln('cgen: <nil> | pos: ${node.pos.line_str():-39} | node: ${ntype} | ${node}')
        } else {
            eprintln('cgen: ${g.file.path:-30} | pos: ${node.pos.line_str():-39} | node: ${ntype} | ${node}')
        }
    }
    old_inside_call := g.inside_call
    g.inside_call = false
    defer {
        g.inside_call = old_inside_call
    }
    if !g.skip_stmt_pos {
        g.set_current_pos_as_last_stmt_pos()
    }
    match node {
        ast.FnDecl {
            g.fn_decl(node)
        }
        ast.Block {
            g.write_v_source_line_info_stmt(node)
            if node.is_unsafe {
                g.unsafe_level++
            }

            if g.cur_fn != unsafe { nil } {
                if !node.is_unsafe {
                    g.writeln('{')
                } else {
                    if g.pref.is_prod {
                        g.writeln('{')
                    } else {
                        g.writeln('{ // Unsafe block')
                    }
                }
            }
            g.stmts(node.stmts)
            g.write_defer_stmts(node.scope, false, node.pos)
            if g.cur_fn != unsafe { nil } {
                g.writeln('}')
            }
            if node.is_unsafe {
                g.unsafe_level--
            }
        }
        ast.AssignStmt {
            g.write_v_source_line_info_stmt(node)
            g.assign_stmt(node)
        }
        ast.AssertStmt {
            g.write_v_source_line_info_stmt(node)
            g.assert_stmt(node)
        }
        ast.ConstDecl {
            g.write_v_source_line_info_stmt(node)
            g.const_decl(node)
        }
        ast.ComptimeFor {
            g.comptime_for(node)
        }
        ast.BranchStmt {
            g.write_v_source_line_info_stmt(node)
            g.branch_stmt(node)
        }
        ast.ExprStmt {
            g.write_v_source_line_info_stmt(node)
            // af := g.autofree && node.expr is ast.CallExpr && !g.is_builtin_mod
            // if af {
            // g.autofree_call_pregen(node.expr as ast.CallExpr)
            // }
            can_emit_standalone_expr_stmt := !g.skip_stmt_pos && g.inside_ternary == 0
                && !g.inside_if_option && !g.inside_match_option && !g.inside_if_result
                && !g.inside_match_result && !node.is_expr && node.expr !is ast.IfExpr
            mut needs_tmp_return_autofree := false
            if can_emit_standalone_expr_stmt && g.is_autofree && !g.is_builtin_mod
                && node.expr is ast.CallExpr && g.should_autofree_discarded_call_result(node.typ) {
                call_expr := node.expr as ast.CallExpr
                needs_tmp_return_autofree = call_expr.or_block.kind == .absent
            }
            scope_gc_pins := if can_emit_standalone_expr_stmt && !needs_tmp_return_autofree
                && node.expr is ast.CallExpr {
                g.scope_gc_pin_pregen(node.pos.pos)
            } else {
                []ScopeGcPin{}
            }
            mut discarded_ret_tmp_name := ''
            if needs_tmp_return_autofree {
                discarded_ret_tmp_name = g.new_tmp_var()
                g.write('${g.styp(node.typ)} ${discarded_ret_tmp_name} = ')
            }
            old_is_void_expr_stmt := g.is_void_expr_stmt
            g.is_void_expr_stmt = !node.is_expr && !needs_tmp_return_autofree
            if node.expr.is_auto_deref_var() {
                g.write('*')
            }
            if node.typ != ast.void_type && g.expected_cast_type != 0
                && node.expr !in [ast.IfExpr, ast.MatchExpr] {
                g.expr_with_cast(node.expr, node.typ, g.expected_cast_type)
            } else {
                g.expr(node.expr)
            }
            g.is_void_expr_stmt = old_is_void_expr_stmt
            if needs_tmp_return_autofree {
                g.writeln(';')
                // Discarded non-void call results should still be released under -autofree.
                g.autofree_variable(ast.Var{
                    name: discarded_ret_tmp_name
                    expr: node.expr
                    typ:  node.typ
                    pos:  node.pos
                })
                for g.autofree_scope_stmts.len > 0 {
                    g.write(g.autofree_scope_stmts.pop())
                }
            } else if g.inside_ternary == 0 && !g.inside_if_option && !g.inside_match_option
                && !g.inside_if_result && !g.inside_match_result && !node.is_expr
                && node.expr !is ast.IfExpr {
                if node.expr is ast.MatchExpr {
                    g.writeln('')
                } else {
                    g.writeln(';')
                }
            }
            if can_emit_standalone_expr_stmt && !needs_tmp_return_autofree
                && node.expr is ast.CallExpr {
                g.write_scope_gc_pins(node.pos)
            }
            g.scope_gc_pin_postgen(scope_gc_pins)
        }
        ast.ForCStmt {
            prev_branch_parent_pos := g.branch_parent_pos
            g.branch_parent_pos = node.pos.pos
            save_inner_loop := g.inner_loop
            g.inner_loop = unsafe { &node }
            if node.label != '' {
                unsafe {
                    g.labeled_loops[node.label] = &node
                }
            }
            g.write_v_source_line_info_stmt(node)
            g.for_c_stmt(node)
            g.branch_parent_pos = prev_branch_parent_pos
            g.labeled_loops.delete(node.label)
            g.inner_loop = save_inner_loop
        }
        ast.ForInStmt {
            prev_branch_parent_pos := g.branch_parent_pos
            g.branch_parent_pos = node.pos.pos
            save_inner_loop := g.inner_loop
            g.inner_loop = unsafe { &node }
            if node.label != '' {
                unsafe {
                    g.labeled_loops[node.label] = &node
                }
            }
            g.write_v_source_line_info_stmt(node)
            g.for_in_stmt(node)
            g.branch_parent_pos = prev_branch_parent_pos
            g.labeled_loops.delete(node.label)
            g.inner_loop = save_inner_loop
        }
        ast.ForStmt {
            prev_branch_parent_pos := g.branch_parent_pos
            g.branch_parent_pos = node.pos.pos
            save_inner_loop := g.inner_loop
            g.inner_loop = unsafe { &node }
            if node.label != '' {
                unsafe {
                    g.labeled_loops[node.label] = &node
                }
            }
            g.write_v_source_line_info_stmt(node)
            g.for_stmt(node)
            g.branch_parent_pos = prev_branch_parent_pos
            g.labeled_loops.delete(node.label)
            g.inner_loop = save_inner_loop
        }
        ast.Return {
            g.return_stmt(node)
        }
        ast.DeferStmt {
            mut defer_stmt := node
            defer_stmt.ifdef = g.defer_ifdef
            if defer_stmt.mode == .function {
                g.writeln('${g.defer_flag_var(defer_stmt)} = true;')
            }
            g.defer_stmts << defer_stmt
        }
        ast.EnumDecl {
            g.enum_decl(node)
        }
        ast.GlobalDecl {
            g.global_decl(node)
        }
        ast.Import {}
        ast.InterfaceDecl {
            // definitions are sorted and added in write_types
            ts := g.table.sym(node.typ)
            if !(ts.info as ast.Interface).is_generic
                && (!g.pref.skip_unused || ts.idx in g.table.used_features.used_syms) {
                for method in node.methods {
                    if method.return_type.has_flag(.option) {
                        // Register an option if it's not registered yet
                        g.register_option(method.return_type)
                    } else if method.return_type.has_flag(.result) {
                        if g.pref.skip_unused
                            && g.table.sym(method.return_type).idx !in g.table.used_features.used_syms {
                            continue
                        }
                        // Register a result if it's not registered yet
                        g.register_result(method.return_type)
                    }
                }
            }
        }
        ast.StructDecl {
            name := if node.language == .c {
                util.no_dots(node.name)
            } else if node.name in ['array', 'string'] {
                node.name
            } else if node.scoped_name != '' {
                c_name(node.scoped_name)
            } else {
                c_name(node.name)
            }
            // TODO: For some reason, build fails with autofree with this line
            // as it's only informative, comment it for now
            // g.gen_attrs(node.attrs)
            // g.writeln('typedef struct {')
            // for field in it.fields {
            // field_type_sym := g.table.sym(field.typ)
            // g.writeln('\t${field_type_sym.name} ${field.name};')
            // }
            // g.writeln('} ${name};')
            if node.language == .c {
                return
            }
            if g.pref.skip_unused && node.idx !in g.table.used_features.used_syms {
                return
            }
            if node.is_union {
                g.typedefs.writeln('typedef union ${name} ${name};')
            } else {
                g.typedefs.writeln('typedef struct ${name} ${name};')
            }
        }
        ast.GotoLabel {
            g.writeln('${c_name(node.name)}: {}')
        }
        ast.GotoStmt {
            g.write_v_source_line_info_stmt(node)
            g.writeln('goto ${c_name(node.name)};')
        }
        ast.AsmStmt {
            if g.is_cc_msvc && !g.pref.output_cross_c {
                g.error('msvc does not support inline assembly', node.pos)
            }
            if g.should_skip_linux_bare_startup_stub(node) {
                return
            }
            g.write_v_source_line_info_stmt(node)
            g.asm_stmt(node)
        }
        ast.HashStmt {
            g.hash_stmt(node)
        }
        ast.TypeDecl {
            if !g.pref.skip_unused {
                g.writeln('// TypeDecl')
            }
        }
        ast.SemicolonStmt {
            g.writeln(';')
        }
        ast.SqlStmt {
            g.sql_stmt(node)
        }
        ast.Module {
            g.is_builtin_mod = util.module_is_builtin(node.name)
            g.is_builtin_overflow_mod = node.name == 'builtin.overflow'
            g.cur_mod = node
        }
        ast.EmptyStmt {}
        ast.DebuggerStmt {
            g.debugger_stmt(node)
        }
        ast.NodeError {}
    }

    if !g.skip_stmt_pos { // && g.stmt_path_pos.len > 0 {
        g.stmt_path_pos.delete_last()
    }
    // TODO: If we have temporary string exprs to free after this statement, do it. e.g.:
    // `foo('a' + 'b')` => `tmp := 'a' + 'b'; foo(tmp); string_free(&tmp);`
}

struct SumtypeCastingFn {
    fn_name string
    got     ast.Type
    exp     ast.Type
}

fn (mut g Gen) get_sumtype_casting_fn(got_ ast.Type, exp_ ast.Type) string {
    mut got, exp := got_, exp_.idx_type()
    i := '${u32(got_)}:${u32(exp_)}'
    exp_sym := g.table.sym(exp)
    mut got_sym := g.table.sym(got)
    same_parent_sumtype_alias := got_sym.kind == .alias && g.table.unaliased_type(got_) == exp
    cname := if exp == ast.int_type_idx {
        ast.int_type_name
    } else {
        g.get_sumtype_variant_name(exp_, exp_sym)
    }
    // fn_name := '${got_sym.cname}_to_sumtype_${exp_sym.cname}'
    sumtype_variant_name := g.get_sumtype_casting_variant_name(got_, got_sym)
    fn_name := '${sumtype_variant_name}_to_sumtype_${cname}'
    if g.pref.experimental && fn_name.contains('v__ast__Struct_to_sumtype_v__ast__TypeInfo') {
        print_backtrace()
        eprintln('======\n\n')
        // exit(0)
    }
    if got == exp || g.sumtype_definitions[i] {
        return fn_name
    }
    // Also check by fn_name to avoid duplicates when the same conversion
    // is requested with different type flags (e.g., mutability):
    for existing in g.sumtype_casting_fns {
        if existing.fn_name == fn_name {
            g.sumtype_definitions[i] = true
            return fn_name
        }
    }
    if !same_parent_sumtype_alias {
        for got_sym.parent_idx != 0 && got_sym.idx !in (exp_sym.info as ast.SumType).variants {
            got_sym = g.table.sym(ast.idx_to_type(got_sym.parent_idx))
        }
    }
    g.sumtype_definitions[i] = true
    g.sumtype_casting_fns << SumtypeCastingFn{
        fn_name: fn_name
        got:     if same_parent_sumtype_alias {
            got_
        } else {
            ast.idx_to_type(got_sym.idx).derive(got_)
        }
        exp:     if exp_.has_flag(.option) {
            new_exp := exp.set_flag(.option)
            new_exp
        } else {
            exp
        }
    }
    return fn_name
}

fn (mut g Gen) write_sumtype_casting_fn(fun SumtypeCastingFn) {
    got, exp := fun.got, fun.exp
    got_sym, exp_sym := g.table.sym(got), g.table.sym(exp)
    mut got_cname, exp_cname := g.get_sumtype_variant_type_name(got, got_sym), exp_sym.cname
    mut type_idx := g.type_sidx(got)
    mut sb := strings.new_builder(128)
    mut variant_name := g.get_sumtype_variant_name(got, got_sym)
    if got_sym.kind == .alias && got_sym.info is ast.Alias
        && g.table.unaliased_type(got).idx() == exp.idx() {
        g.definitions.writeln('${exp_cname} ${fun.fn_name}(${got_cname}* x, bool is_mut);')
        sb.writeln('${exp_cname} ${fun.fn_name}(${got_cname}* x, bool is_mut) {')
        sb.writeln('\treturn *(${exp_cname}*)x;')
        sb.writeln('}\n')
        g.auto_fn_definitions << sb.str()
        return
    }
    if got_sym.info is ast.FnType {
        got_name := 'fn ${g.table.fn_type_source_signature(got_sym.info.func)}'
        got_cname = 'anon_fn_${g.table.fn_type_signature(got_sym.info.func)}'
        type_idx = g.type_sidx(ast.idx_to_type(g.table.type_idxs[got_name]))
        for variant in g.sumtype_runtime_variants(exp) {
            variant_sym := g.table.sym(variant)
            if variant_sym.info is ast.FnType {
                if g.table.fn_type_source_signature(variant_sym.info.func) == g.table.fn_type_source_signature(got_sym.info.func) {
                    variant_name = g.get_sumtype_variant_name(variant, variant_sym)
                    got_cname = g.get_sumtype_variant_type_name(variant, variant_sym)
                    type_idx = g.type_sidx(variant)
                    break
                }
            }
        }
        sb.writeln('static inline ${exp_cname} ${fun.fn_name}(${got_cname} x) {')
        sb.writeln('\t${got_cname} ptr = x;')
    } else {
        got_cname = g.styp(got)
        // g.definitions.writeln('${g.static_modifier} inline ${exp_cname} ${fun.fn_name}(${got_cname}* x);')
        // sb.writeln('${g.static_modifier} inline ${exp_cname} ${fun.fn_name}(${got_cname}* x) {')
        g.definitions.writeln('${exp_cname} ${fun.fn_name}(${got_cname}* x, bool is_mut);')
        sb.writeln('${exp_cname} ${fun.fn_name}(${got_cname}* x, bool is_mut) {')
        sb.writeln('\t${got_cname}* ptr = x;')
        sb.writeln('\tif (!is_mut) { ptr = builtin__memdup(x, sizeof(${got_cname})); }')
    }
    for embed_hierarchy in g.table.get_embeds(got_sym) {
        // last embed in the hierarchy
        mut embed_cname := ''
        mut embed_name := ''
        mut accessor := '&x->'
        for j, embed in embed_hierarchy {
            embed_sym := g.table.sym(embed)
            embed_cname = embed_sym.cname
            embed_name = embed_sym.embed_name()
            if j > 0 {
                accessor += '.'
            }
            accessor += embed_name
        }
        // if the variable is not used, the C compiler will optimize it away
        sb.writeln('\t${embed_cname}* ${embed_name}_ptr = builtin__memdup(${accessor}, sizeof(${embed_cname}));')
    }
    sb.write_string('\treturn (${exp_cname}){ ._${variant_name} = ptr, ._typ = ${type_idx}')
    for field in (exp_sym.info as ast.SumType).fields {
        mut ptr := 'ptr'
        mut type_cname := got_cname
        _, embed_types := g.table.find_field_from_embeds(got_sym, field.name) or {
            ast.StructField{}, []ast.Type{}
        }
        if embed_types.len > 0 {
            embed_sym := g.table.sym(embed_types.last())
            ptr = '${embed_sym.embed_name()}_ptr'
            type_cname = embed_sym.cname
        }
        field_styp := g.styp(field.typ)
        if got_sym.kind in [.sum_type, .interface] {
            // the field is already a wrapped pointer; we shouldn't wrap it once again
            sb.write_string(', .${c_name(field.name)} = ptr->${field.name}')
        } else {
            sb.write_string(', .${c_name(field.name)} = (${field_styp}*)((char*)${ptr} + __offsetof_ptr(${ptr}, ${type_cname}, ${c_name(field.name)}))')
        }
    }
    sb.writeln('};\n}')
    g.auto_fn_definitions << sb.str()
}

@[inline]
fn (g &Gen) can_reuse_sumtype_variant_storage(exp ast.Type, got_is_ptr bool) bool {
    // `&SumType(value)` must copy value variants unless the cast is borrowing a mutable argument.
    // When expected_arg_mut is set, the caller wraps with ADDR() and passes back a pointer,
    // so the variant storage can be reused (no copy needed).
    return g.expected_arg_mut || (exp.is_ptr() && (got_is_ptr || g.expected_arg_mut))
}

fn (g &Gen) ident_unwraps_option_or_result(expr ast.Ident) bool {
    if expr.obj is ast.Var && assign_expr_unwraps_option_or_result(expr.obj.expr) {
        return true
    }
    if expr.scope != unsafe { nil } {
        if v := expr.scope.find_var(expr.name) {
            return assign_expr_unwraps_option_or_result(v.expr)
        }
    }
    return false
}

fn (g &Gen) expr_root_ident_unwraps_option_or_result(expr ast.Expr) bool {
    return match expr {
        ast.Ident {
            g.ident_unwraps_option_or_result(expr)
        }
        ast.SelectorExpr {
            g.expr_root_ident_unwraps_option_or_result(expr.expr)
        }
        ast.IndexExpr {
            g.expr_root_ident_unwraps_option_or_result(expr.left)
        }
        ast.ParExpr {
            g.expr_root_ident_unwraps_option_or_result(expr.expr)
        }
        ast.UnsafeExpr {
            g.expr_root_ident_unwraps_option_or_result(expr.expr)
        }
        else {
            false
        }
    }
}

fn (mut g Gen) interface_expr_needs_heap(expr ast.Expr) bool {
    match expr {
        ast.Ident, ast.SelectorExpr, ast.IndexExpr {
            return !g.expr_has_stable_interface_cast_address(expr)
        }
        ast.ParExpr {
            return g.interface_expr_needs_heap(expr.expr)
        }
        ast.UnsafeExpr {
            return g.interface_expr_needs_heap(expr.expr)
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) expr_has_stable_interface_cast_address(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            if expr.kind == .global {
                return true
            }
            return g.resolved_ident_is_auto_heap(expr) && !g.ident_unwraps_option_or_result(expr)
        }
        ast.SelectorExpr {
            if expr.expr_type.is_ptr() {
                return true
            }
            return g.expr_has_stable_interface_cast_address(expr.expr)
        }
        ast.IndexExpr {
            if expr.index is ast.RangeExpr {
                return false
            }
            if expr.left_type.is_ptr() {
                return true
            }
            return g.expr_has_stable_interface_cast_address(expr.left)
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) expr_needs_heap_promotion_for_interface_cast(expr ast.Expr) bool {
    match expr {
        ast.Ident, ast.SelectorExpr, ast.IndexExpr {
            return !g.expr_has_stable_interface_cast_address(expr)
        }
        else {
            return false
        }
    }
}

fn (g &Gen) interface_cast_requires_field_aliasing(expected_type ast.Type, expr ast.Expr) bool {
    if !expr.is_lvalue() {
        return false
    }
    interface_type := if expected_type.is_ptr() {
        expected_type.deref()
    } else {
        expected_type
    }
    interface_sym := g.table.final_sym(interface_type)
    if interface_sym.kind != .interface {
        return false
    }
    return match interface_sym.info {
        ast.Interface { interface_sym.info.fields.any(it.is_mut) }
        else { false }
    }
}

fn (mut g Gen) fn_ptr_cast_typ(func ast.FnType) string {
    ptr_name := '__v_fn_ptr'
    return g.fn_ptr_decl_str(func, ptr_name).replace_once(ptr_name, '')
}

fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Type, got ast.Type, actual_got ast.Type, exp_styp string,
    got_is_ptr bool, got_is_fn bool, got_styp string) {
    mut rparen_n := 1
    mut mutable_is_mut_arg_pos := 0
    mut force_auto_heap_value_deref := false

    is_not_ptr_and_fn := !got_is_ptr && !got_is_fn
    is_sumtype_cast := !got_is_fn && fname.contains('_to_sumtype_')
    is_interface_cast := !got_is_fn && fname.contains('_to_Interface_')
    interface_cast_source_expr := if is_interface_cast && expr is ast.CastExpr {
        expr.expr
    } else {
        expr
    }
    needs_got_cast := is_sumtype_cast && actual_got != 0
        && g.table.can_implicit_array_cast(actual_got, got)
    expr_is_lvalue := if needs_got_cast {
        false
    } else if is_interface_cast {
        interface_cast_source_expr.is_lvalue()
    } else {
        expr.is_lvalue()
    }
    is_comptime_variant := is_not_ptr_and_fn && expr is ast.Ident
        && g.comptime.is_comptime_variant_var(expr)
    mut is_stack_rooted_interface_expr := false
    if exp.is_ptr() {
        if (expr is ast.UnsafeExpr && expr.expr is ast.Nil) || got == ast.nil_type {
            g.write('(void*)0')
            return
        } else {
            g.write('HEAP(${exp_styp}, ${fname}(')
            rparen_n++
        }
    } else {
        g.write('${fname}(')
    }
    mutable_is_mut_arg_pos = rparen_n
    if is_not_ptr_and_fn {
        is_cast_fixed_array_init := expr is ast.CastExpr
            && (expr.expr is ast.ArrayInit && expr.expr.is_fixed)

        is_primitive_to_interface := is_interface_cast && expr is ast.Ident
            && g.table.sym(got).kind in [.i8, .i16, .i32, .int, .i64, .isize, .u8, .u16, .u32, .u64, .usize, .f32, .f64, .bool, .rune, .string]
        preserve_interface_field_aliasing := is_interface_cast
            && g.interface_cast_requires_field_aliasing(exp, interface_cast_source_expr)

        // Interface casts must not store pointers into stack-rooted lvalues such as
        // local variables or fields on by-value fn args (`p.email`).
        is_stack_rooted_interface_expr = is_interface_cast && !preserve_interface_field_aliasing
            && g.interface_expr_needs_heap(interface_cast_source_expr)
        // Interface casts must not store pointers into expressions without a
        // stable address, including stack-rooted lvalues and slice results.
        needs_interface_cast_promotion := is_interface_cast && !preserve_interface_field_aliasing
            && g.expr_needs_heap_promotion_for_interface_cast(interface_cast_source_expr)
        // Value-to-interface conversions should preserve value semantics by storing a detached copy.
        // The only exception is an explicit mutable borrow, which must keep aliasing the original.
        // Interfaces with mutable fields also need to alias the original lvalue so field reads/writes
        // stay connected to the concrete value instead of a detached clone.
        needs_interface_value_copy := is_interface_cast && !preserve_interface_field_aliasing
            && !g.expected_arg_mut && !got_is_ptr && expr_is_lvalue
        force_auto_heap_value_deref = needs_interface_value_copy && expr is ast.Ident
            && g.scope_ident_is_auto_heap(expr)

        if !is_cast_fixed_array_init && (is_comptime_variant || !expr_is_lvalue
            || (expr is ast.Ident && (expr.obj.is_simple_define_const()
            || (expr.obj is ast.Var && expr.obj.is_index_var)))
            || is_primitive_to_interface || needs_interface_cast_promotion
            || needs_interface_value_copy) {
            // Note: the `_to_sumtype_` family of functions do call memdup internally, making
            // another duplicate with the HEAP macro is redundant, so use ADDR instead:
            if expr.is_as_cast() {
                if !got_is_ptr && expr is ast.SelectorExpr {
                    // (var as Type).field_non_ptr
                    g.write('&')
                }
                old_inside_smartcast := g.inside_smartcast
                g.inside_smartcast = true
                defer(fn) {
                    g.inside_smartcast = old_inside_smartcast
                }
            } else {
                promotion_macro_name := if is_sumtype_cast { 'ADDR' } else { 'HEAP' }
                g.write('${promotion_macro_name}(${got_styp}, (')
                rparen_n += 2
            }
        } else {
            g.write('&')
        }
    }
    if got_styp == 'none' && !g.cur_fn.return_type.has_flag(.option) {
        g.write('(none){E_STRUCT}')
    } else if is_comptime_variant {
        ctyp := g.type_resolver.get_ct_type_or_default('${g.comptime.comptime_for_variant_var}.typ',
            ast.void_type)
        g.write(g.type_default(ctyp))
    } else {
        old_inside_sumtype_cast := g.inside_sumtype_cast
        g.inside_sumtype_cast = true
        old_left_is_opt := g.left_is_opt
        g.left_is_opt = !exp.has_flag(.option)
        old_inside_assign_fn_var := g.inside_assign_fn_var
        if force_auto_heap_value_deref {
            g.inside_assign_fn_var = false
        } else if is_stack_rooted_interface_expr && g.expr_root_ident_unwraps_option_or_result(expr) {
            g.inside_assign_fn_var = true
        }
        if needs_got_cast {
            g.expr_with_cast(expr, actual_got, got)
        } else {
            g.expr(expr)
        }
        g.inside_assign_fn_var = old_inside_assign_fn_var
        g.left_is_opt = old_left_is_opt
        g.inside_sumtype_cast = old_inside_sumtype_cast
    }
    if is_sumtype_cast {
        // the `_to_sumtype_` family of functions last `is_mut` param
        g.write(')'.repeat(rparen_n - mutable_is_mut_arg_pos))
        g.write(', ${g.can_reuse_sumtype_variant_storage(exp, got_is_ptr)}')
        g.write(')'.repeat(mutable_is_mut_arg_pos))
    } else {
        g.write(')'.repeat(rparen_n))
    }
}

fn (g &Gen) single_pointer_sumtype_nil_variant(expected_type ast.Type, expr ast.Expr, got_type ast.Type) ast.Type {
    if !expr.is_nil() && got_type != ast.nil_type {
        return 0
    }
    expected_sym := g.table.final_sym(expected_type)
    if expected_sym.kind != .sum_type {
        return 0
    }
    mut variant := ast.Type(0)
    for sumtype_variant in g.sumtype_runtime_variants(expected_type) {
        if g.table.unaliased_type(sumtype_variant).is_any_kind_of_pointer() {
            if variant != 0 {
                return 0
            }
            variant = sumtype_variant
        }
    }
    return variant
}

@[inline]
fn (g &Gen) is_exact_sumtype_variant_match(variant ast.Type, got ast.Type) bool {
    if variant.idx() != got.idx() || variant.has_flag(.option) != got.has_flag(.option)
        || variant.nr_muls() != got.nr_muls() {
        return false
    }
    variant_sym := g.table.sym(variant)
    got_sym := g.table.sym(got)
    if variant_sym.info is ast.FnType && got_sym.info is ast.FnType {
        return g.table.fn_type_source_signature(variant_sym.info.func) == g.table.fn_type_source_signature(got_sym.info.func)
    }
    return true
}

fn (g &Gen) find_matching_sumtype_variant(expected_type ast.Type, got_type ast.Type) ast.Type {
    expected_sym := g.table.final_sym(expected_type)
    if expected_sym.kind != .sum_type {
        return got_type
    }
    variants := g.sumtype_runtime_variants(expected_type)
    for variant in variants {
        if g.is_exact_sumtype_variant_match(variant, got_type) {
            return variant
        }
    }
    for variant in variants {
        if g.table.can_implicit_array_cast(got_type, variant) {
            return variant
        }
    }
    if got_type.is_any_kind_of_pointer() {
        deref_got_type := got_type.deref()
        for variant in variants {
            if g.is_exact_sumtype_variant_match(variant, deref_got_type) {
                return variant
            }
        }
    }
    return got_type
}

fn (mut g Gen) sumtype_ptr_cast_payload_field(sumtype_typ ast.Type, target_ptr_typ ast.Type) string {
    matched_variant := g.find_matching_sumtype_variant(sumtype_typ, target_ptr_typ.deref())
    if g.table.sumtype_has_variant(sumtype_typ, matched_variant, false) {
        matched_variant_sym := g.table.sym(matched_variant)
        return g.get_sumtype_variant_name(matched_variant, matched_variant_sym)
    }
    return ''
}

fn (mut g Gen) write_payload_pointer_from_ptr_wrapper(expr ast.Expr, wrapper_typ ast.Type,
    target_ptr_typ ast.Type) {
    wrapper_sym := g.table.final_sym(wrapper_typ)
    match wrapper_sym.kind {
        .interface {
            g.write('((')
            g.expr(expr)
            g.write(')->_object')
            g.write(')')
        }
        .sum_type {
            field_name := g.sumtype_ptr_cast_payload_field(wrapper_typ, target_ptr_typ)
            if field_name == '' {
                g.write('((*((void**)(')
                g.expr(expr)
                g.write('))))')
            } else {
                g.write('((')
                g.expr(expr)
                g.write(')->_${field_name})')
            }
        }
        else {}
    }
}

fn (mut g Gen) ptr_wrapper_expr_is_raw_alias(expr ast.Expr, wrapper_typ ast.Type) bool {
    expected_wrapper_typ := g.table.unaliased_type(g.unwrap_generic(wrapper_typ))
    return match expr {
        ast.UnsafeExpr {
            g.ptr_wrapper_expr_is_raw_alias(expr.expr, expected_wrapper_typ)
        }
        ast.ParExpr {
            g.ptr_wrapper_expr_is_raw_alias(expr.expr, expected_wrapper_typ)
        }
        ast.CastExpr {
            target_typ := g.unwrap_generic(expr.typ)
            target_wrapper_typ := if target_typ.is_ptr() {
                g.table.unaliased_type(g.unwrap_generic(target_typ.deref()))
            } else {
                ast.void_type
            }
            source_typ := g.unwrap_generic(expr.expr_type)
            if target_wrapper_typ != expected_wrapper_typ
                || (!source_typ.is_any_kind_of_pointer() && source_typ != ast.voidptr_type) {
                false
            } else if source_typ.is_ptr() && source_typ.nr_muls() == 1 {
                source_wrapper_typ := g.table.unaliased_type(g.unwrap_generic(source_typ.deref()))
                source_wrapper_typ != expected_wrapper_typ
            } else {
                true
            }
        }
        ast.Ident {
            if expr.obj is ast.Var && expr.obj.expr !is ast.EmptyExpr
                && !(expr.obj.expr is ast.Ident && expr.obj.expr.name == expr.name) {
                g.ptr_wrapper_expr_is_raw_alias(expr.obj.expr, expected_wrapper_typ)
            } else if expr.scope != unsafe { nil } {
                if v := expr.scope.find_var(expr.name) {
                    if v.expr !is ast.EmptyExpr && !(v.expr is ast.Ident
                        && v.expr.name == expr.name) {
                        return g.ptr_wrapper_expr_is_raw_alias(v.expr, expected_wrapper_typ)
                    }
                }
                false
            } else {
                false
            }
        }
        else {
            false
        }
    }
}

// use instead of expr() when you need a var to use as reference
fn (mut g Gen) expr_with_var(expr ast.Expr, expected_type ast.Type, do_cast bool) string {
    stmt_str := g.go_before_last_stmt().trim_space()
    g.empty_line = true
    tmp_var := g.new_tmp_var()
    styp := g.styp(expected_type)

    g.writeln('${styp} ${tmp_var};')
    g.write('memcpy(&${tmp_var}, ')
    if do_cast {
        g.write('(${styp})')
    }
    // Temporarily clear inside_struct_init and assign_op so that cast expressions
    // for fixed array aliases generate proper compound literal casts
    old_inside_struct_init := g.inside_struct_init
    old_assign_op := g.assign_op
    g.inside_struct_init = false
    g.assign_op = .unknown
    g.expr(expr)
    g.inside_struct_init = old_inside_struct_init
    g.assign_op = old_assign_op
    g.writeln(', sizeof(${styp}));')
    g.write(stmt_str)
    return tmp_var
}

// expr_with_fixed_array generates code for fixed array initialization with expr which requires tmp var
fn (mut g Gen) expr_with_fixed_array(expr ast.Expr, got_type_raw ast.Type, expected_type ast.Type) string {
    stmt_str := g.go_before_last_stmt().trim_space()
    g.empty_line = true
    tmp_var := g.new_tmp_var()
    styp := g.styp(expected_type)
    if expr is ast.ArrayInit {
        g.writeln('${styp} ${tmp_var};')
        // [ foo(), foo() ]!
        val_typ := g.table.value_type(got_type_raw)
        val_styp := g.styp(val_typ)
        val_sym := g.table.final_sym(val_typ)
        prefix := if val_sym.kind !in [.array, .array_fixed] { '&' } else { '' }
        prepared_exprs := g.prepare_array_init_exprs(expr.exprs, expr.expr_types, val_typ)
        for i, item_expr in prepared_exprs {
            actual_item_expr := array_init_orig_expr(item_expr)
            g.write('memcpy(${prefix}${tmp_var}[${i}], ')
            needs_addr :=
                (actual_item_expr is ast.CallExpr && !actual_item_expr.return_type.is_ptr()
                && g.table.final_sym(actual_item_expr.return_type).kind !in [.array, .array_fixed])
                || (actual_item_expr is ast.InfixExpr && !actual_item_expr.promoted_type.is_ptr())
                || actual_item_expr is ast.StructInit
            if needs_addr {
                g.write('ADDR(${val_styp}, ')
            }
            g.expr(item_expr)
            if needs_addr {
                g.write(')')
            }
            g.writeln(', sizeof(${val_styp}));')
        }
    } else if expr is ast.CallExpr {
        // return var.call() where returns is option/result fixed array
        g.writeln('${styp} ${tmp_var} = {0};')
        g.write('memcpy(&${tmp_var}.data, ')
        g.expr(expr)
        g.writeln(', sizeof(${g.base_type(expected_type)}));')
    } else {
        g.expr(expr)
    }
    g.write(stmt_str)
    return tmp_var
}

fn (mut g Gen) gen_interface_to_interface_conversion(expr ast.Expr, expr_type ast.Type, to_type ast.Type) {
    mut expr_type_sym := g.table.sym(expr_type)
    to_sym := g.table.sym(to_type)
    g.write('I_${expr_type_sym.cname}_as_I_${to_sym.cname}(')
    if expr_type.is_ptr() {
        g.write('*')
    }
    g.expr(expr)
    g.write(')')

    mut info := expr_type_sym.info as ast.Interface
    right_info := to_sym.info as ast.Interface
    left_variants := g.runtime_interface_variants(info)
    right_variants := g.runtime_interface_variants(right_info)
    lock info.conversions {
        if to_type !in info.conversions {
            // For conversion into an empty interface, all of the left's variants
            // are valid (empty interfaces accept anything).
            if right_info.methods.len == 0 && right_info.fields.len == 0 {
                info.conversions[to_type] = left_variants.clone()
            } else {
                info.conversions[to_type] = g.interface_conversion_variants(left_variants,
                    right_variants)
            }
        }
    }
    expr_type_sym.info = info
}

fn (g &Gen) interface_conversion_variants(left_variants []ast.Type, right_variants []ast.Type) []ast.Type {
    mut variants := []ast.Type{cap: left_variants.len}
    for left_variant in left_variants {
        left_idx := left_variant.idx()
        for right_variant in right_variants {
            if right_variant.idx() == left_idx {
                variants << left_variant
                break
            }
        }
    }
    return variants
}

// expr_with_array_element_upcast materializes an array whose elements are boxed into
// the expected interface or sum type element type.
fn (mut g Gen) expr_with_array_element_upcast(expr ast.Expr, got_type ast.Type, expected_type ast.Type) {
    got_sym := g.table.final_sym(got_type)
    expected_sym := g.table.final_sym(expected_type)
    got_info := got_sym.info as ast.Array
    expected_info := expected_sym.info as ast.Array
    got_elem_type := got_info.elem_type
    expected_elem_type := expected_info.elem_type
    got_styp := g.styp(got_type)
    expected_styp := g.styp(expected_type)
    got_elem_styp := g.styp(got_elem_type)
    expected_elem_styp := g.styp(expected_elem_type)
    expected_elem_sym := g.table.final_sym(expected_elem_type)
    noscan := g.check_noscan(expected_elem_type)
    stmt_str := g.go_before_last_stmt().trim_space()
    g.empty_line = true
    source_tmp := g.new_tmp_var()
    result_tmp := g.new_tmp_var()
    index_tmp := g.new_tmp_var()
    item_tmp := g.new_tmp_var()
    converted_tmp := g.new_tmp_var()
    g.write('${got_styp} ${source_tmp}_orig = ')
    g.expr(expr)
    g.writeln(';')
    g.writeln('${expected_styp} ${result_tmp} = builtin____new_array${noscan}(0, ${source_tmp}_orig.len, sizeof(${expected_elem_styp}));')
    g.writeln('for (${ast.int_type_name} ${index_tmp} = 0; ${index_tmp} < ${source_tmp}_orig.len; ++${index_tmp}) {')
    g.indent++
    if expected_elem_sym.kind == .interface {
        expected_interface_info := expected_elem_sym.info as ast.Interface
        concrete_got_elem_type := g.concrete_interface_cast_type(got_elem_type)
        concrete_got_elem_styp := g.styp(concrete_got_elem_type)
        mut fname := 'I_${g.cc_type(concrete_got_elem_type, true)}_to_Interface_${expected_elem_sym.cname}'
        lock g.referenced_fns {
            g.referenced_fns[fname] = true
        }
        if expected_interface_info.is_generic {
            fname = g.generic_fn_name(expected_interface_info.concrete_types, fname)
        }
        g.writeln('${expected_elem_styp} ${converted_tmp} = ${fname}(&(((${concrete_got_elem_styp}*)${source_tmp}_orig.data)[${index_tmp}]));')
    } else {
        g.write_prepared_var(item_tmp, got_elem_type, got_elem_styp, source_tmp, index_tmp, true,
            false)
        g.write('${expected_elem_styp} ${converted_tmp} = ')
        g.expr_with_cast(ast.Ident{
            name: item_tmp
        }, got_elem_type, expected_elem_type)
        g.writeln(';')
    }
    g.writeln('builtin__array_push${noscan}((array*)&${result_tmp}, &${converted_tmp});')
    g.indent--
    g.writeln('}')
    g.write(stmt_str)
    g.write(result_tmp)
}

fn (mut g Gen) can_widen_small_int_infix_for_cast(expr ast.InfixExpr, got_type ast.Type, expected_type ast.Type) bool {
    if expr.op !in [.plus, .minus] {
        return false
    }
    got_base := g.table.unalias_num_type(g.unwrap_generic(got_type))
    expected_base := g.table.unalias_num_type(g.unwrap_generic(expected_type))
    if !expected_base.is_number() || got_base == expected_base
        || got_base !in ast.int_promoted_type_idxs {
        return false
    }
    left_default := if expr.left_type != 0 { expr.left_type } else { got_type }
    right_default := if expr.right_type != 0 { expr.right_type } else { got_type }
    mut left_type := g.resolved_expr_type(expr.left, left_default)
    mut right_type := g.resolved_expr_type(expr.right, right_default)
    if left_type == 0 {
        left_type = left_default
    }
    if right_type == 0 {
        right_type = right_default
    }
    left_base := g.table.unalias_num_type(g.unwrap_generic(left_type))
    right_base := g.table.unalias_num_type(g.unwrap_generic(right_type))
    return left_base == got_base && right_base == got_base
}

fn (mut g Gen) widen_small_int_infix_for_cast(expr ast.InfixExpr, got_type ast.Type, expected_type ast.Type) {
    left_default := if expr.left_type != 0 { expr.left_type } else { got_type }
    right_default := if expr.right_type != 0 { expr.right_type } else { got_type }
    mut left_type := g.resolved_expr_type(expr.left, left_default)
    mut right_type := g.resolved_expr_type(expr.right, right_default)
    if left_type == 0 {
        left_type = left_default
    }
    if right_type == 0 {
        right_type = right_default
    }
    // Keep small integer arithmetic widened when the result is immediately
    // converted to a larger numeric type, e.g. sort comparator callbacks.
    g.write('(')
    g.expr_with_cast(expr.left, left_type, expected_type)
    g.write(' ${expr.op.str()} ')
    g.expr_with_cast(expr.right, right_type, expected_type)
    g.write(')')
}

// use instead of expr() when you need to cast to a different type
fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_type ast.Type) {
    got_type := ast.mktyp(got_type_raw)
    exp_sym := g.table.final_sym(expected_type)
    got_sym := g.table.sym(got_type)
    expected_is_ptr := expected_type.is_ptr()
    got_is_ptr := got_type.is_ptr()
    unaliased_expected_type := g.table.unaliased_type(g.unwrap_generic(expected_type)).clear_flags()
    unaliased_got_type := g.table.unaliased_type(g.unwrap_generic(got_type)).clear_flags()
    if g.can_convert_array_to_interface_array(got_type, expected_type) {
        fn_name := g.register_array_interface_cast_fn(got_type, expected_type)
        g.write('${fn_name}(')
        g.expr(expr)
        g.write(')')
        return
    }
    if unaliased_expected_type == ast.string_type {
        match unaliased_got_type {
            ast.char_type {
                g.write('builtin__u8_ascii_str((u8)(')
                g.expr(expr)
                g.write('))')
                return
            }
            ast.rune_type {
                g.write('builtin__rune_str((rune)(')
                g.expr(expr)
                g.write('))')
                return
            }
            else {}
        }
    }
    // allow using the new Error struct as a string, to avoid a breaking change
    // TODO: temporary to allow people to migrate their code; remove soon
    if got_type == ast.error_type_idx && expected_type == ast.string_type_idx {
        g.write('(*(')
        g.expr(expr)
        g.write('.msg))')
        return
    }
    if got_sym.kind == .none && exp_sym.idx == ast.error_type_idx {
        g.expr(expr)
        return
    }
    if !got_is_ptr && !expected_is_ptr && !got_type_raw.has_flag(.shared_f)
        && !expected_type.has_flag(.shared_f)
        && g.table.can_implicit_array_cast(got_type, expected_type) {
        g.expr_with_array_element_upcast(expr, got_type, expected_type)
        return
    }
    if got_sym.info !is ast.Interface && exp_sym.info is ast.Interface
        && got_type.idx() != expected_type.idx() && !expected_type.has_flag(.result) {
        concrete_got_type := g.concrete_interface_cast_type(got_type)
        concrete_got_sym := g.table.final_sym(concrete_got_type)
        concrete_got_is_ptr := concrete_got_type.is_ptr()
        if expr is ast.StructInit && !got_type.is_ptr() {
            g.inside_cast_in_heap++
            got_styp := g.cc_type(concrete_got_type.ref(), true)
            // TODO: why does cc_type even add this in the first place?
            exp_styp := exp_sym.cname
            mut fname := 'I_${got_styp}_to_Interface_${exp_styp}'
            if exp_sym.info.is_generic {
                fname = g.generic_fn_name(exp_sym.info.concrete_types, fname)
            }
            g.call_cfn_for_casting_expr(fname, expr, expected_type, concrete_got_type,
                concrete_got_type, exp_styp, true, false, got_styp)
            g.inside_cast_in_heap--
        } else {
            got_styp := g.cc_type(concrete_got_type, true)
            got_is_fn := concrete_got_sym.info is ast.FnType
            got_is_shared := concrete_got_type.has_flag(.shared_f)
            exp_styp := if got_is_shared { '__shared__${exp_sym.cname}' } else { exp_sym.cname }
            // If it's shared, we need to use the other caster:
            mut fname := if got_is_shared {
                'I___shared__${got_styp}_to_shared_Interface_${exp_styp}'
            } else {
                'I_${got_styp}_to_Interface_${exp_styp}'
            }
            lock g.referenced_fns {
                g.referenced_fns[fname] = true
            }
            if exp_sym.info.is_generic {
                fname = g.generic_fn_name(exp_sym.info.concrete_types, fname)
            }
            // Do not allocate for `Interface(unsafe{nil})` casts
            {
                is_nil_cast := expr is ast.UnsafeExpr && expr.expr is ast.Nil
                if is_nil_cast {
                    if expected_type.is_ptr() {
                        g.write('((void*)0)')
                    } else {
                        // Non-pointer interface is a struct in C, use zero-init
                        g.write('(${g.styp(expected_type)}){0}')
                    }
                    return
                }
            }
            // Auto-heap variables are already pointers in C. Treat them as
            // pointer-backed only when interface semantics require aliasing the
            // original storage. Plain value-to-interface conversions still need
            // a detached copy, even when the value itself lives in auto-heap storage.
            mut effective_got_is_ptr := concrete_got_is_ptr
            mut suppress_auto_heap_deref := false
            if !concrete_got_is_ptr && expr is ast.Ident && g.resolved_ident_is_auto_heap(expr)
                && (g.expected_arg_mut
                || g.interface_cast_requires_field_aliasing(expected_type, expr)) {
                effective_got_is_ptr = true
                suppress_auto_heap_deref = true
            }
            if suppress_auto_heap_deref {
                old_inside_assign_fn_var := g.inside_assign_fn_var
                g.inside_assign_fn_var = true
                g.call_cfn_for_casting_expr(fname, expr, expected_type, concrete_got_type,
                    concrete_got_type, exp_styp, effective_got_is_ptr, got_is_fn, got_styp)
                g.inside_assign_fn_var = old_inside_assign_fn_var
            } else {
                g.call_cfn_for_casting_expr(fname, expr, expected_type, concrete_got_type,
                    concrete_got_type, exp_styp, effective_got_is_ptr, got_is_fn, got_styp)
            }
        }
        return
    }
    if got_sym.info is ast.Interface && exp_sym.info is ast.Interface && expected_is_ptr
        && !got_is_ptr && !got_type.has_flag(.shared_f) && !expected_type.has_flag(.shared_f) {
        if expr is ast.UnsafeExpr && expr.expr is ast.Nil {
            g.write('((void*)0)')
            return
        }
        target_interface_type := expected_type.deref()
        g.write('HEAP(${exp_sym.cname}, ')
        if got_type.idx() != target_interface_type.idx() {
            g.gen_interface_to_interface_conversion(expr, got_type, target_interface_type)
        } else {
            g.expr(expr)
        }
        g.write(')')
        return
    }
    if got_sym.info is ast.Interface && exp_sym.info is ast.Interface
        && got_type.idx() != expected_type.idx() && !got_type.has_flag(.shared_f)
        && !expected_type.has_flag(.shared_f) {
        g.gen_interface_to_interface_conversion(expr, got_type, expected_type)
        return
    }
    // cast to sum type
    exp_styp := g.styp(expected_type)
    mut got_styp := g.styp(got_type)
    mut got_is_fn := false
    if got_sym.info is ast.FnType {
        if got_sym.info.is_anon {
            got_styp = 'anon_fn_${g.table.fn_type_signature(got_sym.info.func)}'
        }
        got_is_fn = true
    }
    if expected_type != ast.void_type {
        unwrapped_expected_type := g.unwrap_generic(expected_type)
        unwrapped_exp_sym := g.table.sym(unwrapped_expected_type)
        mut unwrapped_got_type := g.unwrap_generic(got_type)
        mut unwrapped_got_sym := g.table.sym(unwrapped_got_type)
        mut sumtype_got_type := unwrapped_got_type
        mut sumtype_got_sym := unwrapped_got_sym
        mut sumtype_got_styp := got_styp
        mut sumtype_got_is_fn := got_is_fn
        mut sumtype_got_is_ptr := got_is_ptr
        nil_sumtype_variant := g.single_pointer_sumtype_nil_variant(unwrapped_expected_type, expr,
            got_type)
        if nil_sumtype_variant != 0 {
            sumtype_got_type = nil_sumtype_variant
            sumtype_got_sym = g.table.sym(sumtype_got_type)
            sumtype_got_styp = g.styp(sumtype_got_type)
            sumtype_got_is_fn = sumtype_got_sym.kind == .function
            sumtype_got_is_ptr = sumtype_got_type.is_ptr()
        }

        expected_deref_type := if expected_is_ptr {
            unwrapped_expected_type.deref()
        } else {
            unwrapped_expected_type
        }
        got_deref_type := if sumtype_got_is_ptr {
            sumtype_got_type.deref()
        } else {
            sumtype_got_type
        }
        if nil_sumtype_variant != 0
            || g.table.sumtype_has_variant(expected_deref_type, got_deref_type, false)
            || g.table.sumtype_has_variant_recursive(expected_deref_type, got_deref_type, false) {
            mut is_already_sum_type := false
            scope := g.file.scope.innermost(expr.pos().pos)
            if expr is ast.Ident {
                if v := scope.find_var(expr.name) {
                    if v.smartcasts.len > 0
                        && unwrapped_expected_type == g.unwrap_generic(v.orig_type) {
                        is_already_sum_type = true
                    }
                }
            } else if expr is ast.SelectorExpr {
                v := scope.find_struct_field(expr.expr.str(), expr.expr_type, expr.field_name)
                if v != unsafe { nil } {
                    if v.smartcasts.len > 0
                        && unwrapped_expected_type == g.unwrap_generic(v.orig_type) {
                        is_already_sum_type = true
                    }
                }
            }
            if is_already_sum_type {
                // Don't create a new sum type wrapper if there is already one
                g.prevent_sum_type_unwrapping_once = true
                g.expr(expr)
            } else {
                sumtype_got_sym_val := *sumtype_got_sym
                variant_typ := sumtype_got_sym_val.aggregate_variant_type(g.aggregate_type_idx)
                if variant_typ != 0 {
                    sumtype_got_type = variant_typ
                    sumtype_got_sym = g.table.sym(sumtype_got_type)
                    sumtype_got_styp = g.styp(sumtype_got_type)
                    sumtype_got_is_fn = sumtype_got_sym.kind == .function
                    sumtype_got_is_ptr = sumtype_got_type.is_ptr()
                }
                actual_sumtype_got_type := sumtype_got_type
                sumtype_got_type = g.find_matching_sumtype_variant(unwrapped_expected_type,
                    sumtype_got_type)
                sumtype_got_sym = g.table.sym(sumtype_got_type)
                sumtype_got_styp = g.styp(sumtype_got_type)
                sumtype_got_is_fn = sumtype_got_sym.kind == .function
                sumtype_got_is_ptr = sumtype_got_type.is_ptr()

                fname := g.get_sumtype_casting_fn(sumtype_got_type, unwrapped_expected_type)
                sumtype_cast_got_is_ptr := if sumtype_got_type.is_any_kind_of_pointer()
                    && g.is_exact_sumtype_variant_match(sumtype_got_type, actual_sumtype_got_type) {
                    false
                } else {
                    got_is_ptr
                }
                if expr is ast.ArrayInit && got_sym.kind == .array_fixed {
                    stmt_str := g.go_before_last_stmt().trim_space()
                    g.empty_line = true
                    tmp_var := g.new_tmp_var()
                    g.write('${got_styp} ${tmp_var} = ')
                    g.expr(expr)
                    g.writeln(';')
                    g.write2(stmt_str, ' ')
                    g.write('${fname}(&${tmp_var}, ${g.can_reuse_sumtype_variant_storage(unwrapped_expected_type,
                        sumtype_cast_got_is_ptr)})')
                    return
                } else {
                    g.call_cfn_for_casting_expr(fname, expr, expected_type, sumtype_got_type,
                        actual_sumtype_got_type, unwrapped_exp_sym.cname, sumtype_cast_got_is_ptr,
                        sumtype_got_is_fn, sumtype_got_styp)
                }
            }
            return
        }
    }
    // Generic dereferencing logic
    neither_void := ast.voidptr_type !in [got_type.idx_type(), expected_type.idx_type()]
        && ast.nil_type !in [got_type.idx_type(), expected_type.idx_type()]
    if expected_type.has_flag(.shared_f) && !got_type_raw.has_flag(.shared_f)
        && !expected_type.has_option_or_result() {
        shared_styp := exp_styp[0..exp_styp.len - 1] // `shared` implies ptr, so eat one `*`
        if exp_sym.kind == .array {
            g.writeln('(${shared_styp}*)__dup_shared_array(&(${shared_styp}){.mtx = {0}, .val =')
        } else if exp_sym.kind == .map {
            g.writeln('(${shared_styp}*)__dup_shared_map(&(${shared_styp}){.mtx = {0}, .val =')
        } else {
            g.writeln('(${shared_styp}*)__dup${shared_styp}(&(${shared_styp}){.mtx = {0}, .val =')
        }
        old_is_shared := g.is_shared
        g.is_shared = false
        if got_type_raw.is_ptr() {
            g.write('*'.repeat(got_type_raw.nr_muls()))
        }
        g.expr(expr)
        g.is_shared = old_is_shared
        g.writeln('}, sizeof(${shared_styp}))')
        return
    } else if got_type_raw.has_flag(.shared_f) && !expected_type.has_flag(.shared_f) {
        if expected_is_ptr {
            g.write('&')
        }
        g.expr(expr)
        if expr !is ast.IndexExpr {
            g.write('->val')
        }
        return
    }
    if got_is_ptr && !expected_is_ptr && neither_void && exp_sym.kind != .placeholder
        && expr !is ast.InfixExpr {
        got_deref_type := got_type.deref()
        deref_sym := g.table.sym(got_deref_type)
        deref_will_match := expected_type in [got_type, got_deref_type, deref_sym.parent_idx]
        got_is_opt_or_res := got_type.has_option_or_result()
        if deref_will_match || got_is_opt_or_res || expr.is_auto_deref_var() {
            g.write('*')
        }
    }
    if expr is ast.Ident && g.resolved_ident_is_auto_heap(expr) && expected_is_ptr && !got_is_ptr
        && neither_void {
        old_inside_assign_fn_var := g.inside_assign_fn_var
        g.inside_assign_fn_var = true
        g.expr(expr)
        g.inside_assign_fn_var = old_inside_assign_fn_var
        return
    }
    if (g.inside_struct_init && expected_type == ast.voidptr_type && expected_type != got_type_raw
        && expr !is ast.StructInit) || (g.inside_call && expected_type == ast.voidptr_type
        && expr is ast.ArrayInit && (expr as ast.ArrayInit).is_fixed) {
        g.write('(voidptr)')
    }
    if expr is ast.InfixExpr && g.can_widen_small_int_infix_for_cast(expr, got_type, expected_type) {
        g.widen_small_int_infix_for_cast(expr, got_type, expected_type)
        return
    }
    // no cast
    g.expr(expr)
}

fn write_octal_escape(mut b strings.Builder, c u8) {
    b << 92 // \
    b << 48 + (c >> 6) // oct digit 2
    b << 48 + (c >> 3) & 7 // oct digit 1
    b << 48 + c & 7 // oct digit 0
}

fn cescape_nonascii(original string) string {
    mut b := strings.new_builder(original.len)
    for c in original {
        if c < 32 || c > 126 {
            // Encode with a 3 digit octal escape code, which has the
            // advantage to be limited/non dependent on what character
            // will follow next, unlike hex escapes:
            write_octal_escape(mut b, c)
            continue
        }
        b << c
    }
    res := b.str()
    return res
}

// cestring returns a V string, properly escaped for embedding in a C string literal.
fn cestring(s string) string {
    return s.replace('\\', '\\\\').replace('"', "'")
}

// ctoslit returns a '_S("${s}")' call, where s is properly escaped.
fn ctoslit(s string) string {
    return '_S(' + cescaped_string_literal(cescape_nonascii(cestring(s))) + ')'
}

fn cescaped_string_literal(s string) string {
    if s.len <= max_c_string_literal_segment_len {
        return '"${s}"'
    }
    mut b := strings.new_builder(s.len + (s.len / max_c_string_literal_segment_len + 1) * 3)
    mut start := 0
    for start < s.len {
        end := cescaped_string_literal_segment_end(s, start, max_c_string_literal_segment_len)
        if start > 0 {
            b.write_u8(` `)
        }
        b.write_u8(`"`)
        b.write_string(s[start..end])
        b.write_u8(`"`)
        start = end
    }
    return b.str()
}

fn cescaped_string_literal_segment_end(s string, start int, max_len int) int {
    limit := if start + max_len < s.len { start + max_len } else { s.len }
    mut i := start
    mut last_safe := start
    for i < limit {
        if s[i] == `\\` {
            escape_end := cescaped_string_escape_end(s, i)
            if escape_end > limit {
                break
            }
            i = escape_end
            last_safe = i
            continue
        }
        i++
        last_safe = i
    }
    if last_safe > start {
        return last_safe
    }
    return limit
}

fn cescaped_string_escape_end(s string, start int) int {
    if start + 1 >= s.len {
        return s.len
    }
    next := s[start + 1]
    if next >= `0` && next <= `7` {
        mut end := start + 2
        for end < s.len && end < start + 4 && s[end] >= `0` && s[end] <= `7` {
            end++
        }
        return end
    }
    if next == `x` {
        mut end := start + 2
        for end < s.len && end < start + 4 && ((s[end] >= `0` && s[end] <= `9`)
            || (s[end] >= `a` && s[end] <= `f`) || (s[end] >= `A` && s[end] <= `F`)) {
            end++
        }
        return end
    }
    if next == `u` {
        return if start + 6 < s.len { start + 6 } else { s.len }
    }
    if next == `U` {
        return if start + 10 < s.len { start + 10 } else { s.len }
    }
    return start + 2
}

fn (mut g Gen) gen_attrs(attrs []ast.Attr) {
    if g.pref.skip_unused {
        return
    }
    if g.inside_c_extern {
        return
    }
    for attr in attrs {
        g.writeln('// Attr: [${attr.name}]')
    }
}

fn (g &Gen) should_skip_linux_bare_startup_stub(stmt ast.AsmStmt) bool {
    if !g.pref.is_bare || g.file.path == '' {
        return false
    }
    if !g.file.path.ends_with(os.join_path('vlib', 'builtin', 'linux_bare', 'linux_syscalls.v')) {
        return false
    }
    mut exports_start := false
    for template in stmt.templates {
        if !template.is_directive || template.name !in ['globl', 'global'] {
            continue
        }
        for arg in template.args {
            if arg is ast.AsmAlias && arg.name == '_start' {
                exports_start = true
                break
            }
        }
        if exports_start {
            break
        }
    }
    if !exports_start {
        return false
    }
    for _, f in g.table.fns {
        if f.attrs.any(it.name == 'export' && it.arg == '_start') {
            return true
        }
    }
    return false
}

fn (mut g Gen) asm_stmt(stmt ast.AsmStmt) {
    if stmt.templates.len == 0 && stmt.input.len == 0 && stmt.output.len == 0
        && stmt.global_labels.len == 0 && !stmt.is_goto && !stmt.is_volatile {
        return
    }
    g.write('__asm__')
    if stmt.is_volatile {
        g.write(' volatile')
    }
    if stmt.is_goto {
        g.write(' goto')
    }
    g.writeln(' (')
    g.indent++
    if stmt.templates.len == 0 {
        g.writeln('""')
    }
    for template_tmp in stmt.templates {
        mut template := template_tmp
        g.write('"')
        if template.is_directive {
            g.write('.')
        }
        g.write(template.name)
        if template.is_label {
            g.write(':')
        } else {
            g.write(' ')
        }
        // swap destination and operands for att syntax, not for arm64
        if template.args.len != 0 && !template.is_directive
            && stmt.arch !in [.arm64, .s390x, .ppc64le, .loongarch64, .rv64, .rv32] {
            template.args.prepend(template.args.last())
            template.args.delete(template.args.len - 1)
        }

        for i, arg in template.args {
            if stmt.arch == .amd64 && (template.name == 'call' || template.name[0] == `j`)
                && arg is ast.AsmRegister {
                g.write('*') // indirect branching
            }

            g.asm_arg(arg, stmt)
            if i + 1 < template.args.len {
                g.write(', ')
            }
        }

        if !template.is_label {
            g.write('\\n\\t')
        }
        g.writeln('"')
    }

    if stmt.output.len != 0 || stmt.input.len != 0 || stmt.clobbered.len != 0 || stmt.is_goto {
        g.write(': ')
    }
    g.gen_asm_ios(stmt.output)
    if stmt.input.len != 0 || stmt.clobbered.len != 0 || stmt.is_goto {
        g.write(': ')
    }
    g.gen_asm_ios(stmt.input)
    if stmt.clobbered.len != 0 || stmt.is_goto {
        g.write(': ')
    }
    for i, clob in stmt.clobbered {
        g.write2('"', clob.reg.name)
        g.write('"')
        if i + 1 < stmt.clobbered.len {
            g.writeln(',')
        } else {
            g.writeln('')
        }
    }
    if stmt.is_goto {
        g.write(': ')
    }
    for i, label in stmt.global_labels {
        g.write(label)
        if i + 1 < stmt.clobbered.len {
            g.writeln(',')
        } else {
            g.writeln('')
        }
    }
    g.indent--
    g.writeln(');')
}

fn (mut g Gen) asm_arg(arg ast.AsmArg, stmt ast.AsmStmt) {
    match arg {
        ast.AsmAlias {
            name := arg.name
            if name in stmt.local_labels || name in stmt.global_labels
                || name in g.file.global_labels || stmt.is_basic
                || (name !in stmt.input.map(it.alias) && name !in stmt.output.map(it.alias)) {
                asm_formatted_name := if name in stmt.global_labels { '%l[${name}]' } else { name }
                g.write(asm_formatted_name)
            } else {
                g.write('%[${name}]')
            }
        }
        ast.CharLiteral {
            g.write("'${arg.val}'")
        }
        ast.IntegerLiteral {
            if stmt.arch == .arm64 {
                g.write('#${arg.val}')
            } else if stmt.arch in [.s390x, .ppc64le, .loongarch64, .rv64, .rv32] {
                g.write('${arg.val}')
            } else {
                g.write('\$${arg.val}')
            }
        }
        ast.FloatLiteral {
            if g.pref.nofloat {
                g.write('\$${arg.val.int()}')
            } else {
                g.write('\$${arg.val}')
            }
        }
        ast.BoolLiteral {
            g.write('\$${arg.val.str()}')
        }
        ast.AsmRegister {
            if stmt.arch in [.rv64, .rv32] {
                g.write('${arg.name}')
            } else if stmt.arch == .loongarch64 {
                g.write('$${arg.name}')
            } else {
                if !stmt.is_basic {
                    g.write('%') // escape percent with percent in extended assembly
                }
                g.write('%${arg.name}')
            }
        }
        ast.AsmAddressing {
            if arg.segment != '' {
                g.write('%%${arg.segment}:')
            }
            base := arg.base
            index := arg.index
            displacement := arg.displacement
            scale := arg.scale
            match arg.mode {
                .base {
                    if stmt.arch == .arm64 {
                        g.write('[')
                    } else if stmt.arch == .loongarch64 {
                        g.write('')
                    } else {
                        g.write('(')
                    }
                    g.asm_arg(base, stmt)
                    if stmt.arch == .arm64 {
                        g.write(']')
                    } else if stmt.arch == .loongarch64 {
                        g.write('')
                    } else {
                        g.write(')')
                    }
                }
                .displacement {
                    g.asm_arg(displacement, stmt)
                }
                .base_plus_displacement {
                    g.asm_arg(displacement, stmt)
                    g.write('(')
                    g.asm_arg(base, stmt)
                    g.write(')')
                }
                .index_times_scale_plus_displacement {
                    if displacement is ast.AsmDisp {
                        g.asm_arg(displacement, stmt)
                        g.write('(, ')
                    } else if displacement is ast.AsmRegister {
                        g.write('(')
                        g.asm_arg(displacement, stmt)
                        g.write(',')
                    } else {
                        panic('unexpected ${displacement.type_name()}')
                    }
                    g.asm_arg(index, stmt)
                    g.write(',${scale})')
                }
                .base_plus_index_plus_displacement {
                    g.asm_arg(displacement, stmt)
                    g.write('(')
                    g.asm_arg(base, stmt)
                    g.write(',')
                    g.asm_arg(index, stmt)
                    g.write(',1)')
                }
                .base_plus_index_times_scale_plus_displacement {
                    g.asm_arg(displacement, stmt)
                    g.write('(')
                    g.asm_arg(base, stmt)
                    g.write(',')
                    g.asm_arg(index, stmt)
                    g.write(',${scale})')
                }
                .rip_plus_displacement {
                    g.asm_arg(displacement, stmt)
                    g.write('(')
                    g.asm_arg(base, stmt)
                    g.write(')')
                }
                .invalid {
                    g.error('invalid addressing mode', arg.pos)
                }
            }
        }
        ast.AsmDisp {
            g.write(arg.val)
        }
        string {
            g.write(arg)
        }
    }
}

fn (mut g Gen) gen_asm_ios(ios []ast.AsmIO) {
    for i, io in ios {
        if io.alias != '' {
            g.write('[${io.alias}] ')
        }
        g.write('"${io.constraint}" (')
        g.expr(io.expr)
        g.write(')')
        if i + 1 < ios.len {
            g.writeln(',')
        } else {
            g.writeln('')
        }
    }
}

fn cnewlines(s string) string {
    return s.replace('\n', r'\n')
}

fn (mut g Gen) write_fn_ptr_decl(func &ast.FnType, ptr_name string) {
    ret_styp := g.styp(func.func.return_type)
    g.write('${ret_styp} (*${ptr_name}) (')
    arg_len := func.func.params.len
    for i, arg in func.func.params {
        g.write(g.fn_param_type_decl(arg.typ, arg.name))
        if i < arg_len - 1 {
            g.write(', ')
        }
    }
    g.write(')')
}

fn (mut g Gen) fn_ptr_decl_str(func ast.FnType, ptr_name string) string {
    pos := g.out.len
    g.write_fn_ptr_decl(&func, ptr_name)
    return g.out.cut_to(pos)
}

fn (mut g Gen) register_ternary_name(name string) {
    level_key := g.inside_ternary.str()
    if level_key !in g.ternary_level_names {
        g.ternary_level_names[level_key] = []string{}
    }
    new_name := g.new_tmp_var()
    g.ternary_names[name] = new_name
    g.ternary_level_names[level_key] << name
}

fn (mut g Gen) get_ternary_name(name string) string {
    if g.inside_ternary == 0 {
        return name
    }
    if name !in g.ternary_names {
        return name
    }
    return g.ternary_names[name]
}

fn (mut g Gen) gen_clone_assignment(var_type ast.Type, val ast.Expr, typ ast.Type, add_eq bool) bool {
    if val !in [ast.Ident, ast.SelectorExpr] {
        return false
    }
    right_sym := g.table.sym(typ)
    if g.is_autofree {
        if add_eq {
            g.write('=')
        }
        if right_sym.kind == .array {
            // `arr1 = arr2` => `arr1 = arr2.clone()`
            shared_styp := g.styp(typ.set_nr_muls(0))
            if typ.share() == .shared_t {
                g.write('(${shared_styp}*)__dup_shared_array(&(${shared_styp}){.mtx = {0}, .val =')
            }
            is_sumtype := g.table.type_kind(var_type) == .sum_type
            if is_sumtype {
                variant_typ := g.styp(typ).replace('*', '')
                fn_name := g.get_sumtype_casting_fn(typ, var_type)
                g.write('${fn_name}(ADDR(${variant_typ}, builtin__array_clone_static_to_depth(')
                if typ.is_ptr() {
                    g.write('*')
                }
            } else {
                g.write(' builtin__array_clone_static_to_depth(')
            }
            g.expr(val)
            if typ.share() == .shared_t {
                g.write('->val')
            }
            elem_type := (right_sym.info as ast.Array).elem_type
            array_depth := g.get_array_depth(elem_type)
            g.write(', ${array_depth})')
            if typ.share() == .shared_t {
                g.write('}, sizeof(${shared_styp}))')
            }
            if is_sumtype {
                g.write('), false)')
            }
        } else if right_sym.kind == .string {
            // `str1 = str2` => `str1 = str2.clone()`
            if var_type.has_flag(.option) {
                g.write(' builtin__string_option_clone_static(')
            } else {
                g.write(' builtin__string_clone_static(')
            }
            g.expr(val)
            g.write(')')
        }
    }
    return true
}

fn (mut g Gen) map_fn_ptrs(key_sym ast.TypeSymbol) (string, string, string, string) {
    mut hash_fn := ''
    mut key_eq_fn := ''
    mut clone_fn := ''
    mut free_fn := '&builtin__map_free_nop'
    match key_sym.kind {
        .alias {
            alias_key_type := (key_sym.info as ast.Alias).parent_type
            return g.map_fn_ptrs(g.table.sym(alias_key_type))
        }
        .u8, .i8, .char {
            hash_fn = '&builtin__map_hash_int_1'
            key_eq_fn = '&builtin__map_eq_int_1'
            clone_fn = '&builtin__map_clone_int_1'
        }
        .i16, .u16 {
            hash_fn = '&builtin__map_hash_int_2'
            key_eq_fn = '&builtin__map_eq_int_2'
            clone_fn = '&builtin__map_clone_int_2'
        }
        .enum {
            hash_fn = 'builtin__map_enum_fn(1,sizeof(${key_sym.cname}))'
            key_eq_fn = 'builtin__map_enum_fn(2,sizeof(${key_sym.cname}))'
            clone_fn = 'builtin__map_enum_fn(3,sizeof(${key_sym.cname}))'
        }
        .int {
            $if new_int ? && x64 {
                hash_fn = '&builtin__map_hash_int_8'
                key_eq_fn = '&builtin__map_eq_int_8'
                clone_fn = '&builtin__map_clone_int_8'
            } $else {
                hash_fn = '&builtin__map_hash_int_4'
                key_eq_fn = '&builtin__map_eq_int_4'
                clone_fn = '&builtin__map_clone_int_4'
            }
        }
        .i32, .u32, .rune, .f32 {
            hash_fn = '&builtin__map_hash_int_4'
            key_eq_fn = '&builtin__map_eq_int_4'
            clone_fn = '&builtin__map_clone_int_4'
        }
        .voidptr {
            ts := if g.pref.m64 {
                unsafe { g.table.sym_by_idx(ast.u64_type_idx) }
            } else {
                unsafe { g.table.sym_by_idx(ast.u32_type_idx) }
            }
            return g.map_fn_ptrs(ts)
        }
        .u64, .i64, .f64 {
            hash_fn = '&builtin__map_hash_int_8'
            key_eq_fn = '&builtin__map_eq_int_8'
            clone_fn = '&builtin__map_clone_int_8'
        }
        .string {
            hash_fn = '&builtin__map_hash_string'
            key_eq_fn = '&builtin__map_eq_string'
            clone_fn = '&builtin__map_clone_string'
            free_fn = '&builtin__map_free_string'
        }
        .array_fixed {
            key_type := ast.new_type(key_sym.idx)
            return g.fixed_array_map_fn_ptrs(key_type)
        }
        else {
            verror('map key type `${key_sym.name}` not supported')
        }
    }

    return hash_fn, key_eq_fn, clone_fn, free_fn
}

@[inline]
fn (mut g Gen) map_key_fn_key(typ ast.Type) ast.Type {
    return g.table.fully_unaliased_type(g.unwrap_generic(typ).set_nr_muls(0))
}

@[inline]
fn (mut g Gen) fixed_array_map_fn_base(typ ast.Type) string {
    return '${g.styp(g.map_key_fn_key(typ))}_map_key'
}

fn (mut g Gen) fixed_array_map_fn_ptrs(key_type ast.Type) (string, string, string, string) {
    key := g.map_key_fn_key(key_type)
    g.needed_map_key_fns << key
    base := g.fixed_array_map_fn_base(key)
    return '&${base}_hash', '&${base}_eq', '&${base}_clone', '&${base}_free'
}

fn (mut g Gen) gen_map_key_fns() {
    for needed_typ in g.needed_map_key_fns {
        key := g.map_key_fn_key(needed_typ)
        if g.generated_map_key_fns[key] {
            continue
        }
        sym := g.table.sym(key)
        match sym.kind {
            .array_fixed {
                g.gen_fixed_array_map_key_fns(key)
            }
            else {
                verror('could not generate map key functions for type `${sym.name}`')
            }
        }
    }
}

fn (mut g Gen) gen_fixed_array_map_key_fns(key_type ast.Type) {
    key := g.map_key_fn_key(key_type)
    if g.generated_map_key_fns[key] {
        return
    }
    g.generated_map_key_fns[key] = true
    key_sym := g.table.sym(key)
    if key_sym.kind != .array_fixed {
        verror('map key type `${key_sym.name}` is not a fixed array')
    }
    key_info := key_sym.info as ast.ArrayFixed
    key_styp := g.styp(key)
    base := g.fixed_array_map_fn_base(key)
    hash_fn := '${base}_hash'
    eq_fn := '${base}_eq'
    clone_fn := '${base}_clone'
    free_fn := '${base}_free'
    array_eq_fn := g.gen_fixed_array_equality_fn(key)
    g.definitions.writeln('${g.static_non_parallel}u64 ${hash_fn}(voidptr pkey);')
    g.definitions.writeln('${g.static_non_parallel}bool ${eq_fn}(voidptr a, voidptr b);')
    g.definitions.writeln('${g.static_non_parallel}void ${clone_fn}(voidptr dest, voidptr pkey);')
    g.definitions.writeln('${g.static_non_parallel}void ${free_fn}(voidptr pkey);')

    mut hash_builder := strings.new_builder(256)
    hash_builder.writeln('${g.static_non_parallel}u64 ${hash_fn}(voidptr pkey) {')
    hash_builder.writeln('\t${key_styp}* key = (${key_styp}*)pkey;')
    hash_builder.writeln('\tu64 hash = 0;')
    hash_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${key_info.size}; ++i) {')
    hash_builder.writeln('\t\thash = wyhash64(hash, ${g.fixed_array_map_key_hash_expr(key_info.elem_type,
        '(*key)[i]')});')
    hash_builder.writeln('\t}')
    hash_builder.writeln('\treturn hash;')
    hash_builder.writeln('}')
    g.auto_fn_definitions << hash_builder.str()

    mut eq_builder := strings.new_builder(128)
    eq_builder.writeln('${g.static_non_parallel}bool ${eq_fn}(voidptr a, voidptr b) {')
    eq_builder.writeln('\treturn ${array_eq_fn}_arr_eq(*(${key_styp}*)a, *(${key_styp}*)b);')
    eq_builder.writeln('}')
    g.auto_fn_definitions << eq_builder.str()

    mut clone_builder := strings.new_builder(256)
    clone_builder.writeln('${g.static_non_parallel}void ${clone_fn}(voidptr dest, voidptr pkey) {')
    clone_builder.writeln('\t${key_styp}* dest_key = (${key_styp}*)dest;')
    clone_builder.writeln('\t${key_styp}* src_key = (${key_styp}*)pkey;')
    clone_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${key_info.size}; ++i) {')
    g.fixed_array_map_key_clone_stmt(mut clone_builder, key_info.elem_type, '(*dest_key)[i]',
        '(*src_key)[i]')
    clone_builder.writeln('\t}')
    clone_builder.writeln('}')
    g.auto_fn_definitions << clone_builder.str()

    mut free_builder := strings.new_builder(256)
    free_builder.writeln('${g.static_non_parallel}void ${free_fn}(voidptr pkey) {')
    free_builder.writeln('\t${key_styp}* key = (${key_styp}*)pkey;')
    free_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${key_info.size}; ++i) {')
    g.fixed_array_map_key_free_stmt(mut free_builder, key_info.elem_type, '(*key)[i]')
    free_builder.writeln('\t}')
    free_builder.writeln('}')
    g.auto_fn_definitions << free_builder.str()
}

fn (mut g Gen) fixed_array_map_key_hash_expr(elem_type ast.Type, expr string) string {
    elem := g.map_key_fn_key(elem_type)
    elem_sym := g.table.final_sym(elem)
    match elem_sym.kind {
        .string {
            return 'builtin__map_hash_string(&${expr})'
        }
        .array_fixed {
            g.gen_fixed_array_map_key_fns(elem)
            return '${g.fixed_array_map_fn_base(elem)}_hash(&${expr})'
        }
        else {
            return 'wyhash((const void*)(&${expr}), sizeof(${g.styp(elem)}), 0, _wyp)'
        }
    }
}

fn (mut g Gen) fixed_array_map_key_clone_stmt(mut sb strings.Builder, elem_type ast.Type, dest string,
    src string) {
    elem := g.map_key_fn_key(elem_type)
    elem_sym := g.table.final_sym(elem)
    match elem_sym.kind {
        .string {
            sb.writeln('\t\tbuiltin__map_clone_string(&${dest}, &${src});')
        }
        .array_fixed {
            g.gen_fixed_array_map_key_fns(elem)
            sb.writeln('\t\t${g.fixed_array_map_fn_base(elem)}_clone(&${dest}, &${src});')
        }
        else {
            sb.writeln('\t\tmemcpy(&${dest}, &${src}, sizeof(${g.styp(elem)}));')
        }
    }
}

fn (mut g Gen) fixed_array_map_key_free_stmt(mut sb strings.Builder, elem_type ast.Type, expr string) {
    elem := g.map_key_fn_key(elem_type)
    elem_sym := g.table.final_sym(elem)
    match elem_sym.kind {
        .string {
            sb.writeln('\t\tbuiltin__map_free_string(&${expr});')
        }
        .array_fixed {
            g.gen_fixed_array_map_key_fns(elem)
            sb.writeln('\t\t${g.fixed_array_map_fn_base(elem)}_free(&${expr});')
        }
        else {}
    }
}

fn (mut g Gen) write_map_key_arg(expr ast.Expr, key_type ast.Type) {
    key_styp := g.styp(key_type)
    if g.table.final_sym(key_type).kind == .array_fixed && expr is ast.Ident {
        g.expr(expr)
        return
    }
    g.write('&(${key_styp}[]){')
    g.expr(expr)
    g.write('}')
}

fn (mut g Gen) write_atomic_postfix_target(node ast.PostfixExpr) {
    if node.expr.is_auto_deref_var() {
        g.write('*')
    }
    g.expr(node.expr)
    if node.typ.has_flag(.shared_f) {
        g.write('->val')
    }
}

fn (g &Gen) is_windows_tcc() bool {
    return g.pref.os == .windows
        && (g.pref.ccompiler_type == .tinyc || pref.cc_from_string(g.pref.ccompiler) == .tinyc)
}

fn (mut g Gen) write_atomic_postfix_expr(node ast.PostfixExpr) {
    atomic_value_styp := g.styp(node.typ.clear_flag(.atomic_f))
    if g.is_windows_tcc() {
        g.write_windows_tcc_atomic_postfix_expr(node, atomic_value_styp)
        return
    }
    atomic_op := if node.op == .inc {
        '__atomic_fetch_add'
    } else {
        '__atomic_fetch_sub'
    }
    g.write('${atomic_op}((${atomic_value_styp}*)&(')
    g.write_atomic_postfix_target(node)
    g.write('), 1, 5)')
}

fn (mut g Gen) write_windows_tcc_atomic_postfix_expr(node ast.PostfixExpr, atomic_value_styp string) {
    if !g.wrote_windows_tcc_atomic_include {
        atomic_h_path :=
            os.join_path(@VEXEROOT, 'thirdparty', 'stdatomic', 'win', 'atomic.h').replace('\\', '/')
        g.includes.writeln('#include "${atomic_h_path}"')
        g.wrote_windows_tcc_atomic_include = true
    }
    base_typ := g.table.unaliased_type(g.unwrap_generic(node.typ.clear_flags(.shared_f, .atomic_f)))
    mut atomic_fn := 'InterlockedExchangeAdd'
    mut atomic_ptr_styp := 'LONG'
    match base_typ.idx() {
        ast.i8_type_idx, ast.u8_type_idx, ast.char_type_idx {
            atomic_fn = 'InterlockedExchangeAdd8'
            atomic_ptr_styp = 'char'
        }
        ast.i16_type_idx, ast.u16_type_idx {
            atomic_fn = 'InterlockedExchangeAdd16'
            atomic_ptr_styp = 'short'
        }
        ast.i64_type_idx, ast.u64_type_idx {
            atomic_fn = 'InterlockedExchangeAdd64'
            atomic_ptr_styp = 'LONG64'
        }
        ast.isize_type_idx, ast.usize_type_idx {
            if g.pref.arch != .i386 {
                atomic_fn = 'InterlockedExchangeAdd64'
                atomic_ptr_styp = 'LONG64'
            }
        }
        else {}
    }

    delta := if node.op == .inc { '1' } else { '-1' }
    g.write('((${atomic_value_styp})${atomic_fn}((${atomic_ptr_styp} volatile*)&(')
    g.write_atomic_postfix_target(node)
    g.write('), ${delta}))')
}

fn (mut g Gen) expr(node_ ast.Expr) {
    old_discard_or_result := g.discard_or_result
    old_is_void_expr_stmt := g.is_void_expr_stmt
    if g.is_void_expr_stmt {
        g.discard_or_result = true
        g.is_void_expr_stmt = false
    } else {
        g.discard_or_result = false
    }
    // Note: please keep the type names in the match here in alphabetical order:
    mut node := unsafe { node_ }
    match mut node {
        ast.ComptimeType {
            g.error('g.expr(): Unhandled ComptimeType', node.pos)
        }
        ast.EmptyExpr {
            g.error('g.expr(): unhandled EmptyExpr', token.Pos{})
        }
        ast.AnonFn {
            save_cur_concrete_types := g.cur_concrete_types
            call_concrete := g.active_call_generic_concrete_types(node.decl.generic_names)
            if call_concrete.len > 0 && !call_concrete.any(it.has_flag(.generic)
                || g.type_has_unresolved_generic_parts(it)) {
                g.cur_concrete_types = call_concrete
                g.clear_type_resolution_caches()
            }
            g.gen_anon_fn(mut node)
            g.cur_concrete_types = save_cur_concrete_types
            g.clear_type_resolution_caches()
        }
        ast.ArrayDecompose {
            g.expr(node.expr)
        }
        ast.ArrayInit {
            g.array_init(node, '')
        }
        ast.AsCast {
            g.as_cast(node)
        }
        ast.Assoc {
            g.assoc(node)
        }
        ast.AtExpr {
            g.comptime_at(node)
        }
        ast.BoolLiteral {
            g.write(node.val.str())
        }
        ast.CallExpr {
            ret_type := if node.or_block.kind == .absent {
                node.return_type
            } else {
                node.return_type.clear_option_and_result()
            }
            mut shared_styp := ''
            ret_typ_is_shared := ret_type.has_flag(.shared_f)
            if g.is_shared && !ret_typ_is_shared && !g.inside_or_block {
                ret_sym := g.table.sym(ret_type)
                shared_typ := if ret_type.is_ptr() {
                    ret_type.deref().set_flag(.shared_f)
                } else {
                    ret_type.set_flag(.shared_f)
                }
                shared_styp = g.styp(shared_typ)
                if ret_sym.kind == .array {
                    g.writeln('(${shared_styp}*)__dup_shared_array(&(${shared_styp}){.mtx = {0}, .val =')
                } else if ret_sym.kind == .map {
                    g.writeln('(${shared_styp}*)__dup_shared_map(&(${shared_styp}){.mtx = {0}, .val =')
                } else {
                    g.writeln('(${shared_styp}*)__dup${shared_styp}(&(${shared_styp}){.mtx = {0}, .val =')
                }
            }
            stmt_before_call_expr_pos := if g.stmt_path_pos.len > 0 {
                g.stmt_path_pos.last()
            } else {
                0
            }

            if g.is_shared && !ret_typ_is_shared && !g.inside_or_block && ret_type.is_ptr() {
                g.write('*'.repeat(ret_type.nr_muls()))
            }
            g.call_expr(node)
            if g.is_autofree && !g.is_builtin_mod && !g.is_js_call && g.strs_to_free0.len == 0
                && !g.is_autofree_tmp && !g.inside_lambda && g.inside_ternary == 0 {
                // if len != 0, that means we are handling call expr inside call expr (arg)
                // and it'll get messed up here, since it's handled recursively in autofree_call_pregen()
                // so just skip it
                g.autofree_call_pregen(node)
                if g.strs_to_free0.len > 0 {
                    g.insert_at(stmt_before_call_expr_pos, g.strs_to_free0.join('\n'))
                }
                g.strs_to_free0 = []
            }
            if g.is_shared && !ret_typ_is_shared && !g.inside_or_block {
                g.writeln('}, sizeof(${shared_styp}))')
            }
            /*
            if g.autofree {
                s := g.autofree_pregen[node.pos.pos.str()]
                if s != '' {
                    // g.insert_before_stmt('/*START2*/' + g.strs_to_free0.join('\n') + '/*END*/')
                    // g.insert_before_stmt('/*START3*/' + node.autofree_pregen + '/*END*/')
                    g.insert_before_stmt('/*START3*/' + s + '/*END*/')
                    // for s in g.strs_to_free0 {
                }
                // //g.writeln(s)
                // }
                g.strs_to_free0 = []
            }
            */
        }
        ast.CastExpr {
            g.cast_expr(node)
        }
        ast.ChanInit {
            resolved_elem_type := g.unwrap_generic(g.recheck_concrete_type(node.elem_type))
            mut muttable := unsafe { &ast.Table(g.table) }
            chan_type := ast.new_type(muttable.find_or_register_chan(resolved_elem_type,
                resolved_elem_type.nr_muls() > 0))
            g.note_chan_type_definition(chan_type)
            elem_typ_str := g.styp(resolved_elem_type)
            noscan := g.check_noscan(resolved_elem_type)
            g.write('sync__new_channel_st${noscan}(')
            if node.has_cap {
                g.expr(node.cap_expr)
            } else {
                g.write('0')
            }
            g.write2(', sizeof(', elem_typ_str)
            g.write2(')>0 ? sizeof(', elem_typ_str)
            g.write(') : 1)')
        }
        ast.CharLiteral {
            g.char_literal(node)
        }
        ast.Comment {}
        ast.ComptimeCall {
            g.comptime_call(mut node)
        }
        ast.ComptimeSelector {
            g.comptime_selector(node)
        }
        ast.ConcatExpr {
            g.concat_expr(node)
        }
        ast.CTempVar {
            g.write(node.name)
            if node.is_fixed_ret {
                g.write('.ret_arr')
            }
        }
        ast.DumpExpr {
            g.dump_expr(node)
        }
        ast.EnumVal {
            g.enum_val(node)
        }
        ast.FloatLiteral {
            if g.pref.nofloat {
                g.write(node.val.int().str())
            } else {
                g.write(node.val)
            }
        }
        ast.SpawnExpr {
            old_is_arraymap_set := g.is_arraymap_set
            g.is_arraymap_set = false
            g.spawn_and_go_expr(node, .spawn_)
            g.is_arraymap_set = old_is_arraymap_set
        }
        ast.GoExpr {
            // XTODO this results in a cgen bug, order of fields is broken
            // g.spawn_and_go_expr(ast.SpawnExpr{node.pos, node.call_expr, node.is_expr},
            old_is_arraymap_set := g.is_arraymap_set
            g.is_arraymap_set = false
            g.spawn_and_go_expr(ast.SpawnExpr{
                pos:       node.pos
                call_expr: node.call_expr
                is_expr:   node.is_expr
            }, .go_)
            g.is_arraymap_set = old_is_arraymap_set
        }
        ast.Ident {
            g.ident(node)
        }
        ast.IfExpr {
            if !node.is_comptime {
                g.if_expr(node)
            } else {
                g.comptime_if(node)
            }
        }
        ast.IfGuardExpr {
            g.write('/* guard */')
        }
        ast.IndexExpr {
            g.index_expr(node)
        }
        ast.InfixExpr {
            if node.op !in [.left_shift, .plus_assign, .minus_assign] {
                g.infix_expr(node)
            } else {
                g.inside_map_infix = true
                g.infix_expr(node)
                g.inside_map_infix = false
            }
        }
        ast.IntegerLiteral {
            if node.val.starts_with('0o') {
                g.write2('0', node.val[2..])
            } else if node.val.starts_with('-0o') {
                g.write2('-0', node.val[3..])
            } else {
                g.write(node.val)
                val_type := determine_integer_literal_type(node)
                if val_type in [ast.u32_type, ast.u64_type] {
                    g.write('U')
                }
                if val_type in [ast.i64_type, ast.u64_type] {
                    g.write('LL')
                }
            }
        }
        ast.IsRefType {
            typ := g.type_resolver.typeof_type(node.expr, g.get_type(node.typ))
            node_typ := g.unwrap_generic(typ)
            sym := g.table.sym(node_typ)
            if sym.language == .v && sym.kind in [.placeholder, .any] {
                g.error('unknown type `${sym.name}`', node.pos)
            }
            is_ref_type := g.contains_ptr(node_typ)
            g.write('/*IsRefType*/ ${is_ref_type}')
        }
        ast.LambdaExpr {
            if node.call_ctx != unsafe { nil } {
                save_cur_concrete_types := g.cur_concrete_types
                call_concrete := g.active_call_lambda_concrete_types(node)
                // Only override cur_concrete_types if the call context has
                // fully resolved (non-generic) types. When inside a generic
                // function instantiation, g.cur_concrete_types already has
                // the correct concrete types from gen_fn_decl. The call_ctx
                // may still have unresolved generic placeholders from the
                // checker's first pass.
                if call_concrete.len > 0 && !call_concrete.any(it.has_flag(.generic)
                    || g.type_has_unresolved_generic_parts(it)) {
                    g.cur_concrete_types = call_concrete
                    g.clear_type_resolution_caches()
                }
                g.gen_anon_fn(mut node.func)
                g.cur_concrete_types = save_cur_concrete_types
                g.clear_type_resolution_caches()
            } else {
                g.gen_anon_fn(mut node.func)
            }
        }
        ast.Likely {
            if node.is_likely {
                g.write('_likely_')
            } else {
                g.write('_unlikely_')
            }
            g.write('(')
            g.expr(node.expr)
            g.write(')')
        }
        ast.LockExpr {
            g.lock_expr(node)
        }
        ast.MapInit {
            g.map_init(node)
        }
        ast.MatchExpr {
            if node.is_comptime {
                g.comptime_match(node)
            } else {
                g.match_expr(node)
            }
        }
        ast.NodeError {}
        ast.Nil {
            g.write('((void*)0)')
        }
        ast.None {
            g.write('_const_none__')
        }
        ast.OffsetOf {
            styp := g.styp(node.struct_type)
            g.write('/*OffsetOf*/ (u32)(__offsetof(${util.no_dots(styp)}, ${node.field}))')
        }
        ast.OrExpr {
            // this should never appear here
        }
        ast.ParExpr {
            g.write('(')
            if node.expr is ast.ArrayInit && node.expr.is_fixed && !g.inside_assign {
                array_init := node.expr as ast.ArrayInit
                g.fixed_array_init_with_cast(array_init, array_init.typ)
            } else {
                g.expr(node.expr)
            }
            g.write(')')
        }
        ast.PostfixExpr {
            if node.auto_locked != '' {
                g.writeln('sync__RwMutex_lock(&${node.auto_locked}->mtx);')
            }
            is_safe_inc := g.do_int_overflow_checks && node.op == .inc
            is_safe_dec := g.do_int_overflow_checks && node.op == .dec
            is_atomic_postfix := node.typ.has_flag(.atomic_f) && node.op in [.inc, .dec]
                && g.pref.ccompiler_type != .msvc
            g.inside_map_postfix = true
            if is_atomic_postfix {
                g.write_atomic_postfix_expr(node)
            } else if node.is_c2v_prefix {
                g.write(node.op.str())
            }
            if is_atomic_postfix {
                // already emitted above
            } else if node.expr.is_auto_deref_var() {
                g.write('(*')
                g.expr(node.expr)
                g.write(')')
            } else if node.op == .question {
                mut expr_type := ast.void_type
                if mut node.expr is ast.ComptimeSelector {
                    if node.expr.field_expr is ast.SelectorExpr
                        && g.comptime.is_comptime_selector_field_name(node.expr.field_expr, 'name') {
                        expr_type = g.unwrap_generic(g.comptime.comptime_for_field_type)
                    }
                } else if mut node.expr is ast.Ident && node.expr.ct_expr {
                    expr_type = g.get_comptime_for_var_type(node.expr, g.type_resolver.get_type_or_default(ast.Expr(node.expr),
                        ast.void_type))
                }
                if expr_type != ast.void_type {
                    if !expr_type.has_flag(.option) {
                        g.error('cannot use `?` on non-option expression', node.pos)
                    }
                }
                cur_line := g.go_before_last_stmt().trim_space()
                mut expr_str := ''
                mut is_unwrapped := true
                mut dot_or_ptr := '.'
                if mut node.expr is ast.ComptimeSelector && node.expr.left is ast.Ident {
                    // val.$(field.name)?
                    expr_str = g.gen_comptime_selector(node.expr)
                } else if mut node.expr is ast.Ident && node.expr.ct_expr {
                    // val?
                    expr_str = node.expr.name
                    is_unwrapped = !g.inside_assign
                    dot_or_ptr = if !(node.expr.obj is ast.Var && node.expr.obj.is_auto_deref) {
                        '.'
                    } else {
                        '->'
                    }
                }
                g.writeln('if (${expr_str}${dot_or_ptr}state != 0) {')
                g.writeln2('\tbuiltin__panic_option_not_set(_S("none"));', '}')
                g.write(cur_line)
                if is_unwrapped {
                    typ := g.type_resolver.typeof_type(node.expr, node.typ)
                    g.write('*(${g.base_type(typ)}*)&')
                    g.expr(node.expr)
                    g.write('.data')
                } else {
                    g.expr(node.expr)
                }
            } else {
                g.expr(node.expr)
                if node.typ.has_flag(.shared_f) {
                    g.write('->val')
                }
            }
            g.inside_map_postfix = false
            if is_atomic_postfix {
                // already emitted above
            } else if !node.is_c2v_prefix && node.op != .question && !is_safe_inc && !is_safe_dec {
                g.write(node.op.str())
            } else if is_safe_inc || is_safe_dec {
                overflow_styp := g.styp(get_overflow_fn_type(node.typ))
                vsafe_fn_name := if is_safe_inc {
                    'builtin__overflow__add_${overflow_styp}'
                } else {
                    'builtin__overflow__sub_${overflow_styp}'
                }
                g.write('=${vsafe_fn_name}(')
                g.expr(node.expr)
                if node.typ.has_flag(.shared_f) {
                    g.write('->val')
                }
                g.write(',1)')
            }
            if node.auto_locked != '' {
                g.writeln(';')
                g.write('sync__RwMutex_unlock(&${node.auto_locked}->mtx)')
            }
        }
        ast.PrefixExpr {
            gen_or := node.op == .arrow && (node.or_block.kind != .absent || node.is_option)
            if node.op == .amp {
                g.is_amp = true
            }
            if node.op == .arrow {
                mut right_type := g.resolved_expr_type(node.right, node.right_type)
                if right_type == 0 {
                    right_type = node.right_type
                }
                right_type = g.unwrap_generic(g.recheck_concrete_type(right_type))
                mut styp := g.styp(right_type)
                mut right_sym := g.table.sym(right_type)
                if right_sym.info !is ast.Chan {
                    right_type = node.right_type
                    styp = g.styp(right_type)
                    right_sym = g.table.sym(right_type)
                }
                g.note_chan_type_definition(right_type)
                mut right_inf := right_sym.info as ast.Chan
                elem_type := g.unwrap_generic(g.recheck_concrete_type(right_inf.elem_type))
                if g.pref.skip_unused {
                    mut muttable := unsafe { &ast.Table(g.table) }
                    muttable.used_features.used_syms[right_type.idx()] = true
                    muttable.used_features.used_syms[elem_type.idx()] = true
                }
                is_gen_or_and_assign_rhs := gen_or && !g.discard_or_result
                cur_line := if is_gen_or_and_assign_rhs {
                    line := g.go_before_last_stmt()
                    g.out.write_string(util.tabs(g.indent))
                    line
                } else {
                    ''
                }
                tmp_opt := if gen_or { g.new_tmp_var() } else { '' }
                if gen_or {
                    opt_elem_type := g.styp(elem_type.set_flag(.option))
                    g.register_chan_pop_option_call(opt_elem_type, styp)
                    g.write('${opt_elem_type} ${tmp_opt} = __Option_${styp}_popval(')
                } else {
                    g.write('__${styp}_popval(')
                }
                g.expr(node.right)
                g.write(')')
                if gen_or {
                    if !node.is_option {
                        g.or_block(tmp_opt, node.or_block, elem_type)
                    }
                    if is_gen_or_and_assign_rhs {
                        elem_styp := g.styp(elem_type)
                        g.write(';\n${cur_line}*(${elem_styp}*)${tmp_opt}.data')
                    }
                }
            } else {
                if g.is_option_auto_heap {
                    g.write('(${g.base_type(node.right_type)}*)')
                }
                mut tmp_var := ''
                if node.op == .amp {
                    if node.right is ast.ParExpr && node.right.expr is ast.AsCast
                        && (node.right.expr as ast.AsCast).expr is ast.CallExpr {
                        str := g.go_before_last_stmt()
                        g.empty_line = true
                        typ := g.styp(((node.right as ast.ParExpr).expr as ast.AsCast).typ)
                        tmp_var = g.new_tmp_var()
                        g.writeln('${typ} ${tmp_var};')
                        mut stmts := []ast.Stmt{cap: 1}
                        stmts << ast.ExprStmt{
                            pos:  node.pos
                            expr: node.right
                        }
                        g.stmts_with_tmp_var(stmts, tmp_var)
                        g.set_current_pos_as_last_stmt_pos()
                        g.write(str)
                    }
                }
                mut has_slice_call := false
                // When taking the address of an auto-deref variable (e.g. `&receiver`
                // where the receiver is already a pointer in C), the `&` and the
                // implicit dereference cancel out, so emit neither.
                is_amp_auto_deref := node.op == .amp && node.right.is_auto_deref_var()
                if !g.is_option_auto_heap {
                    has_slice_call = node.op == .amp && node.right is ast.IndexExpr
                        && node.right.index is ast.RangeExpr
                    if has_slice_call {
                        g.write('ADDR(${g.styp(node.right_type)}, ')
                    } else if !is_amp_auto_deref {
                        g.write(node.op.str())
                    }
                }
                // For `*val` where val is a mut generic param with pointer type
                // (e.g. `mut val T` where T=&int -> C: `int** val`), auto-deref needs
                // an extra `*` so `*val` in V becomes `**val` in C.
                if node.op == .mul && node.right is ast.Ident {
                    ident_right := node.right as ast.Ident
                    if ident_right.obj is ast.Var && ident_right.obj.is_auto_deref
                        && ident_right.obj.is_arg && ident_right.obj.generic_typ != 0 {
                        // generic_typ stores the mut-lowered surface type (`&T`) for mut
                        // generic params, but we only need the underlying `T` here.
                        resolved_generic := g.unwrap_generic(ident_right.obj.generic_typ.deref())
                        if resolved_generic.is_ptr() {
                            g.write('*')
                        }
                    }
                }
                if node.right.is_auto_deref_var() && node.op !in [.amp, .mul, .arrow] {
                    g.write('*')
                }
                // Keep nested unary +/- parenthesized so C does not collapse them into ++/--
                // when the parser has preserved a nested prefix node or folded a signed literal.
                needs_nested_prefix_parens := prefix_expr_operand_needs_parens(node)
                if needs_nested_prefix_parens {
                    g.write('(')
                }
                if tmp_var == '' {
                    g.expr(node.right)
                } else {
                    g.write(tmp_var)
                }
                if needs_nested_prefix_parens {
                    g.write(')')
                }
                if has_slice_call {
                    g.write(')')
                }
                if g.is_option_auto_heap {
                    g.write('.data')
                }
            }
            g.is_amp = false
        }
        ast.RangeExpr {
            // Only used in IndexExpr and InfixExpr
        }
        ast.SelectExpr {
            g.select_expr(node)
        }
        ast.SelectorExpr {
            g.selector_expr(node)
        }
        ast.SizeOf {
            g.size_of(node)
        }
        ast.SqlExpr {
            if node.is_insert {
                g.sql_insert_expr(node)
            } else {
                g.sql_select_expr(node)
            }
        }
        ast.SqlQueryDataExpr {
            left := g.go_before_last_stmt()
            query_var := g.emit_sql_query_data(node, false)
            g.write2(left, query_var)
        }
        ast.StringLiteral {
            g.string_literal(node)
        }
        ast.StringInterLiteral {
            g.string_inter_literal(node)
        }
        ast.StructInit {
            if node.unresolved {
                g.expr(g.table.resolve_init(node, g.unwrap_generic(node.typ)))
            } else {
                // `user := User{name: 'Bob'}`
                g.inside_struct_init = true
                g.cur_struct_init_typ = node.typ
                g.struct_init(node)
                g.cur_struct_init_typ = 0
                g.inside_struct_init = false
            }
        }
        ast.TypeNode {
            // match sum Type
            typ := g.unwrap_generic(node.typ)
            sym := g.table.sym(typ)
            sidx := g.type_sidx(typ)
            g.write('${sidx}')
            if !g.pref.is_prod {
                g.write(' /* ${sym.name} */')
            }
        }
        ast.TypeOf {
            g.typeof_expr(node)
        }
        ast.UnsafeExpr {
            g.unsafe_level++
            g.expr(node.expr)
            g.unsafe_level--
        }
    }

    g.discard_or_result = old_discard_or_result
    g.is_void_e