module c

import v3.flat
import v3.types

// c_field_name supports c field name handling for c.
fn c_field_name(name string) string {
    if name.starts_with('&') {
        return c_field_name(name[1..])
    }
    if name.starts_with('ptr') && name.len > 3 && name[3..].contains('__') {
        return c_name(name[3..])
    }
    if name.starts_with('ptr') && name.len > 3 && name[3..].contains('.') {
        return c_name(name[3..])
    }
    return c_name(name)
}

// struct_init_fields_key returns the key under which the initialized struct's checked fields
// (and their concrete types) live. For a bare generic literal that adopts a concrete instance
// (`Box{..}` where `Box[int]` is expected) that is the instance key `Box[int]`; the bare `Box`
// entry is removed by monomorphization, so field-type lookups and omitted default-field
// emission must use the instance key or they miss fields like `items []T` (leaving invalid
// zeroed array/map metadata). Falls back to the given key for non-generic structs.
fn (g &FlatGen) struct_init_fields_key(type_name string, fallback string) string {
    if inst := g.generic_struct_init_instance_name(type_name) {
        if inst in g.tc.structs {
            return inst
        }
    }
    return fallback
}

fn (mut g FlatGen) gen_struct_field_expr(value_id flat.NodeId, expected types.Type) {
    if g.gen_callback_fn_value_for_expected_type(value_id, expected) {
        return
    }
    g.gen_expr_with_expected_type(value_id, expected)
}

fn (mut g FlatGen) gen_struct_field_expr_for_field(value_id flat.NodeId, struct_name string, field_name string, expected types.Type) {
    if c_abi_fn := g.struct_field_c_abi_fn_ptr_type(struct_name, field_name) {
        if g.gen_callback_fn_value_for_field_c_abi(value_id, expected, c_abi_fn) {
            return
        }
    }
    g.gen_struct_field_expr(value_id, expected)
}

// gen_struct_init emits struct init output for c.
fn (mut g FlatGen) gen_struct_init(node flat.Node) {
    init_module := g.tc.cur_module
    if node.value.starts_with('chan ') {
        g.gen_channel_init(node)
        return
    }
    if g.gen_lowered_sum_init(node) {
        return
    }
    mut name := g.struct_init_c_type_name(node.value)
    // A bare generic struct literal (`Vec4{..}`) carries no type args; when the
    // surrounding expected type fixes them (e.g. a `Vec4[f32]` return), emit the
    // concrete instance name so it matches the materialized struct.
    if inst := g.generic_struct_init_instance_ct(node.value) {
        name = inst
    }
    // A bare generic literal stores its fields under the concrete instance key (`Box[int]`);
    // the bare `node.value` (`Box`) entry is removed by monomorphization, so resolve the
    // instance for the fixed-array-field test, field-type lookups, and omitted-default emission.
    lookup_name := g.struct_init_fields_key(node.value, node.value)
    if node.children_count == 0 && g.is_scalar_zero_init_type(node.value, name) {
        g.write(g.scalar_zero_init(name))
        return
    }
    if !g.is_interface_type_name(node.value)
        && g.struct_init_has_fixed_array_field(node, lookup_name) {
        g.gen_struct_init_with_fixed_array_fields(node, name, init_module)
        return
    }
    g.write('(${name}){')
    mut allowed_fields := map[string]bool{}
    if fields := g.struct_fields_for_type(lookup_name) {
        for f in fields {
            allowed_fields[f.name] = true
        }
    }
    mut set_fields := map[string]bool{}
    mut has_field := false
    if g.is_interface_type_name(node.value) {
        if tid := g.interface_init_typ_id(node) {
            g.write('._typ = ${tid}')
            has_field = true
        }
    }
    for i in 0 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.value.len > 0 && allowed_fields.len > 0 && field.value !in allowed_fields {
            continue
        }
        if has_field {
            g.write(', ')
        }
        value_id := g.a.child(field, 0)
        if field.value.len == 0 {
            if sf := g.struct_field_at(lookup_name, i) {
                if heap_copy_type := g.heap_copy_type_for_sum_pointer_field(node.value, sf.name,
                    value_id)
                {
                    inner_ct := g.tc.c_type(heap_copy_type)
                    g.write('(${inner_ct}*)memdup(')
                    g.gen_expr(value_id)
                    g.write(', sizeof(${inner_ct}))')
                } else {
                    g.gen_struct_field_expr_for_field(value_id, node.value, sf.name, sf.typ)
                }
                set_fields[sf.name] = true
            } else {
                g.gen_expr(value_id)
            }
        } else {
            g.write('.${c_field_name(field.value)} = ')
            if heap_copy_type := g.heap_copy_type_for_sum_pointer_field(node.value, field.value,
                value_id)
            {
                inner_ct := g.tc.c_type(heap_copy_type)
                g.write('(${inner_ct}*)memdup(')
                g.gen_expr(value_id)
                g.write(', sizeof(${inner_ct}))')
            } else {
                if ftyp := g.struct_field_type(lookup_name, field.value) {
                    if g.struct_field_value_is_plainly_incompatible(value_id, ftyp) {
                        g.gen_default_value_for_type(ftyp)
                    } else {
                        g.gen_struct_field_expr_for_field(value_id, node.value, field.value, ftyp)
                    }
                } else {
                    g.gen_expr(value_id)
                }
            }
            set_fields[field.value] = true
        }
        has_field = true
    }
    after_fields_module := g.tc.cur_module
    g.tc.cur_module = init_module
    sname := g.struct_init_resolved_decl_name(node.value)
    g.tc.cur_module = after_fields_module
    has_field = g.gen_struct_default_fields(sname, mut set_fields, has_field)
    defaults_key := if lookup_name in g.tc.structs { lookup_name } else { sname }
    if defaults_key in g.tc.structs {
        for f in g.tc.structs[defaults_key] {
            if f.name in set_fields {
                continue
            }
            if f.typ is types.Map {
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = ')
                g.write_new_map(f.typ.key_type, f.typ.value_type)
                has_field = true
            } else if f.typ is types.Array {
                c_elem := g.tc.c_type(f.typ.elem_type)
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = array_new(sizeof(${c_elem}), 0, 0)')
                has_field = true
            } else if g.field_needs_default_init(f.typ) {
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = ')
                g.gen_default_value_for_type(f.typ)
                has_field = true
            }
        }
    }
    g.write('}')
}

fn (mut g FlatGen) struct_init_has_fixed_array_field(node flat.Node, type_name string) bool {
    for i in 0 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.value.len == 0 {
            if sf := g.struct_field_at(type_name, i) {
                if sf.typ is types.ArrayFixed {
                    return true
                }
            }
            continue
        }
        if ftyp := g.struct_field_type(type_name, field.value) {
            if ftyp is types.ArrayFixed {
                return true
            }
        }
    }
    return false
}

fn (mut g FlatGen) gen_struct_init_with_fixed_array_fields(node flat.Node, name string, init_module string) {
    g.gen_struct_init_with_fixed_array_fields_impl(node, name, init_module, false)
}

