// 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 strings
import v.ast

fn array_init_orig_expr(expr ast.Expr) ast.Expr {
    return match expr {
        ast.CTempVar { expr.orig }
        else { expr }
    }
}

fn (g &Gen) can_keep_array_init_expr_inline(expr ast.Expr) bool {
    return match expr {
        ast.BoolLiteral, ast.CharLiteral, ast.EnumVal, ast.FloatLiteral, ast.IntegerLiteral,
        ast.None, ast.OffsetOf, ast.SizeOf, ast.StringLiteral, ast.TypeNode {
            true
        }
        ast.Ident {
            expr.or_expr.kind == .absent
        }
        ast.ParExpr {
            g.can_keep_array_init_expr_inline(expr.expr)
        }
        ast.SelectorExpr {
            expr.or_block.kind == .absent && g.can_keep_array_init_expr_inline(expr.expr)
        }
        else {
            false
        }
    }
}

fn (mut g Gen) array_init_expr_needs_gc_root(expr ast.Expr, expr_type ast.Type) bool {
    if g.pref.gc_mode !in [.boehm_full, .boehm_incr, .boehm_full_opt, .boehm_incr_opt] {
        return false
    }
    if g.inside_const || g.inside_global_decl || g.inside_cinit {
        return false
    }
    if expr is ast.CTempVar || g.can_keep_array_init_expr_inline(expr) || expr.is_lvalue() {
        return false
    }
    resolved_expr_type := g.unwrap_generic(g.recheck_concrete_type(expr_type))
    return resolved_expr_type != 0 && g.contains_ptr(resolved_expr_type)
}

fn (mut g Gen) prepare_array_init_exprs(exprs []ast.Expr, expr_types []ast.Type, default_type ast.Type) []ast.Expr {
    mut needs_order_preserved := false
    for i, expr in exprs {
        expr_type := if expr_types.len > i && expr_types[i] != 0 {
            expr_types[i]
        } else {
            default_type
        }
        if g.need_tmp_var_in_expr(expr) || g.array_init_expr_needs_gc_root(expr, expr_type) {
            needs_order_preserved = true
            break
        }
    }
    if !needs_order_preserved {
        return exprs
    }
    stmt_str := if g.inside_ternary > 0 {
        g.go_before_ternary().trim_space()
    } else {
        g.go_before_last_stmt().trim_space()
    }
    g.empty_line = true
    mut prepared := []ast.Expr{cap: exprs.len}
    for i, expr in exprs {
        expr_type := if expr_types.len > i && expr_types[i] != 0 {
            expr_types[i]
        } else {
            default_type
        }
        if g.can_keep_array_init_expr_inline(expr)
            && !g.array_init_expr_needs_gc_root(expr, expr_type) {
            prepared << expr
            continue
        }
        mut tmp := g.new_ctemp_var(expr, expr_type)
        g.gen_ctemp_var(mut tmp)
        prepared << ast.Expr(tmp)
    }
    if stmt_str.ends_with('return') {
        g.write(stmt_str)
        g.write(' ')
    } else {
        g.write(stmt_str)
    }
    return prepared
}

fn (mut g Gen) array_init(node ast.ArrayInit, var_name string) {
    base_array_typ := if node.generic_typ != 0 { node.generic_typ } else { node.typ }
    base_elem_typ := if node.generic_elem_type != 0 {
        node.generic_elem_type
    } else {
        node.elem_type
    }
    mut array_type := g.unwrap(g.recheck_concrete_type(base_array_typ))
    mut array_styp := ''
    elem_type := g.unwrap(g.recheck_concrete_type(base_elem_typ))
    mut expr_types := node.expr_types.clone()
    mut shared_styp := '' // only needed for shared &[]{...}
    is_amp := g.is_amp
    g.is_amp = false
    if is_amp {
        g.go_back(1) // delete the `&` already generated in `prefix_expr()
    }
    if g.is_shared {
        shared_styp = g.styp(array_type.typ.set_flag(.shared_f))
        g.writeln('(${shared_styp}*)__dup_shared_array(&(${shared_styp}){.mtx = {0}, .val =')
    } else if is_amp {
        array_styp = g.styp(array_type.typ)
        if node.is_fixed && !g.inside_global_decl {
            line := g.go_before_last_stmt()
            tmp_var := g.new_tmp_var()
            g.write('${array_styp} ${tmp_var} = ')
            g.fixed_array_init(node, array_type, var_name, is_amp)
            g.writeln(';')
            g.write(line)

            g.write('builtin__memdup((void*)&${tmp_var}, sizeof(${array_styp}))')
        } else {
            g.write('HEAP(${array_styp}, ')
        }
    }
    len := node.exprs.len
    mut resolved_elem_type := elem_type
    if g.cur_concrete_types.len > 0 && len > 0 && !node.is_fixed {
        expr_types = []ast.Type{cap: len}
        mut inferred_elem_type := ast.void_type
        for expr in node.exprs {
            default_expr_type := if inferred_elem_type != ast.void_type {
                inferred_elem_type
            } else {
                base_elem_typ
            }
            mut resolved_expr_type := ast.void_type
            if expr is ast.Ident {
                resolved_expr_type = g.resolved_scope_var_type(expr)
            }
            if resolved_expr_type == ast.void_type {
                resolved_expr_type = g.unwrap_generic(g.recheck_concrete_type(g.resolved_expr_type(expr,
                    default_expr_type)))
            }
            expr_types << resolved_expr_type
            if inferred_elem_type == ast.void_type && resolved_expr_type != 0 {
                inferred_elem_type = if expr.is_auto_deref_var() && resolved_expr_type.is_ptr() {
                    ast.mktyp(resolved_expr_type.deref())
                } else {
                    ast.mktyp(resolved_expr_type)
                }
            }
        }
        if inferred_elem_type != ast.void_type {
            resolved_elem_type = g.unwrap(inferred_elem_type)
        }
    }
    if g.cur_concrete_types.len > 0 && array_type.unaliased_sym.kind == .array
        && resolved_elem_type.typ != 0 {
        current_elem_type :=
            g.unwrap_generic(g.recheck_concrete_type(g.table.value_type(array_type.typ)))
        if current_elem_type != resolved_elem_type.typ {
            resolved_array_type := g.table.find_or_register_array(resolved_elem_type.typ)
            array_type = g.unwrap(resolved_array_type)
            if g.is_shared {
                shared_styp = g.styp(array_type.typ.set_flag(.shared_f))
            } else if is_amp {
                array_styp = g.styp(array_type.typ)
            }
        }
    }
    $if trace_ci_fixes ? {
        if g.cur_fn != unsafe { nil } && g.cur_fn.name == 'arrays.group_by' && len > 0 {
            eprintln('cgen array ${g.cur_fn.name} elem=${g.table.type_to_str(resolved_elem_type.typ)} exprs=${expr_types.map(g.table.type_to_str(it))} cur=${g.cur_concrete_types.map(g.table.type_to_str(it))}')
        }
    }
    elem_sym := g.table.sym(g.unwrap_generic(resolved_elem_type.typ))
    if node.is_fixed || array_type.unaliased_sym.kind == .array_fixed {
        if !(is_amp && !g.inside_global_decl) {
            g.fixed_array_init(node, array_type, var_name, is_amp)
            if is_amp {
                g.write(')')
            }
        }
    } else if len == 0 {
        // `[]int{len: 6, cap:10, init:22}`
        g.array_init_with_fields(node, elem_type, is_amp, shared_styp, var_name)
    } else {
        // `[1, 2, 3]`
        elem_styp := g.styp(resolved_elem_type.typ)
        noscan := g.check_noscan(resolved_elem_type.typ)
        prepared_exprs := g.prepare_array_init_exprs(node.exprs, expr_types, resolved_elem_type.typ)
        if resolved_elem_type.unaliased_sym.kind == .function {
            g.write('builtin__new_array_from_c_array(${len}, ${len}, sizeof(voidptr), _MOV((voidptr[${len}]){')
        } else {
            g.write('builtin__new_array_from_c_array${noscan}(${len}, ${len}, sizeof(${elem_styp}), _MOV((${elem_styp}[${len}]){')
        }
        if len > 8 {
            g.writeln('')
            g.write('\t\t')
        }
        is_iface_or_sumtype := elem_sym.kind in [.sum_type, .interface]
        for i, expr in prepared_exprs {
            actual_expr := array_init_orig_expr(expr)
            expr_type := if expr_types.len > i { expr_types[i] } else { resolved_elem_type.typ }
            if expr_type == ast.string_type
                && actual_expr !in [ast.IndexExpr, ast.CallExpr, ast.StringLiteral, ast.StringInterLiteral, ast.InfixExpr] {
                if is_iface_or_sumtype {
                    g.expr_with_cast(expr, expr_type, resolved_elem_type.typ)
                } else {
                    g.write('builtin__string_clone(')
                    g.expr(expr)
                    g.write(')')
                }
            } else {
                if resolved_elem_type.typ.has_flag(.option) {
                    g.expr_with_opt(expr, expr_type, resolved_elem_type.typ)
                } else if resolved_elem_type.unaliased_sym.kind == .array_fixed
                    && (expr is ast.CTempVar
                    || actual_expr in [ast.Ident, ast.SelectorExpr, ast.CallExpr]) {
                    info := resolved_elem_type.unaliased_sym.info as ast.ArrayFixed
                    g.fixed_array_var_init(g.expr_string(expr), expr.is_auto_deref_var(),
                        info.elem_type, info.size)
                } else {
                    g.expr_with_cast(expr, expr_type, resolved_elem_type.typ)
                }
            }
            if i != len - 1 {
                if i > 0 && i & 7 == 0 { // i > 0 && i % 8 == 0
                    g.writeln(',')
                    g.write('\t\t')
                } else {
                    g.write(', ')
                }
            }
        }
        g.write('}))')
        if g.is_shared {
            g.write('}, sizeof(${shared_styp}))')
        } else if is_amp {
            g.write(')')
        }
    }
}

fn (mut g Gen) normalized_array_interface_cast_type(typ ast.Type) ast.Type {
    return g.table.unaliased_type(g.unwrap_generic(typ)).clear_flags(.generic, .variadic)
}

fn (mut g Gen) can_convert_array_to_interface_array(got_type ast.Type, expected_type ast.Type) bool {
    if got_type.is_ptr() || expected_type.is_ptr() || got_type.has_option_or_result()
        || expected_type.has_option_or_result() {
        return false
    }
    got := g.normalized_array_interface_cast_type(got_type)
    expected := g.normalized_array_interface_cast_type(expected_type)
    if got == expected {
        return false
    }
    if g.table.final_sym(got).kind != .array || g.table.final_sym(expected).kind != .array {
        return false
    }
    return g.can_convert_array_elem_to_interface_array(got, expected)
}

fn (mut g Gen) can_convert_array_elem_to_interface_array(got ast.Type, expected ast.Type) bool {
    got_type := g.normalized_array_interface_cast_type(got)
    expected_type := g.normalized_array_interface_cast_type(expected)
    got_sym := g.table.final_sym(got_type)
    expected_sym := g.table.final_sym(expected_type)
    if got_sym.kind == .array && expected_sym.kind == .array {
        return g.can_convert_array_elem_to_interface_array(got_sym.array_info().elem_type,
            expected_sym.array_info().elem_type)
    }
    return !expected_type.is_ptr() && expected_sym.kind == .interface
        && g.table.does_type_implement_interface(got_type, expected_type)
}

fn (mut g Gen) register_array_interface_cast_fn(got_type ast.Type, expected_type ast.Type) string {
    got := g.normalized_array_interface_cast_type(got_type)
    expected := g.normalized_array_interface_cast_type(expected_type)
    fn_name := '__v_array_to_interface_array__${g.styp(got)}__to__${g.styp(expected)}'
    mut already_generated := false
    lock g.generated_array_interface_cast_fns {
        already_generated = fn_name in g.generated_array_interface_cast_fns
        if !already_generated {
            g.generated_array_interface_cast_fns[fn_name] = true
        }
    }
    if already_generated {
        return fn_name
    }
    got_info := g.table.final_sym(got).array_info()
    expected_info := g.table.final_sym(expected).array_info()
    expected_styp := g.styp(expected)
    expected_elem_styp := g.styp(expected_info.elem_type)
    noscan := g.check_noscan(expected_info.elem_type)
    g.definitions.writeln('${g.static_non_parallel}${expected_styp} ${fn_name}(${g.styp(got)} a);')
    mut fn_builder := strings.new_builder(512)
    fn_builder.writeln('${g.static_non_parallel}inline ${expected_styp} ${fn_name}(${g.styp(got)} a) {')
    fn_builder.writeln('\t${expected_styp} res = builtin____new_array_with_default${noscan}(a.len, a.cap, sizeof(${expected_elem_styp}), 0);')
    fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < a.len; ++i) {')
    src_elem_expr := '((${g.styp(got_info.elem_type)}*)a.data)[i]'
    converted_expr := g.array_interface_cast_expr(src_elem_expr, got_info.elem_type,
        expected_info.elem_type)
    fn_builder.writeln('\t\t((${expected_elem_styp}*)res.data)[i] = ${converted_expr};')
    fn_builder.writeln('\t}')
    fn_builder.writeln('\treturn res;')
    fn_builder.writeln('}')
    g.auto_fn_definitions << fn_builder.str()
    return fn_name
}

