module transform

import v3.flat
import v3.types

// make_array_new_call builds make array new call data for transform.
fn (mut t Transformer) make_array_new_call(elem_type string, len_expr flat.NodeId, cap_expr flat.NodeId) flat.NodeId {
    return t.make_call_typed('array_new', arr3(t.make_sizeof_type(elem_type), len_expr, cap_expr),
        '[]${elem_type}')
}

fn (mut t Transformer) try_lower_array_repeat_call(_id flat.NodeId, node flat.Node) ?flat.NodeId {
    if node.children_count != 2 {
        return none
    }
    fn_id := t.a.child(&node, 0)
    fn_node := t.a.nodes[int(fn_id)]
    if fn_node.kind != .selector || fn_node.value != 'repeat' || fn_node.children_count == 0 {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    base_type := t.node_type(base_id)
    count_id := t.a.child(&node, 1)
    if expanded := t.try_expand_interface_array_literal_repeat(base_id, count_id, base_type) {
        return expanded
    }
    depth := array_repeat_clone_depth(base_type)
    if depth == 0 {
        return none
    }
    base := t.transform_expr(base_id)
    count := t.transform_expr(count_id)
    selector := t.make_selector(base, 'repeat_to_depth', '')
    return t.make_call_expr_typed(selector, arr2(count, t.make_int_literal(depth)), node.typ)
}

fn (mut t Transformer) try_expand_interface_array_literal_repeat(base_id flat.NodeId, count_id flat.NodeId, base_type string) ?flat.NodeId {
    if !base_type.starts_with('[]') {
        return none
    }
    elem_type := base_type[2..]
    if elem_type !in t.tc.interface_names && t.tc.qualify_name(elem_type) !in t.tc.interface_names {
        return none
    }
    base := t.a.nodes[int(base_id)]
    count_node := t.a.nodes[int(count_id)]
    if base.kind != .array_literal || count_node.kind != .int_literal {
        return none
    }
    count := count_node.value.int()
    if count < 0 || count > 32 {
        return none
    }
    if !t.array_repeat_literal_can_duplicate(base) {
        return none
    }
    mut values := []flat.NodeId{cap: int(base.children_count) * count}
    for _ in 0 .. count {
        for i in 0 .. base.children_count {
            values << t.a.child(&base, i)
        }
    }
    lit := t.make_array_literal_typed(values, base_type)
    return t.transform_array_literal(lit, t.a.nodes[int(lit)])
}

fn (t &Transformer) array_repeat_literal_can_duplicate(node flat.Node) bool {
    for i in 0 .. node.children_count {
        if !t.array_repeat_expr_can_duplicate(t.a.child(&node, i)) {
            return false
        }
    }
    return true
}

fn (t &Transformer) array_repeat_expr_can_duplicate(id flat.NodeId) bool {
    node := t.a.nodes[int(id)]
    match node.kind {
        .int_literal, .float_literal, .bool_literal, .char_literal, .string_literal, .ident,
        .enum_val, .nil_literal, .none_expr {
            return true
        }
        .paren, .prefix, .postfix, .cast_expr, .as_expr, .field_init, .array_literal, .struct_init {
            for i in 0 .. node.children_count {
                if !t.array_repeat_expr_can_duplicate(t.a.child(&node, i)) {
                    return false
                }
            }
            return true
        }
        else {
            return false
        }
    }
}

fn array_repeat_clone_depth(typ string) int {
    mut clean := typ
    if clean.starts_with('&') {
        clean = clean[1..]
    }
    mut depth := 0
    for clean.starts_with('[]') {
        depth++
        clean = clean[2..]
    }
    if depth <= 1 {
        return 0
    }
    return depth - 1
}

fn array_nested_eq_depth(typ string) int {
    mut clean := typ
    if clean.starts_with('&') {
        clean = clean[1..]
    }
    mut depth := 0
    for clean.starts_with('[]') {
        depth++
        clean = clean[2..]
    }
    if depth <= 1 {
        return 1
    }
    return depth
}

fn (mut t Transformer) make_array_push_many_call(lhs_addr flat.NodeId, rhs flat.NodeId, rhs_type string) flat.NodeId {
    t.mark_fn_used('array__push_many')
    rhs_value := t.stable_transformed_expr_for_reuse(rhs, rhs_type, 'push_many')
    return t.make_call_typed('array__push_many', arr3(lhs_addr, t.make_selector(rhs_value, 'data',
        'voidptr'), t.make_selector(rhs_value, 'len', 'int')), 'void')
}

fn (mut t Transformer) make_array_insert_many_call(lhs_addr flat.NodeId, index flat.NodeId, rhs flat.NodeId, rhs_type string) flat.NodeId {
    if t.is_fixed_array_type(rhs_type) {
        return t.make_call_typed('array__insert_many', arr4(lhs_addr, index, rhs,
            t.make_fixed_array_len_expr(rhs_type)), 'void')
    }
    rhs_value := t.stable_transformed_expr_for_reuse(rhs, rhs_type, 'insert_many')
    return t.make_call_typed('array__insert_many', arr4(lhs_addr, index, t.make_selector(rhs_value,
        'data', 'voidptr'), t.make_selector(rhs_value, 'len', 'int')), 'void')
}

fn (mut t Transformer) make_array_clone_call(base_id flat.NodeId, base_type string) flat.NodeId {
    t.mark_fn_used('array__clone')
    receiver := t.transform_expr(base_id)
    return t.make_array_clone_value(receiver, base_type)
}

fn (mut t Transformer) make_array_clone_value(receiver flat.NodeId, base_type string) flat.NodeId {
    clean_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
    depth := array_repeat_clone_depth(clean_type)
    if depth > 0 {
        return t.make_call_typed('array__clone_to_depth', arr2(t.runtime_addr(receiver, base_type),
            t.make_int_literal(depth)), clean_type)
    }
    return t.make_call_typed('array__clone', arr1(t.runtime_addr(receiver, base_type)), clean_type)
}

// lower_array_init_to_runtime converts lower array init to runtime data for transform.
fn (mut t Transformer) lower_array_init_to_runtime(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.value.len == 0 || t.is_fixed_array_type(node.value) {
        return id
    }
    elem_type := node.value
    mut len_expr := t.make_int_literal(0)
    mut cap_expr := t.make_int_literal(0)
    mut init_expr := flat.empty_node
    for i in 0 .. node.children_count {
        child := t.a.child_node(&node, i)
        if child.kind == .field_init && child.children_count > 0 {
            val := t.transform_expr(t.a.child(child, 0))
            if child.value == 'len' {
                len_expr = val
            } else if child.value == 'cap' {
                cap_expr = val
            } else if child.value == 'init' {
                init_expr = val
            }
        }
    }
    new_call := t.make_array_new_call(elem_type, len_expr, cap_expr)
    if int(init_expr) < 0 {
        clean_elem_type := t.normalize_type_alias(elem_type)
        if clean_elem_type.starts_with('[]') {
            init_expr = t.make_array_new_call(clean_elem_type[2..], t.make_int_literal(0),
                t.make_int_literal(0))
        } else if default_value := t.make_struct_runtime_default_value(clean_elem_type) {
            init_expr = default_value
        } else {
            return new_call
        }
    }
    tmp_name := t.new_temp('arr_init')
    idx_name := t.new_temp('arr_idx')
    t.pending_stmts << t.make_decl_assign_typed(tmp_name, new_call, '[]${elem_type}')
    init_idx := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
    cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(t.make_ident(tmp_name),
        'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
    elem_lhs := t.make_index(t.make_ident(tmp_name), t.make_ident(idx_name), elem_type)
    // `init:` expressions may reference the magic `index` variable, which V binds to
    // the current element index. Declare it inside the loop body so it resolves to the
    // generated loop counter instead of leaking to an external symbol (e.g. libc `index`).
    index_decl := t.make_decl_assign_typed('index', t.make_ident(idx_name), 'int')
    mut loop_body := []flat.NodeId{}
    loop_body << index_decl
    mut assign_value := init_expr
    clean_elem_type := t.normalize_type_alias(elem_type)
    if clean_elem_type.starts_with('[]') {
        if !t.expr_can_take_address(assign_value) {
            value_name := t.new_temp('arr_init_val')
            loop_body << t.make_decl_assign_typed(value_name, assign_value, clean_elem_type)
            assign_value = t.make_ident(value_name)
        }
        assign_value = t.make_array_clone_value(assign_value, clean_elem_type)
    }
    assign := t.make_assign(elem_lhs, assign_value)
    loop_body << assign
    t.pending_stmts << t.make_for_stmt(init_idx, cond, post, loop_body, node)
    result := t.make_ident(tmp_name)
    t.a.nodes[int(result)].typ = '[]${elem_type}'
    return result
}

fn (mut t Transformer) make_struct_runtime_default_value(struct_type string) ?flat.NodeId {
    info := t.lookup_struct_info(struct_type) or { return none }
    mut field_ids := []flat.NodeId{}
    for field in info.fields {
        field_type := if field.typ.len > 0 { field.typ } else { field.raw_typ }
        clean_type := t.normalize_type_alias(field_type)
        mut value := flat.empty_node
        if clean_type.starts_with('map[') || clean_type.starts_with('[]') {
            value = t.zero_value_for_type(clean_type)
        } else if nested := t.make_struct_runtime_default_value(clean_type) {
            value = nested
        }
        if int(value) < 0 {
            continue
        }
        start := t.a.children.len
        t.a.children << value
        field_ids << t.a.add_node(flat.Node{
            kind:           .field_init
            children_start: start
            children_count: 1
            value:          field.name
            typ:            field_type
        })
    }
    if field_ids.len == 0 {
        return none
    }
    start := t.a.children.len
    for field_id in field_ids {
        t.a.children << field_id
    }
    return t.a.add_node(flat.Node{
        kind:           .struct_init
        children_start: start
        children_count: flat.child_count(field_ids.len)
        value:          struct_type
        typ:            struct_type
    })
}

// lower_array_literal_to_runtime converts lower array literal to runtime data for transform.
fn (mut t Transformer) lower_array_literal_to_runtime(id flat.NodeId, node flat.Node) flat.NodeId {
    array_type := if checker_alias_type := t.array_literal_checker_alias_type(id) {
        checker_alias_type
    } else if alias_type := t.array_literal_alias_type(node) {
        alias_type
    } else {
        t.node_type(id)
    }
    if !array_type.starts_with('[]') {
        return id
    }
    elem_type := array_type[2..]
    tmp_name := t.new_temp('arr_lit')
    t.pending_stmts << t.make_decl_assign_typed(tmp_name, t.make_array_new_call(elem_type,
        t.make_int_literal(0), t.make_int_literal(node.children_count)), array_type)
    for i in 0 .. node.children_count {
        elem_id := t.a.child(&node, i)
        elem := t.a.nodes[int(elem_id)]
        if elem.kind == .prefix && elem.value == '...' && elem.children_count > 0 {
            spread_id := t.a.child(&elem, 0)
            spread := t.transform_expr(spread_id)
            spread_type := if t.node_type(spread_id).len > 0 {
                t.node_type(spread_id)
            } else {
                array_type
            }
            call := t.make_array_push_many_call(t.make_prefix(.amp, t.make_ident(tmp_name)),
                spread, spread_type)
            t.pending_stmts << t.make_expr_stmt(call)
            continue
        }
        value_name := t.new_temp('arr_val')
        value := if elem_type in t.sum_types || t.resolve_sum_name(elem_type) in t.sum_types {
            t.wrap_sum_value(elem_id, elem_type)
        } else {
            t.transform_expr_for_type(elem_id, elem_type)
        }
        t.pending_stmts << t.make_decl_assign_typed(value_name, value, elem_type)
        call := t.make_call_typed('array_push', arr2(t.make_prefix(.amp, t.make_ident(tmp_name)), t.make_prefix(.amp,
            t.make_ident(value_name))), 'void')
        t.pending_stmts << t.make_expr_stmt(call)
    }
    result := t.make_ident(tmp_name)
    t.a.nodes[int(result)].typ = array_type
    return result
}

fn (t &Transformer) array_literal_checker_alias_type(id flat.NodeId) ?string {
    if isnil(t.tc) || int(id) < 0 {
        return none
    }
    typ := t.tc.expr_type(id) or { t.tc.resolve_type(id) }
    name := typ.name()
    if !name.starts_with('[]') {
        return none
    }
    elem := name[2..]
    if !t.generic_arg_is_alias_name(elem, t.cur_module) {
        return none
    }
    return '[]${elem.all_after_last('.')}'
}

fn (t &Transformer) array_literal_alias_type(node flat.Node) ?string {
    if node.kind != .array_literal || node.children_count == 0 {
        return none
    }
    first_id := t.a.child(&node, 0)
    first := t.a.nodes[int(first_id)]
    mut alias_name := ''
    if first.kind in [.cast_expr, .as_expr] && first.value.len > 0 {
        alias_name = first.value
    } else if first.kind == .call && first.children_count > 0 {
        callee := t.a.child_node(&first, 0)
        if callee.kind == .ident {
            alias_name = callee.value
        }
    }
    if alias_name.len == 0 {
        return none
    }
    if !t.generic_arg_is_alias_name(alias_name, t.cur_module) {
        return none
    }
    return '[]${alias_name}'
}

// transform_array_literal_for_type transforms transform array literal for type data for transform.
fn (mut t Transformer) transform_array_literal_for_type(id flat.NodeId, node flat.Node, target_type string) ?flat.NodeId {
    array_type := if checker_alias_type := t.array_literal_checker_alias_type(id) {
        checker_alias_type
    } else if alias_type := t.array_literal_alias_type(node) {
        alias_type
    } else {
        t.normalize_type_alias(target_type)
    }
    if !array_type.starts_with('[]') {
        return none
    }
    elem_type := array_type[2..]
    tmp_name := t.new_temp('arr_lit')
    t.pending_stmts << t.make_decl_assign_typed(tmp_name, t.make_array_new_call(elem_type,
        t.make_int_literal(0), t.make_int_literal(node.children_count)), array_type)
    for i in 0 .. node.children_count {
        elem_id := t.a.child(&node, i)
        elem := t.a.nodes[int(elem_id)]
        if elem.kind == .prefix && elem.value == '...' && elem.children_count > 0 {
            spread := t.transform_expr_for_type(t.a.child(&elem, 0), array_type)
            call := t.make_array_push_many_call(t.make_prefix(.amp, t.make_ident(tmp_name)),
                spread, array_type)
            t.pending_stmts << t.make_expr_stmt(call)
            continue
        }
        value_name := t.new_temp('arr_val')
        value := if elem_type in t.sum_types || t.resolve_sum_name(elem_type) in t.sum_types {
            t.wrap_sum_value(elem_id, elem_type)
        } else {
            t.transform_expr_for_type(elem_id, elem_type)
        }
        t.pending_stmts << t.make_decl_assign_typed(value_name, value, elem_type)
        call := t.make_call_typed('array_push', arr2(t.make_prefix(.amp, t.make_ident(tmp_name)), t.make_prefix(.amp,
            t.make_ident(value_name))), 'void')
        t.pending_stmts << t.make_expr_stmt(call)
    }
    result := t.make_ident(tmp_name)
    t.a.nodes[int(result)].typ = array_type
    return result
}

fn (mut t Transformer) transform_fixed_array_literal_for_type(_id flat.NodeId, node flat.Node, target_type string) ?flat.NodeId {
    fixed_type := t.normalize_type_alias(target_type)
    if !t.is_fixed_array_type(fixed_type) {
        return none
    }
    elem_type := fixed_array_elem_type(fixed_type)
    mut values := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        elem_id := t.a.child(&node, i)
        values << t.transform_expr_for_type(elem_id, elem_type)
    }
    return t.make_array_literal_typed(values, fixed_type)
}

fn (mut t Transformer) transform_fixed_array_init_expr(node flat.Node) ?flat.NodeId {
    fixed_type := t.normalize_type_alias(if node.value.len > 0 { node.value } else { node.typ })
    if !t.is_fixed_array_type(fixed_type) || node.children_count == 0 {
        return none
    }
    len_text := fixed_array_len_text(fixed_type)
    len := if is_decimal_text(len_text) {
        len_text.int()
    } else if !isnil(t.tc) {
        t.tc.const_int_value_in_module(len_text, t.cur_module, []string{}) or { return none }
    } else {
        return none
    }
    mut init_id := flat.empty_node
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        child := t.a.nodes[int(child_id)]
        if child.kind == .field_init && child.value == 'init' && child.children_count > 0 {
            init_id = t.a.child(&child, 0)
            break
        }
    }
    if int(init_id) < 0 {
        return none
    }
    elem_type := fixed_array_elem_type(fixed_type)
    mut values := []flat.NodeId{cap: len}
    for i in 0 .. len {
        indexed_init := t.substitute_ident_expr(init_id, 'index', t.make_int_literal(i))
        values << t.transform_expr_for_type(indexed_init, elem_type)
    }
    return t.make_array_literal_typed(values, fixed_type)
}