// gen_struct_init_with_fixed_array_fields_impl builds a struct that has fixed-array
// fields via a temp + per-field `memcpy` (array members can't be assigned in a
// compound literal). When `heap`, the temp is `memdup`'d and a pointer returned,
// for `&Struct{...}` initializers.
fn (mut g FlatGen) gen_struct_init_with_fixed_array_fields_impl(node flat.Node, name string, init_module string, heap bool) {
    tmp := g.tmp_name()
    if heap {
        g.write('(${name}*)')
    }
    g.write('({${name} ${tmp} = (${name}){')
    // A bare generic literal stores its fields under the concrete instance key (`Box[int]`);
    // the bare `node.value` (`Box`) entry is removed by monomorphization, so resolve the
    // instance for the field lookups and omitted-default emission below.
    lookup_name := g.struct_init_fields_key(node.value, node.value)
    mut allowed_fields := map[string]bool{}
    if fields := g.struct_fields_for_type(lookup_name) {
        for f in fields {
            allowed_fields[f.name] = true
        }
    }
    mut fixed_fields := []string{}
    mut fixed_values := []flat.NodeId{}
    mut fixed_field_types := []types.Type{}
    mut set_fields := map[string]bool{}
    mut has_field := false
    for i in 0 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.value.len > 0 && allowed_fields.len > 0 && field.value !in allowed_fields {
            continue
        }
        value_id := g.a.child(field, 0)
        if field.value.len == 0 {
            if sf := g.struct_field_at(lookup_name, i) {
                if sf.typ is types.ArrayFixed {
                    fixed_fields << sf.name
                    fixed_values << value_id
                    fixed_field_types << sf.typ
                    set_fields[sf.name] = true
                    continue
                }
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(sf.name)} = ')
                g.gen_struct_field_expr_for_field(value_id, node.value, sf.name, sf.typ)
                set_fields[sf.name] = true
                has_field = true
            } else {
                if has_field {
                    g.write(', ')
                }
                g.gen_expr(value_id)
                has_field = true
            }
        } else {
            ftyp := g.struct_field_type(lookup_name, field.value) or { types.Type(types.void_) }
            if ftyp is types.ArrayFixed {
                fixed_fields << field.value
                fixed_values << value_id
                fixed_field_types << ftyp
                set_fields[field.value] = true
                continue
            }
            if has_field {
                g.write(', ')
            }
            g.write('.${c_field_name(field.value)} = ')
            if heap_copy_type := g.heap_copy_type_for_sum_pointer_field(node.value, field.value,
                value_id)
            {
                inner_ct := g.tc.c_type(heap_copy_type)
                g.write('(${inner_ct}*)memdup(')
                g.gen_expr(value_id)
                g.write(', sizeof(${inner_ct}))')
            } else if ftyp !is types.Void {
                if g.struct_field_value_is_plainly_incompatible(value_id, ftyp) {
                    g.gen_default_value_for_type(ftyp)
                } else {
                    g.gen_struct_field_expr_for_field(value_id, node.value, field.value, ftyp)
                }
            } else {
                g.gen_expr(value_id)
            }
            set_fields[field.value] = true
            has_field = true
        }
    }
    after_fields_module := g.tc.cur_module
    g.tc.cur_module = init_module
    sname := g.struct_init_resolved_decl_name(node.value)
    g.tc.cur_module = after_fields_module
    has_field = g.gen_struct_default_fields(sname, mut set_fields, has_field)
    defaults_key := if lookup_name in g.tc.structs { lookup_name } else { sname }
    if defaults_key in g.tc.structs {
        for f in g.tc.structs[defaults_key] {
            if f.name in set_fields {
                continue
            }
            if f.typ is types.Map {
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = ')
                g.write_new_map(f.typ.key_type, f.typ.value_type)
                has_field = true
            } else if f.typ is types.Array {
                c_elem := g.tc.c_type(f.typ.elem_type)
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = array_new(sizeof(${c_elem}), 0, 0)')
                has_field = true
            } else if g.field_needs_default_init(f.typ) {
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = ')
                g.gen_default_value_for_type(f.typ)
                has_field = true
            }
        }
    }
    g.write('};')
    for i in 0 .. fixed_fields.len {
        cfield := c_field_name(fixed_fields[i])
        g.write(' memcpy(${tmp}.${cfield}, ')
        g.gen_fixed_array_copy_source(fixed_values[i], fixed_field_types[i])
        g.write(', sizeof(${tmp}.${cfield}));')
    }
    if heap {
        g.write(' memdup(&${tmp}, sizeof(${name}));})')
    } else {
        g.write(' ${tmp};})')
    }
}

// gen_fixed_array_copy_source emits a `memcpy` source for assigning into a fixed
// array. A raw array literal becomes a typed compound literal (a valid expression
// that decays to a pointer); a dynamic array value copies from its `.data` buffer;
// other fixed-array expressions (variables, fields, unwrapped calls) decay as-is.
fn (mut g FlatGen) gen_fixed_array_copy_source(value_id flat.NodeId, field_type types.Type) {
    val_node := g.a.node(value_id)
    if val_node.kind == .array_literal {
        g.write('(${g.tc.c_type(field_type)})')
        g.gen_expr(value_id)
        return
    }
    val_type := types.unwrap_pointer(g.usable_expr_type(value_id))
    if val_type is types.Array {
        g.write('(')
        g.gen_expr(value_id)
        g.write(').data')
        return
    }
    g.gen_expr(value_id)
}

// gen_lowered_sum_init emits lowered sum init output for c.
fn (mut g FlatGen) gen_lowered_sum_init(node flat.Node) bool {
    sum_name := g.resolve_sum_name(node.value)
    if sum_name !in g.tc.sum_types || node.children_count == 0 {
        return false
    }
    name := g.struct_init_c_type_name(node.value)
    g.write('(${name}){')
    for i in 0 .. node.children_count {
        field := g.a.child_node(&node, i)
        if i > 0 {
            g.write(', ')
        }
        g.write('.${c_field_name(field.value)} = ')
        g.gen_lowered_sum_field_value(sum_name, field)
    }
    g.write('}')
    return true
}

// gen_lowered_sum_field_value emits lowered sum field value output for c.
fn (mut g FlatGen) gen_lowered_sum_field_value(sum_name string, field &flat.Node) {
    child_id := g.a.child(field, 0)
    if field.value != 'typ' {
        mut variant := ''
        if field.typ.starts_with('&') {
            variant = field.typ[1..]
        } else if field.typ.len > 0 {
            variant = field.typ
        } else {
            for v in g.tc.sum_types[sum_name] {
                if g.sum_field_name(v) == field.value {
                    variant = v
                    break
                }
            }
        }
        if variant.len > 0 {
            variant = g.resolve_variant(sum_name, variant)
            inner_type := g.tc.parse_type(variant)
            inner_ct := g.tc.c_type(inner_type)
            child_type := g.tc.resolve_type(child_id)
            g.write('(${inner_ct}*)memdup(')
            if child_type is types.Pointer && g.type_names_match(child_type.base_type, inner_type) {
                g.gen_expr(child_id)
            } else {
                g.write('(${inner_ct}[]){')
                g.gen_expr_with_expected_type(child_id, inner_type)
                g.write('}')
            }
            g.write(', sizeof(${inner_ct}))')
            return
        }
    }
    if field.typ.len > 0 {
        g.gen_expr_with_expected_type(child_id, g.tc.parse_type(field.typ))
    } else {
        g.gen_expr(child_id)
    }
}

// gen_channel_init emits channel init output for c.
fn (mut g FlatGen) gen_channel_init(node flat.Node) {
    elem_type := g.tc.parse_type(node.value[5..])
    elem_ct := g.tc.c_type(elem_type)
    g.write('sync__new_channel_st((u32)(')
    if cap_id := channel_init_field(node, g.a, 'cap') {
        g.gen_expr(cap_id)
    } else {
        g.write('0')
    }
    g.write('), (u32)(sizeof(${elem_ct})))')
}

// channel_init_field supports channel init field handling for c.
fn channel_init_field(node flat.Node, a &flat.FlatAst, name string) ?flat.NodeId {
    for i in 0 .. node.children_count {
        field := a.child_node(&node, i)
        if field.kind == .field_init && field.value == name && field.children_count > 0 {
            return a.child(field, 0)
        }
    }
    return none
}