fn (mut g Gen) array_interface_cast_expr(src_elem_expr string, got_type ast.Type, expected_type ast.Type) string {
    got := g.normalized_array_interface_cast_type(got_type)
    expected := g.normalized_array_interface_cast_type(expected_type)
    if got == expected {
        return src_elem_expr
    }
    got_sym := g.table.final_sym(got)
    expected_sym := g.table.final_sym(expected)
    if got_sym.kind == .array && expected_sym.kind == .array {
        inner_fn := g.register_array_interface_cast_fn(got, expected)
        return '${inner_fn}(${src_elem_expr})'
    }
    if expected_sym.kind == .interface && !expected.is_ptr() {
        concrete_got := g.concrete_interface_cast_type(got)
        got_styp := g.cc_type(concrete_got, true)
        mut cast_fn := 'I_${got_styp}_to_Interface_${expected_sym.cname}'
        if expected_sym.info is ast.Interface && expected_sym.info.is_generic {
            cast_fn = g.generic_fn_name(expected_sym.info.concrete_types, cast_fn)
        }
        lock g.referenced_fns {
            g.referenced_fns[cast_fn] = true
        }
        if concrete_got.is_ptr() {
            return '${cast_fn}(${src_elem_expr})'
        }
        return '${cast_fn}(HEAP(${got_styp}, ${src_elem_expr}))'
    }
    return src_elem_expr
}

fn (mut g Gen) interface_clone_fn_name(interface_type ast.Type) string {
    interface_sym := g.table.final_sym(g.table.unaliased_type(g.unwrap_generic(interface_type)))
    mut fn_name := '__v_interface_clone__${interface_sym.cname}'
    if interface_sym.info is ast.Interface && interface_sym.info.is_generic {
        fn_name = g.generic_fn_name(interface_sym.info.concrete_types, fn_name)
    }
    return fn_name
}

fn (mut g Gen) register_array_interface_repeat_fn(array_type ast.Type) string {
    array_typ := g.table.unaliased_type(g.unwrap_generic(array_type))
    array_sym := g.table.final_sym(array_typ)
    if array_sym.kind != .array {
        return ''
    }
    array_info := array_sym.info as ast.Array
    interface_sym :=
        g.table.final_sym(g.table.unaliased_type(g.unwrap_generic(array_info.elem_type)))
    if interface_sym.kind != .interface {
        return ''
    }
    array_styp := g.styp(array_type)
    elem_styp := g.styp(array_info.elem_type)
    clone_fn_name := g.interface_clone_fn_name(array_info.elem_type)
    fn_name := '__v_array_repeat_interface__${array_styp}'
    mut already_generated := false
    lock g.generated_array_interface_repeat_fns {
        already_generated = fn_name in g.generated_array_interface_repeat_fns
        if !already_generated {
            g.generated_array_interface_repeat_fns[fn_name] = true
        }
    }
    if already_generated {
        return fn_name
    }
    g.definitions.writeln('${g.static_non_parallel}${array_styp} ${fn_name}(${array_styp} a, ${ast.int_type_name} count);')
    mut fn_builder := strings.new_builder(512)
    fn_builder.writeln('${g.static_non_parallel}inline ${array_styp} ${fn_name}(${array_styp} a, ${ast.int_type_name} count) {')
    fn_builder.writeln('\t${array_styp} res = builtin__array_repeat_to_depth(*(array*)&a, count, 0);')
    fn_builder.writeln('\tif (a.len > 0) {')
    fn_builder.writeln('\t\tfor (${ast.int_type_name} i = 0; i < res.len; ++i) {')
    fn_builder.writeln('\t\t\t((${elem_styp}*)res.data)[i] = ${clone_fn_name}(((${elem_styp}*)a.data)[i % a.len]);')
    fn_builder.writeln('\t\t}')
    fn_builder.writeln('\t}')
    fn_builder.writeln('\treturn res;')
    fn_builder.writeln('}')
    g.auto_fn_definitions << fn_builder.str()
    return fn_name
}

fn (mut g Gen) fixed_array_init(node ast.ArrayInit, array_type Type, var_name string, is_amp bool) {
    prev_inside_lambda := g.inside_lambda
    g.inside_lambda = true
    defer {
        g.inside_lambda = prev_inside_lambda
    }
    array_info := array_type.unaliased_sym.array_fixed_info()
    if node.has_index {
        past := g.past_tmp_var_from_var_name(var_name)
        defer(fn) {
            g.past_tmp_var_done(past)
        }

        ret_typ_str := g.styp(node.typ)
        elem_typ_str := g.styp(node.elem_type)
        if var_name == '' {
            g.write('${ret_typ_str} ${past.tmp_var} =')
        }
        g.write('{')
        if node.has_val {
            g.write_c99_0_elements_for_array(node.exprs.len)
        } else if node.has_init {
            g.write_c99_0_elements_for_array(array_info.size)
        } else {
            g.write('0')
        }
        g.write('}')
        g.writeln2(';', '{')
        g.indent++
        g.writeln('${elem_typ_str}* pelem = (${elem_typ_str}*)${past.tmp_var};')
        g.writeln('${ast.int_type_name} _len = (${ast.int_type_name})sizeof(${past.tmp_var}) / sizeof(${elem_typ_str});')
        g.writeln('for (${ast.int_type_name} index=0; index<_len; index++, pelem++) {')
        g.set_current_pos_as_last_stmt_pos()
        g.indent++
        g.writeln('${ast.int_type_name} it = index;') // FIXME: Remove this line when it is fully forbidden
        g.set_current_pos_as_last_stmt_pos()
        g.write('*pelem = ')
        g.expr_with_init(node)
        g.writeln(';')
        g.indent--
        g.writeln('}')
        g.indent--
        g.writeln('}')
        g.set_current_pos_as_last_stmt_pos()
        return
    }
    is_none := node.is_option && !node.has_init && !node.has_val

    if node.has_val && node.exprs.len == 0 {
        g.write('NULL')
        return
    }

    if (g.inside_struct_init && g.inside_cast && !g.inside_memset && !g.inside_opt_or_res
        && !g.inside_sumtype_cast) || (node.is_option && !is_none) {
        ret_typ_str := g.styp(node.typ)
        g.write('(${ret_typ_str})')
    }
    elem_sym := g.table.final_sym(node.elem_type)
    is_struct := g.inside_array_fixed_struct && elem_sym.kind == .struct
    if !is_struct && !is_none {
        g.write('{')
    }
    if node.is_option && !is_none {
        g.write('.state=0, .err=_const_none__, .data={')
    }
    if node.has_val {
        tmp_inside_array := g.inside_array_item
        g.inside_array_item = true
        defer(fn) {
            g.inside_array_item = tmp_inside_array
        }
        nelen := node.exprs.len
        prepared_exprs := g.prepare_array_init_exprs(node.exprs, node.expr_types, node.elem_type)
        for i, expr in prepared_exprs {
            actual_expr := array_init_orig_expr(expr)
            if elem_sym.kind == .array_fixed
                && (expr is ast.CTempVar || actual_expr in [ast.Ident, ast.SelectorExpr]) {
                elem_info := elem_sym.array_fixed_info()
                g.fixed_array_var_init(g.expr_string(expr), expr.is_auto_deref_var(),
                    elem_info.elem_type, elem_info.size)
            } else if elem_sym.kind == .array_fixed && actual_expr is ast.CallExpr
                && g.table.final_sym(actual_expr.return_type).kind == .array_fixed {
                elem_info := elem_sym.array_fixed_info()
                tmp_var := g.expr_with_var(expr, node.expr_types[i], false)
                g.fixed_array_var_init(tmp_var, false, elem_info.elem_type, elem_info.size)
            } else {
                expr_type := if node.expr_types.len > i && node.expr_types[i] != 0 {
                    node.expr_types[i]
                } else {
                    node.elem_type
                }
                if node.elem_type.has_flag(.option) {
                    g.expr_with_opt(expr, expr_type, node.elem_type)
                } else {
                    g.expr_with_cast(expr, expr_type, node.elem_type)
                }
            }
            g.add_commas_and_prevent_long_lines(i, nelen)
        }
    } else if node.has_init {
        info := array_type.unaliased_sym.info as ast.ArrayFixed
        // Always loop and call expr_with_init for each element to avoid copying
        // temporary variable declarations and initialization code
        for i in 0 .. info.size {
            g.expr_with_init(node)
            g.add_commas_and_prevent_long_lines(i, info.size)
        }
    } else if is_amp {
        g.write('0')
    } else {
        if elem_sym.kind == .map {
            // fixed array for map -- [N]map[key_type]value_type
            map_info := elem_sym.map_info()
            before_map_expr_pos := g.out.len
            {
                g.expr(ast.MapInit{
                    key_type:   map_info.key_type
                    value_type: map_info.value_type
                })
            }
            smap_expr := g.out.cut_to(before_map_expr_pos)
            g.write_all_n_elements_for_array(array_info.size, smap_expr)
        } else if elem_sym.kind == .array_fixed {
            // nested fixed array -- [N][N]type
            arr_info := elem_sym.array_fixed_info()
            mut exprs := []ast.Expr{cap: 1}
            exprs << ast.IntegerLiteral{}
            {
                g.expr(ast.ArrayInit{
                    exprs:     exprs
                    typ:       node.elem_type
                    elem_type: arr_info.elem_type
                })
            }
            sarr_expr := g.cut_and_get_fixed_array_init_elements()
            g.write_c99_elements_for_array(array_info.size, sarr_expr)
        } else if elem_sym.kind == .chan {
            // fixed array for chan -- [N]chan
            chan_info := elem_sym.chan_info()
            before_chan_expr_pos := g.out.len
            g.expr(ast.ChanInit{
                typ:       node.elem_type
                elem_type: chan_info.elem_type
            })
            schan_expr := g.out.cut_to(before_chan_expr_pos)
            g.write_c99_elements_for_array(array_info.size, schan_expr)
        } else if is_none {
            g.gen_option_error(node.typ, ast.None{})
        } else {
            std := g.type_default(node.elem_type)
            if g.can_use_c99_designators() && std == '0' {
                g.write('0')
            } else if node.elem_type.has_flag(.option) {
                for i in 0 .. array_info.size {
                    g.expr_with_opt(ast.None{}, ast.none_type, node.elem_type)
                    g.add_commas_and_prevent_long_lines(i, array_info.size)
                }
            } else {
                g.write_c99_elements_for_array(array_info.size, std)
            }
        }
    }
    if node.is_option && !is_none {
        g.write('}')
    }
    if !is_struct && !is_none {
        g.write('}')
    }
}

// cut_and_get_fixed_array_init_elements
// for `Array_fixed_Array_fixed_Array_fixed__option_int_2_2_2 a = {{ _t1, _t2}`
// will cut to `=` and return `{ _t1, _t2}`
@[direct_array_access]
fn (mut g Gen) cut_and_get_fixed_array_init_elements() string {
    // extract the `{{},{}}` string
    mut nested_level := 0
    for i := g.out.len - 1; i >= 0; i-- {
        if g.out[i] == `}` {
            nested_level++
        } else if g.out[i] == `{` {
            nested_level--
        } else if g.out[i] == ` ` {
            continue
        }
        if nested_level == 0 {
            return g.out.cut_to(i)
        }
    }
    return '/*this should not happend*/'
}

fn (mut g Gen) expr_with_init(node ast.ArrayInit) {
    if node.elem_type.has_flag(.option) {
        g.expr_with_opt(node.init_expr, node.init_type, node.elem_type)
    } else {
        g.expr_with_cast(node.init_expr, node.init_type, node.elem_type)
    }
}

fn (mut g Gen) struct_has_array_or_map_field(elem_typ ast.Type) bool {
    unaliased_sym := g.table.final_sym(elem_typ)
    if unaliased_sym.kind == .struct {
        info := unaliased_sym.info as ast.Struct
        for field in info.fields {
            field_sym := g.table.final_sym(field.typ)
            if field_sym.kind in [.array, .map] {
                return true
            }
        }
    }
    return false
}