// transform_empty_array_init_for_type supports transform_empty_array_init_for_type handling.
fn (mut t Transformer) transform_empty_array_init_for_type(node flat.Node, target_type string) ?flat.NodeId {
    if node.value.len > 0 || node.children_count > 0 {
        return none
    }
    array_type := t.normalize_type_alias(target_type)
    if !array_type.starts_with('[]') {
        return none
    }
    elem_type := array_type[2..]
    return t.make_array_new_call(elem_type, t.make_int_literal(0), t.make_int_literal(0))
}

// try_lower_array_append_stmt supports try lower array append stmt handling for Transformer.
fn (mut t Transformer) try_lower_array_append_stmt(id flat.NodeId) ?[]flat.NodeId {
    if int(id) < 0 {
        return none
    }
    node := t.a.nodes[int(id)]
    if node.kind != .infix || node.op != .left_shift || node.children_count < 2 {
        return none
    }
    lhs_id := t.a.child(&node, 0)
    mut lhs_type := t.lvalue_type(lhs_id)
    if !array_type_has_generic_placeholder(lhs_type) {
        lhs_type = t.normalize_type_alias(lhs_type)
    }
    mut array_type := t.clean_array_append_lhs_type(lhs_type)
    if !array_type.starts_with('[]') {
        return none
    }
    elem_type := array_type[2..]
    rhs_id := t.a.child(&node, 1)
    mut rhs_type := t.normalize_type_alias(t.node_type(rhs_id))
    rhs_node := t.a.nodes[int(rhs_id)]
    mut push_many := t.array_append_rhs_is_push_many(lhs_id, rhs_id, rhs_type, elem_type)
    if rhs_node.kind == .array_literal && !elem_type.starts_with('[]')
        && !t.is_fixed_array_type(elem_type) {
        // `[]scalar << [a, b, c]` always appends the literal's elements. Retype the
        // literal from the destination so a mis-inferred element type (e.g. `[]int`
        // for `[f32_expr, ..]`) is corrected and the append stays a clean push_many,
        // instead of degrading to a single push of the whole array. (An array-typed
        // element is genuinely ambiguous, so leave that to the inferred decision.)
        push_many = true
        t.a.nodes[int(rhs_id)].typ = array_type
        rhs_type = array_type
    } else if push_many && rhs_node.kind == .array_literal && !rhs_type.starts_with('[]') {
        t.a.nodes[int(rhs_id)].typ = array_type
        rhs_type = array_type
    }

    mut result := []flat.NodeId{}
    lhs := t.transform_lvalue(lhs_id)
    t.drain_pending(mut result)
    mut rhs := if !push_many
        && (elem_type in t.sum_types || t.resolve_sum_name(elem_type) in t.sum_types) {
        t.wrap_sum_value(rhs_id, elem_type)
    } else {
        t.transform_expr(rhs_id)
    }
    if !push_many {
        rhs = t.coerce_transformed_expr_to_type(rhs, rhs_id, elem_type)
    }
    t.drain_pending(mut result)
    if rhs_type.len == 0 {
        rhs_type = t.node_type(rhs)
        push_many = t.array_append_rhs_is_push_many(lhs_id, rhs_id, rhs_type, elem_type)
    }

    lhs_addr := t.runtime_addr(lhs, lhs_type)
    if push_many {
        call := if t.is_fixed_array_type(rhs_type) {
            t.make_call_typed('array_push_many_ptr', arr3(lhs_addr, rhs,
                t.make_fixed_array_len_expr(rhs_type)), 'void')
        } else {
            t.make_array_push_many_call(lhs_addr, rhs, rhs_type)
        }
        result << t.make_expr_stmt(call)
        return result
    }
    value_name := t.new_temp('arr_val')
    result << t.make_decl_assign_typed(value_name, rhs, elem_type)
    result << t.make_expr_stmt(t.make_call_typed('array_push', arr2(lhs_addr, t.make_prefix(.amp,
        t.make_ident(value_name))), 'void'))
    return result
}