// gen_heap_struct_init emits heap struct init output for c.
fn (mut g FlatGen) gen_heap_struct_init(node flat.Node) {
    init_module := g.tc.cur_module
    mut name := g.struct_init_c_type_name(node.value)
    // A bare generic heap literal (`&Vec4{..}`) carries no type args; when the
    // surrounding expected type fixes them (e.g. a `&Vec4[f32]` return), emit the
    // concrete instance name so the materialized struct matches the value path.
    if inst := g.generic_struct_init_instance_ct(node.value) {
        name = inst
    }
    sum_name := g.resolve_sum_name(node.value)
    is_sum_literal := sum_name in g.tc.sum_types
    // A bare generic literal stores its fields under the concrete instance key (`Box[int]`);
    // the bare `node.value` (`Box`) entry is removed by monomorphization, so resolve the
    // instance for the fixed-array-field test, field-type lookups, and omitted-default emission.
    lookup_name := g.struct_init_fields_key(node.value, node.value)
    if !is_sum_literal && !g.is_interface_type_name(node.value)
        && g.struct_init_has_fixed_array_field(node, lookup_name) {
        // Fixed-array fields can't be set in the `&(T){...}` compound literal; build
        // via a temp + memcpy and memdup the result.
        g.gen_struct_init_with_fixed_array_fields_impl(node, name, init_module, true)
        return
    }
    g.write('(${name}*)memdup(&(${name}){')
    mut allowed_fields := map[string]bool{}
    if fields := g.struct_fields_for_type(lookup_name) {
        for f in fields {
            allowed_fields[f.name] = true
        }
    }
    mut set_fields := map[string]bool{}
    mut has_field := false
    if g.is_interface_type_name(node.value) {
        if tid := g.interface_init_typ_id(node) {
            g.write('._typ = ${tid}')
            has_field = true
        }
    }
    for i in 0 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.value.len > 0 && allowed_fields.len > 0 && field.value !in allowed_fields {
            continue
        }
        if has_field {
            g.write(', ')
        }
        value_id := g.a.child(field, 0)
        if field.value.len == 0 {
            // Positional initializer (empty field name): emit a positional C value mapped
            // to the field at this index (mirrors gen_struct_init); a `. = v` designator
            // is invalid C.
            if sf := g.struct_field_at(lookup_name, i) {
                if heap_copy_type := g.heap_copy_type_for_sum_pointer_field(lookup_name, sf.name,
                    value_id)
                {
                    inner_ct := g.tc.c_type(heap_copy_type)
                    g.write('(${inner_ct}*)memdup(')
                    g.gen_expr(value_id)
                    g.write(', sizeof(${inner_ct}))')
                } else {
                    g.gen_struct_field_expr_for_field(value_id, node.value, sf.name, sf.typ)
                }
                set_fields[sf.name] = true
            } else {
                g.gen_expr(value_id)
            }
            has_field = true
            continue
        }
        g.write('.${c_field_name(field.value)} = ')
        if is_sum_literal {
            g.gen_lowered_sum_field_value(sum_name, field)
        } else if heap_copy_type := g.heap_copy_type_for_sum_pointer_field(node.value, field.value,
            value_id)
        {
            inner_ct := g.tc.c_type(heap_copy_type)
            g.write('(${inner_ct}*)memdup(')
            g.gen_expr(value_id)
            g.write(', sizeof(${inner_ct}))')
        } else {
            if ftyp := g.struct_field_type(lookup_name, field.value) {
                if g.struct_field_value_is_plainly_incompatible(value_id, ftyp) {
                    g.gen_default_value_for_type(ftyp)
                } else {
                    g.gen_struct_field_expr_for_field(value_id, node.value, field.value, ftyp)
                }
            } else {
                g.gen_expr(value_id)
            }
        }
        set_fields[field.value] = true
        has_field = true
    }
    after_fields_module := g.tc.cur_module
    g.tc.cur_module = init_module
    sname := g.struct_init_resolved_decl_name(node.value)
    g.tc.cur_module = after_fields_module
    has_field = g.gen_struct_default_fields(sname, mut set_fields, has_field)
    defaults_key := if lookup_name in g.tc.structs { lookup_name } else { sname }
    if defaults_key in g.tc.structs {
        for f in g.tc.structs[defaults_key] {
            if f.name in set_fields {
                continue
            }
            if f.typ is types.Map {
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = ')
                g.write_new_map(f.typ.key_type, f.typ.value_type)
                has_field = true
            } else if f.typ is types.Array {
                c_elem := g.tc.c_type(f.typ.elem_type)
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = array_new(sizeof(${c_elem}), 0, 0)')
                has_field = true
            } else if g.field_needs_default_init(f.typ) {
                if has_field {
                    g.write(', ')
                }
                g.write('.${c_field_name(f.name)} = ')
                g.gen_default_value_for_type(f.typ)
                has_field = true
            }
        }
    }
    g.write('}, sizeof(${name}))')
}

// heap_copy_type_for_sum_pointer_field supports heap_copy_type_for_sum_pointer_field handling in c.
fn (g &FlatGen) heap_copy_type_for_sum_pointer_field(type_name string, field_name string, value_id flat.NodeId) ?types.Type {
    resolved_sum := g.resolve_sum_name(type_name)
    if resolved_sum !in g.tc.sum_types || int(value_id) < 0 {
        return none
    }
    value := g.a.nodes[int(value_id)]
    if !g.pointer_variant_arg_needs_heap_copy(value) {
        return none
    }
    for variant in g.tc.sum_types[resolved_sum] {
        if g.sum_field_name(variant) != field_name
            || !g.variant_references_sum(variant, resolved_sum) {
            continue
        }
        variant_type := g.tc.parse_type(g.resolve_variant(resolved_sum, variant))
        return variant_type
    }
    return none
}

// gen_struct_default_fields emits struct default fields output for c.
fn (mut g FlatGen) gen_struct_default_fields(type_name string, mut set_fields map[string]bool, has_field bool) bool {
    mut has := has_field
    info := g.find_struct_decl(type_name) or { return has }
    old_module := g.tc.cur_module
    g.tc.cur_module = info.module
    for i in 0 .. info.node.children_count {
        field := g.a.child_node(&info.node, i)
        if field.kind != .field_decl || field.children_count == 0 || field.value in set_fields {
            continue
        }
        if has {
            g.write(', ')
        }
        g.write('.${c_name(field.value)} = ')
        g.gen_struct_field_expr_for_field(g.a.child(field, 0), info.full_name, field.value, g.struct_default_field_type(info,
            field))
        set_fields[field.value] = true
        has = true
    }
    g.tc.cur_module = old_module
    return has
}

fn (mut g FlatGen) struct_default_field_type(info StructDeclInfo, field flat.Node) types.Type {
    if field.typ.len > 0 && !field.typ.contains('.') && info.module.len > 0 && info.module != 'main'
        && info.module != 'builtin' {
        qtyp := '${info.module}.${field.typ}'
        if qtyp in g.tc.enum_names || qtyp in g.tc.structs || qtyp in g.tc.sum_types
            || qtyp in g.tc.interface_names {
            return g.tc.parse_type(qtyp)
        }
    }
    return g.tc.parse_type(field.typ)
}

// gen_default_value_for_type emits default value for type output for c.
fn (mut g FlatGen) gen_default_value_for_type(typ types.Type) {
    raw_typ := typ
    if typ is types.OptionType || typ is types.ResultType {
        ct := g.optional_type_name(typ)
        g.write('(${ct}){0}')
        return
    }
    if typ is types.Struct && !typ.name.starts_with('C.') {
        ct := g.tc.c_type(raw_typ)
        g.write('(${ct}){')
        mut set_fields := map[string]bool{}
        mut has_field := g.gen_struct_default_fields(typ.name, mut set_fields, false)
        mut sname := g.tc.qualify_name(typ.name)
        if typ.name in g.tc.structs {
            sname = typ.name
        }
        if sname in g.tc.structs {
            for f in g.tc.structs[sname] {
                if f.name in set_fields {
                    continue
                }
                if f.typ is types.Map {
                    if has_field {
                        g.write(', ')
                    }
                    g.write('.${c_name(f.name)} = ')
                    g.write_new_map(f.typ.key_type, f.typ.value_type)
                    has_field = true
                } else if f.typ is types.Array {
                    c_elem := g.tc.c_type(f.typ.elem_type)
                    if has_field {
                        g.write(', ')
                    }
                    g.write('.${c_name(f.name)} = array_new(sizeof(${c_elem}), 0, 0)')
                    has_field = true
                } else if g.field_needs_default_init(f.typ) {
                    if has_field {
                        g.write(', ')
                    }
                    g.write('.${c_name(f.name)} = ')
                    g.gen_default_value_for_type(f.typ)
                    has_field = true
                }
            }
        }
        g.write('}')
        return
    }
    ct := g.tc.c_type(typ)
    if g.is_scalar_c_type(ct) {
        g.write(g.scalar_zero_init(ct))
        return
    }
    g.write('(${ct}){0}')
}