// `[]int{len: 6, cap: 10, init: index * index}`
fn (mut g Gen) array_init_with_fields(node ast.ArrayInit, elem_type Type, is_amp bool, shared_styp string,
    var_name string) {
    prev_inside_lambda := g.inside_lambda
    g.inside_lambda = true
    defer {
        g.inside_lambda = prev_inside_lambda
    }
    elem_styp := g.styp(elem_type.typ)
    noscan := g.check_noscan(elem_type.typ)
    is_default_array := elem_type.unaliased_sym.kind == .array && node.has_init
    is_default_map := elem_type.unaliased_sym.kind == .map && node.has_init
    needs_more_defaults := node.has_len && (g.struct_has_array_or_map_field(elem_type.typ)
        || elem_type.unaliased_sym.kind in [.array, .map])
    if node.has_index {
        // []int{len: 6, init: index * index} when variable it is used in init expression
        past := g.past_tmp_var_from_var_name(var_name)
        defer(fn) {
            g.past_tmp_var_done(past)
        }

        // Use the resolved elem_type (not stale AST types) for generating correct C types
        // in generic function instantiations.
        resolved_array_idx := g.table.find_or_register_array(elem_type.typ)
        ret_typ := g.styp(ast.new_type(resolved_array_idx))
        elem_typ := g.styp(elem_type.typ)
        if var_name == '' {
            g.write('${ret_typ} ${past.tmp_var} =')
        }
        if is_default_array {
            g.write('builtin____new_array_with_array_default${noscan}(')
        } else if is_default_map {
            g.write('builtin____new_array_with_map_default${noscan}(')
        } else {
            g.write('builtin____new_array_with_default${noscan}(')
        }
        if node.has_len {
            g.expr(node.len_expr)
            g.write(', ')
        } else {
            g.write('0, ')
        }
        if node.has_cap {
            g.expr(node.cap_expr)
            g.write(', ')
        } else {
            g.write('0, ')
        }
        if elem_type.unaliased_sym.kind == .function {
            g.write('sizeof(voidptr), ')
        } else {
            g.write('sizeof(${elem_styp}), ')
        }
        if is_default_array {
            info := elem_type.unaliased_sym.info as ast.Array
            depth := if g.table.sym(info.elem_type).kind == .array { 1 } else { 0 }
            g.write2('(${elem_styp}[]){', g.type_default(elem_type.typ))
            g.write('}[0], ${depth})')
        } else if node.has_len && elem_type.typ == ast.string_type {
            g.write2('&(${elem_styp}[]){', '_S("")')
            g.write('})')
        } else if node.has_len && elem_type.unaliased_sym.kind in [.array, .map] {
            g.write2('(voidptr)&(${elem_styp}[]){', g.type_default(elem_type.typ))
            g.write('}[0])')
        } else {
            g.write('0)')
        }
        if g.is_shared {
            g.write('}, sizeof(${shared_styp}))')
        } else if is_amp {
            g.write(')')
        }
        g.writeln2(';', '{')
        g.indent++
        g.writeln('${elem_typ}* pelem = (${elem_typ}*)${past.tmp_var}.data;')
        g.writeln('for (${ast.int_type_name} index=0; index<${past.tmp_var}.len; index++, pelem++) {')
        g.set_current_pos_as_last_stmt_pos()
        g.indent++
        g.writeln('${ast.int_type_name} it = index;') // FIXME: Remove this line when it is fully forbidden
        g.set_current_pos_as_last_stmt_pos()
        if elem_type.unaliased_sym.kind != .array_fixed {
            g.write('*pelem = ')
            g.expr_with_init(node)
            g.writeln(';')
        } else {
            g.write('memcpy(pelem, ')
            g.expr_with_init(node)
            g.writeln(', sizeof(${elem_styp}));')
        }
        g.indent--
        g.writeln('}')
        g.indent--
        g.writeln('}')
        g.set_current_pos_as_last_stmt_pos()
        return
    }
    if is_default_array {
        g.write('builtin____new_array_with_array_default${noscan}(')
    } else if is_default_map {
        g.write('builtin____new_array_with_map_default${noscan}(')
    } else if needs_more_defaults {
        g.write('builtin____new_array_with_multi_default${noscan}(')
    } else {
        g.write('builtin____new_array_with_default${noscan}(')
    }
    if node.has_len {
        g.expr(node.len_expr)
        g.write(', ')
    } else {
        g.write('0, ')
    }
    if node.has_cap {
        g.expr(node.cap_expr)
        g.write(', ')
    } else {
        g.write('0, ')
    }
    if elem_type.unaliased_sym.kind == .function {
        g.write('sizeof(voidptr), ')
    } else {
        g.write('sizeof(${elem_styp}), ')
    }
    if is_default_array {
        info := elem_type.unaliased_sym.info as ast.Array
        depth := if g.table.sym(info.elem_type).kind == .array { 1 } else { 0 }
        g.write('(${elem_styp}[]){')
        g.expr(node.init_expr)
        g.write('}[0], ${depth})')
    } else if is_default_map {
        g.write('(${elem_styp}[]){')
        g.expr(node.init_expr)
        g.write('}[0])')
    } else if needs_more_defaults {
        tmp := g.new_tmp_var()
        line := g.go_before_last_stmt().trim_space()
        g.empty_line = true

        g.write('${elem_styp}* ${tmp} = (${elem_styp}*) builtin___v_malloc((')
        g.expr(node.len_expr)
        g.writeln(') * sizeof(${elem_styp}));')
        ind := g.new_tmp_var()
        g.write('for (${ast.int_type_name} ${ind}=0; ${ind}<')
        g.expr(node.len_expr)
        g.writeln('; ${ind}++) {')
        g.write('\t${tmp}[${ind}] = ')
        if node.has_init {
            g.expr_with_init(node)
        } else {
            if node.elem_type.has_flag(.option) {
                g.expr_with_opt(ast.None{}, ast.none_type, elem_type.typ)
            } else if elem_type.unaliased_sym.kind == .struct {
                // `T{}` stays expression-safe for struct field defaults that expand
                // to statement-based array/map initialization.
                g.struct_init(ast.StructInit{
                    typ: elem_type.typ
                })
            } else {
                g.write(g.type_default(elem_type.typ))
            }
        }
        g.writeln2(';', '}')
        g.write2(line, ' (voidptr)${tmp})')
    } else if node.has_init {
        g.write('&(${elem_styp}[]){')
        g.expr_with_init(node)
        g.write('})')
    } else if node.has_len && node.elem_type.has_flag(.option) {
        g.write('&')
        g.expr_with_opt(ast.None{}, ast.none_type, elem_type.typ)
        g.write(')')
    } else if node.has_len && node.elem_type == ast.string_type {
        g.write2('&(${elem_styp}[]){', '_S("")')
        g.write('})')
    } else if node.has_len && elem_type.unaliased_sym.kind in [.struct, .array, .map] {
        g.write2('(voidptr)&(${elem_styp}[]){', g.type_default(elem_type.typ))
        g.write('}[0])')
    } else {
        g.write('0)')
    }
    if g.is_shared {
        g.write('}, sizeof(${shared_styp}))')
    } else if is_amp {
        g.write(')')
    }
}

fn (mut g Gen) declare_closure_fn(mut expr ast.AnonFn, var_name string) {
    decl_var := g.fn_var_signature(expr.typ, expr.decl.return_type, expr.decl.params.map(it.typ),
        var_name)
    g.write('${decl_var} = ')
    g.gen_anon_fn(mut expr)
    g.writeln(';')
}

fn (mut g Gen) write_closure_fn(mut expr ast.AnonFn, var_name string, declared_var string) {
    if declared_var == '' {
        past := g.past_tmp_var_new()
        g.declare_closure_fn(mut expr, past.var_name)
        g.past_tmp_var_done(past)
        g.write('(${var_name})') // usually `it`
    } else {
        g.write('${declared_var}(${var_name})')
    }
}

// `nums.map(it % 2 == 0)`
fn (mut g Gen) gen_array_map(node ast.CallExpr) {
    prev_inside_lambda := g.inside_lambda
    g.inside_lambda = true
    defer {
        g.inside_lambda = prev_inside_lambda
    }

    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }

    left_type := g.resolved_array_receiver_type(node)
    left_sym := g.table.final_sym(left_type)
    left_is_array := left_sym.kind == .array
    inp_sym := left_sym
    inp_elem_type := if left_is_array {
        (inp_sym.info as ast.Array).elem_type
    } else {
        (inp_sym.info as ast.ArrayFixed).elem_type
    }
    inp_elem_styp := g.styp(inp_elem_type)
    if inp_sym.kind !in [.array, .array_fixed] {
        verror('map() requires an array or a fixed array')
    }

    mut expr := node.args[0].expr
    var_name := g.get_array_expr_param_name(mut expr)
    g.refresh_array_expr_param_type(expr, var_name, inp_elem_type)

    mut return_type := g.resolve_return_type(node)
    if g.table.final_sym(g.unwrap_generic(return_type)).kind !in [.array, .array_fixed] {
        return_type = if g.type_resolver.is_generic_expr(node.args[0].expr) {
            mut ctyp := ast.void_type
            if node.args[0].expr is ast.CallExpr && node.args[0].expr.return_type_generic != 0
                && node.args[0].expr.return_type_generic.has_flag(.generic) {
                ctyp = g.resolve_return_type(node.args[0].expr)
                if g.table.type_kind(node.args[0].expr.return_type_generic) in [
                    .array,
                    .array_fixed,
                ] {
                    ctyp = ast.new_type(g.table.find_or_register_array(ctyp))
                }
            }
            if ctyp == ast.void_type {
                ctyp = g.type_resolver.unwrap_generic_expr(node.args[0].expr, node.return_type)
            }
            if g.table.type_kind(g.unwrap_generic(ctyp)) !in [.array, .array_fixed] {
                ast.new_type(g.table.find_or_register_array(ctyp))
            } else {
                ctyp
            }
        } else {
            node.return_type
        }
    }
    ret_styp := g.styp(return_type)
    ret_sym := g.table.final_sym(return_type)

    ret_elem_type := if left_is_array {
        (ret_sym.info as ast.Array).elem_type
    } else {
        (ret_sym.info as ast.ArrayFixed).elem_type
    }
    ret_elem_sym := g.table.final_sym(ret_elem_type)
    mut ret_elem_styp := g.styp(ret_elem_type)
    mut closure_var_decl := ''
    tmp_map_expr_result_name := g.new_tmp_var()
    if mut expr is ast.SelectorExpr {
        if expr.typ != ast.void_type {
            var_sym := g.table.sym(expr.typ)
            if var_sym.info is ast.FnType {
                ret_elem_styp = 'voidptr'
                closure_var_decl = g.fn_var_signature(expr.typ, var_sym.info.func.return_type,
                    var_sym.info.func.params.map(it.typ), tmp_map_expr_result_name)
            }
        }
    }
    noscan := g.check_noscan(ret_elem_type)
    has_infix_left_var_name := g.write_prepared_tmp_value(past.tmp_var, node, ret_styp, '{0}')
    if left_is_array {
        g.writeln('${past.tmp_var} = builtin____new_array${noscan}(0, ${past.tmp_var}_len, sizeof(${ret_elem_styp}));\n')
    }

    mut closure_var := ''
    if mut expr is ast.AnonFn {
        if expr.inherited_vars.len > 0 {
            closure_var = g.new_tmp_var()
            g.declare_closure_fn(mut expr, closure_var)
        }
    }

    i := g.new_tmp_var()
    g.writeln('for (${ast.int_type_name} ${i} = 0; ${i} < ${past.tmp_var}_len; ++${i}) {')
    g.indent++
    is_auto_heap := g.array_expr_param_needs_indirect_access(expr, var_name)
    old_param_auto_heap := g.set_array_expr_param_auto_heap(expr, var_name, is_auto_heap)
    defer {
        g.set_array_expr_param_auto_heap(expr, var_name, old_param_auto_heap)
    }
    g.write_prepared_var(var_name, inp_elem_type, inp_elem_styp, past.tmp_var, i, left_is_array,
        is_auto_heap)
    g.set_current_pos_as_last_stmt_pos()
    mut is_embed_map_filter := false
    match mut expr {
        ast.AnonFn {
            g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            if ret_elem_sym.kind == .array_fixed {
                // unpack fixed array return value
                g.writeln('{0};')
                g.write('memcpy(&${tmp_map_expr_result_name}, ')
            }
            if expr.inherited_vars.len > 0 {
                g.write_closure_fn(mut expr, var_name, closure_var)
            } else {
                g.gen_anon_fn_decl(mut expr)
                g.write('${expr.decl.name}(${var_name})')
            }
            if ret_elem_sym.kind == .array_fixed {
                g.write('.ret_arr, sizeof(${ret_elem_styp}))')
            }
        }
        ast.Ident {
            g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            if expr.kind == .function {
                if expr.obj is ast.Var && expr.obj.is_inherited {
                    g.write(closure_ctx + '->')
                }
                g.write('${c_name(expr.name)}(${var_name})')
            } else if expr.kind == .variable {
                var_info := expr.var_info()
                sym := g.table.sym(var_info.typ)
                if sym.kind == .function {
                    if expr.obj is ast.Var && expr.obj.is_inherited {
                        g.write(closure_ctx + '->')
                    }
                    g.write('${c_name(expr.name)}(${var_name})')
                } else {
                    g.expr(expr)
                }
            } else {
                g.expr(expr)
            }
        }
        ast.CallExpr {
            if expr.name in ['map', 'filter', 'all', 'any', 'count'] {
                is_embed_map_filter = true
                g.set_current_pos_as_last_stmt_pos()
            }
            g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            g.expr(expr)
        }
        ast.CastExpr {
            // value.map(Type(it)) when `value` is a comptime var
            if expr.expr is ast.Ident && node.left is ast.Ident && node.left.ct_expr {
                ctyp := g.type_resolver.get_type(ast.Expr(node.left))
                if ctyp != ast.void_type {
                    expr.expr_type = g.table.value_type(ctyp)
                }
            }
            g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            g.expr(expr)
        }
        ast.LambdaExpr {
            g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            g.expr(expr.expr)
        }
        ast.SelectorExpr {
            if expr.typ != ast.void_type && g.table.final_sym(expr.typ).kind == .array_fixed {
                atype := g.styp(expr.typ)
                if closure_var_decl != '' {
                    g.write('memcpy(&${closure_var_decl}, &')
                    g.expr(expr)
                    g.write(', sizeof(${atype}))')
                } else {
                    g.writeln('${ret_elem_styp} ${tmp_map_expr_result_name};')
                    g.write('memcpy(&${tmp_map_expr_result_name}, &')
                    g.expr(expr)
                    g.write(', sizeof(${atype}))')
                }
            } else {
                if closure_var_decl != '' {
                    g.write('${closure_var_decl} = ')
                } else {
                    g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
                }
                g.expr(expr)
            }
        }
        ast.AsCast {
            if expr.typ.has_flag(.generic) {
                ret_elem_styp = g.styp(g.unwrap_generic(expr.typ))
            }
            g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            g.expr(expr)
        }
        else {
            if closure_var_decl != '' {
                g.write('${closure_var_decl} = ')
            } else {
                g.write('${ret_elem_styp} ${tmp_map_expr_result_name} = ')
            }
            g.expr(expr)
        }
    }

    if left_is_array {
        g.writeln2(';',
            'builtin__array_push${noscan}((array*)&${past.tmp_var}, &${tmp_map_expr_result_name});')
    } else {
        g.writeln2(';', '${past.tmp_var}[${i}] = ${tmp_map_expr_result_name};')
    }
    g.indent--
    g.writeln('}')
    if !is_embed_map_filter {
        g.set_current_pos_as_last_stmt_pos()
    }
    if has_infix_left_var_name {
        g.indent--
        g.writeln('}')
    }
}

@[inline]
fn (mut g Gen) array_receiver_is_auto_heap(left ast.Expr) bool {
    return left is ast.Ident && g.resolved_ident_is_auto_heap(left)
}