// clean_array_append_lhs_type transforms clean array append lhs type data for transform.
fn (t &Transformer) clean_array_append_lhs_type(typ string) string {
    mut clean := if array_type_has_generic_placeholder(typ) {
        typ.trim_space()
    } else {
        t.normalize_type_alias(typ).trim_space()
    }
    for {
        if clean.starts_with('&') {
            clean = clean[1..].trim_space()
            continue
        }
        if clean.starts_with('shared ') {
            clean = clean[7..].trim_space()
            continue
        }
        if clean.starts_with('atomic ') {
            clean = clean[7..].trim_space()
            continue
        }
        break
    }
    return clean
}

fn array_type_has_generic_placeholder(typ string) bool {
    clean := typ.trim_space()
    if clean.len == 0 {
        return false
    }
    if is_generic_placeholder_type_name(clean) {
        return true
    }
    if clean.starts_with('&') {
        return array_type_has_generic_placeholder(clean[1..])
    }
    if clean.starts_with('[]') {
        return array_type_has_generic_placeholder(clean[2..])
    }
    if clean.starts_with('map[') {
        bracket_end := clean.index(']') or { return false }
        return array_type_has_generic_placeholder(clean[4..bracket_end])
            || array_type_has_generic_placeholder(clean[bracket_end + 1..])
    }
    if clean.starts_with('[') {
        bracket_end := clean.index(']') or { return false }
        return array_type_has_generic_placeholder(clean[bracket_end + 1..])
    }
    return false
}