fn (g &FlatGen) struct_field_value_is_plainly_incompatible(value_id flat.NodeId, field_type types.Type) bool {
    value_type := g.tc.resolve_type(value_id)
    if field_type is types.Primitive && value_type is types.Struct {
        return true
    }
    if field_type is types.Primitive && value_type is types.SumType {
        return true
    }
    return false
}

// field_needs_default_init reports whether an unset field of type `typ` must be
// explicitly default-initialized in a struct literal — i.e. it is a by-value
// struct whose type carries field defaults that C's `{0}` would not apply
// (e.g. `min_len int = 999999`).
fn (mut g FlatGen) field_needs_default_init(typ types.Type) bool {
    if typ is types.Struct && !typ.name.starts_with('C.') {
        return g.struct_has_field_defaults(typ.name)
    }
    return false
}

// struct_has_field_defaults reports whether building `type_name` as a struct
// literal would set any non-zero field: a field with an explicit default
// (`x int = 5`), or a by-value struct field whose own type has such defaults.
// Returns false for structs with interface/sum-typed field defaults, since the
// codegen default path cannot box those values.
fn (mut g FlatGen) struct_has_field_defaults(type_name string) bool {
    mut visited := map[string]bool{}
    return g.struct_has_field_defaults_inner(type_name, mut visited)
}

// struct_has_field_defaults_inner converts struct has field defaults inner data for c.
fn (mut g FlatGen) struct_has_field_defaults_inner(type_name string, mut visited map[string]bool) bool {
    if type_name in visited {
        return false
    }
    visited[type_name] = true
    info := g.find_struct_decl(type_name) or { return false }
    old_module := g.tc.cur_module
    g.tc.cur_module = info.module
    defer {
        g.tc.cur_module = old_module
    }
    mut found := false
    for i in 0 .. info.node.children_count {
        field := g.a.child_node(&info.node, i)
        if field.kind != .field_decl {
            continue
        }
        ftyp := g.tc.parse_type(field.typ)
        if field.children_count > 0 {
            // Defaults for interface/sum-typed fields require boxing the value into
            // the interface/sum representation, which the codegen default path cannot
            // do. Treat the whole struct as unsafe to default-emit (leave it
            // zero-initialized, as before) rather than emit an unboxed value.
            if ftyp is types.SumType || ftyp is types.Interface {
                return false
            }
            found = true
        }
        if ftyp is types.Struct && !ftyp.name.starts_with('C.') {
            if g.struct_has_field_defaults_inner(ftyp.name, mut visited) {
                found = true
            }
        }
    }
    return found
}

// gen_params_struct_arg emits a struct literal for a `@[params]` argument passed as
// trailing `key: value` call args (e.g. `atof64(s, allow_extra_chars: true)`).
// `node` is the call node; field_init children are read from `field_start` onward.
fn (mut g FlatGen) gen_params_struct_arg(typ types.Type, node flat.Node, field_start int) {
    raw_typ := typ
    if typ is types.Struct {
        ct := g.tc.c_type(raw_typ)
        g.write('(${ct}){')
        mut set_fields := map[string]bool{}
        mut has_field := false
        for i in field_start .. node.children_count {
            field := g.a.child_node(&node, i)
            if field.kind != .field_init || field.children_count == 0 {
                continue
            }
            if has_field {
                g.write(', ')
            }
            g.write('.${c_name(field.value)} = ')
            if ftyp := g.struct_field_type(typ.name, field.value) {
                g.gen_struct_field_expr_for_field(g.a.child(field, 0), typ.name, field.value, ftyp)
            } else {
                g.gen_expr(g.a.child(field, 0))
            }
            set_fields[field.value] = true
            has_field = true
        }
        mut sname := g.tc.qualify_name(typ.name)
        if typ.name in g.tc.structs {
            sname = typ.name
        }
        has_field = g.gen_struct_default_fields(typ.name, mut set_fields, has_field)
        if sname in g.tc.structs {
            for f in g.tc.structs[sname] {
                if f.name in set_fields {
                    continue
                }
                if f.typ is types.Map {
                    if has_field {
                        g.write(', ')
                    }
                    g.write('.${c_name(f.name)} = ')
                    g.write_new_map(f.typ.key_type, f.typ.value_type)
                    has_field = true
                } else if f.typ is types.Array {
                    c_elem := g.tc.c_type(f.typ.elem_type)
                    if has_field {
                        g.write(', ')
                    }
                    g.write('.${c_name(f.name)} = array_new(sizeof(${c_elem}), 0, 0)')
                    has_field = true
                } else if g.field_needs_default_init(f.typ) {
                    if has_field {
                        g.write(', ')
                    }
                    g.write('.${c_name(f.name)} = ')
                    g.gen_default_value_for_type(f.typ)
                    has_field = true
                }
            }
        }
        g.write('}')
        return
    }
    g.gen_default_value_for_type(typ)
}

// is_scalar_zero_init_type reports whether is scalar zero init type applies in c.
fn (g &FlatGen) is_scalar_zero_init_type(type_name string, c_type string) bool {
    if type_name in g.tc.structs || g.tc.qualify_name(type_name) in g.tc.structs {
        return false
    }
    if _ := g.find_struct_decl(type_name) {
        return false
    }
    return g.is_scalar_c_type(c_type)
}

// is_scalar_c_type reports whether is scalar c type applies in c.
fn (g &FlatGen) is_scalar_c_type(c_type string) bool {
    if c_type.ends_with('*') {
        return true
    }
    return c_type in ['bool', 'char', 'byte', 'u8', 'i8', 'u16', 'i16', 'u32', 'i32', 'u64', 'i64',
        'int', 'isize', 'usize', 'size_t', 'ptrdiff_t', 'float', 'double', 'voidptr']
}

// is_aggregate_zero_init_type reports whether is aggregate zero init type applies in c.
fn (g &FlatGen) is_aggregate_zero_init_type(typ types.Type, c_type string) bool {
    if g.is_scalar_c_type(c_type) {
        return false
    }
    return match typ {
        types.Alias {
            g.is_aggregate_zero_init_type(typ.base_type, c_type)
        }
        types.Array, types.ArrayFixed, types.Channel, types.Map, types.String, types.Struct,
        types.Interface, types.SumType, types.OptionType, types.ResultType, types.MultiReturn {
            true
        }
        else {
            false
        }
    }
}

// can_use_global_brace_zero_init reports whether can use global brace zero init applies in c.
fn (mut g FlatGen) can_use_global_brace_zero_init(typ types.Type, c_type string) bool {
    return g.is_aggregate_zero_init_type(typ, c_type) && !g.has_zero_sized_leading_init_slot(typ)
}

// has_zero_sized_leading_init_slot reports whether has zero sized leading init slot applies in c.
fn (mut g FlatGen) has_zero_sized_leading_init_slot(typ types.Type) bool {
    mut visited := map[string]bool{}
    return g.has_zero_sized_leading_init_slot_inner(typ, mut visited)
}