@[inline]
fn (mut g Gen) resolved_array_receiver_type(node ast.CallExpr) ast.Type {
    resolved_left_type := g.recheck_concrete_type(g.resolved_expr_type(node.left, node.left_type))
    default_left_type := g.recheck_concrete_type(node.left_type)
    unwrapped_resolved := g.unwrap_generic(resolved_left_type)
    unwrapped_default := g.unwrap_generic(default_left_type)
    resolved_left_sym := if unwrapped_resolved != 0 {
        g.table.final_sym(unwrapped_resolved)
    } else {
        g.table.final_sym(node.left_type)
    }
    default_left_sym := if unwrapped_default != 0 {
        g.table.final_sym(unwrapped_default)
    } else {
        g.table.final_sym(node.left_type)
    }
    if resolved_left_type != 0 && resolved_left_sym.kind in [.array, .array_fixed] {
        return resolved_left_type
    }
    if default_left_type != 0 && default_left_sym.kind in [.array, .array_fixed] {
        return default_left_type
    }
    return if resolved_left_type != 0 {
        resolved_left_type
    } else {
        default_left_type
    }
}

@[inline]
fn (mut g Gen) array_receiver_is_indirect(left ast.Expr, left_type ast.Type) bool {
    return !left_type.has_flag(.shared_f)
        && (left_type.is_ptr() || g.array_receiver_is_auto_heap(left))
}

@[inline]
fn (mut g Gen) array_receiver_field_access(left ast.Expr, left_type ast.Type) string {
    return if g.array_receiver_is_auto_heap(left) && !left_type.has_flag(.shared_f) {
        '->'
    } else {
        g.dot_or_ptr(left_type)
    }
}

fn (mut g Gen) write_array_receiver(left ast.Expr) {
    old_inside_selector_lhs := g.inside_selector_lhs
    g.inside_selector_lhs = true
    defer {
        g.inside_selector_lhs = old_inside_selector_lhs
    }
    g.expr(left)
}

// `susers := users.sorted(a.age < b.age)`
fn (mut g Gen) gen_array_sorted(node ast.CallExpr) {
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }
    mut resolved_return_type := g.resolve_return_type(node)
    mut sym := g.table.final_sym(resolved_return_type)
    if sym.kind !in [.array, .array_fixed] {
        resolved_return_type = node.return_type
        sym = g.table.final_sym(resolved_return_type)
    }
    atype := g.styp(resolved_return_type)
    left_is_array := sym.kind == .array
    elem_type := if left_is_array {
        (sym.info as ast.Array).elem_type
    } else {
        (sym.info as ast.ArrayFixed).elem_type
    }
    if left_is_array {
        depth := g.get_array_depth(elem_type)
        resolved_left_type := g.resolved_array_receiver_type(node)
        left_is_indirect := g.array_receiver_is_indirect(node.left, resolved_left_type)
        if !left_is_indirect {
            g.write('${atype} ${past.tmp_var} = builtin__array_clone_to_depth(ADDR(${atype},')
            g.write_array_receiver(node.left)
            g.writeln('), ${depth});')
        } else {
            g.write('${atype} ${past.tmp_var} = builtin__array_clone_to_depth(')
            g.write_array_receiver(node.left)
            g.writeln(', ${depth});')
        }
    } else {
        g.writeln('${atype} ${past.tmp_var};')
        g.write('memcpy(&${past.tmp_var}, &')
        if node.left is ast.ArrayInit {
            g.fixed_array_init_with_cast(node.left, node.left_type)
        } else {
            g.expr(node.left)
        }
        g.writeln(', sizeof(${atype}));')
    }

    unsafe {
        node.left = ast.Expr(ast.Ident{
            name: past.tmp_var
        })
        // The tmp_var is a cloned array (value, not pointer), so update
        // left_type to strip pointer flags from the mut receiver.
        node.left_type = resolved_return_type
    }
    g.gen_array_sort(node)
    g.writeln(';')
}

// `users.sort(a.age < b.age)`
fn (mut g Gen) gen_array_sort(node ast.CallExpr) {
    // println('filter s="${s}"')
    resolved_left_type := g.resolved_array_receiver_type(node)
    rec_sym := g.table.final_sym(resolved_left_type)
    if rec_sym.kind !in [.array, .array_fixed] {
        // println(rec_sym.kind)
        verror('.sort() is an array method or a fixed array method')
    }
    if g.pref.is_bare {
        g.writeln('bare_panic(_S("sort does not work with -freestanding"))')
        return
    }
    left_is_array := rec_sym.kind == .array
    elem_type := if left_is_array {
        (rec_sym.info as ast.Array).elem_type
    } else {
        (rec_sym.info as ast.ArrayFixed).elem_type
    }
    // `users.sort(a.age > b.age)`
    // Generate a comparison function for a custom type
    elem_stype := g.styp(elem_type)
    mut compare_fn := 'compare_${g.unique_file_path_hash}_${elem_stype.replace('*', '_ptr')}'
    mut comparison_type := g.unwrap(ast.void_type)
    mut left_expr, mut right_expr := '', ''
    mut use_lambda := false
    mut lambda_fn_name := ''
    // the only argument can only be an infix expression like `a < b` or `b.field > a.field`
    if node.args.len == 0 {
        comparison_type = g.unwrap(elem_type.set_nr_muls(0))
        rlock g.array_sort_fn {
            if compare_fn in g.array_sort_fn {
                g.gen_array_sort_call(node,
                    g.ensure_array_sort_qsort_adapter(compare_fn, elem_type), left_is_array)
                return
            }
        }
        left_expr = '*a'
        right_expr = '*b'
    } else if node.args[0].expr is ast.LambdaExpr {
        lambda_fn_name = node.args[0].expr.func.decl.name
        compare_fn = '${lambda_fn_name}_lambda_wrapper'
        use_lambda = true
        mut lambda_node := unsafe { node.args[0].expr }
        g.gen_anon_fn_decl(mut lambda_node.func)
    } else {
        infix_expr := node.args[0].expr as ast.InfixExpr
        // For plain `a < b` / `b < a`, the comparison_type is the element type.
        // Avoid using `infix_expr.left_type` here because the AST node is shared
        // across generic instantiations and may have been mutated by a later
        // checker pass for a different concrete type. See vlang/v#27121.
        comparison_left_type := if infix_expr.left is ast.Ident
            && (infix_expr.left.name == 'a' || infix_expr.left.name == 'b') {
            elem_type
        } else {
            infix_expr.left_type
        }
        comparison_type = g.unwrap(comparison_left_type.set_nr_muls(0))
        left_name := infix_expr.left.str()
        if left_name.len > 1 {
            compare_fn += '_by' +
                left_name[1..].replace_each(['.', '_', '[', '_', ']', '_', "'", '_', '"', '_', '(', '', ')', '', ',', '', '/', '_'])
        }
        // is_reverse is `true` for `.sort(a > b)` and `.sort(b < a)`
        is_reverse := (left_name.starts_with('a') && infix_expr.op == .gt)
            || (left_name.starts_with('b') && infix_expr.op == .lt)
        if is_reverse {
            compare_fn += '_reverse'
        }
        rlock g.array_sort_fn {
            if compare_fn in g.array_sort_fn {
                g.gen_array_sort_call(node,
                    g.ensure_array_sort_qsort_adapter(compare_fn, elem_type), left_is_array)
                return
            }
        }
        if left_name.starts_with('a') != is_reverse {
            left_expr = g.expr_string(infix_expr.left)
            right_expr = g.expr_string(infix_expr.right)
            if infix_expr.left is ast.Ident {
                left_expr = '*' + left_expr
            }
            if infix_expr.right is ast.Ident {
                right_expr = '*' + right_expr
            }
        } else {
            left_expr = g.expr_string(infix_expr.right)
            right_expr = g.expr_string(infix_expr.left)
            if infix_expr.left is ast.Ident {
                right_expr = '*' + right_expr
            }
            if infix_expr.right is ast.Ident {
                left_expr = '*' + left_expr
            }
        }
    }

    // Register a new custom `compare_xxx` function for qsort()
    // TODO: move to checker
    lock g.array_sort_fn {
        g.array_sort_fn << compare_fn
    }

    stype_arg := g.styp(elem_type)
    // In -parallel-cc these bodies are seen by every split C translation unit via `out.h`,
    // so they need internal linkage to avoid duplicate symbols at link time.
    g.sort_fn_definitions.writeln('${g.array_sort_fn_visibility()}int ${compare_fn}(${stype_arg}* a, ${stype_arg}* b) {')
    c_condition := g.array_sort_lt_condition(comparison_type, use_lambda, lambda_fn_name,
        left_expr, right_expr, 'a', 'b')
    reverse_condition := g.array_sort_lt_condition(comparison_type, use_lambda, lambda_fn_name,
        right_expr, left_expr, 'b', 'a')
    g.sort_fn_definitions.writeln('\tif (${c_condition}) return -1;')
    g.sort_fn_definitions.writeln('\tif (${reverse_condition}) return 1;')
    g.sort_fn_definitions.writeln('\treturn 0;')
    g.sort_fn_definitions.writeln('}\n')

    // write call to the generated function
    g.gen_array_sort_call(node, g.ensure_array_sort_qsort_adapter(compare_fn, elem_type),
        left_is_array)
}

fn (mut g Gen) array_sort_lt_condition(comparison_type Type, use_lambda bool, lambda_fn_name string, left_expr string, right_expr string, left_arg string, right_arg string) string {
    if use_lambda {
        return '${lambda_fn_name}(${left_arg}, ${right_arg})'
    }
    if comparison_type.sym.has_method('<') {
        method_name := if comparison_type.sym.is_builtin() {
            'builtin__${g.styp(comparison_type.typ)}__lt'
        } else {
            '${g.styp(comparison_type.typ)}__lt'
        }
        return '${method_name}(${left_expr}, ${right_expr})'
    }
    if comparison_type.unaliased_sym.has_method('<') {
        method_name := if comparison_type.unaliased_sym.is_builtin() {
            'builtin__${g.styp(comparison_type.unaliased)}__lt'
        } else {
            '${g.styp(comparison_type.unaliased)}__lt'
        }
        return '${method_name}(${left_expr}, ${right_expr})'
    }
    return '${left_expr} < ${right_expr}'
}

@[inline]
fn (g &Gen) array_sort_fn_visibility() string {
    return if g.static_modifier != '' { g.static_modifier } else { 'VV_LOC ' }
}

fn (mut g Gen) ensure_array_sort_qsort_adapter(compare_fn string, elem_type ast.Type) string {
    qsort_compare_fn := '${compare_fn}_qsort_adapter'
    rlock g.array_sort_wrappers {
        if qsort_compare_fn in g.array_sort_wrappers {
            return qsort_compare_fn
        }
    }
    lock g.array_sort_wrappers {
        g.array_sort_wrappers << qsort_compare_fn
    }
    elem_stype := g.styp(elem_type)
    g.sort_fn_definitions.writeln('${g.array_sort_fn_visibility()}int ${qsort_compare_fn}(const void* a, const void* b) {')
    g.sort_fn_definitions.writeln('\treturn ${compare_fn}((${elem_stype}*)a, (${elem_stype}*)b);')
    g.sort_fn_definitions.writeln('}\n')
    return qsort_compare_fn
}

@[inline]
fn (g &Gen) qsort_callback_cast(compare_expr string) string {
    return '((int (*)(const void*, const void*))(${compare_expr}))'
}

@[inline]
fn (mut g Gen) plain_array_sort_callback_cname(expr ast.Expr) ?string {
    if expr is ast.CastExpr {
        return g.plain_array_sort_callback_cname(expr.expr)
    }
    if expr is ast.ParExpr {
        return g.plain_array_sort_callback_cname(expr.expr)
    }
    if expr is ast.UnsafeExpr {
        return g.plain_array_sort_callback_cname(expr.expr)
    }
    if expr is ast.Ident && expr.kind == .function {
        return g.expr_string(expr)
    }
    return none
}

@[inline]
fn (mut g Gen) can_generate_array_sort_qsort_adapter(expr ast.Expr) bool {
    return g.plain_array_sort_callback_cname(expr) != none
}

fn (mut g Gen) array_sort_qsort_callback_expr(expr ast.Expr, elem_type ast.Type) (string, bool) {
    if expr is ast.CastExpr {
        return g.array_sort_qsort_callback_expr(expr.expr, elem_type)
    }
    if expr is ast.ParExpr {
        return g.array_sort_qsort_callback_expr(expr.expr, elem_type)
    }
    if expr is ast.UnsafeExpr {
        return g.array_sort_qsort_callback_expr(expr.expr, elem_type)
    }
    if expr is ast.LambdaExpr {
        lambda_fn_name := expr.func.decl.name
        mut lambda_node := unsafe { expr }
        g.gen_anon_fn_decl(mut lambda_node.func)
        return g.ensure_array_sort_qsort_adapter('${lambda_fn_name}_lambda_wrapper', elem_type), true
    }
    if expr is ast.AnonFn {
        mut fn_expr := unsafe { expr }
        g.gen_anon_fn_decl(mut fn_expr)
        return g.ensure_array_sort_qsort_adapter(expr.decl.name, elem_type), true
    }
    if expr is ast.Ident && expr.kind == .function {
        return g.ensure_array_sort_qsort_adapter(g.expr_string(expr), elem_type), true
    }
    return g.qsort_callback_cast(g.expr_string(expr)), false
}

fn (mut g Gen) gen_array_sort_call(node ast.CallExpr, qsort_compare_fn string, is_array bool) {
    resolved_left_type := g.resolved_array_receiver_type(node)
    deref_field := g.array_receiver_field_access(node.left, resolved_left_type)
    // eprintln('> qsort: pointer ${node.left_type} | deref_field: `${deref_field}`')
    g.empty_line = true
    if is_array {
        g.write('if (')
        g.write_array_receiver(node.left)
        g.write2('${deref_field}len > 0) { ', 'v_stable_sort(')
        g.write_array_receiver(node.left)
        g.write('${deref_field}data, ')
        g.write_array_receiver(node.left)
        g.write('${deref_field}len, ')
        g.write_array_receiver(node.left)
        g.write2('${deref_field}element_size, ${qsort_compare_fn});', ' }')
    } else {
        info := g.table.final_sym(node.left_type).info as ast.ArrayFixed
        elem_styp := g.styp(info.elem_type)
        g.write('v_stable_sort(&')
        g.write_array_receiver(node.left)
        g.write(', ${info.size}, sizeof(${elem_styp}), ${qsort_compare_fn});')
    }
    g.writeln('')
}