// lower_array_prepend_call builds lower array prepend call data for transform.
fn (mut t Transformer) lower_array_prepend_call(node flat.Node, fn_node flat.Node, base_type string, elem_type string) ?flat.NodeId {
    if node.children_count < 2 || fn_node.children_count == 0 {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    value_id := t.a.child(&node, 1)
    mut rhs_type := t.normalize_type_alias(t.node_type(value_id))
    value_node := t.a.nodes[int(value_id)]
    mut prepend_many := t.array_append_rhs_is_push_many(base_id, value_id, rhs_type, elem_type)
    if value_node.kind == .array_literal && !elem_type.starts_with('[]')
        && !t.is_fixed_array_type(elem_type) {
        prepend_many = true
        t.a.nodes[int(value_id)].typ = base_type
        rhs_type = base_type
    } else if prepend_many && value_node.kind == .array_literal && !rhs_type.starts_with('[]') {
        t.a.nodes[int(value_id)].typ = base_type
        rhs_type = base_type
    }
    base := t.transform_lvalue(base_id)
    if prepend_many {
        value := t.transform_expr(value_id)
        return t.make_array_insert_many_call(t.runtime_addr(base, base_type),
            t.make_int_literal(0), value, rhs_type)
    }
    value := if elem_type in t.sum_types || t.resolve_sum_name(elem_type) in t.sum_types {
        t.wrap_sum_value(value_id, elem_type)
    } else {
        t.transform_expr_for_type(value_id, elem_type)
    }
    value_name := t.new_temp('arr_val')
    t.pending_stmts << t.make_decl_assign_typed(value_name, value, elem_type)
    t.mark_fn_used('array__prepend')
    t.mark_fn_used('array__insert')
    t.mark_fn_used('array__needs_unique_shift')
    return t.make_call_typed('array__prepend', arr2(t.runtime_addr(base, base_type), t.make_prefix(.amp,
        t.make_ident(value_name))), 'void')
}

// lower_array_insert_call builds lower array insert call data for transform.
fn (mut t Transformer) lower_array_insert_call(node flat.Node, fn_node flat.Node, base_type string, elem_type string) ?flat.NodeId {
    if node.children_count < 3 || fn_node.children_count == 0 {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    index_id := t.a.child(&node, 1)
    value_id := t.a.child(&node, 2)
    mut rhs_type := t.normalize_type_alias(t.node_type(value_id))
    value_node := t.a.nodes[int(value_id)]
    mut insert_many := t.array_append_rhs_is_push_many(base_id, value_id, rhs_type, elem_type)
    if value_node.kind == .array_literal && !elem_type.starts_with('[]')
        && !t.is_fixed_array_type(elem_type) {
        insert_many = true
        t.a.nodes[int(value_id)].typ = base_type
        rhs_type = base_type
    } else if insert_many && value_node.kind == .array_literal && !rhs_type.starts_with('[]') {
        t.a.nodes[int(value_id)].typ = base_type
        rhs_type = base_type
    }
    base := t.transform_lvalue(base_id)
    index := t.transform_expr_for_type(index_id, 'int')
    if insert_many {
        value := t.transform_expr(value_id)
        return t.make_array_insert_many_call(t.runtime_addr(base, base_type), index, value,
            rhs_type)
    }
    value := if elem_type in t.sum_types || t.resolve_sum_name(elem_type) in t.sum_types {
        t.wrap_sum_value(value_id, elem_type)
    } else {
        t.transform_expr_for_type(value_id, elem_type)
    }
    value_name := t.new_temp('arr_val')
    t.pending_stmts << t.make_decl_assign_typed(value_name, value, elem_type)
    t.mark_fn_used('array__insert')
    t.mark_fn_used('array__needs_unique_shift')
    return t.make_call_typed('array__insert', arr3(t.runtime_addr(base, base_type), index, t.make_prefix(.amp,
        t.make_ident(value_name))), 'void')
}

fn (mut t Transformer) lower_array_push_many_call(node flat.Node, fn_node flat.Node, base_type string, elem_type string) ?flat.NodeId {
    if node.children_count < 3 || fn_node.children_count == 0 {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    value_id := t.a.child(&node, 1)
    count_id := t.a.child(&node, 2)
    base := t.transform_lvalue(base_id)
    base_addr := t.runtime_addr(base, base_type)
    t.mark_fn_used('array__push_many')
    if t.push_many_count_is_type_name(count_id) {
        value := if elem_type in t.sum_types || t.resolve_sum_name(elem_type) in t.sum_types {
            t.wrap_sum_value(value_id, elem_type)
        } else {
            t.transform_expr_for_type(value_id, elem_type)
        }
        value_name := t.new_temp('arr_val')
        t.pending_stmts << t.make_decl_assign_typed(value_name, value, elem_type)
        return t.make_call_typed('array_push_many_ptr', arr3(base_addr, t.make_prefix(.amp,
            t.make_ident(value_name)), t.make_int_literal(1)), 'void')
    }
    value := t.transform_expr(value_id)
    count := t.transform_expr_for_type(count_id, 'int')
    return t.make_call_typed('array_push_many_ptr', arr3(base_addr, value, count), 'void')
}

fn (t &Transformer) push_many_count_is_type_name(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    return node.kind == .ident && node.value.len > 0 && node.value[0] >= `A` && node.value[0] <= `Z`
}

// array_append_rhs_is_push_many supports array append rhs is push many handling for Transformer.
fn (t &Transformer) array_append_rhs_is_push_many(lhs_id flat.NodeId, rhs_id flat.NodeId, rhs_type string, elem_type string) bool {
    clean_rhs_type := rhs_type.trim_space()
    if clean_rhs_type.starts_with('...') {
        return t.array_append_elem_types_match(clean_rhs_type[3..], elem_type)
    }
    if clean_rhs_type.starts_with('[]') {
        if t.array_append_elem_types_match(clean_rhs_type[2..], elem_type) {
            return true
        }
        if declared_rhs_type := t.array_append_ident_type(rhs_id) {
            if declared_rhs_type.starts_with('...') {
                return t.array_append_elem_types_match(declared_rhs_type[3..], elem_type)
            }
            if declared_rhs_type.starts_with('[]') {
                return t.array_append_elem_types_match(declared_rhs_type[2..], elem_type)
            }
        }
        return false
    }
    if t.is_fixed_array_type(clean_rhs_type) {
        return t.array_append_elem_types_match(fixed_array_elem_type(clean_rhs_type), elem_type)
    }
    if !isnil(t.tc) {
        if rhs_resolved := t.tc.expr_type(rhs_id) {
            rhs_clean := types.unwrap_pointer(rhs_resolved)
            if rhs_clean is types.Array {
                return t.array_append_elem_types_match(rhs_clean.elem_type.name(), elem_type)
            }
            if rhs_clean is types.ArrayFixed {
                return t.array_append_elem_types_match(rhs_clean.elem_type.name(), elem_type)
            }
        }
        if lhs_resolved := t.tc.expr_type(lhs_id) {
            lhs_clean := types.unwrap_pointer(lhs_resolved)
            if lhs_clean is types.Array && clean_rhs_type in ['array', 'Array'] {
                return t.tc.c_type(lhs_clean.elem_type) == 'void*'
            }
        }
    }
    if clean_rhs_type in ['array', 'Array'] {
        return t.array_append_elem_c_type(elem_type) !in ['array', 'Array']
    }
    return false
}

// array_append_elem_types_match supports array append elem types match handling for Transformer.
fn (t &Transformer) array_append_elem_types_match(rhs_elem_type string, lhs_elem_type string) bool {
    rhs_raw := rhs_elem_type.trim_space()
    lhs_raw := lhs_elem_type.trim_space()
    if rhs_raw == lhs_raw {
        return true
    }
    rhs_clean := t.normalize_type_alias(rhs_elem_type)
    lhs_clean := t.normalize_type_alias(lhs_elem_type)
    if rhs_clean == lhs_clean {
        return true
    }
    if isnil(t.tc) {
        return false
    }
    return t.array_append_elem_c_type(rhs_clean) == t.array_append_elem_c_type(lhs_clean)
}

// array_append_ident_type supports array append ident type handling for Transformer.
fn (t &Transformer) array_append_ident_type(id flat.NodeId) ?string {
    if int(id) < 0 {
        return none
    }
    node := t.a.nodes[int(id)]
    if node.kind != .ident || node.value.len == 0 {
        return none
    }
    typ := t.var_type(node.value)
    if typ.len == 0 {
        return none
    }
    return typ
}

// array_append_elem_c_type supports array append elem c type handling for Transformer.
fn (t &Transformer) array_append_elem_c_type(typ string) string {
    if isnil(t.tc) {
        return typ
    }
    clean := typ.trim_space()
    if clean.len == 0 {
        return clean
    }
    if !clean.contains('.') {
        for alias, target in t.tc.type_aliases {
            if alias.all_after_last('.') == clean {
                return t.tc.c_type(t.tc.parse_type(target))
            }
        }
    }
    return t.tc.c_type(t.tc.parse_type(clean))
}

// array_get_value supports array get value handling for Transformer.
fn (mut t Transformer) array_get_value(base flat.NodeId, index flat.NodeId, elem_type string) flat.NodeId {
    get_call := t.make_call_typed('array_get', arr2(base, index), 'voidptr')
    ptr := t.make_cast('&${elem_type}', get_call, '&${elem_type}')
    value := t.make_prefix(.mul, ptr)
    t.a.nodes[int(value)].typ = elem_type
    return value
}

// array_get_ptr supports array get ptr handling for Transformer.
fn (mut t Transformer) array_get_ptr(base flat.NodeId, index flat.NodeId, elem_type string) flat.NodeId {
    get_call := t.make_call_typed('array_get', arr2(base, index), 'voidptr')
    return t.make_cast('&${elem_type}', get_call, '&${elem_type}')
}

// lower_array_filter_call builds lower array filter call data for transform.
fn (mut t Transformer) lower_array_filter_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if node.children_count < 2 || !base_type.starts_with('[]') {
        return none
    }
    elem_type := base_type[2..]
    base_id := t.a.child(&fn_node, 0)
    base := t.stable_expr_for_reuse(base_id)
    mut prefix := []flat.NodeId{}
    t.drain_pending(mut prefix)
    out_name := t.new_temp('filter')
    idx_name := t.new_temp('filter_idx')
    prefix << t.make_decl_assign_typed(out_name, t.make_array_new_call(elem_type,
        t.make_int_literal(0), t.make_selector(base, 'len', 'int')), base_type)
    init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
    cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(base, 'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
    elem_name_default := t.new_temp('filter_it')
    elem_expr := t.array_get_value(base, t.make_ident(idx_name), elem_type)
    predicate_id := t.a.child(&node, 1)
    predicate_node := t.a.nodes[int(predicate_id)]
    mut predicate_expr_id := predicate_id
    mut lambda_param := ''
    mut predicate_fn_name := ''
    if predicate_node.kind == .lambda_expr && predicate_node.children_count > 0 {
        predicate_expr_id = t.a.child(&predicate_node, predicate_node.children_count - 1)
        if predicate_node.children_count > 1 {
            param := t.a.child_node(&predicate_node, 0)
            if param.kind == .ident && param.value.len > 0 {
                lambda_param = param.value
            }
        }
    } else if predicate_node.kind == .ident {
        if fn_name := t.resolve_fn_value_ident(predicate_node.value) {
            predicate_fn_name = fn_name
        } else if ret_type := t.fn_value_return_type_name(predicate_id) {
            if ret_type == 'bool' {
                predicate_fn_name = predicate_node.value
            }
        }
    }
    elem_name := if lambda_param.len > 0 { lambda_param } else { elem_name_default }
    elem_decl := t.make_decl_assign_typed(elem_name, elem_expr, elem_type)
    old_elem := t.var_type(elem_name)
    t.set_var_type(elem_name, elem_type)
    predicate_source := if lambda_param.len > 0 {
        predicate_expr_id
    } else {
        t.substitute_ident(predicate_expr_id, 'it', elem_name)
    }
    saved_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    predicate := if predicate_fn_name.len > 0 {
        t.make_call_typed(predicate_fn_name, arr1(t.make_ident(elem_name)), 'bool')
    } else if predicate_node.kind == .fn_literal {
        fn_value := t.transform_expr(predicate_id)
        fn_value_node := t.a.nodes[int(fn_value)]
        if fn_value_node.kind == .ident {
            t.make_call_typed(fn_value_node.value, arr1(t.make_ident(elem_name)), 'bool')
        } else {
            fn_value
        }
    } else {
        t.transform_expr(predicate_source)
    }
    predicate_pending := t.pending_stmts.clone()
    t.pending_stmts = saved_pending
    if old_elem.len > 0 {
        t.set_var_type(elem_name, old_elem)
    } else {
        t.unset_var_type(elem_name)
    }
    mut loop_body := []flat.NodeId{}
    loop_body << elem_decl
    for stmt in predicate_pending {
        loop_body << stmt
    }
    push_call := t.make_call_typed('array_push', arr2(t.make_prefix(.amp, t.make_ident(out_name)), t.make_prefix(.amp,
        t.make_ident(elem_name))), 'void')
    then_block := t.make_block(arr1(t.make_expr_stmt(push_call)))
    loop_body << t.make_if(predicate, then_block, t.make_empty())
    prefix << t.make_for_stmt(init, cond, post, loop_body, node)
    for stmt in prefix {
        t.pending_stmts << stmt
    }
    return t.make_ident(out_name)
}

// lower_array_map_call builds lower array map call data for transform.
fn (mut t Transformer) lower_array_map_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if node.children_count < 2 || !base_type.starts_with('[]') {
        return none
    }
    elem_type := base_type[2..]
    map_expr_id := t.a.child(&node, 1)
    map_expr := t.a.nodes[int(map_expr_id)]
    mut map_fn_name := ''
    elem_name := t.new_temp('map_it')
    old_elem := t.var_type(elem_name)
    t.set_var_type(elem_name, elem_type)
    mapped_source := t.substitute_ident(map_expr_id, 'it', elem_name)
    mut result_elem_type := t.node_type(map_expr_id)
    mut direct_selector_type := ''
    mut mapped_source_node := t.a.nodes[int(mapped_source)]
    if mapped_source_node.kind == .map_init {
        inferred_map_type := t.infer_map_init_entry_type(mapped_source_node)
        if inferred_map_type.len > 0 {
            result_elem_type = inferred_map_type
            t.a.nodes[int(mapped_source)].value = inferred_map_type
            t.a.nodes[int(mapped_source)].typ = inferred_map_type
            mapped_source_node = t.a.nodes[int(mapped_source)]
        }
    }
    if mapped_source_node.kind == .selector {
        selector_type := t.resolve_selector_type(mapped_source_node)
        if selector_type.len > 0 {
            direct_selector_type = selector_type
            result_elem_type = selector_type
        }
    }
    if map_expr.kind == .ident {
        if fn_name := t.resolve_fn_value_ident(map_expr.value) {
            map_fn_name = fn_name
            if ret := t.fn_ret_types[fn_name] {
                result_elem_type = ret
            } else if !isnil(t.tc) {
                if ret_type := t.tc.fn_ret_types[fn_name] {
                    result_elem_type = t.normalize_type_alias(ret_type.name())
                }
            }
        } else if ret_type := t.fn_value_return_type_name(map_expr_id) {
            map_fn_name = map_expr.value
            result_elem_type = ret_type
        }
    } else if map_expr.kind == .fn_literal || map_expr.kind == .lambda_expr {
        if ret_type := t.fn_value_return_type_name(map_expr_id) {
            result_elem_type = ret_type
        }
    }
    if result_elem_type.len == 0 {
        result_elem_type = t.reliable_stringify_type(map_expr_id)
    }
    saved_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    mapped_expr := if map_fn_name.len > 0 {
        t.make_call_typed(map_fn_name, arr1(t.make_ident(elem_name)), result_elem_type)
    } else if map_expr.kind == .fn_literal || map_expr.kind == .lambda_expr {
        fn_value := t.transform_expr(map_expr_id)
        fn_value_node := t.a.nodes[int(fn_value)]
        if fn_value_node.kind == .ident && result_elem_type.len > 0 {
            t.make_call_typed(fn_value_node.value, arr1(t.make_ident(elem_name)), result_elem_type)
        } else {
            fn_value
        }
    } else if mapped_source_node.kind == .map_init && result_elem_type.starts_with('map[') {
        t.transform_expr_for_type(mapped_source, result_elem_type)
    } else {
        t.transform_expr(mapped_source)
    }
    mapped_pending := t.pending_stmts.clone()
    t.pending_stmts = saved_pending
    if old_elem.len > 0 {
        t.set_var_type(elem_name, old_elem)
    } else {
        t.unset_var_type(elem_name)
    }
    mapped_type := t.node_type(mapped_expr)
    if mapped_type.len > 0 && mapped_type != 'unknown' {
        result_elem_type = mapped_type
    }
    if direct_selector_type.len > 0 {
        result_elem_type = direct_selector_type
    }
    if mapped_expr_node := t.selector_expr_node(mapped_expr) {
        selector_type := t.resolve_selector_type(mapped_expr_node)
        if selector_type.len > 0 {
            result_elem_type = selector_type
        }
    }
    if result_elem_type.len == 0 {
        result_elem_type = elem_type
    }
    out_type := '[]${result_elem_type}'
    base_id := t.a.child(&fn_node, 0)
    base := t.stable_expr_for_reuse(base_id)
    mut prefix := []flat.NodeId{}
    t.drain_pending(mut prefix)
    out_name := t.new_temp('map')
    idx_name := t.new_temp('map_idx')
    prefix << t.make_decl_assign_typed(out_name, t.make_array_new_call(result_elem_type,
        t.make_int_literal(0), t.make_selector(base, 'len', 'int')), out_type)
    init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
    cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(base, 'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
    elem_expr := t.array_get_value(base, t.make_ident(idx_name), elem_type)
    elem_decl := t.make_decl_assign_typed(elem_name, elem_expr, elem_type)
    mut loop_body := []flat.NodeId{}
    loop_body << elem_decl
    for stmt in mapped_pending {
        loop_body << stmt
    }
    value_name := t.new_temp('map_val')
    loop_body << t.make_decl_assign_typed(value_name, mapped_expr, result_elem_type)
    loop_body << t.make_expr_stmt(t.make_call_typed('array_push', arr2(t.make_prefix(.amp,
        t.make_ident(out_name)), t.make_prefix(.amp, t.make_ident(value_name))), 'void'))
    prefix << t.make_for_stmt(init, cond, post, loop_body, node)
    for stmt in prefix {
        t.pending_stmts << stmt
    }
    result := t.make_ident(out_name)
    t.a.nodes[int(result)].typ = out_type
    return result
}

fn (t &Transformer) fn_value_return_type_name(id flat.NodeId) ?string {
    if int(id) < 0 {
        return none
    }
    node := t.a.nodes[int(id)]
    mut typ := node.typ
    if node.kind == .ident {
        typ = t.var_type(node.value)
    }
    if typ.len == 0 || isnil(t.tc) {
        return none
    }
    parsed := t.tc.parse_type(typ)
    if parsed is types.FnType {
        name := parsed.return_type.name()
        if name.len > 0 {
            return t.normalize_type_alias(name)
        }
    }
    return none
}

// selector_expr_node supports selector expr node handling for Transformer.
fn (t &Transformer) selector_expr_node(id flat.NodeId) ?flat.Node {
    if int(id) < 0 {
        return none
    }
    node := t.a.nodes[int(id)]
    if node.kind == .selector {
        return node
    }
    return none
}

// substitute_ident supports substitute ident handling for Transformer.
fn (mut t Transformer) substitute_ident(id flat.NodeId, name string, replacement string) flat.NodeId {
    if int(id) < 0 || name.len == 0 || replacement.len == 0 || name == replacement {
        return id
    }
    node := t.a.nodes[int(id)]
    if node.kind == .ident && node.value == name {
        new_id := t.make_ident(replacement)
        if t.a.nodes[int(new_id)].typ.len == 0 {
            t.a.nodes[int(new_id)].typ = node.typ
        }
        return new_id
    }
    if node.kind == .lambda_expr && node.children_count > 1 {
        first := t.a.child_node(&node, 0)
        if first.kind == .ident && first.value == name {
            return id
        }
    }
    if node.kind == .call && node.children_count > 1 {
        fn_id := t.a.child(&node, 0)
        fn_node := t.a.nodes[int(fn_id)]
        if fn_node.kind == .selector && fn_node.value in ['any', 'all', 'count', 'filter', 'map'] {
            mut new_children := []flat.NodeId{cap: int(node.children_count)}
            new_children << t.substitute_ident(fn_id, name, replacement)
            for i in 1 .. node.children_count {
                new_children << t.a.child(&node, i)
            }
            start := t.a.children.len
            for child in new_children {
                t.a.children << child
            }
            return t.a.add_node(flat.Node{
                kind:           node.kind
                op:             node.op
                children_start: start
                children_count: flat.child_count(new_children.len)
                pos:            node.pos
                value:          node.value
                typ:            node.typ
            })
        }
    }
    if node.children_count == 0 {
        return id
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        new_children << t.substitute_ident(t.a.child(&node, i), name, replacement)
    }
    start := t.a.children.len
    for child in new_children {
        t.a.children << child
    }
    return t.a.add_node(flat.Node{
        kind:           node.kind
        op:             node.op
        kind_id:        node.kind_id
        children_start: start
        children_count: flat.child_count(new_children.len)
        pos:            node.pos
        value:          node.value
        typ:            node.typ
        generic_params: node.generic_params.clone()
    })
}

fn (mut t Transformer) substitute_ident_expr(id flat.NodeId, name string, replacement flat.NodeId) flat.NodeId {
    if int(id) < 0 || name.len == 0 || int(replacement) < 0 {
        return id
    }
    node := t.a.nodes[int(id)]
    if node.kind == .ident && node.value == name {
        return replacement
    }
    if node.kind == .lambda_expr && node.children_count > 1 {
        first := t.a.child_node(&node, 0)
        if first.kind == .ident && first.value == name {
            return id
        }
    }
    if node.children_count == 0 {
        return id
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        new_children << t.substitute_ident_expr(t.a.child(&node, i), name, replacement)
    }
    start := t.a.children.len
    for child in new_children {
        t.a.children << child
    }
    return t.a.add_node(flat.Node{
        kind:           node.kind
        op:             node.op
        kind_id:        node.kind_id
        children_start: start
        children_count: flat.child_count(new_children.len)
        pos:            node.pos
        value:          node.value
        typ:            node.typ
        generic_params: node.generic_params.clone()
    })
}

fn (mut t Transformer) infer_map_init_entry_type(node flat.Node) string {
    if node.kind != .map_init || node.children_count < 2 {
        return ''
    }
    key_type := t.node_type(t.a.child(&node, 0))
    value_type := t.node_type(t.a.child(&node, 1))
    if key_type.len == 0 || value_type.len == 0 {
        return ''
    }
    return 'map[${key_type}]${value_type}'
}

fn (t &Transformer) is_array_transform_call(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    if node.kind != .call || node.children_count == 0 {
        return false
    }
    fn_id := t.a.child(&node, 0)
    fn_node := t.a.nodes[int(fn_id)]
    if fn_node.kind != .selector || fn_node.children_count == 0 {
        return false
    }
    if fn_node.value !in ['filter', 'map', 'sorted'] {
        return false
    }
    base_type := t.node_type(t.a.child(&fn_node, 0))
    return base_type.starts_with('[]')
}

// lower_array_count_call builds lower array count call data for transform.
fn (mut t Transformer) lower_array_count_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if node.children_count < 2 || !base_type.starts_with('[]') {
        return none
    }
    elem_type := base_type[2..]
    base_id := t.a.child(&fn_node, 0)
    base := t.stable_expr_for_reuse(base_id)
    mut prefix := []flat.NodeId{}
    t.drain_pending(mut prefix)
    result_name := t.new_temp('count')
    idx_name := t.new_temp('count_idx')
    prefix << t.make_decl_assign_typed(result_name, t.make_int_literal(0), 'int')
    init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
    cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(base, 'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
    elem_name := t.new_temp('count_it')
    elem_expr := t.array_get_value(base, t.make_ident(idx_name), elem_type)
    elem_decl := t.make_decl_assign_typed(elem_name, elem_expr, elem_type)
    predicate_id := t.a.child(&node, 1)
    old_elem := t.var_type(elem_name)
    t.set_var_type(elem_name, elem_type)
    predicate := t.transform_expr(t.substitute_ident(predicate_id, 'it', elem_name))
    if old_elem.len > 0 {
        t.set_var_type(elem_name, old_elem)
    } else {
        t.unset_var_type(elem_name)
    }
    mut loop_body := []flat.NodeId{}
    loop_body << elem_decl
    t.drain_pending(mut loop_body)
    inc := t.make_assign_op(t.make_ident(result_name), t.make_int_literal(1), .plus_assign)
    loop_body << t.make_if(predicate, t.make_block(arr1(inc)), t.make_empty())
    prefix << t.make_for_stmt(init, cond, post, loop_body, node)
    for stmt in prefix {
        t.pending_stmts << stmt
    }
    return t.make_ident(result_name)
}

// lower_array_any_all_call builds lower array any all call data for transform.
fn (mut t Transformer) lower_array_any_all_call(node flat.Node, fn_node flat.Node, base_type string, method string) ?flat.NodeId {
    if node.children_count < 2 || !base_type.starts_with('[]') {
        return none
    }
    elem_type := base_type[2..]
    base_id := t.a.child(&fn_node, 0)
    base := t.stable_expr_for_reuse(base_id)
    mut prefix := []flat.NodeId{}
    t.drain_pending(mut prefix)
    result_name := t.new_temp(method)
    idx_name := t.new_temp('${method}_idx')
    default_value := if method == 'all' {
        t.make_bool_literal(true)
    } else {
        t.make_bool_literal(false)
    }
    prefix << t.make_decl_assign_typed(result_name, default_value, 'bool')
    init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
    cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(base, 'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
    elem_name := t.new_temp('${method}_it')
    elem_expr := t.array_get_value(base, t.make_ident(idx_name), elem_type)
    elem_decl := t.make_decl_assign_typed(elem_name, elem_expr, elem_type)
    predicate_id := t.a.child(&node, 1)
    old_elem := t.var_type(elem_name)
    t.set_var_type(elem_name, elem_type)
    predicate := t.transform_expr(t.substitute_ident(predicate_id, 'it', elem_name))
    if old_elem.len > 0 {
        t.set_var_type(elem_name, old_elem)
    } else {
        t.unset_var_type(elem_name)
    }
    mut loop_body := []flat.NodeId{}
    loop_body << elem_decl
    t.drain_pending(mut loop_body)
    if method == 'all' {
        not_predicate := t.make_prefix(.not, predicate)
        assign_false := t.make_assign(t.make_ident(result_name), t.make_bool_literal(false))
        loop_body << t.make_if(not_predicate, t.make_block(arr1(assign_false)), t.make_empty())
    } else {
        assign_true := t.make_assign(t.make_ident(result_name), t.make_bool_literal(true))
        loop_body << t.make_if(predicate, t.make_block(arr1(assign_true)), t.make_empty())
    }
    prefix << t.make_for_stmt(init, cond, post, loop_body, node)
    for stmt in prefix {
        t.pending_stmts << stmt
    }
    return t.make_ident(result_name)
}

// lower_array_sort_call builds lower array sort call data for transform.
fn (mut t Transformer) lower_array_sort_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if !base_type.starts_with('[]') && !(base_type.starts_with('&')
        && base_type[1..].starts_with('[]')) {
        return none
    }
    if node.children_count > 2 {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    base := t.transform_lvalue(base_id)
    clean_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
    elem_type := clean_type[2..]
    cmp_id := if node.children_count > 1 { t.a.child(&node, 1) } else { flat.empty_node }
    t.pending_stmts << t.make_array_default_sort_stmt(base, elem_type, node, cmp_id)
    return t.make_empty()
}

// lower_array_sorted_call builds lower array sorted call data for transform.
fn (mut t Transformer) lower_array_sorted_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if node.children_count > 2 || !base_type.starts_with('[]') {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    clone_name := t.new_temp('sorted')
    clone_call := t.make_array_clone_call(base_id, base_type)
    t.set_var_type(clone_name, base_type)
    t.pending_stmts << t.make_decl_assign_typed(clone_name, clone_call, base_type)
    cmp_id := if node.children_count > 1 { t.a.child(&node, 1) } else { flat.empty_node }
    t.pending_stmts << t.make_array_default_sort_stmt(t.make_ident(clone_name), base_type[2..],
        node, cmp_id)
    return t.make_ident(clone_name)
}

// lower_array_sort_with_compare_call builds lower array sort with compare call data for transform.
fn (mut t Transformer) lower_array_sort_with_compare_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if node.children_count != 2
        || (!base_type.starts_with('[]') && !(base_type.starts_with('&')
        && base_type[1..].starts_with('[]'))) {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    base := t.transform_lvalue(base_id)
    clean_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
    elem_type := clean_type[2..]
    cmp := t.stable_array_compare_fn(t.a.child(&node, 1), elem_type)
    t.pending_stmts << t.make_array_compare_sort_stmt(base, elem_type, node, cmp)
    return t.make_empty()
}

// lower_array_sorted_with_compare_call supports lower_array_sorted_with_compare_call handling.
fn (mut t Transformer) lower_array_sorted_with_compare_call(node flat.Node, fn_node flat.Node, base_type string) ?flat.NodeId {
    if node.children_count != 2 || !base_type.starts_with('[]') {
        return none
    }
    base_id := t.a.child(&fn_node, 0)
    clone_name := t.new_temp('sorted')
    clone_call := t.make_array_clone_call(base_id, base_type)
    elem_type := base_type[2..]
    cmp := t.stable_array_compare_fn(t.a.child(&node, 1), elem_type)
    t.set_var_type(clone_name, base_type)
    t.pending_stmts << t.make_decl_assign_typed(clone_name, clone_call, base_type)
    t.pending_stmts << t.make_array_compare_sort_stmt(t.make_ident(clone_name), elem_type, node, cmp)
    return t.make_ident(clone_name)
}

// stable_array_compare_fn supports stable array compare fn handling for Transformer.
fn (mut t Transformer) stable_array_compare_fn(cmp_id flat.NodeId, elem_type string) flat.NodeId {
    cmp := t.transform_expr(cmp_id)
    cmp_type := 'fn (&${elem_type}, &${elem_type}) int'
    return t.stable_transformed_expr_for_reuse(cmp, cmp_type, 'sort_cmp')
}

// make_array_default_sort_stmt builds make array default sort stmt data for transform.
fn (mut t Transformer) make_array_default_sort_stmt(base flat.NodeId, elem_type string, src flat.Node, cmp_id flat.NodeId) flat.NodeId {
    i_name := t.new_temp('sort_i')
    j_name := t.new_temp('sort_j')
    tmp_name := t.new_temp('sort_tmp')
    t.set_var_type(i_name, 'int')
    t.set_var_type(j_name, 'int')
    t.set_var_type(tmp_name, elem_type)
    init := t.make_decl_assign_typed(i_name, t.make_int_literal(1), 'int')
    cond := t.make_infix(.lt, t.make_ident(i_name), t.make_selector(base, 'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(i_name), .inc))
    j_decl := t.make_decl_assign_typed(j_name, t.make_ident(i_name), 'int')
    inner_cond := t.make_infix(.logical_and, t.make_infix(.gt, t.make_ident(j_name),
        t.make_int_literal(0)), t.array_sort_less_expr(base, elem_type, j_name, cmp_id))
    tmp_decl := t.make_decl_assign_typed(tmp_name, t.make_index(base, t.make_ident(j_name),
        elem_type), elem_type)
    prev_idx := t.make_infix(.minus, t.make_ident(j_name), t.make_int_literal(1))
    assign_cur := t.make_index_assign(t.make_index(base, t.make_ident(j_name), elem_type), t.make_index(base,
        prev_idx, elem_type))
    prev_idx2 := t.make_infix(.minus, t.make_ident(j_name), t.make_int_literal(1))
    assign_prev := t.make_index_assign(t.make_index(base, prev_idx2, elem_type),
        t.make_ident(tmp_name))
    dec_j := t.make_expr_stmt(t.make_postfix(t.make_ident(j_name), .dec))
    inner_body := [tmp_decl, assign_cur, assign_prev, dec_j]
    inner_for := t.make_for_stmt(t.make_empty(), inner_cond, t.make_empty(), inner_body, src)
    return t.make_for_stmt(init, cond, post, [j_decl, inner_for], src)
}

// make_array_compare_sort_stmt builds make array compare sort stmt data for transform.
fn (mut t Transformer) make_array_compare_sort_stmt(base flat.NodeId, elem_type string, src flat.Node, cmp flat.NodeId) flat.NodeId {
    i_name := t.new_temp('sort_i')
    j_name := t.new_temp('sort_j')
    tmp_name := t.new_temp('sort_tmp')
    t.set_var_type(i_name, 'int')
    t.set_var_type(j_name, 'int')
    t.set_var_type(tmp_name, elem_type)
    init := t.make_decl_assign_typed(i_name, t.make_int_literal(1), 'int')
    cond := t.make_infix(.lt, t.make_ident(i_name), t.make_selector(base, 'len', 'int'))
    post := t.make_expr_stmt(t.make_postfix(t.make_ident(i_name), .inc))
    j_decl := t.make_decl_assign_typed(j_name, t.make_ident(i_name), 'int')
    inner_cond := t.make_infix(.logical_and, t.make_infix(.gt, t.make_ident(j_name),
        t.make_int_literal(0)), t.array_sort_compare_less_expr(base, elem_type, j_name, cmp))
    tmp_decl := t.make_decl_assign_typed(tmp_name, t.make_index(base, t.make_ident(j_name),
        elem_type), elem_type)
    prev_idx := t.make_infix(.minus, t.make_ident(j_name), t.make_int_literal(1))
    assign_cur := t.make_index_assign(t.make_index(base, t.make_ident(j_name), elem_type), t.make_index(base,
        prev_idx, elem_type))
    prev_idx2 := t.make_infix(.minus, t.make_ident(j_name), t.make_int_literal(1))
    assign_prev := t.make_index_assign(t.make_index(base, prev_idx2, elem_type),
        t.make_ident(tmp_name))
    dec_j := t.make_expr_stmt(t.make_postfix(t.make_ident(j_name), .dec))
    inner_body := [tmp_decl, assign_cur, assign_prev, dec_j]
    inner_for := t.make_for_stmt(t.make_empty(), inner_cond, t.make_empty(), inner_body, src)
    return t.make_for_stmt(init, cond, post, [j_decl, inner_for], src)
}

// array_sort_less_expr supports array sort less expr handling for Transformer.
fn (mut t Transformer) array_sort_less_expr(base flat.NodeId, elem_type string, idx_name string, cmp_id flat.NodeId) flat.NodeId {
    cur := t.make_index(base, t.make_ident(idx_name), elem_type)
    prev := t.make_index(base, t.make_infix(.minus, t.make_ident(idx_name), t.make_int_literal(1)),
        elem_type)
    if int(cmp_id) >= 0 {
        old_a := t.var_type('a')
        old_b := t.var_type('b')
        t.set_var_type('a', elem_type)
        t.set_var_type('b', elem_type)
        raw_cmp := t.substitute_array_sort_vars(cmp_id, cur, prev)
        cmp := t.transform_expr(raw_cmp)
        if old_a.len > 0 {
            t.set_var_type('a', old_a)
        } else {
            t.unset_var_type('a')
        }
        if old_b.len > 0 {
            t.set_var_type('b', old_b)
        } else {
            t.unset_var_type('b')
        }
        return cmp
    }
    if elem_type == 'string' {
        return t.make_call_typed('string__lt', arr2(cur, prev), 'bool')
    }
    return t.make_infix(.lt, cur, prev)
}

// array_sort_compare_less_expr supports array sort compare less expr handling for Transformer.
fn (mut t Transformer) array_sort_compare_less_expr(base flat.NodeId, elem_type string, idx_name string, cmp flat.NodeId) flat.NodeId {
    cur := t.make_index(base, t.make_ident(idx_name), elem_type)
    prev := t.make_index(base, t.make_infix(.minus, t.make_ident(idx_name), t.make_int_literal(1)),
        elem_type)
    call := t.make_call_expr_typed(cmp, arr2(t.make_prefix(.amp, cur), t.make_prefix(.amp, prev)),
        'int')
    return t.make_infix(.lt, call, t.make_int_literal(0))
}

// substitute_array_sort_vars supports substitute array sort vars handling for Transformer.
fn (mut t Transformer) substitute_array_sort_vars(id flat.NodeId, a_expr flat.NodeId, b_expr flat.NodeId) flat.NodeId {
    if int(id) < 0 {
        return id
    }
    node := t.a.nodes[int(id)]
    if node.kind == .ident {
        if node.value == 'a' {
            return a_expr
        }
        if node.value == 'b' {
            return b_expr
        }
        return id
    }
    if node.children_count == 0 {
        return id
    }
    mut children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        children << t.substitute_array_sort_vars(t.a.child(&node, i), a_expr, b_expr)
    }
    start := t.a.children.len
    for child in children {
        t.a.children << child
    }
    return t.a.add_node(flat.Node{
        kind:           node.kind
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
}

// make_index_assign builds make index assign data for transform.
fn (mut t Transformer) make_index_assign(lhs flat.NodeId, rhs flat.NodeId) flat.NodeId {
    start := t.a.children.len
    t.a.children << lhs
    t.a.children << rhs
    return t.a.add_node(flat.Node{
        kind:           .index_assign
        op:             .assign
        children_start: start
        children_count: 2
    })
}