// has_zero_sized_leading_init_slot_inner reports has_zero_sized_leading_init_slot_inner logic in c.
fn (mut g FlatGen) has_zero_sized_leading_init_slot_inner(typ types.Type, mut visited map[string]bool) bool {
    return match typ {
        types.Alias {
            g.has_zero_sized_leading_init_slot_inner(typ.base_type, mut visited)
        }
        types.ArrayFixed {
            if g.fixed_array_len_is_zero(typ) {
                true
            } else {
                g.has_zero_sized_leading_init_slot_inner(typ.elem_type, mut visited)
            }
        }
        types.Struct {
            if info := g.find_struct_decl(typ.name) {
                if info.full_name in visited {
                    false
                } else {
                    visited[info.full_name] = true
                    old_module := g.tc.cur_module
                    g.tc.cur_module = info.module
                    first := g.struct_field_at(info.full_name, 0) or {
                        g.tc.cur_module = old_module
                        return false
                    }
                    has := g.has_zero_sized_leading_init_slot_inner(first.typ, mut visited)
                    g.tc.cur_module = old_module
                    has
                }
            } else {
                if typ.name in visited {
                    false
                } else {
                    visited[typ.name] = true
                    first := g.struct_field_at(typ.name, 0) or { return false }
                    g.has_zero_sized_leading_init_slot_inner(first.typ, mut visited)
                }
            }
        }
        else {
            false
        }
    }
}

// scalar_zero_init supports scalar zero init handling for FlatGen.
fn (g &FlatGen) scalar_zero_init(c_type string) string {
    if c_type in ['float', 'double'] {
        return '0.0'
    }
    return '0'
}

// StructDeclInfo stores struct decl info metadata used by c.
struct StructDeclInfo {
    node      flat.Node
    module    string
    full_name string
}

// struct_init_c_type_name supports struct init c type name handling for FlatGen.
// generic_struct_init_instance_ct returns the concrete-instance C type name for a
// bare generic struct literal whose type args are pinned by the surrounding expected
// type (e.g. `Vec4{..}` written where a `Vec4[f32]` is expected). Returns none when
// the literal is already specialized, the base is not a generic struct, or the
// expected type is not a matching concrete instance.
fn (g &FlatGen) generic_struct_init_instance_ct(type_name string) ?string {
    return g.tc.c_type(g.generic_struct_init_instance_type(type_name)?)
}

// generic_struct_init_instance_name is the concrete-instance V type name (`Box[int]`)
// for a bare generic struct literal, so field and default lookups use the materialized
// key under which the struct's fields are stored (the bare `Box` entry is removed by
// monomorphization), not just the emitted C type.
fn (g &FlatGen) generic_struct_init_instance_name(type_name string) ?string {
    return g.generic_struct_init_instance_type(type_name)?.name()
}

// generic_struct_init_instance_type resolves the concrete generic instance a bare literal
// adopts from the surrounding expected/return type (e.g. `Vec4{..}` -> `Vec4[f32]`).
// Returns none when the literal is already specialized, the base is not a generic struct,
// or the expected type is not a matching concrete instance.
fn (g &FlatGen) generic_struct_init_instance_type(type_name string) ?types.Type {
    if type_name.contains('[') {
        return none
    }
    short := type_name.all_after_last('.')
    // Prefer the explicit expected type; fall back to the enclosing function's return
    // type ONLY for a literal in return position (a bare generic literal there carries
    // no expected_expr_type) — otherwise a `Box{...}` in a local decl / argument whose
    // expected type is the bare `Box` would be wrongly materialised as `Box_int`. Only
    // adopt a candidate whose generic base matches the literal's base, so unrelated
    // expected types never rename the struct.
    //
    // Note: `tc.struct_generic_params` is empty by cgen time, so the candidate's
    // shape (a `Base[args]` instance whose base short-name equals the literal's) is
    // the sole evidence that this bare literal is a generic struct instantiation.
    mut candidates := [g.expected_expr_type]
    if g.in_return {
        candidates << g.cur_fn_ret
    }
    for cand in candidates {
        // Unwrap a pointer so a `&Box[int]` expected type still matches a bare `Box`
        // literal — the heap path (`&Box{..}`) needs the struct (`Box_int`), not the
        // pointer, type name.
        base_cand := types.unwrap_pointer(cand)
        // A fixed/dynamic array type is not a generic struct instance even though its
        // `.name()` renders like one (`[2]Foo` -> `Foo[2]`); skip it so a `Foo{..}` element
        // of a `[2]Foo` literal keeps its element type instead of adopting the array type.
        if base_cand is types.ArrayFixed || base_cand is types.Array {
            continue
        }
        cand_name := base_cand.name()
        if !cand_name.contains('[') {
            continue
        }
        cand_base := cand_name.all_before('[')
        if cand_base.len == 0 || cand_base.all_after_last('.') != short {
            continue
        }
        return base_cand
    }
    return none
}

fn (mut g FlatGen) struct_init_c_type_name(type_name string) string {
    typ := g.tc.parse_type(type_name)
    if typ is types.OptionType || typ is types.ResultType {
        return g.optional_type_name(typ)
    }
    info := g.find_struct_decl(type_name) or { return g.tc.c_type(g.tc.parse_type(type_name)) }
    if info.full_name.starts_with('C.') {
        return g.tc.c_type(g.tc.parse_type(info.full_name))
    }
    return c_name(info.full_name)
}

// find_struct_decl resolves find struct decl information for c.
fn (g &FlatGen) find_struct_decl(type_name string) ?StructDeclInfo {
    if info := g.find_struct_decl_preferred(type_name) {
        return info
    }
    if alias_target := g.struct_type_alias_target(type_name) {
        if info := g.find_struct_decl_preferred(alias_target) {
            return info
        }
        if info := g.find_struct_decl_fallback(alias_target) {
            return info
        }
    }
    return g.find_struct_decl_fallback(type_name)
}

fn (g &FlatGen) find_struct_decl_preferred(type_name string) ?StructDeclInfo {
    short_name := if type_name.contains('.') { type_name.all_after_last('.') } else { type_name }
    preferred_name := if !type_name.contains('.') && g.tc.cur_module.len > 0
        && g.tc.cur_module != 'main' && g.tc.cur_module != 'builtin' {
        '${g.tc.cur_module}.${type_name}'
    } else {
        type_name
    }
    if info := g.struct_decl_infos[preferred_name] {
        if info.node.value == short_name {
            return info
        }
    }
    if type_name.contains('.') {
        if info := g.struct_decl_infos[type_name] {
            return info
        }
    }
    return none
}

fn (g &FlatGen) find_struct_decl_fallback(type_name string) ?StructDeclInfo {
    if type_name.contains('.') {
        return none
    }
    if info := g.struct_decl_short_infos[type_name] {
        return info
    }
    return none
}

fn (g &FlatGen) struct_type_alias_target(type_name string) ?string {
    qname := g.tc.qualify_name(type_name)
    if target := g.tc.type_aliases[qname] {
        return target
    }
    if target := g.tc.type_aliases[type_name] {
        return target
    }
    return none
}

fn (g &FlatGen) struct_init_resolved_decl_name(type_name string) string {
    if info := g.find_struct_decl(type_name) {
        return info.full_name
    }
    qname := g.tc.qualify_name(type_name)
    if qname in g.tc.structs {
        return qname
    }
    return type_name
}

// struct_field_type supports struct field type handling for FlatGen.
fn (g &FlatGen) struct_field_type(type_name string, field_name string) ?types.Type {
    fields := g.struct_fields_for_type(type_name) or { return none }
    for f in fields {
        if f.name == field_name {
            return f.typ
        }
    }
    return none
}

fn (g &FlatGen) struct_field_c_abi_fn_ptr_type(type_name string, field_name string) ?string {
    if info := g.find_struct_decl(type_name) {
        if typ := g.tc.struct_field_c_abi_fn_ptr_type(info.full_name, field_name) {
            return typ
        }
    }
    if typ := g.tc.struct_field_c_abi_fn_ptr_type(type_name, field_name) {
        return typ
    }
    if !type_name.contains('.') {
        qname := g.tc.qualify_name(type_name)
        if qname != type_name {
            if typ := g.tc.struct_field_c_abi_fn_ptr_type(qname, field_name) {
                return typ
            }
        }
    }
    return none
}