fn (mut g Gen) gen_array_sorted_with_compare(node ast.CallExpr) bool {
    mut resolved_return_type := g.resolve_return_type(node)
    mut sym := g.table.final_sym(resolved_return_type)
    if sym.kind !in [.array, .array_fixed] {
        resolved_return_type = node.return_type
        sym = g.table.final_sym(resolved_return_type)
    }
    left_is_array := sym.kind == .array
    elem_type := if left_is_array {
        (sym.info as ast.Array).elem_type
    } else {
        (sym.info as ast.ArrayFixed).elem_type
    }
    if left_is_array && !g.can_generate_array_sort_qsort_adapter(node.args[0].expr) {
        return false
    }
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }
    atype := g.styp(resolved_return_type)
    if left_is_array {
        depth := g.get_array_depth(elem_type)
        resolved_left_type := g.resolved_array_receiver_type(node)
        left_is_indirect := g.array_receiver_is_indirect(node.left, resolved_left_type)
        if !left_is_indirect {
            g.write('${atype} ${past.tmp_var} = builtin__array_clone_to_depth(ADDR(${atype},')
            g.write_array_receiver(node.left)
            g.writeln('), ${depth});')
        } else {
            g.write('${atype} ${past.tmp_var} = builtin__array_clone_to_depth(')
            g.write_array_receiver(node.left)
            g.writeln(', ${depth});')
        }
    } else {
        g.writeln('${atype} ${past.tmp_var};')
        g.write('memcpy(&${past.tmp_var}, &')
        if node.left is ast.ArrayInit {
            g.fixed_array_init_with_cast(node.left, node.left_type)
        } else {
            g.expr(node.left)
        }
        g.writeln(', sizeof(${atype}));')
    }

    unsafe {
        node.left = ast.Expr(ast.Ident{
            name: past.tmp_var
        })
        if left_is_array {
            node.left_type = resolved_return_type
        }
    }
    return g.gen_array_sort_with_compare(node)
}

fn (mut g Gen) gen_array_sort_with_compare(node ast.CallExpr) bool {
    resolved_left_type := g.resolved_array_receiver_type(node)
    rec_sym := g.table.final_sym(resolved_left_type)
    if rec_sym.kind !in [.array, .array_fixed] {
        verror('.sort_with_compare() is an array method or a fixed array method')
    }
    if g.pref.is_bare {
        g.writeln('bare_panic(_S("sort_with_compare does not work with -freestanding"))')
        return true
    }
    left_is_array := rec_sym.kind == .array
    elem_type := if left_is_array {
        (rec_sym.info as ast.Array).elem_type
    } else {
        (rec_sym.info as ast.ArrayFixed).elem_type
    }
    if left_is_array {
        if compare_fn := g.plain_array_sort_callback_cname(node.args[0].expr) {
            g.gen_array_sort_call(node, g.ensure_array_sort_qsort_adapter(compare_fn, elem_type),
                true)
            return true
        }
        return false
    }
    qsort_compare_fn, has_qsort_adapter := g.array_sort_qsort_callback_expr(node.args[0].expr,
        elem_type)
    _ = has_qsort_adapter
    g.gen_array_sort_call(node, qsort_compare_fn, left_is_array)
    return true
}

fn (mut g Gen) gen_fixed_array_sorted_with_compare(node ast.CallExpr) {
    _ = g.gen_array_sorted_with_compare(node)
}

fn (mut g Gen) gen_fixed_array_sort_with_compare(node ast.CallExpr) {
    _ = g.gen_array_sort_with_compare(node)
}

fn (mut g Gen) gen_fixed_array_reverse(node ast.CallExpr) {
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }
    atype := g.styp(node.return_type)
    g.writeln('${atype} ${past.tmp_var};')
    g.write('memcpy(&${past.tmp_var}, &')
    if node.left is ast.ArrayInit {
        g.fixed_array_init_with_cast(node.left, node.left_type)
    } else {
        g.expr(node.left)
    }
    g.writeln(', sizeof(${atype}));')

    unsafe {
        node.left = ast.Expr(ast.Ident{
            name: past.tmp_var
        })
    }
    g.gen_fixed_array_reverse_in_place(node)
}

fn (mut g Gen) gen_fixed_array_reverse_in_place(node ast.CallExpr) {
    left_sym := g.table.final_sym(node.left_type)
    info := left_sym.info as ast.ArrayFixed
    elem_type := info.elem_type
    elem_styp := g.styp(elem_type)
    tmp_var := g.new_tmp_var()
    g.writeln('${elem_styp} ${tmp_var};')
    i := g.new_tmp_var()
    left_var := g.expr_string(node.left)
    g.empty_line = true
    g.writeln('for (${ast.int_type_name} ${i} = 0; ${i} < ${info.size}/2; ++${i}) {')
    g.writeln('\tmemcpy(&${tmp_var}, &${left_var}[${i}], sizeof(${elem_styp}));')
    g.writeln('\tmemcpy(&${left_var}[${i}], &${left_var}[${info.size}-${i}-1], sizeof(${elem_styp}));')
    g.writeln('\tmemcpy(&${left_var}[${info.size}-${i}-1], &${tmp_var}, sizeof(${elem_styp}));')
    g.writeln('}')
}

// `nums.filter(it % 2 == 0)`
fn (mut g Gen) gen_array_filter(node ast.CallExpr) {
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }

    resolved_left_type := g.resolved_array_receiver_type(node)
    left_sym := g.table.final_sym(g.unwrap_generic(resolved_left_type))
    if left_sym.kind !in [.array_fixed, .array] {
        verror('filter() requires an array')
    }
    left_is_array := left_sym.kind == .array
    left_elem_type := if left_is_array {
        (left_sym.info as ast.Array).elem_type
    } else {
        (left_sym.info as ast.ArrayFixed).elem_type
    }
    left_elem_type_str := g.styp(left_elem_type)
    mut resolved_return_type := g.resolve_return_type(node)
    if g.table.final_sym(g.unwrap_generic(resolved_return_type)).kind !in [
        .array_fixed,
        .array,
    ] {
        resolved_return_type = resolved_left_type
    }
    // .filter() returns a new plain array, not shared.
    if resolved_return_type.has_flag(.shared_f) {
        resolved_return_type = resolved_return_type.clear_flag(.shared_f)
        if resolved_return_type.is_ptr() {
            resolved_return_type = resolved_return_type.deref()
        }
    }
    return_sym := g.table.final_sym(g.unwrap_generic(resolved_return_type))
    return_elem_type := if return_sym.kind == .array {
        (return_sym.info as ast.Array).elem_type
    } else {
        (return_sym.info as ast.ArrayFixed).elem_type
    }
    styp := g.styp(resolved_return_type)
    return_elem_type_str := g.styp(return_elem_type)
    noscan := g.check_noscan(return_elem_type)
    has_infix_left_var_name := g.write_prepared_tmp_value(past.tmp_var, node, styp, '{0}')
    g.writeln('${past.tmp_var} = builtin____new_array${noscan}(0, ${past.tmp_var}_len, sizeof(${return_elem_type_str}));\n')

    mut expr := node.args[0].expr
    var_name := g.get_array_expr_param_name(mut expr)
    g.refresh_array_expr_param_type(expr, var_name, left_elem_type)

    mut closure_var := ''
    if mut expr is ast.AnonFn {
        if expr.inherited_vars.len > 0 {
            closure_var = g.new_tmp_var()
            g.declare_closure_fn(mut expr, closure_var)
        }
    }

    i := g.new_tmp_var()
    g.writeln('for (${ast.int_type_name} ${i} = 0; ${i} < ${past.tmp_var}_len; ++${i}) {')
    g.indent++
    g.write_prepared_var(var_name, left_elem_type, left_elem_type_str, past.tmp_var, i,
        left_is_array, false)
    g.set_current_pos_as_last_stmt_pos()
    mut is_embed_map_filter := false
    match mut expr {
        ast.AnonFn {
            g.write('if (')
            if expr.inherited_vars.len > 0 {
                g.write_closure_fn(mut expr, var_name, closure_var)
            } else {
                g.gen_anon_fn_decl(mut expr)
                g.write('${expr.decl.name}(${var_name})')
            }
        }
        ast.Ident {
            g.write('if (')
            if expr.kind == .function {
                g.write('${c_name(expr.name)}(${var_name})')
            } else if expr.kind == .variable {
                var_info := expr.var_info()
                sym_t := g.table.sym(var_info.typ)
                if sym_t.kind == .function {
                    g.write('${c_name(expr.name)}(${var_name})')
                } else {
                    g.expr(expr)
                }
            } else {
                g.expr(expr)
            }
        }
        ast.CallExpr {
            if expr.name in ['map', 'filter', 'all', 'any', 'count'] {
                is_embed_map_filter = true
                g.set_current_pos_as_last_stmt_pos()
            }
            g.write('if (')
            g.expr(expr)
        }
        ast.LambdaExpr {
            g.write('if (')
            g.expr(expr.expr)
        }
        else {
            g.write('if (')
            g.expr(expr)
        }
    }

    g.writeln2(') {', '\tbuiltin__array_push${noscan}((array*)&${past.tmp_var}, &${var_name});')
    g.writeln('}')
    g.indent--
    g.writeln('}')
    if !is_embed_map_filter {
        g.set_current_pos_as_last_stmt_pos()
    }
    if has_infix_left_var_name {
        g.indent--
        g.writeln('}')
    }
}

// `nums.insert(0, 2)` `nums.insert(0, [2,3,4])`
fn (mut g Gen) gen_array_insert(node ast.CallExpr) {
    left_sym := g.table.final_sym(node.left_type)
    left_info := left_sym.info as ast.Array
    elem_type_str := g.styp(left_info.elem_type)
    arg2_sym := g.table.final_sym(node.args[1].typ)
    is_arg2_array := arg2_sym.kind == .array
        && g.table.unaliased_type(node.args[1].typ.clear_flag(.variadic)) == g.table.unaliased_type(node.left_type)
    noscan := g.check_noscan(left_info.elem_type)
    resolved_left_type := g.resolved_array_receiver_type(node)
    addr := if g.array_receiver_is_indirect(node.left, resolved_left_type) { '' } else { '&' }
    if is_arg2_array {
        g.write('builtin__array_insert_many${noscan}(${addr}')
    } else {
        g.write('builtin__array_insert${noscan}(${addr}')
    }
    g.write_array_receiver(node.left)
    g.write(', ')
    g.expr(node.args[0].expr)
    if is_arg2_array {
        g.write(', ')
        g.expr(node.args[1].expr)
        g.write('.data, ')
        g.expr(node.args[1].expr)
        g.write('.len)')
    } else {
        needs_clone := left_info.elem_type == ast.string_type
            && node.args[1].expr !in [ast.IndexExpr, ast.CallExpr, ast.StringLiteral, ast.StringInterLiteral, ast.InfixExpr]
        g.write(', &(${elem_type_str}[]){')
        if needs_clone {
            g.write('builtin__string_clone(')
        }
        g.expr_with_cast(node.args[1].expr, node.args[1].typ, left_info.elem_type)
        if needs_clone {
            g.write(')')
        }
        g.write('})')
    }
}

// `nums.prepend(2)` `nums.prepend([2,3,4])`
fn (mut g Gen) gen_array_prepend(node ast.CallExpr) {
    left_sym := g.table.final_sym(node.left_type)
    left_info := left_sym.info as ast.Array
    elem_type_str := g.styp(left_info.elem_type)
    arg_sym := g.table.final_sym(node.args[0].typ)
    is_arg_array := arg_sym.kind == .array
        && g.table.unaliased_type(node.args[0].typ) == g.table.unaliased_type(node.left_type)
    noscan := g.check_noscan(left_info.elem_type)
    resolved_left_type := g.resolved_array_receiver_type(node)
    addr := if g.array_receiver_is_indirect(node.left, resolved_left_type) { '' } else { '&' }
    if is_arg_array {
        g.write('builtin__array_prepend_many${noscan}(${addr}')
    } else {
        g.write('builtin__array_prepend${noscan}(${addr}')
    }
    g.write_array_receiver(node.left)
    if is_arg_array {
        g.write(', ')
        g.expr(node.args[0].expr)
        g.write('.data, ')
        g.expr(node.args[0].expr)
        g.write('.len)')
    } else {
        g.write(', &(${elem_type_str}[]){')
        g.expr_with_cast(node.args[0].expr, node.args[0].typ, left_info.elem_type)
        g.write('})')
    }
}

fn (mut g Gen) get_array_contains_method(typ ast.Type) string {
    t := g.table.final_sym(g.unwrap_generic(typ).set_nr_muls(0)).idx
    g.array_contains_types << t
    return g.styp(ast.idx_to_type(t)) + '_contains'
}

fn (mut g Gen) gen_array_contains_methods() {
    mut done := []ast.Type{}
    for t in g.array_contains_types {
        left_final_sym := g.table.final_sym(t)
        if left_final_sym.idx in done || g.table.sym(t).has_method('contains') {
            continue
        }
        done << t
        mut fn_builder := strings.new_builder(512)
        mut left_type_str := g.styp(t)
        fn_name := '${left_type_str}_contains'

        if left_final_sym.kind == .array {
            elem_type := (left_final_sym.info as ast.Array).elem_type
            mut elem_type_str := g.styp(elem_type)
            elem_kind := g.table.sym(elem_type).kind
            elem_is_not_ptr := elem_type.nr_muls() == 0
            if elem_kind == .function {
                left_type_str = 'Array_voidptr'
                elem_type_str = 'voidptr'
            }
            g.type_definitions.writeln('${g.static_non_parallel}bool ${fn_name}(${left_type_str} a, ${elem_type_str} v);')
            fn_builder.writeln('${g.static_non_parallel}bool ${fn_name}(${left_type_str} a, ${elem_type_str} v) {')
            fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < a.len; ++i) {')
            if elem_kind == .string {
                fn_builder.writeln('\t\tif (builtin__fast_string_eq(((string*)a.data)[i], v)) {')
            } else if elem_kind in [.array, .array_fixed] && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_arr_eq(((${elem_type_str}*)a.data)[i], v)) {')
            } else if elem_kind == .function {
                fn_builder.writeln('\t\tif (((voidptr*)a.data)[i] == v) {')
            } else if elem_kind == .map && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_map_eq(((${elem_type_str}*)a.data)[i], v)) {')
            } else if elem_kind == .struct && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_struct_eq(((${elem_type_str}*)a.data)[i], v)) {')
            } else if elem_kind == .interface && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_interface_eq(((${elem_type_str}*)a.data)[i], v)) {')
            } else if elem_kind == .sum_type && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_sumtype_eq(((${elem_type_str}*)a.data)[i], v)) {')
            } else if elem_kind == .alias && elem_is_not_ptr {
                if g.no_eq_method_types[elem_type] {
                    fn_builder.writeln('\t\tif (((${elem_type_str}*)a.data)[i] == v) {')
                } else {
                    ptr_typ := g.equality_fn(elem_type)
                    fn_builder.writeln('\t\tif (${ptr_typ}_alias_eq(((${elem_type_str}*)a.data)[i], v)) {')
                }
            } else {
                fn_builder.writeln('\t\tif (((${elem_type_str}*)a.data)[i] == v) {')
            }
        } else if left_final_sym.kind == .array_fixed {
            left_info := left_final_sym.info as ast.ArrayFixed
            size := left_info.size
            elem_type := left_info.elem_type
            mut elem_type_str := g.styp(elem_type)
            elem_kind := g.table.sym(elem_type).kind
            elem_is_not_ptr := elem_type.nr_muls() == 0
            if elem_kind == .function {
                elem_type_str = 'voidptr'
            }
            g.type_definitions.writeln('${g.static_non_parallel}bool ${fn_name}(${left_type_str} a, ${elem_type_str} v);')
            fn_builder.writeln('${g.static_non_parallel}bool ${fn_name}(${left_type_str} a, ${elem_type_str} v) {')
            fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${size}; ++i) {')
            if elem_kind == .string {
                fn_builder.writeln('\t\tif (builtin__fast_string_eq(a[i], v)) {')
            } else if elem_kind in [.array, .array_fixed] && elem_is_not_ptr {
                ptr_typ := g.equality_fn(left_info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_arr_eq(a[i], v)) {')
            } else if elem_kind == .function {
                fn_builder.writeln('\t\tif (a[i] == v) {')
            } else if elem_kind == .map && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_map_eq(a[i], v)) {')
            } else if elem_kind == .struct && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_struct_eq(a[i], v)) {')
            } else if elem_kind == .interface && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_interface_eq(a[i], v)) {')
            } else if elem_kind == .sum_type && elem_is_not_ptr {
                ptr_typ := g.equality_fn(elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_sumtype_eq(a[i], v)) {')
            } else if elem_kind == .alias && elem_is_not_ptr {
                if g.no_eq_method_types[elem_type] {
                    fn_builder.writeln('\t\tif (a[i] == v) {')
                } else {
                    ptr_typ := g.equality_fn(elem_type)
                    fn_builder.writeln('\t\tif (${ptr_typ}_alias_eq(a[i], v)) {')
                }
            } else {
                fn_builder.writeln('\t\tif (a[i] == v) {')
            }
        }
        fn_builder.writeln('\t\t\treturn true;')
        fn_builder.writeln('\t\t}')
        fn_builder.writeln('\t}')
        fn_builder.writeln('\treturn false;')
        fn_builder.writeln('}')
        g.auto_fn_definitions << fn_builder.str()
    }
}

// `nums.contains(2)`
fn (mut g Gen) gen_array_contains(left_type ast.Type, left ast.Expr, right_type ast.Type, right ast.Expr) {
    fn_name := g.get_array_contains_method(left_type)
    left_sym := g.table.final_sym(left_type)
    g.write2('${fn_name}(', strings.repeat(`*`, left_type.nr_muls()))
    if left_type.share() == .shared_t {
        g.go_back(1)
    }
    if left_sym.kind == .array_fixed && left is ast.ArrayInit {
        g.fixed_array_init_with_cast(left, left_type)
    } else {
        g.expr(left)
    }
    if left_type.share() == .shared_t {
        g.write('->val')
    }
    g.write(', ')
    elem_typ := if left_sym.kind == .array {
        left_sym.array_info().elem_type
    } else {
        left_sym.array_fixed_info().elem_type
    }
    is_auto_deref_var := right.is_auto_deref_var()
    // Check if the right side is an interface/sumtype variable that needs
    // dereferencing. Skip this for smartcast variables (match arms) since
    // the smartcast codegen already handles the deref.
    mut is_interface_needs_deref := false
    if right is ast.Ident && right.info is ast.IdentVar && right.obj is ast.Var {
        if g.table.sym(elem_typ).kind !in [.interface, .sum_type, .struct]
            && g.table.sym(right.obj.typ).kind in [.interface, .sum_type] {
            is_interface_needs_deref = right.obj.smartcasts.len == 0
        }
    }
    if (is_auto_deref_var && !elem_typ.is_ptr()) || is_interface_needs_deref
        || elem_typ.nr_muls() + 1 == right_type.nr_muls() {
        g.write('*')
    }
    if g.table.sym(elem_typ).kind in [.interface, .sum_type] {
        g.expr_with_cast(right, right_type, elem_typ)
    } else if right is ast.ArrayInit && g.table.final_sym(right_type).kind == .array_fixed {
        g.fixed_array_init_with_cast(right, right_type)
    } else {
        g.expr(right)
    }
    g.write(')')
}

fn (mut g Gen) get_array_index_method(typ ast.Type, is_last_index bool) string {
    t := g.unwrap_generic(typ).set_nr_muls(0)
    return if is_last_index {
        g.array_last_index_types << t
        g.styp(t) + '_last_index'
    } else {
        g.array_index_types << t
        g.styp(t) + '_index'
    }
}

fn (mut g Gen) get_array_get_method(typ ast.Type) string {
    t := g.unwrap_generic(typ).set_nr_muls(0)
    g.array_get_types << t
    return g.styp(t) + '__v_get'
}

fn (mut g Gen) gen_array_index_methods(is_last_index bool) {
    mut done := []ast.Type{}
    indxe_types := if is_last_index { g.array_last_index_types } else { g.array_index_types }
    for t in indxe_types {
        if t in done || (is_last_index && g.table.sym(t).has_method('last_index'))
            || (!is_last_index && g.table.sym(t).has_method('index')) {
            continue
        }
        done << t
        final_left_sym := g.table.final_sym(t)
        mut left_type_str := g.styp(t)
        fn_name := if is_last_index {
            '${left_type_str}_last_index'
        } else {
            '${left_type_str}_index'
        }
        mut fn_builder := strings.new_builder(512)

        if final_left_sym.kind == .array {
            info := final_left_sym.info as ast.Array
            mut elem_type_str := g.styp(info.elem_type)
            elem_sym := g.table.sym(info.elem_type)
            if elem_sym.kind == .function {
                left_type_str = 'Array_voidptr'
                elem_type_str = 'voidptr'
            }
            g.type_definitions.writeln('${g.static_non_parallel}${ast.int_type_name} ${fn_name}(${left_type_str} a, ${elem_type_str} v);')
            fn_builder.writeln('${g.static_non_parallel}${ast.int_type_name} ${fn_name}(${left_type_str} a, ${elem_type_str} v) {')
            if is_last_index {
                fn_builder.writeln('\tif (a.len == 0) return -1;')
                fn_builder.writeln('\t${elem_type_str}* pelem = (${elem_type_str}*)((byte*)a.data + (a.len-1)*a.element_size);')
                fn_builder.writeln('\tfor (${ast.int_type_name} i = a.len-1; i >= 0; --i, --pelem) {')
            } else {
                fn_builder.writeln('\t${elem_type_str}* pelem = a.data;')
                fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < a.len; ++i, ++pelem) {')
            }
            if elem_sym.kind == .string {
                fn_builder.writeln('\t\tif (builtin__fast_string_eq(*pelem, v)) {')
            } else if elem_sym.kind in [.array, .array_fixed] && !info.elem_type.is_ptr() {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_arr_eq(*pelem, v)) {')
            } else if elem_sym.kind == .function && !info.elem_type.is_ptr() {
                fn_builder.writeln('\t\tif ( *pelem == v) {')
            } else if elem_sym.kind == .map && !info.elem_type.is_ptr() {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_map_eq((*pelem, v))) {')
            } else if elem_sym.kind == .struct && !info.elem_type.is_ptr() {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_struct_eq(*pelem, v)) {')
            } else if elem_sym.kind == .interface {
                ptr_typ := g.equality_fn(info.elem_type)
                if info.elem_type.is_ptr() {
                    fn_builder.writeln('\t\tif (${ptr_typ}_interface_eq(**pelem, *v)) {')
                } else {
                    fn_builder.writeln('\t\tif (${ptr_typ}_interface_eq(*pelem, v)) {')
                }
            } else if elem_sym.kind == .sum_type {
                ptr_typ := g.equality_fn(info.elem_type)
                if info.elem_type.is_ptr() {
                    fn_builder.writeln('\t\tif (${ptr_typ}_sumtype_eq(**pelem, *v)) {')
                } else {
                    fn_builder.writeln('\t\tif (${ptr_typ}_sumtype_eq(*pelem, v)) {')
                }
            } else if elem_sym.kind == .alias {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_alias_eq(*pelem, v)) {')
            } else {
                fn_builder.writeln('\t\tif (*pelem == v) {')
            }
        } else if final_left_sym.kind == .array_fixed {
            info := final_left_sym.info as ast.ArrayFixed
            mut elem_type_str := g.styp(info.elem_type)
            elem_sym := g.table.sym(info.elem_type)
            if elem_sym.kind == .function {
                elem_type_str = 'voidptr'
            }
            g.type_definitions.writeln('${g.static_non_parallel}${ast.int_type_name} ${fn_name}(${left_type_str} a, ${elem_type_str} v);')
            fn_builder.writeln('${g.static_non_parallel}${ast.int_type_name} ${fn_name}(${left_type_str} a, ${elem_type_str} v) {')
            fn_builder.writeln('\tfor (${ast.int_type_name} i = 0; i < ${info.size}; ++i) {')
            if elem_sym.kind == .string {
                fn_builder.writeln('\t\tif (builtin__fast_string_eq(a[i], v)) {')
            } else if elem_sym.kind in [.array, .array_fixed] && !info.elem_type.is_ptr() {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_arr_eq(a[i], v)) {')
            } else if elem_sym.kind == .function && !info.elem_type.is_ptr() {
                fn_builder.writeln('\t\tif (a[i] == v) {')
            } else if elem_sym.kind == .map && !info.elem_type.is_ptr() {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_map_eq((a[i], v))) {')
            } else if elem_sym.kind == .struct && !info.elem_type.is_ptr() {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_struct_eq(a[i], v)) {')
            } else if elem_sym.kind == .interface {
                ptr_typ := g.equality_fn(info.elem_type)
                if info.elem_type.is_ptr() {
                    fn_builder.writeln('\t\tif (${ptr_typ}_interface_eq(*a[i], *v)) {')
                } else {
                    fn_builder.writeln('\t\tif (${ptr_typ}_interface_eq(a[i], v)) {')
                }
            } else if elem_sym.kind == .sum_type {
                ptr_typ := g.equality_fn(info.elem_type)
                if info.elem_type.is_ptr() {
                    fn_builder.writeln('\t\tif (${ptr_typ}_sumtype_eq(*a[i], *v)) {')
                } else {
                    fn_builder.writeln('\t\tif (${ptr_typ}_sumtype_eq(a[i], v)) {')
                }
            } else if elem_sym.kind == .alias {
                ptr_typ := g.equality_fn(info.elem_type)
                fn_builder.writeln('\t\tif (${ptr_typ}_alias_eq(a[i], v)) {')
            } else {
                fn_builder.writeln('\t\tif (a[i] == v) {')
            }
        }
        fn_builder.writeln('\t\t\treturn i;')
        fn_builder.writeln('\t\t}')
        fn_builder.writeln('\t}')
        fn_builder.writeln('\treturn -1;')
        fn_builder.writeln('}')
        g.auto_fn_definitions << fn_builder.str()
    }
}