// precompute_embedded_fields records, per struct type, only its embedded fields (those
// whose field name is the embedded type name). Most structs have none. Done once so the
// per-selector embedded-field resolution doesn't rescan (and re-c_name) every field of
// the receiver struct on every field access — a major cgen cost after #27538.
fn (mut g FlatGen) precompute_embedded_fields() {
    for type_name, fields in g.tc.structs {
        mut emb := []types.StructField{}
        for field in fields {
            if g.embedded_field_type_name(field).len > 0 {
                emb << field
            }
        }
        g.embedded_fields_by_type[type_name] = emb
    }
}

// struct_embedded_fields returns the embedded fields of a type (mirrors
// struct_fields_for_type's key resolution against the precomputed map). Returns an empty
// slice for non-embedding structs, which is the common case.
fn (g &FlatGen) struct_embedded_fields(type_name string) []types.StructField {
    if emb := g.embedded_fields_by_type[type_name] {
        return emb
    }
    qname := g.tc.qualify_name(type_name)
    if emb := g.embedded_fields_by_type[qname] {
        return emb
    }
    if info := g.find_struct_decl(type_name) {
        if emb := g.embedded_fields_by_type[info.full_name] {
            return emb
        }
    }
    if type_name.contains('.') {
        short_name := type_name.all_after_last('.')
        if emb := g.embedded_fields_by_type[short_name] {
            return emb
        }
    }
    return []
}

fn (g &FlatGen) struct_fields_for_type(type_name string) ?[]types.StructField {
    if info := g.find_struct_decl(type_name) {
        if fields := g.tc.structs[info.full_name] {
            return fields
        }
    }
    if type_name.contains('.') {
        if fields := g.tc.structs[type_name] {
            return fields
        }
    } else {
        qname := g.tc.qualify_name(type_name)
        if qname != type_name {
            if fields := g.tc.structs[qname] {
                return fields
            }
        }
    }
    if fields := g.tc.structs[type_name] {
        return fields
    }
    if type_name.contains('.') {
        short_name := type_name.all_after_last('.')
        if fields := g.tc.structs[short_name] {
            return fields
        }
    }
    return none
}

fn (g &FlatGen) embedded_field_type_name(field types.StructField) string {
    clean_type := types.unwrap_pointer(field.typ)
    field_type_name := clean_type.name()
    if field_type_name.len == 0 {
        return ''
    }
    mut names := [field_type_name]
    base_name := types.generic_base_name(field_type_name)
    if base_name != field_type_name {
        names << base_name
    }
    short_field := if field.name.contains('.') { field.name.all_after_last('.') } else { field.name }
    for name in names {
        short_type := if name.contains('.') { name.all_after_last('.') } else { name }
        if field.name == name || short_field == short_type || c_name(field.name) == c_name(name) {
            return field_type_name
        }
    }
    return ''
}

fn (g &FlatGen) direct_struct_field_exists(type_name string, field_name string) bool {
    fields := g.struct_fields_for_type(type_name) or { return false }
    for field in fields {
        if field.name == field_name {
            return true
        }
    }
    return false
}

fn (g &FlatGen) embedded_field_for_promoted_field(type_name string, field_name string) ?types.StructField {
    path := g.embedded_field_path_for_promoted_field(type_name, field_name) or { return none }
    if path.len == 0 {
        return none
    }
    return path[0]
}

fn (g &FlatGen) direct_embedded_field_for_selector(base_type types.Type, field_name string) ?types.StructField {
    type_name := g.type_lookup_name(base_type)
    if type_name.len == 0 {
        return none
    }
    // Only the embedded fields (precomputed) can match — no need to scan every field.
    for field in g.struct_embedded_fields(type_name) {
        embedded_type_name := g.embedded_field_type_name(field)
        if embedded_type_name.len == 0 {
            continue
        }
        short_type := if embedded_type_name.contains('.') {
            embedded_type_name.all_after_last('.')
        } else {
            embedded_type_name
        }
        if field_name == embedded_type_name || field_name == short_type
            || c_name(field_name) == c_name(embedded_type_name) {
            return field
        }
    }
    return none
}

fn (g &FlatGen) embedded_field_path_for_promoted_field(type_name string, field_name string) ?[]types.StructField {
    for field in g.struct_embedded_fields(type_name) {
        embedded_type_name := g.embedded_field_type_name(field)
        if embedded_type_name.len == 0 {
            continue
        }
        if g.direct_struct_field_exists(embedded_type_name, field_name) {
            return [field]
        }
        if nested := g.embedded_field_path_for_promoted_field(embedded_type_name, field_name) {
            mut path := [field]
            path << nested
            return path
        }
    }
    return none
}

fn (g &FlatGen) embedded_field_path_for_promoted_selector(base_type types.Type, field_name string) ?[]types.StructField {
    type_name := g.type_lookup_name(base_type)
    if type_name.len == 0 {
        return none
    }
    return g.embedded_field_path_for_promoted_field(type_name, field_name)
}

fn (g &FlatGen) embedded_field_for_promoted_selector(base_type types.Type, field_name string) ?types.StructField {
    type_name := g.type_lookup_name(base_type)
    if type_name.len == 0 {
        return none
    }
    return g.embedded_field_for_promoted_field(type_name, field_name)
}

fn (g &FlatGen) type_lookup_name(typ types.Type) string {
    clean_type := types.unwrap_pointer(typ)
    if clean_type is types.Alias {
        return clean_type.base_type.name()
    }
    return clean_type.name()
}

// struct_field_at supports struct field at handling for FlatGen.
fn (g &FlatGen) struct_field_at(type_name string, index int) ?types.StructField {
    if index < 0 {
        return none
    }
    fields := g.struct_fields_for_type(type_name) or { return none }
    if index < fields.len {
        return fields[index]
    }
    return none
}

// struct_field_type_at supports struct field type at handling for FlatGen.
fn (g &FlatGen) struct_field_type_at(type_name string, index int) ?types.Type {
    if field := g.struct_field_at(type_name, index) {
        return field.typ
    }
    return none
}

// gen_return_assoc emits return assoc output for c.
fn (mut g FlatGen) gen_return_assoc(node flat.Node) {
    tmp := g.tmp_name()
    g.gen_assoc_return_tmp(node, tmp)
    g.writeln('return ${tmp};')
}

fn (mut g FlatGen) gen_assoc_return_tmp(node flat.Node, tmp string) {
    ct := g.tc.c_type(g.tc.parse_type(node.value))
    g.write('${ct} ${tmp} = ')
    g.gen_expr(g.a.child(&node, 0))
    g.writeln(';')
    for i in 1 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.kind == .field_init && field.children_count > 0 {
            g.write('${tmp}.${c_name(field.value)} = ')
            if ftyp := g.struct_field_type(node.value, field.value) {
                g.gen_struct_field_expr_for_field(g.a.child(field, 0), node.value, field.value,
                    ftyp)
            } else {
                g.gen_expr(g.a.child(field, 0))
            }
            g.writeln(';')
        }
    }
}

// gen_assoc_expr emits assoc expr output for c.
fn (mut g FlatGen) gen_assoc_expr(node flat.Node) {
    ct := g.tc.c_type(g.tc.parse_type(node.value))
    tmp := g.tmp_name()
    g.write('({${ct} ${tmp} = ')
    g.gen_expr(g.a.child(&node, 0))
    g.write(';')
    for i in 1 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.kind == .field_init && field.children_count > 0 {
            g.write(' ${tmp}.${c_name(field.value)} = ')
            if ftyp := g.struct_field_type(node.value, field.value) {
                g.gen_struct_field_expr_for_field(g.a.child(field, 0), node.value, field.value,
                    ftyp)
            } else {
                g.gen_expr(g.a.child(field, 0))
            }
            g.write(';')
        }
    }
    g.write(' ${tmp};})')
}

// gen_heap_assoc_expr emits heap assoc expr output for c.
fn (mut g FlatGen) gen_heap_assoc_expr(node flat.Node) {
    ct := g.tc.c_type(g.tc.parse_type(node.value))
    tmp := g.tmp_name()
    g.write('({${ct} ${tmp} = ')
    g.gen_expr(g.a.child(&node, 0))
    g.write(';')
    for i in 1 .. node.children_count {
        field := g.a.child_node(&node, i)
        if field.kind == .field_init && field.children_count > 0 {
            g.write(' ${tmp}.${c_name(field.value)} = ')
            if ftyp := g.struct_field_type(node.value, field.value) {
                g.gen_struct_field_expr_for_field(g.a.child(field, 0), node.value, field.value,
                    ftyp)
            } else {
                g.gen_expr(g.a.child(field, 0))
            }
            g.write(';')
        }
    }
    g.write(' (${ct}*)memdup(&${tmp}, sizeof(${ct}));})')
}

// gen_map_init emits map init output for c.
fn (mut g FlatGen) gen_map_init(id flat.NodeId, node flat.Node) {
    if node.value.len > 0 {
        map_type := g.tc.parse_type(node.value)
        if map_type is types.Map {
            g.write_new_map(map_type.key_type, map_type.value_type)
            return
        }
    }
    if node.typ.len > 0 {
        map_type := g.tc.parse_type(node.typ)
        if map_type is types.Map {
            g.write_new_map(map_type.key_type, map_type.value_type)
            return
        }
    }
    if g.expected_expr_type is types.Map {
        g.write_new_map(g.expected_expr_type.key_type, g.expected_expr_type.value_type)
        return
    }
    resolved_type := g.tc.resolve_type(id)
    if resolved_type is types.Map {
        g.write_new_map(resolved_type.key_type, resolved_type.value_type)
        return
    }
    g.write('new_map(sizeof(int), sizeof(int), 0, 0, 0, 0)')
}

// write_new_map writes new map output for c.
fn (mut g FlatGen) write_new_map(key_type types.Type, value_type types.Type) {
    mut c_key := g.tc.c_type(key_type)
    mut c_val := g.tc.c_type(value_type)
    if c_key.starts_with('fn_ptr:') {
        c_key = g.resolve_fn_ptr_type(c_key)
    }
    if c_val.starts_with('fn_ptr:') {
        c_val = g.resolve_fn_ptr_type(c_val)
    }
    hash_fn, eq_fn, clone_fn, free_fn := g.map_callback_names(key_type)
    g.write('new_map(sizeof(${c_key}), sizeof(${c_val}), ${hash_fn}, ${eq_fn}, ${clone_fn}, ${free_fn})')
}

// map_callback_names supports map callback names handling for FlatGen.
fn (g &FlatGen) map_callback_names(key_type types.Type) (string, string, string, string) {
    if key_type is types.String {
        return 'map_hash_string', 'map_eq_string', 'map_clone_string', 'map_free_string'
    }
    c_key := g.tc.c_type(key_type)
    size_suffix := match c_key {
        'u8', 'i8', 'bool', 'char' { '1' }
        'u16', 'i16' { '2' }
        'i64', 'u64', 'isize', 'usize', 'voidptr' { '8' }
        else { '4' }
    }

    return 'map_hash_int_${size_suffix}', 'map_eq_int_${size_suffix}', 'map_clone_int_${size_suffix}', 'map_free_nop'
}

// skip_builtin_struct supports skip builtin struct handling for FlatGen.
fn (g &FlatGen) skip_builtin_struct(name string) bool {
    _ = g
    if name.starts_with('C.') {
        return true
    }
    return false
}

// emit_interface_struct emits emit interface struct output for c.
fn (mut g FlatGen) emit_interface_struct(name string) {
    cn := c_name(name)
    g.writeln('struct ${cn} {')
    g.writeln('\tint _typ;')
    if cn == 'IError' {
        g.writeln('\tvoid* _object;')
        g.writeln('\tstring message;')
        g.writeln('\tint code;')
    } else {
        // pointer to the boxed concrete value, used by method dispatch
        g.writeln('\tvoid* _object;')
    }
    for field in g.tc.interface_fields[name] or { []types.StructField{} } {
        ct := g.tc.c_type(field.typ)
        g.writeln('\t${ct} ${c_name(field.name)};')
    }
    g.writeln('};')
    g.writeln('')
}

// struct_decls supports struct decls handling for FlatGen.
fn (mut g FlatGen) struct_decls() {
    // Fixed-array typedefs whose element is a struct are emitted interleaved with the
    // structs below (right after the element struct is defined), so struct fields that
    // reference them resolve. Primitive-element ones were already emitted earlier.
    fixed_array_needed := g.collect_fixed_array_typedefs_needed()
    for name, _ in g.tc.structs {
        if g.skip_builtin_struct(name) {
            continue
        }
        tag := if name in g.tc.unions { 'union' } else { 'struct' }
        g.writeln('typedef ${tag} ${c_name(name)} ${c_name(name)};')
    }
    for name, variants in g.tc.sum_types {
        g.writeln('typedef struct ${c_name(name)} ${c_name(name)};')
        _ = variants
    }
    for name, _ in g.interfaces {
        g.writeln('typedef struct ${c_name(name)} ${c_name(name)};')
    }
    if g.has_builtins {
        g.writeln('typedef array Array;')
    }
    mut emitted := map[string]bool{}
    mut remaining := map[string]bool{}
    mut remaining_cnames := map[string]bool{}
    mut iface_remaining := map[string]bool{}
    for name, _ in g.interfaces {
        iface_remaining[name] = true
        remaining_cnames[c_name(name)] = true
    }
    for name, _ in g.tc.structs {
        if g.skip_builtin_struct(name) {
            continue
        }
        remaining[name] = true
        remaining_cnames[c_name(name)] = true
    }
    mut sum_remaining := map[string]bool{}
    for name, _ in g.tc.sum_types {
        sum_remaining[name] = true
        remaining_cnames[c_name(name)] = true
    }
    if 'string' in remaining {
        g.emit_struct('string')
        emitted['string'] = true
        remaining.delete('string')
        remaining_cnames.delete('string')
    }
    mut has_ierror := false
    for name, _ in iface_remaining {
        if c_name(name) == 'IError' {
            g.emit_interface_struct(name)
            emitted['IError'] = true
            iface_remaining.delete(name)
            remaining_cnames.delete('IError')
            has_ierror = true
            break
        }
    }
    err_field := if has_ierror { 'IError err; ' } else { '' }
    g.writeln('typedef struct Optional { bool ok; ${err_field}int value; } Optional;')
    g.writeln('')
    if g.has_builtins && 'array' in remaining {
        g.emit_struct('array')
        emitted['array'] = true
        emitted['Array'] = true
        remaining.delete('array')
        remaining_cnames.delete('array')
    }
    for _ in 0 .. 30 {
        if remaining.len == 0 && iface_remaining.len == 0 && sum_remaining.len == 0 {
            break
        }
        mut progress := false
        mut emitted_ifaces := []string{}
        for name, _ in iface_remaining {
            cn := c_name(name)
            mut can_emit := true
            if cn == 'IError' {
                if 'string' !in emitted && 'string' in remaining_cnames {
                    can_emit = false
                }
            }
            // An interface struct embeds its declared data fields by value, so the
            // field types must be fully defined first (same constraint as structs).
            for field in g.tc.interface_fields[name] or { []types.StructField{} } {
                if field.typ is types.Pointer {
                    continue
                }
                fct := g.tc.c_type(field.typ)
                if fct !in emitted && fct != cn && fct in remaining_cnames {
                    can_emit = false
                    break
                }
            }
            if can_emit {
                g.emit_interface_struct(name)
                emitted[cn] = true
                remaining_cnames.delete(cn)
                emitted_ifaces << name
                progress = true
            }
        }
        for name in emitted_ifaces {
            iface_remaining.delete(name)
        }
        mut emitted_structs := []string{}
        for name, _ in remaining {
            cn := c_name(name)
            if cn in emitted {
                remaining_cnames.delete(cn)
                emitted_structs << name
                progress = true
                continue
            }
            mut can_emit := true
            if name in g.tc.structs {
                for f in g.tc.structs[name] {
                    if f.typ is types.Pointer {
                        continue
                    }
                    mut ct := ''
                    if f.typ is types.ArrayFixed {
                        ct = g.tc.c_type(f.typ.elem_type)
                    } else if f.typ is types.OptionType {
                        ct = g.tc.c_type(f.typ.base_type)
                    } else if f.typ is types.ResultType {
                        ct = g.tc.c_type(f.typ.base_type)
                    } else {
                        ct = g.tc.c_type(f.typ)
                    }
                    if ct !in emitted && ct != cn && ct in remaining_cnames {
                        can_emit = false
                        break
                    }
                }
            }
            if can_emit {
                if fields := g.tc.structs[name] {
                    g.emit_struct_option_typedefs(fields)
                }
                g.emit_struct(name)
                emitted[cn] = true
                g.emit_ready_fixed_array_typedefs(fixed_array_needed, emitted)
                remaining_cnames.delete(cn)
                emitted_structs << name
                progress = true
            }
        }
        for name in emitted_structs {
            remaining.delete(name)
        }
        mut emitted_sums := []string{}
        for name, _ in sum_remaining {
            cn := c_name(name)
            mut can_emit_sum := true
            if name in g.tc.sum_types {
                for v in g.tc.sum_types[name] {
                    if g.variant_references_sum(v, name) {
                        continue
                    }
                    vt := g.tc.parse_type(v)
                    if vt is types.SumType {
                        if vt.name in sum_remaining {
                            can_emit_sum = false
                            break
                        }
                    }
                    vct := g.tc.c_type(vt)
                    if vct !in emitted && vct in remaining_cnames {
                        can_emit_sum = false
                        break
                    }
                }
            }
            if can_emit_sum {
                g.emit_sum_type(name)
                emitted[cn] = true
                remaining_cnames.delete(cn)
                emitted_sums << name
                progress = true
            }
        }
        for name in emitted_sums {
            sum_remaining.delete(name)
        }
        if !progress {
            break
        }
    }
    for name, _ in iface_remaining {
        cn := c_name(name)
        g.emit_interface_struct(name)
        emitted[cn] = true
    }
    for name, _ in sum_remaining {
        g.emit_sum_type(name)
    }
    for name, _ in remaining {
        if fields := g.tc.structs[name] {
            g.emit_struct_option_typedefs(fields)
        }
        g.emit_struct(name)
    }
}