fn (mut g Gen) gen_array_get_methods() {
    mut done := []ast.Type{}
    for t in g.array_get_types {
        if t in done {
            continue
        }
        done << t
        final_left_sym := g.table.final_sym(t)
        if final_left_sym.kind != .array {
            continue
        }
        info := final_left_sym.info as ast.Array
        left_type_str := g.styp(t)
        elem_type_str := g.styp(info.elem_type)
        elem_sym := g.table.sym(info.elem_type)
        option_type_str := g.styp(info.elem_type.set_flag(.option))
        base_elem_type_str := g.base_type(info.elem_type)
        default_value := if info.elem_type.has_flag(.option) {
            g.type_default(info.elem_type.clear_flag(.option))
        } else if elem_sym.kind == .function {
            '0'
        } else {
            g.type_default(info.elem_type)
        }
        fn_name := '${left_type_str}__v_get'
        g.type_definitions.writeln('${g.static_non_parallel}${option_type_str} ${fn_name}(${left_type_str} a, ${ast.int_type_name} i);')
        mut fn_builder := strings.new_builder(512)
        fn_builder.writeln('${g.static_non_parallel}${option_type_str} ${fn_name}(${left_type_str} a, ${ast.int_type_name} i) {')
        fn_builder.writeln('\t${option_type_str} res = {0};')
        fn_builder.writeln('\tif (i < 0 || i >= a.len) {')
        fn_builder.writeln('\t\tbuiltin___option_none(&(${base_elem_type_str}[]){ ${default_value} }, (_option*)&res, sizeof(${base_elem_type_str}));')
        fn_builder.writeln('\t\treturn res;')
        fn_builder.writeln('\t}')
        if info.elem_type.has_flag(.option) {
            fn_builder.writeln('\t${elem_type_str}* opt_elem = (${elem_type_str}*)((byte*)a.data + i * a.element_size);')
            fn_builder.writeln('\tif (opt_elem->state == 0) {')
            fn_builder.writeln('\t\tbuiltin___option_ok(opt_elem->data, (_option*)&res, sizeof(${base_elem_type_str}));')
            fn_builder.writeln('\t} else {')
            fn_builder.writeln('\t\tres.state = opt_elem->state;')
            fn_builder.writeln('\t\tres.err = opt_elem->err;')
            fn_builder.writeln('\t}')
        } else {
            storage_type_str := if elem_sym.kind == .function { 'voidptr' } else { elem_type_str }
            fn_builder.writeln('\tbuiltin___option_ok(((${storage_type_str}*)((byte*)a.data + i * a.element_size)), (_option*)&res, sizeof(${storage_type_str}));')
        }
        fn_builder.writeln('\treturn res;')
        fn_builder.writeln('}')
        g.auto_fn_definitions << fn_builder.str()
    }
}

fn (mut g Gen) gen_array_get(node ast.CallExpr) {
    resolved_left_type := g.resolved_array_receiver_type(node)
    fn_name := g.get_array_get_method(resolved_left_type)
    left_is_ptr := g.array_receiver_is_indirect(node.left, resolved_left_type)
    left_is_shared := resolved_left_type.has_flag(.shared_f)
    g.write('${fn_name}(')
    if left_is_ptr && !left_is_shared {
        g.write('*')
    }
    g.write_array_receiver(node.left)
    if left_is_shared {
        if left_is_ptr {
            g.write('->val')
        } else {
            g.write('.val')
        }
    }
    g.write(', ')
    g.expr(node.args[0].expr)
    g.write(')')
}

// `nums.index(2)`
// `nums.last_index(2)`
fn (mut g Gen) gen_array_index(node ast.CallExpr, is_last_index bool) {
    resolved_left_type := g.resolved_array_receiver_type(node)
    fn_name := g.get_array_index_method(resolved_left_type, is_last_index)
    left_sym := g.table.final_sym(resolved_left_type)
    g.write('${fn_name}(')
    if g.array_receiver_is_indirect(node.left, resolved_left_type) {
        g.write('*')
    }
    if left_sym.kind == .array_fixed && node.left is ast.ArrayInit {
        g.fixed_array_init_with_cast(node.left, node.left_type)
    } else {
        g.write_array_receiver(node.left)
    }
    g.write(', ')

    elem_typ := if left_sym.kind == .array {
        left_sym.array_info().elem_type
    } else {
        left_sym.array_fixed_info().elem_type
    }
    // auto deref var is redundant for interfaces and sum types.
    if node.args[0].expr.is_auto_deref_var()
        && g.table.sym(elem_typ).kind !in [.interface, .sum_type] {
        g.write('*')
    }
    if g.table.sym(elem_typ).kind in [.interface, .sum_type] {
        g.expr_with_cast(node.args[0].expr, node.args[0].typ, elem_typ)
    } else if node.args[0].expr is ast.ArrayInit
        && g.table.final_sym(node.args[0].typ).kind == .array_fixed {
        g.fixed_array_init_with_cast(node.args[0].expr, node.args[0].typ)
    } else {
        g.expr(node.args[0].expr)
    }
    g.write(')')
}

fn (mut g Gen) gen_array_wait(node ast.CallExpr) {
    resolved_left_type := g.resolved_array_receiver_type(node)
    arr := g.table.sym(g.unwrap_generic(resolved_left_type))
    thread_type := arr.array_info().elem_type
    thread_sym := g.table.sym(thread_type)
    thread_ret_type := thread_sym.thread_info().return_type
    fn_name := g.register_thread_array_wait_call(g.unwrap_generic(thread_ret_type))
    g.write('${fn_name}(')
    if g.array_receiver_is_indirect(node.left, resolved_left_type) {
        g.write('*')
    }
    g.write_array_receiver(node.left)
    g.write(')')
}

fn (mut g Gen) gen_fixed_array_wait(node ast.CallExpr) {
    arr := g.table.sym(g.unwrap_generic(node.receiver_type))
    thread_type := arr.array_fixed_info().elem_type
    thread_sym := g.table.sym(thread_type)
    thread_ret_type := thread_sym.thread_info().return_type
    fn_name := g.register_thread_fixed_array_wait_call(node, g.unwrap_generic(thread_ret_type))
    g.write('${fn_name}(')
    g.expr(node.left)
    g.write(')')
}

fn (mut g Gen) gen_array_any(node ast.CallExpr) {
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }

    resolved_left_type := g.resolved_array_receiver_type(node)
    sym := g.table.final_sym(g.unwrap_generic(resolved_left_type))
    left_is_array := sym.kind == .array
    elem_type := if left_is_array {
        (sym.info as ast.Array).elem_type
    } else {
        (sym.info as ast.ArrayFixed).elem_type
    }
    elem_type_str := g.styp(elem_type)
    has_infix_left_var_name := g.write_prepared_tmp_value(past.tmp_var, node, 'bool', 'false')

    mut expr := node.args[0].expr
    var_name := g.get_array_expr_param_name(mut expr)
    g.refresh_array_expr_param_type(expr, var_name, elem_type)

    mut closure_var := ''
    if mut expr is ast.AnonFn {
        if expr.inherited_vars.len > 0 {
            closure_var = g.new_tmp_var()
            g.declare_closure_fn(mut expr, closure_var)
        }
    }
    i := g.new_tmp_var()
    g.writeln('for (${ast.int_type_name} ${i} = 0; ${i} < ${past.tmp_var}_len; ++${i}) {')
    g.indent++

    g.write_prepared_var(var_name, elem_type, elem_type_str, past.tmp_var, i, left_is_array, false)
    g.set_current_pos_as_last_stmt_pos()
    mut is_embed_map_filter := false
    match mut expr {
        ast.AnonFn {
            g.write('if (')
            if expr.inherited_vars.len > 0 {
                g.write_closure_fn(mut expr, var_name, closure_var)
            } else {
                g.gen_anon_fn_decl(mut expr)
                g.write('${expr.decl.name}(${var_name})')
            }
        }
        ast.Ident {
            g.write('if (')
            if expr.kind == .function {
                g.write('${c_name(expr.name)}(${var_name})')
            } else if expr.kind == .variable {
                var_info := expr.var_info()
                sym_t := g.table.sym(var_info.typ)
                if sym_t.kind == .function {
                    g.write('${c_name(expr.name)}(${var_name})')
                } else {
                    g.expr(expr)
                }
            } else {
                g.expr(expr)
            }
        }
        ast.CallExpr {
            if expr.name in ['map', 'filter', 'all', 'any', 'count'] {
                is_embed_map_filter = true
                g.set_current_pos_as_last_stmt_pos()
            }
            g.write('if (')
            g.expr(expr)
        }
        ast.LambdaExpr {
            g.write('if (')
            g.expr(expr.expr)
        }
        else {
            g.write('if (')
            g.expr(expr)
        }
    }

    g.writeln2(') {', '\t${past.tmp_var} = true;')
    g.writeln2('\tbreak;', '}')
    g.indent--
    g.writeln('}')
    if !is_embed_map_filter {
        g.set_current_pos_as_last_stmt_pos()
    }
    if has_infix_left_var_name {
        g.indent--
        g.writeln('}')
        g.set_current_pos_as_last_stmt_pos()
    }
}

fn (mut g Gen) gen_array_count(node ast.CallExpr) {
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }

    resolved_left_type := g.resolved_array_receiver_type(node)
    sym := g.table.final_sym(g.unwrap_generic(resolved_left_type))
    left_is_array := sym.kind == .array
    elem_type := if left_is_array {
        (sym.info as ast.Array).elem_type
    } else {
        (sym.info as ast.ArrayFixed).elem_type
    }
    elem_type_str := g.styp(elem_type)
    has_infix_left_var_name :=
        g.write_prepared_tmp_value(past.tmp_var, node, ast.int_type_name, '0')

    mut expr := node.args[0].expr
    var_name := g.get_array_expr_param_name(mut expr)
    g.refresh_array_expr_param_type(expr, var_name, elem_type)

    mut closure_var := ''
    if mut expr is ast.AnonFn {
        if expr.inherited_vars.len > 0 {
            closure_var = g.new_tmp_var()
            g.declare_closure_fn(mut expr, closure_var)
        }
    }
    i := g.new_tmp_var()
    g.writeln('for (${ast.int_type_name} ${i} = 0; ${i} < ${past.tmp_var}_len; ++${i}) {')
    g.indent++

    g.write_prepared_var(var_name, elem_type, elem_type_str, past.tmp_var, i, left_is_array, false)
    g.set_current_pos_as_last_stmt_pos()
    mut is_embed_map_filter := false
    match mut expr {
        ast.AnonFn {
            g.write('if (')
            if expr.inherited_vars.len > 0 {
                g.write_closure_fn(mut expr, var_name, closure_var)
            } else {
                g.gen_anon_fn_decl(mut expr)
                g.write('${expr.decl.name}(${var_name})')
            }
        }
        ast.Ident {
            g.write('if (')
            if expr.kind == .function {
                g.write('${c_name(expr.name)}(${var_name})')
            } else if expr.kind == .variable {
                var_info := expr.var_info()
                sym_t := g.table.sym(var_info.typ)
                if sym_t.kind == .function {
                    g.write('${c_name(expr.name)}(${var_name})')
                } else {
                    g.expr(expr)
                }
            } else {
                g.expr(expr)
            }
        }
        ast.CallExpr {
            if expr.name in ['map', 'filter', 'all', 'any', 'count'] {
                is_embed_map_filter = true
                g.set_current_pos_as_last_stmt_pos()
            }
            g.write('if (')
            g.expr(expr)
        }
        ast.LambdaExpr {
            g.write('if (')
            g.expr(expr.expr)
        }
        else {
            g.write('if (')
            g.expr(expr)
        }
    }

    g.writeln2(') {', '\t++${past.tmp_var};')
    g.writeln('}')
    g.indent--
    g.writeln('}')
    if !is_embed_map_filter {
        g.set_current_pos_as_last_stmt_pos()
    }
    if has_infix_left_var_name {
        g.indent--
        g.writeln('}')
        g.set_current_pos_as_last_stmt_pos()
    }
}

fn (mut g Gen) gen_array_all(node ast.CallExpr) {
    past := g.past_tmp_var_new()
    defer {
        g.past_tmp_var_done(past)
    }

    resolved_left_type := g.resolved_array_receiver_type(node)
    sym := g.table.final_sym(g.unwrap_generic(resolved_left_type))
    left_is_array := sym.kind == .array
    elem_type := if left_is_array {
        (sym.info as ast.Array).elem_type
    } else {
        (sym.info as ast.ArrayFixed).elem_type
    }
    elem_type_str := g.styp(elem_type)

    has_infix_left_var_name := g.write_prepared_tmp_value(past.tmp_var, node, 'bool', 'true')
    i := g.new_tmp_var()

    mut expr := node.args[0].expr
    var_name := g.get_array_expr_param_name(mut expr)
    g.refresh_array_expr_param_type(expr, var_name, elem_type)

    mut closure_var := ''
    if mut expr is ast.AnonFn {
        if expr.inherited_vars.len > 0 {
            closure_var = g.new_tmp_var()
            g.declare_closure_fn(mut expr, closure_var)
        }
    }

    g.writeln('for (${ast.int_type_name} ${i} = 0; ${i} < ${past.tmp_var}_len; ++${i}) {')
    g.indent++
    g.write_prepared_var(var_name, elem_type, elem_type_str, past.tmp_var, i, left_is_array, false)
    g.empty_line = true
    g.set_current_pos_as_last_stmt_pos()
    mut is_embed_map_filter := false
    match mut expr {
        ast.AnonFn {
            g.write('if (!(')
            if expr.inherited_vars.len > 0 {
                g.write_closure_fn(mut expr, var_name, closure_var)
            } else {
                g.gen_anon_fn_decl(mut expr)
                g.write('${expr.decl.name}(${var_name})')
            }
        }
        ast.Ident {
            g.write('if (!(')
            if expr.kind == .function {
                g.write('${c_name(expr.name)}(${var_name})')
            } else if expr.kind == .variable {
                var_info := expr.var_info()
                sym_t := g.table.sym(var_info.typ)
                if sym_t.kind == .function {
                    g.write('${c_name(expr.name)}(${var_name})')
                } else {
                    g.expr(expr)
                }
            } else {
                g.expr(expr)
            }
        }
        ast.CallExpr {
            if expr.name in ['map', 'filter', 'all', 'any', 'count'] {
                is_embed_map_filter = true
                g.set_current_pos_as_last_stmt_pos()
            }
            g.write('if (!(')
            g.expr(expr)
        }
        ast.LambdaExpr {
            g.write('if (!(')
            g.expr(expr.expr)
        }
        else {
            g.write('if (!(')
            g.expr(expr)
        }
    }

    g.writeln2(')) {', '\t${past.tmp_var} = false;')
    g.writeln2('\tbreak;', '}')
    g.indent--
    g.writeln('}')
    if !is_embed_map_filter {
        g.set_current_pos_as_last_stmt_pos()
    }
    if has_infix_left_var_name {
        g.indent--
        g.writeln('}')
        g.set_current_pos_as_last_stmt_pos()
    }
}