// type_forward_decls returns type forward decls data for FlatGen.
fn (mut g FlatGen) type_forward_decls() {
    for name, _ in g.tc.structs {
        if g.skip_builtin_struct(name) {
            continue
        }
        tag := if name in g.tc.unions { 'union' } else { 'struct' }
        g.writeln('typedef ${tag} ${c_name(name)} ${c_name(name)};')
    }
    for name, _ in g.tc.sum_types {
        g.writeln('typedef struct ${c_name(name)} ${c_name(name)};')
    }
    for name, _ in g.interfaces {
        g.writeln('typedef struct ${c_name(name)} ${c_name(name)};')
    }
    if g.has_builtins {
        g.writeln('typedef array Array;')
    }
    g.writeln('')
}

// emit_struct emits emit struct output for c.
fn (mut g FlatGen) emit_struct(name string) {
    old_module := g.tc.cur_module
    g.tc.cur_module = module_from_qualified_name(name)
    if name in g.tc.structs {
        fields := g.tc.structs[name]
        tag := if name in g.tc.unions { 'union' } else { 'struct' }
        g.writeln('${tag} ${c_name(name)} {')
        if fields.len == 0 {
            g.writeln('\tint _dummy;')
        }
        for f in fields {
            g.write_struct_field(name, f)
        }
        g.writeln('};')
        g.writeln('')
    }
    g.tc.cur_module = old_module
}

// is_generic_struct reports whether is generic struct applies in c.
fn (g &FlatGen) is_generic_struct(name string) bool {
    if info := g.struct_decl_infos[name] {
        return info.node.typ.contains('generic')
    }
    short_name := if name.contains('.') { name.all_after_last('.') } else { name }
    if info := g.struct_decl_short_infos[short_name] {
        return info.full_name == name && info.node.typ.contains('generic')
    }
    return false
}

// write_struct_field writes struct field output for c.
fn (mut g FlatGen) write_struct_field(_struct_name string, f types.StructField) {
    if f.typ is types.Void {
        g.writeln('\tint ${c_name(f.name)};')
        return
    }
    mut field_type := f.typ
    if f.typ is types.Alias {
        field_type = f.typ.base_type
    }
    raw_field_type := field_type
    if field_type is types.FnType {
        c_abi_fn := g.struct_field_c_abi_fn_ptr_type(_struct_name, f.name) or {
            g.tc.c_type(raw_field_type)
        }
        ct := g.resolve_fn_ptr_type(c_abi_fn)
        g.writeln('\t${ct} ${c_name(f.name)};')
    } else if f.typ is types.ArrayFixed {
        c_elem, dims := g.fixed_array_decl_parts(f.typ)
        g.writeln('\t${c_elem} ${c_name(f.name)}${dims};')
    } else {
        mut ct := if f.typ is types.OptionType || f.typ is types.ResultType {
            g.optional_type_name(f.typ)
        } else {
            g.tc.c_type(f.typ)
        }
        if ct.starts_with('fn_ptr:') {
            ct = g.resolve_fn_ptr_type(ct)
        }
        if ct == 'void' {
            ct = 'int'
        }
        g.writeln('\t${ct} ${c_name(f.name)};')
    }
}

// preseed_struct_fn_ptr_types supports preseed struct fn ptr types handling for FlatGen.
fn (mut g FlatGen) preseed_struct_fn_ptr_types() {
    for struct_name, fields in g.tc.structs {
        for f in fields {
            if c_abi_fn := g.struct_field_c_abi_fn_ptr_type(struct_name, f.name) {
                g.resolve_fn_ptr_type(c_abi_fn)
                continue
            }
            g.preseed_fn_ptr_type(f.typ)
        }
    }
}

fn (mut g FlatGen) preseed_global_fn_ptr_types() {
    for _, typ in g.global_types {
        g.preseed_fn_ptr_type(typ)
    }
}

fn (mut g FlatGen) preseed_fn_ptr_type(typ types.Type) {
    if typ is types.Alias {
        g.preseed_fn_ptr_type(typ.base_type)
        return
    }
    if typ is types.FnType {
        ct := g.tc.c_type(typ)
        g.resolve_fn_ptr_type(ct)
        for param in typ.params {
            g.preseed_fn_ptr_type(param)
        }
        g.preseed_fn_ptr_type(typ.return_type)
        return
    }
    if typ is types.Array {
        g.preseed_fn_ptr_type(typ.elem_type)
        return
    }
    if typ is types.ArrayFixed {
        g.preseed_fn_ptr_type(typ.elem_type)
        return
    }
    if typ is types.Map {
        g.preseed_fn_ptr_type(typ.key_type)
        g.preseed_fn_ptr_type(typ.value_type)
        return
    }
    if typ is types.Pointer {
        g.preseed_fn_ptr_type(typ.base_type)
        return
    }
    if typ is types.OptionType {
        g.optional_type_name(typ)
        g.preseed_fn_ptr_type(typ.base_type)
        return
    }
    if typ is types.ResultType {
        g.optional_type_name(typ)
        g.preseed_fn_ptr_type(typ.base_type)
        return
    }
    if typ is types.MultiReturn {
        for item in typ.types {
            g.preseed_fn_ptr_type(item)
        }
    }
}

// emit_struct_option_typedefs emits emit struct option typedefs output for c.
fn (mut g FlatGen) emit_struct_option_typedefs(fields []types.StructField) {
    mut wrote := false
    for f in fields {
        if f.typ is types.OptionType || f.typ is types.ResultType {
            opt_name := g.optional_type_name(f.typ)
            if opt_name == 'Optional' {
                continue
            }
            if val_type := g.needed_optional_types[opt_name] {
                if g.emit_optional_typedef(opt_name, val_type) {
                    wrote = true
                }
            }
        }
    }
    if wrote {
        g.writeln('')
    }
}