fn (mut g Gen) resolve_array_call_left_type(node &ast.CallExpr) ast.Type {
    return g.unwrap_generic(g.type_resolver.get_type_or_default(node.left, node.left_type))
}

fn (mut g Gen) write_prepared_tmp_value(tmp string, node &ast.CallExpr, tmp_stype string, initial_value string) bool {
    g.writeln('${tmp_stype} ${tmp} = ${initial_value};')
    has_infix_left_var_name := g.infix_left_var_name.len > 0
    if has_infix_left_var_name {
        g.writeln('if (${g.infix_left_var_name}) {')
        g.infix_left_var_name = ''
        g.indent++
    }
    resolved_left_type := g.resolved_array_receiver_type(*node)
    left_type := if resolved_left_type.has_flag(.shared_f) && resolved_left_type.is_ptr() {
        resolved_left_type.clear_flag(.shared_f).deref()
    } else if resolved_left_type.has_flag(.shared_f) {
        resolved_left_type.clear_flag(.shared_f)
    } else if resolved_left_type.is_ptr() {
        resolved_left_type.deref()
    } else {
        resolved_left_type
    }
    left_sym := g.table.final_sym(left_type)
    if left_sym.kind == .array {
        g.write('${g.styp(left_type)} ${tmp}_orig = ')
        if g.array_receiver_is_indirect(node.left, resolved_left_type) {
            g.write('*')
        }
        g.write_array_receiver(node.left)
        if resolved_left_type.has_flag(.shared_f) {
            g.write('->val')
        }
        g.writeln(';')
        g.writeln('${ast.int_type_name} ${tmp}_len = ${tmp}_orig.len;')
    } else if left_sym.kind == .array_fixed {
        left_info := left_sym.info as ast.ArrayFixed
        left_styp := g.styp(left_type)
        g.writeln('${left_styp} ${tmp}_orig;')
        g.write('memcpy(&${tmp}_orig, &')
        if node.left is ast.ArrayInit {
            g.fixed_array_init_with_cast(node.left, node.left_type)
        } else {
            if !resolved_left_type.has_flag(.shared_f) && resolved_left_type.is_ptr() {
                g.write('*')
            }
            g.write_array_receiver(node.left)
            if resolved_left_type.has_flag(.shared_f) {
                g.write('->val')
            }
        }
        g.writeln(', sizeof(${left_styp}));')
        g.writeln('${ast.int_type_name} ${tmp}_len = ${left_info.size};')
    }
    return has_infix_left_var_name
}

fn (mut g Gen) write_prepared_var(var_name string, elem_type ast.Type, inp_elem_type string, tmp string,
    i string, is_array bool, auto_heap bool) {
    elem_sym := g.table.sym(elem_type)
    if is_array {
        if elem_sym.kind == .array_fixed {
            g.writeln('${inp_elem_type} ${var_name};')
            g.writeln('memcpy(&${var_name}, ((${inp_elem_type}*) ${tmp}_orig.data)[${i}], sizeof(${inp_elem_type}));')
        } else if elem_sym.kind == .function {
            g.writeln('voidptr ${var_name} = ((${inp_elem_type}*) ${tmp}_orig.data)[${i}];')
        } else {
            g.write('${inp_elem_type} ')
            if auto_heap {
                g.write('*')
            }
            g.write('${var_name} = ')
            if auto_heap {
                g.write('&')
            }
            g.writeln('((${inp_elem_type}*) ${tmp}_orig.data)[${i}];')
        }
    } else {
        if elem_sym.kind == .array_fixed {
            g.writeln('${inp_elem_type} ${var_name};')
            g.writeln('memcpy(&${var_name}, &${tmp}_orig[${i}], sizeof(${inp_elem_type}));')
        } else if auto_heap {
            g.writeln('${inp_elem_type} *${var_name} = &${tmp}_orig[${i}];')
        } else if elem_sym.kind == .function {
            g.writeln('voidptr ${var_name} = (voidptr)${tmp}_orig[${i}];')
        } else {
            g.write('${inp_elem_type} ')
            if auto_heap {
                g.write('*')
            }
            g.write('${var_name} = ')
            if auto_heap {
                g.write('&')
            }
            g.writeln('${tmp}_orig[${i}];')
        }
    }
}

fn (mut g Gen) fixed_array_init_with_cast(expr ast.ArrayInit, typ ast.Type) {
    if g.is_cc_msvc {
        stmts := g.go_before_last_stmt().trim_space()
        tmp_var := g.new_tmp_var()
        g.write('${g.styp(typ)} ${tmp_var} = ')
        g.expr(expr)
        g.writeln(';')
        g.write2(stmts, tmp_var)
    } else {
        g.write('(${g.styp(typ)})')
        g.expr(expr)
    }
}

fn (mut g Gen) fixed_array_update_expr_field(expr_str string, field_type ast.Type, field_name string, is_auto_deref bool, elem_type ast.Type, size int, is_update_embed bool) {
    elem_sym := g.table.sym(elem_type)
    if !g.inside_array_fixed_struct {
        g.write('{')
        defer(fn) {
            g.write('}')
        }
    }
    embed_field := if is_update_embed { g.get_embed_field_name(field_type, field_name) } else { '' }
    for i in 0 .. size {
        if elem_sym.info is ast.ArrayFixed {
            init_str := if g.inside_array_fixed_struct {
                '${expr_str}'
            } else {
                '${expr_str}->${embed_field}${c_name(field_name)}[${i}]'
            }
            g.fixed_array_update_expr_field(init_str, field_type, field_name, is_auto_deref,
                elem_sym.info.elem_type, elem_sym.info.size, is_update_embed)
        } else {
            g.write(expr_str)
            if !expr_str.ends_with(']') {
                g.write(g.dot_or_ptr(field_type))
                if is_update_embed {
                    g.write(embed_field)
                }
                g.write(c_name(field_name))
            }
            g.write('[${i}]')
        }
        g.add_commas_and_prevent_long_lines(i, size)
    }
}

fn (mut g Gen) fixed_array_var_init(expr_str string, is_auto_deref bool, elem_type ast.Type, size int) {
    elem_sym := g.table.final_sym(elem_type)
    if !g.inside_array_fixed_struct {
        g.write('{')
        defer(fn) {
            g.write('}')
        }
    }
    for i in 0 .. size {
        if elem_sym.info is ast.ArrayFixed {
            init_str := if g.inside_array_fixed_struct { '${expr_str}' } else { '${expr_str}[${i}]' }
            g.fixed_array_var_init(init_str, is_auto_deref, elem_sym.info.elem_type,
                elem_sym.info.size)
        } else {
            if is_auto_deref {
                g.write('(*')
            }
            g.write(expr_str)
            if is_auto_deref {
                g.write(')')
            }
            if !expr_str.starts_with('(') && !expr_str.starts_with('{') {
                g.write('[${i}]')
            }
        }
        g.add_commas_and_prevent_long_lines(i, size)
    }
}

fn (mut g Gen) get_array_expr_param_name(mut expr ast.Expr) string {
    return if mut expr is ast.LambdaExpr { expr.params[0].name } else { 'it' }
}

fn (mut g Gen) array_expr_param_needs_indirect_access(expr ast.Expr, var_name string) bool {
    return g.array_expr_param_is_auto_heap(expr, var_name)
        || g.array_expr_takes_param_address(expr, var_name)
}

fn (mut g Gen) array_expr_param_is_auto_heap(expr ast.Expr, var_name string) bool {
    if var_name == '' || g.file.scope == unsafe { nil } {
        return false
    }
    mut scope := g.file.scope.innermost(expr.pos().pos)
    if scope == unsafe { nil } {
        scope = g.file.scope
    }
    if scope == unsafe { nil } {
        return false
    }
    if v := scope.find_var(var_name) {
        return v.is_auto_heap
    }
    return false
}

fn (mut g Gen) set_array_expr_param_auto_heap(expr ast.Expr, var_name string, is_auto_heap bool) bool {
    if var_name == '' || g.file.scope == unsafe { nil } {
        return false
    }
    mut scope := g.file.scope.innermost(expr.pos().pos)
    if scope == unsafe { nil } {
        scope = g.file.scope
    }
    if scope == unsafe { nil } {
        return false
    }
    if mut v := scope.find_var(var_name) {
        old_is_auto_heap := v.is_auto_heap
        v.is_auto_heap = is_auto_heap
        return old_is_auto_heap
    }
    return false
}

fn (mut g Gen) array_expr_takes_param_address(expr ast.Expr, var_name string) bool {
    match expr {
        ast.AsCast {
            return g.array_expr_takes_param_address(expr.expr, var_name)
        }
        ast.CallExpr {
            if g.array_expr_takes_param_address(expr.left, var_name) {
                return true
            }
            for arg in expr.args {
                if g.array_expr_takes_param_address(arg.expr, var_name) {
                    return true
                }
            }
            return false
        }
        ast.CastExpr {
            return g.array_expr_takes_param_address(expr.expr, var_name)
        }
        ast.IndexExpr {
            return g.array_expr_takes_param_address(expr.left, var_name)
                || g.array_expr_takes_param_address(expr.index, var_name)
        }
        ast.InfixExpr {
            return g.array_expr_takes_param_address(expr.left, var_name)
                || g.array_expr_takes_param_address(expr.right, var_name)
        }
        ast.LambdaExpr {
            return g.array_expr_takes_param_address(expr.expr, var_name)
        }
        ast.ParExpr {
            return g.array_expr_takes_param_address(expr.expr, var_name)
        }
        ast.PostfixExpr {
            return g.array_expr_takes_param_address(expr.expr, var_name)
        }
        ast.PrefixExpr {
            if expr.op == .amp && g.array_expr_roots_at_param(expr.right, var_name) {
                return true
            }
            return g.array_expr_takes_param_address(expr.right, var_name)
        }
        ast.SelectorExpr {
            return g.array_expr_takes_param_address(expr.expr, var_name)
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) array_expr_roots_at_param(expr ast.Expr, var_name string) bool {
    mut root := expr
    for {
        mut next_root := root
        if mut root is ast.ParExpr {
            next_root = root.expr
        } else {
            break
        }
        root = next_root
    }
    match mut root {
        ast.AsCast {
            return g.array_expr_roots_at_param(root.expr, var_name)
        }
        ast.CastExpr {
            return g.array_expr_roots_at_param(root.expr, var_name)
        }
        ast.Ident {
            return root.name == var_name
        }
        ast.IndexExpr {
            return g.array_expr_roots_at_param(root.left, var_name)
        }
        ast.PostfixExpr {
            return g.array_expr_roots_at_param(root.expr, var_name)
        }
        ast.SelectorExpr {
            return g.array_expr_roots_at_param(root.expr, var_name)
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) refresh_array_expr_param_type(expr ast.Expr, var_name string, elem_type ast.Type) {
    if var_name == '' || elem_type == 0 || g.file.scope == unsafe { nil } {
        return
    }
    mut scope := g.file.scope.innermost(expr.pos().pos)
    if scope == unsafe { nil } {
        scope = g.file.scope
    }
    if scope == unsafe { nil } {
        return
    }
    if mut v := scope.find_var(var_name) {
        v.typ = g.unwrap_generic(g.recheck_concrete_type(elem_type))
        v.orig_type = ast.no_type
        v.smartcasts = []
        v.is_unwrapped = false
        g.clear_type_resolution_caches()
    }
}

const wrap_at_array_element = 0x0F

fn (mut g Gen) add_commas_and_prevent_long_lines(i int, len int) {
    if i != len - 1 {
        g.write(', ')
    }
    // ensure there is a new line at least once per 16 array elements,
    // to prevent too long lines to cause problems with gcc < gcc-11
    if i & wrap_at_array_element == wrap_at_array_element && len - i > wrap_at_array_element {
        g.writeln('')
    }
}

@[inline]
fn (mut g Gen) can_use_c99_designators() bool {
    // see https://gcc.gnu.org/onlinedocs/gcc-4.1.0/gcc/Designated-Inits.html
    // TODO: all compilers should get the same code, when they really support C99..
    return !g.is_cc_msvc && !g.pref.output_cross_c
}

fn (mut g Gen) write_all_n_elements_for_array(len int, value string) {
    for i in 0 .. len {
        g.write(value)
        g.add_commas_and_prevent_long_lines(i, len)
    }
}

fn (mut g Gen) write_c99_elements_for_array(len int, value string) {
    if len == 0 {
        return
    }
    if g.can_use_c99_designators() {
        if value in ['0', '{0}', '((u8)(0))', '{((u8)(0))}', '((u32)(0))', '{((u32)(0))}'] {
            // zeros are fine for all compilers
            g.write('0')
            return
        }
        // TODO remove this check for != gcc, when this works:
        // `screen_pixels [nb_tiles][nb_tiles]u32 = [nb_tiles][nb_tiles]u32{init: [nb_tiles]u32{init: u32(white)}}`
        // i.e. when `white` as a constant can be handled by gcc without this error:
        // `array initialized from non-constant array expression` error, or when `white` is substituted here with its number value.
        if len > $d('cgen_c99_cutoff_limit', 64) {
            if g.pref.ccompiler_type != .gcc {
                if !value.contains('){.') {
                    // Currently, it is generating this, which works with clang and tcc, but not gcc: ` [0 ... 679] = ((u32)(_const_main__white)) `
                    g.write(' [0 ... ${len - 1}] = ${value} ')
                    return
                }
            }
        }
    }
    g.write_all_n_elements_for_array(len, value)
}

@[inline]
fn (mut g Gen) write_c99_0_elements_for_array(len int) {
    if g.can_use_c99_designators() {
        g.write('0')
        return
    }
    g.write_all_n_elements_for_array(len, '0')
}