module transform

import v3.flat
import v3.types

// arr1 supports arr1 handling for transform.
fn arr1(a flat.NodeId) []flat.NodeId {
    mut r := []flat.NodeId{}
    r << a
    return r
}

// arr2 supports arr2 handling for transform.
fn arr2(a flat.NodeId, b flat.NodeId) []flat.NodeId {
    mut r := []flat.NodeId{}
    r << a
    r << b
    return r
}

// arr3 supports arr3 handling for transform.
fn arr3(a flat.NodeId, b flat.NodeId, c flat.NodeId) []flat.NodeId {
    mut r := []flat.NodeId{}
    r << a
    r << b
    r << c
    return r
}

// node_kind_id supports node kind id handling for transform.
fn node_kind_id(node flat.Node) int {
    mut kind_id := node.kind_id
    if kind_id == 0 && int(node.kind) != 0 {
        kind_id = int(node.kind)
    }
    return kind_id
}

// SmartcastContext stores smartcast context state used by transform.
pub struct SmartcastContext {
pub:
    expr_name     string // the expression being smartcast (e.g. "node")
    variant_name  string // the variant type name (e.g. "Ident")
    sum_type_name string // the parent sum type name (e.g. "Expr")
}

// Transformer represents transformer data used by transform.
pub struct Transformer {
mut:
    a                     &flat.FlatAst      = unsafe { nil }
    tc                    &types.TypeChecker = unsafe { nil }
    structs               map[string]StructInfo
    unique_fields         map[string]string
    alias_methods         map[string]string
    globals               map[string]string
    sum_types             map[string][]string
    sum_variant_parents   map[string][]string
    sum_variant_fields    map[string]string
    qualified_types       map[string]string
    fn_ret_types          map[string]string
    const_suffixes        map[string]string
    enum_types            map[string][]string
    cur_file              string
    cur_module            string
    cur_fn_name           string
    cur_fn_ret_type       string
    var_types             []VarTypeBinding
    pointer_value_lvalues map[string]bool
    temp_counter          int
    pending_stmts         []flat.NodeId
    smartcast_stack       []SmartcastContext
    in_call_callee        bool
    in_const_init         bool
    in_return_expr        bool
    alias_cache           &AliasCache = unsafe { nil }
    sum_cache             &AliasCache = unsafe { nil }
    used_fns              map[string]bool
    // used_struct_operator_fns holds the callee names of direct calls seen during
    // monomorphize. Infix operators on generic instances are lowered to direct calls
    // (`Vec_int__plus(a, b)`) before this pass, so an operator overload is specialized for
    // an instantiated generic struct only when its mangled name appears here — an instance
    // whose type argument never has the operator applied is not emitted with a body that
    // would fail C compilation.
    used_struct_operator_fns map[string]bool
    // active_generic_params holds the generic parameter names of the decl currently
    // being specialized/rewritten, in the same order as the inferred type `args`.
    // It lets type-text substitution map placeholders by name (so non-canonical
    // params like `D`/`F` resolve to the right arg) instead of by the positional
    // `generic_param_index` heuristic (which collapses anything outside the T/U/C
    // sequences to index 0). Empty for struct-generic specialization, which keeps
    // the legacy positional behaviour.
    active_generic_params []string
    // escaping_amp_ptrs holds the names of pointer locals `p` declared as `p := &v`
    // (v a value local) whose pointer escapes the function (is returned). V semantics
    // auto-heap such a `v`; v3 otherwise takes the address of a stack local that dies
    // on return. Recomputed per function (structural pre-pass in transform_fn_body),
    // consumed when the `p := &v` decl is transformed (RHS rewritten to a heap copy).
    escaping_amp_ptrs map[string]bool
    // escaping_amp_sources holds the source locals `v` of such `p := &v` escapes — the
    // values whose address leaves the frame. The local itself is moved to the heap at its
    // declaration (its type becomes `&T`) so a mutation between `p := &v` and `return p`
    // is observed by the caller; copying eagerly at the alias would return stale data.
    escaping_amp_sources map[string]bool
    // heaped_amp_locals records which of those sources were actually moved to the heap, so
    // the `p := &v` alias emits `p = v` (the heap pointer) instead of a fresh memdup copy.
    heaped_amp_locals      map[string]bool
    generic_fn_decls_cache map[string]GenericFnDecl
    generic_fn_decls_ready bool
}

// AliasCache memoizes normalize_type_alias results. It lives on the heap so the
// many `&Transformer` (read-only) query methods can populate it through the
// pointer. normalize_type_alias is a pure function of (cur_module, typ) plus the
// collected type maps (which never change during transform), so the cache is
// keyed by typ and cleared whenever cur_module changes.
struct AliasCache {
mut:
    module  string
    entries map[string]string
}

// StructInfo stores struct info metadata used by transform.
pub struct StructInfo {
pub:
    name      string
    module    string
    is_params bool
    fields    []FieldInfo
}

// FieldInfo stores field info metadata used by transform.
pub struct FieldInfo {
pub:
    name         string
    typ          string
    raw_typ      string
    default_expr flat.NodeId
}

// TupleBlockParts represents tuple block parts data used by transform.
struct TupleBlockParts {
    prefix []flat.NodeId
    values []flat.NodeId
}

// StructFieldLookup represents struct field lookup data used by transform.
struct StructFieldLookup {
    info       StructInfo
    owner_type string
}

// VarTypeBinding represents var type binding data used by transform.
struct VarTypeBinding {
    name string
    typ  string
}

struct GenericFnDecl {
    id     flat.NodeId
    node   flat.Node
    file   string
    module string
    key    string
}

// --- entry point ---

// transform supports transform handling for transform.
pub fn transform(mut a flat.FlatAst, tc &types.TypeChecker) {
    transform_with_used(mut a, tc, map[string]bool{})
}

// transform_with_used transforms transform with used data for transform.
pub fn transform_with_used(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) map[string]bool {
    augmented, _ := transform_with_used_opt(mut a, tc, used_fns, false)
    return augmented
}

// transform_with_used_opt is transform_with_used with an opt-in for parallel
// function-body transform. It returns the augmented used-fn set and whether the
// function bodies were actually transformed across threads (false when parallel
// was not requested, the build lacks thread support, or there was too little work).
pub fn transform_with_used_opt(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool, want_parallel bool) (map[string]bool, bool) {
    mut augmented_used_fns := used_fns.clone()
    mut t := new_transformer(mut a, tc, augmented_used_fns)
    t.prepare()
    if want_parallel {
        // Transform roughly grows the node/children arrays by ~75%. Reserve that capacity
        // up front so they don't double past it (the parsed AST already overshoots to the
        // next power of two, wasting ~40MB, and each doubling briefly holds both the old and
        // new arrays — the dominant peak-RSS contributor under -gc none). The serial path is
        // latency-sensitive and does not clone worker ASTs, so let it grow naturally.
        reserve_nodes := a.nodes.len * 7 / 4 - a.nodes.cap
        if reserve_nodes > 0 {
            unsafe { a.nodes.grow_cap(reserve_nodes) }
        }
        reserve_children := a.children.len * 7 / 4 - a.children.cap
        if reserve_children > 0 {
            unsafe { a.children.grow_cap(reserve_children) }
        }
    }
    was_parallel := t.transform_all_dispatch(want_parallel)
    return augmented_used_fns, was_parallel
}

pub fn monomorphize_with_used(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) map[string]bool {
    mut augmented_used_fns := used_fns.clone()
    mut t := new_transformer(mut a, tc, augmented_used_fns)
    t.prepare()
    for name in t.monomorphize_pass() {
        augmented_used_fns[name] = true
        augmented_used_fns[c_name(name)] = true
        t.used_fns[name] = true
        t.used_fns[c_name(name)] = true
    }
    t.materialize_generic_structs()
    return augmented_used_fns
}

fn new_transformer(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) Transformer {
    return Transformer{
        a:                     a
        tc:                    unsafe { tc }
        pointer_value_lvalues: map[string]bool{}
        escaping_amp_ptrs:     map[string]bool{}
        escaping_amp_sources:  map[string]bool{}
        heaped_amp_locals:     map[string]bool{}
        used_fns:              used_fns.clone()
    }
}

fn (mut t Transformer) prepare() {
    t.collect_types()
    t.collect_const_suffixes()
    t.collect_alias_methods()
    // Enable the alias cache only now that the type maps are fully populated.
    // During collection those maps are incomplete, so caching there would poison
    // entries with results computed against a partial view.
    t.alias_cache = &AliasCache{}
    t.sum_cache = &AliasCache{}
}

// reset_var_types updates reset var types state for transform.
fn (mut t Transformer) reset_var_types() {
    t.var_types.clear()
}

// set_var_type updates set var type state for transform.
fn (mut t Transformer) set_var_type(name string, typ string) {
    if name.len == 0 {
        return
    }
    for i, binding in t.var_types {
        if binding.name == name {
            t.var_types[i] = VarTypeBinding{
                name: name
                typ:  typ
            }
            return
        }
    }
    t.var_types << VarTypeBinding{
        name: name
        typ:  typ
    }
}

// unset_var_type supports unset var type handling for Transformer.
fn (mut t Transformer) unset_var_type(name string) {
    for i, binding in t.var_types {
        if binding.name == name {
            t.var_types.delete(i)
            return
        }
    }
}

// var_type supports var type handling for Transformer.
fn (t &Transformer) var_type(name string) string {
    for binding in t.var_types {
        if binding.name == name {
            return binding.typ
        }
    }
    return ''
}

// --- type collection ---

// collect_types updates collect types state for transform.
fn (mut t Transformer) collect_types() {
    mut cur_mod := ''
    for node in t.a.nodes {
        match node.kind {
            .module_decl {
                cur_mod = node.value
            }
            .struct_decl {
                owner_type := if cur_mod.len > 0 && cur_mod != 'main' && cur_mod != 'builtin' {
                    '${cur_mod}.${node.value}'
                } else {
                    node.value
                }
                mut fields := []FieldInfo{}
                for i in 0 .. node.children_count {
                    f := t.a.child_node(&node, i)
                    if f.kind != .field_decl {
                        continue
                    }
                    default_expr := if f.children_count > 0 {
                        t.a.child(f, 0)
                    } else {
                        flat.empty_node
                    }
                    fields << FieldInfo{
                        name:         f.value
                        typ:          t.normalize_field_type(f.typ, owner_type)
                        raw_typ:      f.typ
                        default_expr: default_expr
                    }
                }
                info := StructInfo{
                    name:      node.value
                    module:    cur_mod
                    is_params: node.typ.contains('params')
                    fields:    fields
                }
                t.structs[node.value] = info
                if cur_mod.len > 0 && cur_mod != 'main' && cur_mod != 'builtin' {
                    qname := '${cur_mod}.${node.value}'
                    t.structs[qname] = info
                    if node.value !in t.qualified_types {
                        t.qualified_types[node.value] = qname
                    }
                }
                for f in fields {
                    t.add_unique_field_type(f.name, f.typ)
                }
            }
            .type_decl {
                if node.children_count > 0 {
                    mut variants := []string{}
                    for i in 0 .. node.children_count {
                        v := t.a.child_node(&node, i)
                        variants << t.normalize_sum_variant_type(v.value, cur_mod)
                    }
                    t.sum_types[node.value] = variants
                    for variant in variants {
                        t.add_sum_variant_parent(variant, node.value)
                    }
                    if cur_mod.len > 0 && cur_mod != 'main' && cur_mod != 'builtin' {
                        qname := '${cur_mod}.${node.value}'
                        t.sum_types[qname] = variants
                        if node.value !in t.qualified_types {
                            t.qualified_types[node.value] = qname
                        }
                        for variant in variants {
                            t.add_sum_variant_parent(variant, qname)
                        }
                    }
                }
            }
            .enum_decl {
                mut field_names := []string{}
                for i in 0 .. node.children_count {
                    f := t.a.child_node(&node, i)
                    if f.kind == .enum_field {
                        field_names << f.value
                    }
                }
                t.enum_types[node.value] = field_names
                if cur_mod.len > 0 && cur_mod != 'main' && cur_mod != 'builtin' {
                    t.enum_types['${cur_mod}.${node.value}'] = field_names
                }
            }
            .global_decl {
                for i in 0 .. node.children_count {
                    f := t.a.child_node(&node, i)
                    mut typ := t.normalize_type_in_module(f.typ, cur_mod)
                    if typ.len == 0 && f.children_count > 0 {
                        typ = t.normalize_type_in_module(t.node_type(t.a.child(f, 0)), cur_mod)
                    }
                    t.globals[f.value] = typ
                    if cur_mod.len > 0 && cur_mod != 'main' && cur_mod != 'builtin' {
                        t.globals['${cur_mod}.${f.value}'] = typ
                    }
                }
            }
            .fn_decl {
                if node.typ.len > 0 {
                    ret_typ := t.normalize_type_in_module(node.typ, cur_mod)
                    if cur_mod.len > 0 && cur_mod != 'main' && cur_mod != 'builtin' {
                        qname := '${cur_mod}.${node.value}'
                        t.fn_ret_types[qname] = ret_typ
                        qlowered := c_name(qname)
                        if qlowered != qname {
                            t.fn_ret_types[qlowered] = ret_typ
                        }
                    } else {
                        t.fn_ret_types[node.value] = ret_typ
                        lowered := c_name(node.value)
                        if lowered != node.value {
                            t.fn_ret_types[lowered] = ret_typ
                        }
                    }
                }
            }
            .c_fn_decl {
                if node.typ.len > 0 {
                    ret_typ := t.normalize_type_in_module(node.typ, cur_mod)
                    t.fn_ret_types[node.value] = ret_typ
                    if node.value.starts_with('C.') {
                        t.fn_ret_types[node.value[2..]] = ret_typ
                    } else {
                        t.fn_ret_types['C.${node.value}'] = ret_typ
                    }
                }
            }
            else {}
        }
    }
}

// add_sum_variant_parent updates add sum variant parent state for Transformer.
fn (mut t Transformer) add_sum_variant_parent(variant string, sum_name string) {
    if variant.len == 0 || sum_name.len == 0 {
        return
    }
    field_name := t.sum_field_name(variant)
    if field_name.contains('__') && field_name !in t.sum_variant_fields {
        t.sum_variant_fields[field_name] = variant
    }
    t.add_sum_variant_parent_key(variant, sum_name)
    if variant.contains('.') {
        t.add_sum_variant_parent_key(variant.all_after_last('.'), sum_name)
    }
}

// add_sum_variant_parent_key updates add sum variant parent key state for Transformer.
fn (mut t Transformer) add_sum_variant_parent_key(key string, sum_name string) {
    mut parents := t.sum_variant_parents[key] or { []string{} }
    if sum_name !in parents {
        parents << sum_name
        t.sum_variant_parents[key] = parents
    }
}

// add_unique_field_type updates add unique field type state for Transformer.
fn (mut t Transformer) add_unique_field_type(name string, typ string) {
    if name.len == 0 || typ.len == 0 {
        return
    }
    if existing := t.unique_fields[name] {
        if existing != typ {
            t.unique_fields[name] = ''
        }
    } else {
        t.unique_fields[name] = typ
    }
}

// collect_const_suffixes updates collect const suffixes state for transform.
fn (mut t Transformer) collect_const_suffixes() {
    if isnil(t.tc) {
        return
    }
    // Register every dot-delimited suffix of each const key so that both
    // unqualified (`foo`) and partially-qualified (`mod.foo`) lookups resolve
    // in O(1) via const_type_key, instead of scanning all consts per ident.
    for key, _ in t.tc.const_types {
        if !key.contains('.') {
            t.add_const_suffix(key, key)
            continue
        }
        mut i := 0
        for i < key.len {
            if key[i] == `.` {
                t.add_const_suffix(key[i + 1..], key)
            }
            i++
        }
    }
}

// add_const_suffix updates add const suffix state for Transformer.
fn (mut t Transformer) add_const_suffix(suffix string, key string) {
    if existing := t.const_suffixes[suffix] {
        if existing != key {
            t.const_suffixes[suffix] = ''
        }
    } else {
        t.const_suffixes[suffix] = key
    }
}

// collect_alias_methods converts collect alias methods data for transform.
fn (mut t Transformer) collect_alias_methods() {
    if isnil(t.tc) {
        return
    }
    for name, params in t.tc.fn_param_types {
        if params.len == 0 || !name.contains('.') {
            continue
        }
        receiver_name := name.all_before_last('.')
        if receiver_name.len == 0 || receiver_name !in t.tc.type_aliases {
            continue
        }
        method := name.all_after_last('.')
        param_name := params[0].name()
        clean_alias := if param_name.starts_with('&') { param_name[1..] } else { param_name }
        alias_target := t.normalize_type_alias(clean_alias)
        if alias_target.len == 0 {
            continue
        }
        key := '${alias_target}.${method}'
        if key !in t.alias_methods {
            t.alias_methods[key] = name
        }
    }
}

// normalize_sum_variant_type transforms normalize sum variant type data for transform.
fn (t &Transformer) normalize_sum_variant_type(typ string, mod string) string {
    clean := typ.trim_space()
    if clean.len == 0 {
        return clean
    }
    if clean.starts_with('&') {
        return '&' + t.normalize_sum_variant_type(clean[1..], mod)
    }
    if clean.starts_with('mut ') {
        return '&' + t.normalize_sum_variant_type(clean[4..], mod)
    }
    if clean.starts_with('?') {
        return '?' + t.normalize_sum_variant_type(clean[1..], mod)
    }
    if clean.starts_with('!') {
        return '!' + t.normalize_sum_variant_type(clean[1..], mod)
    }
    if clean.starts_with('[]') {
        return '[]' + t.normalize_sum_variant_type(clean[2..], mod)
    }
    if clean.starts_with('map[') {
        bracket_end := clean.index(']') or { return clean }
        key := t.normalize_sum_variant_type(clean[4..bracket_end], mod)
        value := t.normalize_sum_variant_type(clean[bracket_end + 1..], mod)
        return 'map[${key}]${value}'
    }
    if clean.starts_with('[') {
        bracket_end := clean.index(']') or { return clean }
        return clean[..bracket_end + 1] + t.normalize_sum_variant_type(clean[bracket_end +
            1..], mod)
    }
    if clean.contains('.') || mod.len == 0 || mod == 'main' || mod == 'builtin'
        || types.is_builtin_type_name(clean) {
        return clean
    }
    return '${mod}.${clean}'
}

// --- main transform pass ---

// transform_all transforms transform all data for transform.
fn (mut t Transformer) transform_all() {
    has_entry_main := t.has_entry_main()
    node_count := t.a.nodes.len
    for i in 0 .. node_count {
        node := t.a.nodes[i]
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            t.cur_file = node.value
        }
        if kind_id == 73 {
            t.cur_module = node.value
        }
        if kind_id == 61 {
            if !t.should_transform_fn(node) {
                continue
            }
            t.transform_fn_body(i)
        } else if kind_id == 65 {
            t.transform_const_decl(node)
        } else if kind_id == 64 {
            t.transform_global_decl(node)
        }
    }
    if !has_entry_main {
        t.transform_top_level_user_stmts()
    }
}

fn (t &Transformer) has_entry_main() bool {
    mut cur_module := ''
    for node in t.a.nodes {
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_module = ''
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            continue
        }
        if kind_id == 61 && node.value == 'main' && (cur_module.len == 0 || cur_module == 'main') {
            return true
        }
    }
    return false
}

fn (mut t Transformer) transform_top_level_user_stmts() {
    node_count := t.a.nodes.len
    for file_idx in 0 .. node_count {
        file_node := t.a.nodes[file_idx]
        if !t.should_transform_top_level_file(file_idx, file_node) {
            continue
        }
        t.transform_top_level_file(file_idx, file_node)
    }
}

fn (t &Transformer) should_transform_top_level_file(file_idx int, file_node flat.Node) bool {
    if file_idx < t.a.user_code_start || file_node.kind != .file || file_node.children_count == 0 {
        return false
    }
    module_name := t.file_module_name(file_node)
    return module_name.len == 0 || module_name == 'main'
}

fn (t &Transformer) file_module_name(file_node flat.Node) string {
    for i in 0 .. file_node.children_count {
        child := t.a.child_node(&file_node, i)
        if child.kind == .module_decl {
            return child.value
        }
    }
    return ''
}

fn transform_is_top_level_stmt(node flat.Node) bool {
    return match node.kind {
        .expr_stmt, .assign, .decl_assign, .selector_assign, .index_assign, .for_stmt,
        .for_in_stmt, .if_expr, .match_stmt, .assert_stmt, .defer_stmt, .block {
            true
        }
        else {
            false
        }
    }
}

fn (mut t Transformer) transform_top_level_file(file_idx int, file_node flat.Node) {
    old_file := t.cur_file
    old_module := t.cur_module
    old_fn_name := t.cur_fn_name
    old_fn_ret_type := t.cur_fn_ret_type
    old_var_types := t.var_types.clone()
    old_smartcast_stack := t.smartcast_stack.clone()
    old_pending_stmts := t.pending_stmts.clone()
    module_name := t.file_module_name(file_node)
    t.cur_file = file_node.value
    t.cur_module = if module_name.len == 0 { 'main' } else { module_name }
    t.cur_fn_name = 'main'
    t.cur_fn_ret_type = 'void'
    t.reset_var_types()
    t.smartcast_stack.clear()
    t.pending_stmts.clear()
    mut new_children := []flat.NodeId{cap: int(file_node.children_count)}
    mut pending_stmts := []flat.NodeId{}
    for i in 0 .. file_node.children_count {
        child_id := t.a.child(&file_node, i)
        if int(child_id) >= t.a.user_code_start {
            child := t.a.nodes[int(child_id)]
            if transform_is_top_level_stmt(child) {
                pending_stmts << child_id
                continue
            }
        }
        t.append_transformed_top_level_stmts(mut new_children, mut pending_stmts)
        new_children << child_id
    }
    t.append_transformed_top_level_stmts(mut new_children, mut pending_stmts)
    start := t.a.children.len
    for child_id in new_children {
        t.a.children << child_id
    }
    t.a.nodes[file_idx] = flat.Node{
        kind:           .file
        kind_id:        file_node.kind_id
        op:             file_node.op
        children_start: start
        children_count: flat.child_count(new_children.len)
        pos:            file_node.pos
        value:          file_node.value
        typ:            file_node.typ
        generic_params: file_node.generic_params
    }
    t.cur_file = old_file
    t.cur_module = old_module
    t.cur_fn_name = old_fn_name
    t.cur_fn_ret_type = old_fn_ret_type
    t.var_types = old_var_types
    t.smartcast_stack = old_smartcast_stack
    t.pending_stmts = old_pending_stmts
}

fn (mut t Transformer) append_transformed_top_level_stmts(mut out []flat.NodeId, mut pending []flat.NodeId) {
    if pending.len == 0 {
        return
    }
    transformed := t.transform_stmts(pending)
    out << transformed
    pending.clear()
}

// FnWorkItem identifies one top-level function body to transform, together with
// the file/module context active at its declaration and a rough cost estimate
// (subtree node count) used to balance work across parallel workers.
struct FnWorkItem {
    fn_idx int
    file   string
    module string
    cost   int
}

// transform_all_dispatch runs the main transform pass either serially (the
// original single-threaded walk) or, when `want_parallel` is set and there is
// enough work, with closure-free function bodies transformed across threads.
// Returns whether function bodies were actually transformed in parallel.
fn (mut t Transformer) transform_all_dispatch(want_parallel bool) bool {
    if !want_parallel {
        t.transform_all()
        return false
    }
    has_entry_main := t.has_entry_main()
    // Serial phase: transform consts/globals and every function whose body
    // contains a function literal (the only construct that lifts new top-level
    // declarations and mutates the shared TypeChecker). Collect the remaining,
    // closure-free functions as parallelizable work items.
    has_fn_literals := t.has_fn_literal_nodes()
    pure_items := t.transform_serial_then_collect_pure(has_fn_literals)
    base_nodes := t.a.nodes.len
    base_children := t.a.children.len
    was_parallel := t.run_parallel_transform(pure_items, base_nodes, base_children)
    if !has_entry_main {
        t.transform_top_level_user_stmts()
    }
    return was_parallel
}

fn (t &Transformer) has_fn_literal_nodes() bool {
    for node in t.a.nodes {
        if node.kind == .fn_literal || node.kind == .lambda_expr {
            return true
        }
    }
    return false
}

// transform_serial_then_collect_pure walks the top level once: it transforms
// const/global declarations and closure-bearing functions in place (serially),
// and returns work items for the closure-free functions left to transform.
fn (mut t Transformer) transform_serial_then_collect_pure(scan_fn_literals bool) []FnWorkItem {
    mut pure := []FnWorkItem{}
    original_len := t.a.nodes.len
    for i in 0 .. original_len {
        node := t.a.nodes[i]
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            t.cur_file = node.value
        } else if kind_id == 73 {
            t.cur_module = node.value
        } else if kind_id == 61 {
            if !t.should_transform_fn(node) {
                continue
            }
            mut has_literal := false
            mut cost := int(node.children_count) + 1
            if scan_fn_literals {
                has_literal, cost = t.fn_subtree_scan(i)
            }
            if has_literal {
                t.transform_fn_body(i)
            } else {
                pure << FnWorkItem{
                    fn_idx: i
                    file:   t.cur_file
                    module: t.cur_module
                    cost:   cost
                }
            }
        } else if kind_id == 65 {
            t.transform_const_decl(node)
        } else if kind_id == 64 {
            t.transform_global_decl(node)
        }
    }
    return pure
}

// fn_subtree_scan walks the subtree rooted at the function declaration `fn_idx`
// and reports (whether it contains a function literal, total node count). The
// function-literal flag routes closure-bearing functions to the serial path; the
// count is a cheap per-function cost used to balance parallel workers.
fn (t &Transformer) fn_subtree_scan(fn_idx int) (bool, int) {
    mut has_literal := false
    mut count := 0
    mut stack := [flat.NodeId(fn_idx)]
    for stack.len > 0 {
        id := stack.pop()
        idx := int(id)
        if idx < 0 || idx >= t.a.nodes.len {
            continue
        }
        node := t.a.nodes[idx]
        count++
        // 21 = fn_literal, 32 = lambda_expr: both can lower to a lifted closure.
        kid := node_kind_id(node)
        if kid == 21 || kid == 32 {
            has_literal = true
        }
        for ci in 0 .. node.children_count {
            child_id := t.a.children[node.children_start + ci]
            if int(child_id) >= 0 {
                stack << child_id
            }
        }
    }
    return has_literal, count
}

// transform_pure_items_serial transforms a list of closure-free function bodies
// on this Transformer, in order. Used both as the serial fallback and as the
// per-worker body in the parallel path.
fn (mut t Transformer) transform_pure_items_serial(items []FnWorkItem) {
    for it in items {
        t.cur_file = it.file
        t.cur_module = it.module
        t.transform_fn_body(it.fn_idx)
    }
}

// clone_ast_base produces a private FlatAst holding an independent copy of the
// first base_nodes nodes / base_children children, so a worker can append its own
// transformed nodes without racing the master or other workers. Read-only metadata
// (disabled_fns) is shared.
fn (t &Transformer) clone_ast_base(base_nodes int, base_children int) &flat.FlatAst {
    return &flat.FlatAst{
        nodes:           t.a.nodes[0..base_nodes].clone()
        children:        t.a.children[0..base_children].clone()
        user_code_start: t.a.user_code_start
        disabled_fns:    t.a.disabled_fns
    }
}

// fork_worker builds a worker Transformer that shares this transformer's
// read-only collected maps (structs, sum types, fn return types, used_fns, …)
// and operates on its own cloned AST `ast` and forked TypeChecker `wtc`. All
// per-function mutable state and memoization caches are reset/private so the
// worker can run on its own thread.
fn (t &Transformer) fork_worker(ast &flat.FlatAst, wtc &types.TypeChecker) &Transformer {
    mut w := *t
    w.a = ast
    w.tc = wtc
    w.alias_cache = &AliasCache{}
    w.sum_cache = &AliasCache{}
    w.generic_fn_decls_cache = map[string]GenericFnDecl{}
    w.generic_fn_decls_ready = false
    w.var_types = []VarTypeBinding{}
    w.smartcast_stack = []SmartcastContext{}
    w.pending_stmts = []flat.NodeId{}
    w.pointer_value_lvalues = map[string]bool{}
    w.escaping_amp_ptrs = map[string]bool{}
    w.escaping_amp_sources = map[string]bool{}
    w.heaped_amp_locals = map[string]bool{}
    w.temp_counter = 0
    w.cur_file = ''
    w.cur_module = ''
    w.cur_fn_name = ''
    w.cur_fn_ret_type = ''
    w.in_call_callee = false
    w.in_const_init = false
    w.in_return_expr = false
    return &w
}

// merge_worker folds a finished worker's transformed output back into the master
// AST. The worker created its new nodes/children at indices base_nodes/base_children
// (matching the master at fork time); here they are appended to the master and every
// reference to a worker-local new node or new children block is shifted by the
// distance the block moved. `items` lists the function indices this worker owned, so
// their rewritten top-level nodes can be copied into place.
fn (mut t Transformer) merge_worker(w &Transformer, items []FnWorkItem, base_nodes int, base_children int) {
    node_shift := i32(t.a.nodes.len - base_nodes)
    child_shift := i32(t.a.children.len - base_children)
    // New children: relocate references to worker-local new nodes.
    for k in base_children .. w.a.children.len {
        cid := w.a.children[k]
        if int(cid) >= base_nodes {
            t.a.children << flat.NodeId(int(cid) + int(node_shift))
        } else {
            t.a.children << cid
        }
    }
    // New nodes: relocate children_start that points into the new children block.
    for k in base_nodes .. w.a.nodes.len {
        n := w.a.nodes[k]
        if n.children_start >= base_children {
            t.a.nodes << n.with_shifted_children(child_shift)
        } else {
            t.a.nodes << n
        }
    }
    // Rewritten top-level function nodes keep their original index in the master.
    for it in items {
        n := w.a.nodes[it.fn_idx]
        if n.children_start >= base_children {
            t.a.nodes[it.fn_idx] = n.with_shifted_children(child_shift)
        } else {
            t.a.nodes[it.fn_idx] = n
        }
    }
}

// split_work_items distributes items across `n` buckets using greedy
// least-loaded-by-cost assignment, so heavy functions are spread evenly. The
// assignment is deterministic for a given input (required for reproducible builds).
fn split_work_items(items []FnWorkItem, n int) [][]FnWorkItem {
    mut buckets := [][]FnWorkItem{len: n, init: []FnWorkItem{}}
    mut loads := []i64{len: n}
    for it in items {
        mut best := 0
        for b in 1 .. n {
            if loads[b] < loads[best] {
                best = b
            }
        }
        buckets[best] << it
        loads[best] += i64(it.cost) + 1
    }
    return buckets
}

// should_transform_fn reports whether should transform fn applies in transform.
fn (t &Transformer) should_transform_fn(node flat.Node) bool {
    if t.used_fns.len == 0 {
        return true
    }
    if node.value in t.used_fns {
        return true
    }
    qname := transform_qualified_fn_name(t.cur_module, node.value)
    if qname in t.used_fns {
        return true
    }
    cname := c_name(qname)
    if cname != qname && cname in t.used_fns {
        return true
    }
    return false
}

// transform_qualified_fn_name transforms transform qualified fn name data for transform.
fn transform_qualified_fn_name(mod string, name string) string {
    if mod.len == 0 || mod == 'main' || mod == 'builtin' {
        return name
    }
    return '${mod}.${name}'
}

// transform_const_decl transforms the initializer expression of each const field
// so that const-level lowering (e.g. string concatenation in the prelude's
// embedded data tables) happens in the transformer rather than the backend.
fn (mut t Transformer) transform_const_decl(node flat.Node) {
    old_in_const_init := t.in_const_init
    t.in_const_init = true
    for ci in 0 .. node.children_count {
        cf_id := t.a.child(&node, ci)
        if int(cf_id) < 0 {
            continue
        }
        cf := t.a.nodes[int(cf_id)]
        if cf.kind == .const_field && cf.children_count >= 1 && cf.children_start >= 0 {
            val_id := t.a.child(&cf, 0)
            if int(val_id) < 0 {
                continue
            }
            val := t.a.nodes[int(val_id)]
            if block_val := t.const_block_value(val) {
                new_val := t.transform_const_value(block_val)
                t.a.children[cf.children_start] = new_val
            } else if val.kind == .string_interp {
                new_val := t.transform_const_string_interp(val_id, val)
                t.a.children[cf.children_start] = new_val
            } else if val.kind == .or_expr {
                const_typ := t.const_field_type_name(cf)
                new_val := t.transform_const_or_expr(val_id, val, const_typ)
                t.a.children[cf.children_start] = new_val
            } else if val.kind == .struct_init || val.kind == .cast_expr || val.kind == .call {
                new_val := t.transform_expr(val_id)
                t.a.children[cf.children_start] = new_val
            } else if val.kind == .infix && val.children_count >= 2 {
                new_val := t.transform_expr(val_id)
                // Overwrite the field's value slot in place (each const_field owns
                // its own single-element child range, so this is safe).
                t.a.children[cf.children_start] = new_val
            }
        }
    }
    t.in_const_init = old_in_const_init
}

// const_field_type_name supports const field type name handling for Transformer.
fn (t &Transformer) const_field_type_name(field flat.Node) string {
    if field.value.len > 0 {
        if t.cur_module.len > 0 {
            if typ := t.const_type_name('${t.cur_module}.${field.value}') {
                return typ
            }
        }
        if typ := t.const_type_name(field.value) {
            return typ
        }
    }
    return field.typ
}

// transform_const_or_expr transforms transform const or expr data for transform.
fn (mut t Transformer) transform_const_or_expr(_id flat.NodeId, node flat.Node, const_typ string) flat.NodeId {
    if node.children_count < 2 {
        return _id
    }
    mut children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        if i == 0 {
            children << t.transform_expr(child_id)
        } else {
            children << child_id
        }
    }
    start := t.a.children.len
    for child in children {
        t.a.children << child
    }
    return t.a.add_node(flat.Node{
        kind:           .or_expr
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            if const_typ.len > 0 { const_typ } else { node.typ }
    })
}

// transform_global_decl transforms transform global decl data for transform.
fn (mut t Transformer) transform_global_decl(node flat.Node) {
    for ci in 0 .. node.children_count {
        gf_id := t.a.child(&node, ci)
        if int(gf_id) < 0 {
            continue
        }
        gf := t.a.nodes[int(gf_id)]
        if gf.kind == .field_decl && gf.children_count >= 1 && gf.children_start >= 0 {
            val_id := t.a.child(&gf, 0)
            if int(val_id) < 0 {
                continue
            }
            val := t.a.nodes[int(val_id)]
            if preserved := t.transform_global_amp_initializer(val_id, val) {
                t.a.children[gf.children_start] = preserved
                continue
            }
            old_pending := t.pending_stmts.clone()
            t.pending_stmts.clear()
            new_val := t.transform_expr(val_id)
            has_pending := t.pending_stmts.len > 0
            t.pending_stmts.clear()
            t.pending_stmts = old_pending
            if !has_pending {
                t.a.children[gf.children_start] = new_val
            }
        }
    }
}

// transform_global_amp_initializer transforms transform global amp initializer data for transform.
fn (mut t Transformer) transform_global_amp_initializer(val_id flat.NodeId, val flat.Node) ?flat.NodeId {
    if val.kind != .prefix || val.op != .amp || val.children_count != 1 {
        return none
    }
    child_id := t.a.child(&val, 0)
    child := t.a.nodes[int(child_id)]
    if child.kind == .assoc {
        return val_id
    }
    old_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    mut result := flat.empty_node
    if child.kind == .struct_init {
        if preserved := t.transform_amp_struct_init_for_type(val_id, val, val.typ) {
            result = preserved
        }
    } else if child.kind == .cast_expr {
        if preserved := t.transform_global_amp_interface_cast(val, val.typ) {
            result = preserved
        }
    }
    has_pending := t.pending_stmts.len > 0
    t.pending_stmts.clear()
    t.pending_stmts = old_pending
    if has_pending || int(result) < 0 {
        return none
    }
    return result
}

// transform_const_value transforms transform const value data for transform.
fn (mut t Transformer) transform_const_value(id flat.NodeId) flat.NodeId {
    if int(id) < 0 {
        return id
    }
    node := t.a.nodes[int(id)]
    if block_val := t.const_block_value(node) {
        return t.transform_const_value(block_val)
    }
    return t.transform_expr(id)
}

// const_block_value supports const block value handling for Transformer.
fn (t &Transformer) const_block_value(node flat.Node) ?flat.NodeId {
    if node.kind != .block || node.children_count == 0 {
        return none
    }
    for i := int(node.children_count) - 1; i >= 0; i-- {
        stmt_id := t.a.child(&node, i)
        stmt := t.a.nodes[int(stmt_id)]
        if stmt.kind == .empty {
            continue
        }
        if stmt.kind == .expr_stmt && stmt.children_count == 1 {
            return t.a.child(&stmt, 0)
        }
        break
    }
    return none
}

// transform_const_string_interp transforms transform const string interp data for transform.
fn (mut t Transformer) transform_const_string_interp(_id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return t.make_string_literal('')
    }
    outer_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    mut parts := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        transformed := t.transform_expr(child_id)
        mut typ := t.reliable_stringify_type(child_id)
        if typ.len == 0 {
            typ = t.node_type(transformed)
        }
        if typ.len == 0 {
            typ = 'string'
        }
        parts << t.wrap_string_conversion(transformed, typ)
    }
    mut expr := parts[0]
    for i in 1 .. parts.len {
        expr = t.make_call_typed('string__plus', arr2(expr, parts[i]), 'string')
    }
    mut stmts := []flat.NodeId{}
    t.drain_pending(mut stmts)
    t.pending_stmts = outer_pending
    if stmts.len == 0 {
        return expr
    }
    stmts << t.make_expr_stmt(expr)
    return t.make_block(stmts)
}

// transform_fn_body transforms transform fn body data for transform.
// try_heap_escaping_amp reports whether a `p := &v` decl is an escaping address of
// a value local that must be heap-copied: `p` is in escaping_amp_ptrs (returned)
// and `v` resolves to a non-reference value type.
fn (t &Transformer) try_heap_escaping_amp(node flat.Node, rhs_id flat.NodeId) bool {
    lhs := t.a.nodes[int(t.a.child(&node, 0))]
    if lhs.kind != .ident || lhs.value !in t.escaping_amp_ptrs {
        return false
    }
    rhs := t.a.nodes[int(rhs_id)]
    if rhs.kind != .prefix || rhs.op != .amp || rhs.children_count == 0 {
        return false
    }
    amp_child := t.a.child(&rhs, 0)
    amp_node := t.a.nodes[int(amp_child)]
    if amp_node.kind != .ident {
        return false
    }
    // The source local was moved to the heap at its declaration: the alias is now just that
    // `&T` pointer (handled below), regardless of its rewritten pointer type.
    if amp_node.value in t.heaped_amp_locals {
        return true
    }
    local_type := t.node_type(amp_child)
    return local_type.len > 0 && !local_type.starts_with('&') && !local_type.starts_with('[]')
        && !local_type.starts_with('map[') && !local_type.starts_with('?')
        && !local_type.starts_with('!')
}

// heap_escaping_amp_rhs rewrites `&v` into `(&T)memdup(&v, sizeof(T))`, a heap copy
// of the value local `v` so the escaping pointer outlives the stack frame. When `v` was
// itself moved to the heap at its declaration, the alias is simply that pointer — copying
// would resurrect the stale-mutation bug the move avoids.
fn (mut t Transformer) heap_escaping_amp_rhs(rhs_id flat.NodeId) flat.NodeId {
    rhs := t.a.nodes[int(rhs_id)]
    amp_child := t.a.child(&rhs, 0)
    amp_node := t.a.nodes[int(amp_child)]
    if amp_node.kind == .ident && amp_node.value in t.heaped_amp_locals {
        return t.transform_expr(amp_child)
    }
    local_type := t.node_type(amp_child)
    addr := t.make_prefix(.amp, t.transform_expr(amp_child))
    size := t.make_sizeof_type(local_type)
    dup := t.make_call_typed('memdup', arr2(addr, size), 'voidptr')
    return t.make_cast('&${local_type}', dup, '&${local_type}')
}

// heapable_value_type reports whether a local of this declared type can be moved to the heap
// as a `&T` — a plain value type, not an already-reference / container / optional type (those
// either carry their own indirection or are not addressable as a single `T`).
fn (t &Transformer) heapable_value_type(typ string) bool {
    return typ.len > 0 && !typ.starts_with('&') && !typ.starts_with('[]')
        && !typ.starts_with('map[') && !typ.starts_with('?') && !typ.starts_with('!')
        && !typ.starts_with('[') && typ != 'unknown' && typ != 'void'
}

// heap_escaping_source_decl rewrites `mut v := <init>` (where `&v` escapes) into a heap
// allocation so `v` is a `&T` to a heap object. A struct literal becomes `&T{..}` (the cgen
// memdup's it); any other initializer is copied into a stack temp and memdup'd. Subsequent
// `v.field = ..` writes then mutate the heap object the returned pointer alias also sees.
fn (mut t Transformer) heap_escaping_source_decl(node flat.Node, var_name string, elem_typ string) []flat.NodeId {
    rhs_id := t.a.child(&node, 1)
    rhs := t.a.nodes[int(rhs_id)]
    ptr_typ := '&${elem_typ}'
    mut stmts := []flat.NodeId{}
    transformed_init := t.transform_expr(rhs_id)
    // Statements lifted out while transforming the initializer must precede the heap decl.
    t.drain_pending(mut stmts)
    mut heap_rhs := flat.NodeId(0)
    if rhs.kind == .struct_init {
        heap_rhs = t.make_prefix(.amp, transformed_init)
    } else {
        tmp := t.new_temp('esc')
        stmts << t.make_decl_assign_typed(tmp, transformed_init, elem_typ)
        addr := t.make_prefix(.amp, t.make_ident(tmp))
        size := t.make_sizeof_type(elem_typ)
        dup := t.make_call_typed('memdup', arr2(addr, size), 'voidptr')
        heap_rhs = t.make_cast(ptr_typ, dup, ptr_typ)
    }
    t.heaped_amp_locals[var_name] = true
    // The local is now a `&T`, so its compound/postfix mutations (`v += 1`, `v++`) must store
    // through the pointer (`*v += 1`); mark it as a pointer-value lvalue so that lowering fires.
    t.pointer_value_lvalues[var_name] = true
    stmts << t.make_decl_assign_typed(var_name, heap_rhs, ptr_typ)
    return stmts
}

// mark_escaping_amp_ptrs runs a structural pre-pass over a function body to find
// `p := &v` declarations whose pointer `p` is later returned. Such a `v` is a local
// value whose address escapes, so it must be heap-copied (V auto-heaps it); the
// names are recorded in `escaping_amp_ptrs` and consumed by the decl-assign
// transform. Purely structural (no type info needed here): the type check happens
// at rewrite time when `v`'s type is known.
fn (mut t Transformer) mark_escaping_amp_ptrs(body_ids []flat.NodeId) {
    t.reset_escaping_amp_state()
    mut amp_ptrs := map[string]bool{}
    mut amp_sources := map[string]string{} // pointer `p` -> source local `v`
    mut ptr_aliases := map[string]string{} // copy `q := p` -> aliased pointer `p`
    mut returned := map[string]bool{}
    for id in body_ids {
        t.scan_escape_pass(id, mut amp_ptrs, mut amp_sources, mut ptr_aliases, mut returned)
    }
    // A pointer may be returned through a copy (`p := &v; q := p; return q`): `q` is collected
    // as returned but `p` is not, so propagate "returned" backward along the `q := p` aliases
    // until a fixpoint. Then `p` (and its source `v`) is recognised as escaping below.
    for _ in 0 .. ptr_aliases.len {
        mut changed := false
        for q, p in ptr_aliases {
            if q in returned && p !in returned {
                returned[p] = true
                changed = true
            }
        }
        if !changed {
            break
        }
    }
    for name, _ in amp_ptrs {
        if name in returned {
            t.escaping_amp_ptrs[name] = true
            if src := amp_sources[name] {
                t.escaping_amp_sources[src] = true
            }
        }
    }
}

fn (mut t Transformer) reset_escaping_amp_state() {
    t.escaping_amp_ptrs.clear()
    t.escaping_amp_sources.clear()
    t.heaped_amp_locals.clear()
    // Cleared per function: heaped locals add their names below (in heap_escaping_source_decl);
    // for-loop element vars set and restore their own entries within the loop body.
    t.pointer_value_lvalues.clear()
}

// scan_escape_pass recursively collects, in a function-body subtree, (a) the LHS
// names of `p := &ident` declarations into `amp_ptrs` (and the source `ident` into
// `amp_sources[p]`), (b) plain pointer copies `q := p` into `ptr_aliases[q] = p`, and
// (c) every ident name appearing inside a return statement into `returned`.
fn (mut t Transformer) scan_escape_pass(id flat.NodeId, mut amp_ptrs map[string]bool, mut amp_sources map[string]string, mut ptr_aliases map[string]string, mut returned map[string]bool) {
    if int(id) < 0 || int(id) >= t.a.nodes.len {
        return
    }
    node := t.a.nodes[int(id)]
    if node.kind == .decl_assign && node.children_count == 2 {
        lhs := t.a.nodes[int(t.a.child(&node, 0))]
        rhs := t.a.nodes[int(t.a.child(&node, 1))]
        if lhs.kind == .ident && lhs.value.len > 0 && rhs.kind == .prefix && rhs.op == .amp
            && rhs.children_count > 0 {
            amp_child := t.a.nodes[int(t.a.child(&rhs, 0))]
            if amp_child.kind == .ident {
                amp_ptrs[lhs.value] = true
                amp_sources[lhs.value] = amp_child.value
            }
        } else if lhs.kind == .ident && lhs.value.len > 0 && rhs.kind == .ident && rhs.value.len > 0 {
            // `q := p` aliases an existing pointer; recorded so a returned alias still marks the
            // underlying `p := &v` as escaping.
            ptr_aliases[lhs.value] = rhs.value
        }
    }
    if node.kind == .return_stmt {
        for i in 0 .. node.children_count {
            t.collect_return_escape_idents(t.a.child(&node, i), mut returned)
        }
    }
    for i in 0 .. node.children_count {
        t.scan_escape_pass(t.a.child(&node, i), mut amp_ptrs, mut amp_sources, mut ptr_aliases, mut
            returned)
    }
}

// collect_return_escape_idents gathers the idents in a return-expression subtree that occupy an
// actual escape position — the returned value itself, or a member of a returned aggregate
// (struct/array/map literal, multi-return). It deliberately stops at operators that consume their
// operands into a fresh value: infix (`==`, `&&`, arithmetic, …), postfix, `is`/`in`, and any
// non-`&` prefix (deref `*p`, `!x`, `-x`). That way a pointer that is merely compared or
// dereferenced in the return expression — e.g. `return p == p && v == 1` — is not mistaken for a
// pointer that escapes, so its source local is not needlessly heap-moved (which would also make
// later non-pointer uses of that local read through an `int*`).
fn (mut t Transformer) collect_return_escape_idents(id flat.NodeId, mut names map[string]bool) {
    if int(id) < 0 || int(id) >= t.a.nodes.len {
        return
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            if node.value.len > 0 {
                names[node.value] = true
            }
            return
        }
        .infix, .postfix, .is_expr, .in_expr {
            // These yield a new scalar/bool; their operands do not escape through the return.
            return
        }
        .prefix {
            // `&x` propagates an address (which may escape); any other prefix (`*x`, `!x`, `-x`)
            // produces a fresh value, so its operand does not escape.
            if node.op != .amp {
                return
            }
        }
        else {}
    }

    for i in 0 .. node.children_count {
        t.collect_return_escape_idents(t.a.child(&node, i), mut names)
    }
}

fn (mut t Transformer) transform_fn_body(fn_idx int) {
    fn_node := t.a.nodes[fn_idx]
    t.cur_fn_name = fn_node.value
    param_count := t.fn_body_param_count(fn_node)
    param_types := t.fn_body_param_types(fn_node, param_count)
    t.cur_fn_ret_type = t.fn_body_return_type(fn_node)
    t.reset_var_types()
    t.smartcast_stack.clear()
    // Collect param types
    mut param_idx := 0
    for i in 0 .. fn_node.children_count {
        child_id := t.a.children[fn_node.children_start + i]
        if int(child_id) < 0 {
            continue
        }
        child := t.a.nodes[int(child_id)]
        if node_kind_id(child) == 75 && child.value.len > 0 && child.typ.len > 0 {
            raw_typ := t.normalize_type_alias(child.typ)
            mut typ := if raw_typ.len > 0 {
                raw_typ
            } else if param_idx < param_types.len {
                t.normalize_type_alias(param_types[param_idx].name())
            } else {
                ''
            }
            if typ.starts_with('&') && raw_typ.len > 0 && !raw_typ.starts_with('&')
                && t.normalize_type_alias(typ[1..]) == raw_typ {
                typ = raw_typ
            }
            t.set_var_type(child.value, typ)
            param_idx++
        }
    }
    mut body_ids := []flat.NodeId{cap: int(fn_node.children_count)}
    for i in 0 .. fn_node.children_count {
        child_id := t.a.children[fn_node.children_start + i]
        if int(child_id) < 0 {
            continue
        }
        child := t.a.nodes[int(child_id)]
        if node_kind_id(child) != 75 {
            body_ids << child_id
        }
    }
    if t.cur_fn_ret_type == 'void' {
        t.reset_escaping_amp_state()
    } else {
        t.mark_escaping_amp_ptrs(body_ids)
    }
    new_body := t.transform_stmts(body_ids)
    // Rebuild function children: params then new body
    start := t.a.children.len
    for i in 0 .. fn_node.children_count {
        child_id := t.a.children[fn_node.children_start + i]
        if int(child_id) < 0 {
            continue
        }
        child := t.a.nodes[int(child_id)]
        if node_kind_id(child) == 75 {
            t.a.children << child_id
        }
    }
    for id in new_body {
        t.a.children << id
    }
    count := t.a.children.len - start
    t.a.nodes[fn_idx] = flat.Node{
        kind:           .fn_decl
        kind_id:        61
        op:             fn_node.op
        children_start: start
        children_count: flat.child_count(count)
        pos:            fn_node.pos
        value:          fn_node.value
        typ:            fn_node.typ
        generic_params: fn_node.generic_params
    }
    t.smartcast_stack.clear()
}

// fn_body_param_types supports fn body param types handling for Transformer.
fn (t &Transformer) fn_body_param_types(fn_node flat.Node, expected int) []types.Type {
    if isnil(t.tc) {
        return []types.Type{}
    }
    if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
        qname := '${t.cur_module}.${fn_node.value}'
        if params := t.fn_param_types_for_name(qname, expected) {
            return params
        }
        cqname := c_name(qname)
        if cqname != qname {
            if params := t.fn_param_types_for_name(cqname, expected) {
                return params
            }
        }
    }
    if params := t.fn_param_types_for_name(fn_node.value, expected) {
        return params
    }
    cname := c_name(fn_node.value)
    if cname != fn_node.value {
        if params := t.fn_param_types_for_name(cname, expected) {
            return params
        }
    }
    return []types.Type{}
}

// fn_param_types_for_name supports fn param types for name handling for Transformer.
fn (t &Transformer) fn_param_types_for_name(name string, expected int) ?[]types.Type {
    params := t.tc.fn_param_types[name] or { return none }
    if expected != 0 && params.len != expected {
        return none
    }
    return params
}

// fn_body_param_count supports fn body param count handling for Transformer.
fn (t &Transformer) fn_body_param_count(fn_node flat.Node) int {
    mut n := 0
    for i in 0 .. fn_node.children_count {
        child := t.a.child_node(&fn_node, i)
        if child.kind == .param {
            n++
        }
    }
    return n
}

// fn_body_return_type supports fn body return type handling for Transformer.
fn (t &Transformer) fn_body_return_type(fn_node flat.Node) string {
    if !isnil(t.tc) {
        if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
            qname := '${t.cur_module}.${fn_node.value}'
            if ret := t.fn_return_type_for_name(qname) {
                return ret
            }
            cqname := c_name(qname)
            if cqname != qname {
                if ret := t.fn_return_type_for_name(cqname) {
                    return ret
                }
            }
        }
        if ret := t.fn_return_type_for_name(fn_node.value) {
            return ret
        }
        cname := c_name(fn_node.value)
        if cname != fn_node.value {
            if ret := t.fn_return_type_for_name(cname) {
                return ret
            }
        }
    }
    return t.normalize_type_alias(fn_node.typ)
}

// fn_return_type_for_name supports fn return type for name handling for Transformer.
fn (t &Transformer) fn_return_type_for_name(name string) ?string {
    ret := t.tc.fn_ret_types[name] or { return none }
    return t.normalize_type_alias(ret.name())
}

// --- statement list driver ---

// transform_stmts transforms transform stmts data for transform.
pub fn (mut t Transformer) transform_stmts(ids []flat.NodeId) []flat.NodeId {
    mut result := []flat.NodeId{cap: ids.len}
    mut i := 0
    for i < ids.len {
        id := ids[i]
        if int(id) >= 0 && i + 1 < ids.len {
            node := t.a.nodes[int(id)]
            if node_kind_id(node) == 44 && node.children_count == 0 && t.cur_fn_ret_type.len > 0
                && t.cur_fn_ret_type != 'void' {
                next_id := ids[i + 1]
                next_node := t.a.nodes[int(next_id)]
                if node_kind_id(next_node) == 39 && next_node.children_count > 0 {
                    expr_id := t.a.child(&next_node, 0)
                    start := t.a.children.len
                    t.a.children << expr_id
                    merged_return := t.a.add_node(flat.Node{
                        kind:           .return_stmt
                        children_start: start
                        children_count: 1
                        typ:            node.typ
                    })
                    expanded := t.transform_stmt(merged_return)
                    t.drain_pending(mut result)
                    for eid in expanded {
                        result << eid
                    }
                    i += 2
                    continue
                }
            }
            if node.kind == .label_stmt {
                next_id := ids[i + 1]
                next_node := t.a.nodes[int(next_id)]
                if next_node.kind in [.for_stmt, .for_in_stmt] {
                    expanded := t.transform_labeled_loop(node.value, next_id, next_node)
                    t.drain_pending(mut result)
                    for eid in expanded {
                        result << eid
                    }
                    i += 2
                    continue
                }
            }
        }
        expanded := t.transform_stmt(id)
        t.drain_pending(mut result)
        for eid in expanded {
            result << eid
        }
        i++
    }
    t.drain_pending(mut result)
    return result
}

// transform_labeled_loop transforms transform labeled loop data for transform.
fn (mut t Transformer) transform_labeled_loop(label string, loop_id flat.NodeId, loop_node flat.Node) []flat.NodeId {
    if label.len == 0 {
        return t.transform_stmt(loop_id)
    }
    continue_label := '${label}_continue'
    break_label := '${label}_break'
    body_start := if loop_node.kind == .for_in_stmt { loop_node.value.int() } else { 3 }
    mut children := []flat.NodeId{cap: int(loop_node.children_count) + 1}
    for i in 0 .. loop_node.children_count {
        children << t.a.child(&loop_node, i)
    }
    if body_start <= children.len {
        children << t.a.add_val(.label_stmt, continue_label)
    }
    start := t.a.children.len
    for child in children {
        t.a.children << child
    }
    new_loop := t.a.add_node(flat.Node{
        kind:           loop_node.kind
        op:             loop_node.op
        children_start: start
        children_count: flat.child_count(children.len)
        pos:            loop_node.pos
        value:          loop_node.value
        typ:            loop_node.typ
    })
    mut result := []flat.NodeId{}
    result << t.a.add_val(.label_stmt, label)
    result << t.transform_stmt(new_loop)
    result << t.a.add_val(.label_stmt, break_label)
    return result
}

// transform_stmt transforms transform stmt data for transform.
pub fn (mut t Transformer) transform_stmt(id flat.NodeId) []flat.NodeId {
    if int(id) < 0 {
        return arr1(id)
    }
    node := t.a.nodes[int(id)]
    kind_id := node_kind_id(node)
    if kind_id == 44 {
        return t.transform_return_stmt(id, node)
    }
    if kind_id == 40 || kind_id == 42 || kind_id == 43 {
        return t.transform_assign_stmt(id, node)
    }
    if kind_id == 41 {
        return t.transform_decl_assign_stmt(id, node)
    }
    if kind_id == 39 {
        return t.transform_expr_stmt(id, node)
    }
    if kind_id == 46 {
        return t.transform_for_stmt(id, node)
    }
    if kind_id == 47 {
        return t.transform_for_in_stmt(id, node)
    }
    if kind_id == 45 {
        return t.transform_block_stmt(id, node)
    }
    if kind_id == 15 {
        return t.transform_if_stmt(id, node)
    }
    if kind_id == 50 {
        return arr1(t.lower_one_match(node))
    }
    if kind_id == 52 {
        return t.transform_defer_stmt(id, node)
    }
    if kind_id == 53 || kind_id == 56 {
        return t.transform_children_stmt(id, node)
    }
    match node.kind {
        .return_stmt {
            return t.transform_return_stmt(id, node)
        }
        .assign, .selector_assign, .index_assign {
            return t.transform_assign_stmt(id, node)
        }
        .decl_assign {
            return t.transform_decl_assign_stmt(id, node)
        }
        .expr_stmt {
            return t.transform_expr_stmt(id, node)
        }
        .for_stmt {
            return t.transform_for_stmt(id, node)
        }
        .for_in_stmt {
            return t.transform_for_in_stmt(id, node)
        }
        .block {
            return t.transform_block_stmt(id, node)
        }
        .if_expr {
            return t.transform_if_stmt(id, node)
        }
        .match_stmt {
            return arr1(t.lower_one_match(node))
        }
        .defer_stmt {
            return t.transform_defer_stmt(id, node)
        }
        .assert_stmt {
            return t.transform_children_stmt(id, node)
        }
        .select_stmt {
            return t.transform_children_stmt(id, node)
        }
        else {
            return arr1(id)
        }
    }
}

// transform_expr transforms transform expr data for transform.
pub fn (mut t Transformer) transform_expr(id flat.NodeId) flat.NodeId {
    if int(id) < 0 {
        return id
    }
    node := t.a.nodes[int(id)]
    kind_id := node_kind_id(node)
    if kind_id == 8 {
        return t.transform_infix_expr(id, node)
    }
    if kind_id == 12 {
        return t.transform_call_expr(id, node)
    }
    if kind_id == 15 {
        return t.transform_if_expr(id, node)
    }
    if kind_id == 16 {
        return t.transform_struct_init(id, node)
    }
    if kind_id == 17 {
        return t.transform_field_init_expr(id, node)
    }
    if kind_id == 14 {
        return t.transform_index_expr(id, node)
    }
    if kind_id == 6 {
        return t.transform_string_interp(id, node)
    }
    if kind_id == 13 {
        return t.transform_selector_expr(id, node)
    }
    if kind_id == 22 {
        return t.transform_or_expr(id, node)
    }
    if kind_id == 24 {
        return t.transform_as_expr(id, node)
    }
    if kind_id == 9 {
        return t.transform_prefix_expr(id, node)
    }
    if kind_id == 11 {
        return t.transform_paren_expr(id, node)
    }
    if kind_id == 10 {
        return t.transform_postfix_expr(id, node)
    }
    if kind_id == 23 {
        return t.transform_cast_expr(id, node)
    }
    if kind_id == 18 {
        return t.transform_array_literal(id, node)
    }
    if kind_id == 19 {
        return t.transform_array_init_expr(id, node)
    }
    if kind_id == 20 {
        return t.transform_map_init(id, node)
    }
    if kind_id == 38 {
        return t.transform_in_expr(id, node)
    }
    if kind_id == 37 {
        return t.transform_is_expr(id, node)
    }
    if kind_id == 50 {
        return t.lower_one_match(node)
    }
    if kind_id == 45 {
        return t.transform_block_expr(id, node)
    }
    if kind_id == 31 {
        return t.transform_lock_expr(id, node)
    }
    if kind_id == 34 {
        return t.transform_typeof_expr(id, node)
    }
    if kind_id == 7 {
        return t.transform_ident_expr(id, node)
    }
    if kind_id == 26 {
        return t.transform_assoc_expr(id, node)
    }
    if kind_id == 21 {
        return t.lift_fn_literal(id, node)
    }
    if kind_id == 30 || kind_id == 35 || kind_id == 27 || kind_id == 56 || kind_id == 57 {
        return t.transform_children_expr(id, node)
    }
    if kind_id == 1 || kind_id == 2 || kind_id == 3 || kind_id == 4 || kind_id == 5 || kind_id == 28
        || kind_id == 29 || kind_id == 25 || kind_id == 33 || kind_id == 36 {
        return id
    }
    match node.kind {
        .infix {
            return t.transform_infix_expr(id, node)
        }
        .call {
            return t.transform_call_expr(id, node)
        }
        .if_expr {
            return t.transform_if_expr(id, node)
        }
        .struct_init {
            return t.transform_struct_init(id, node)
        }
        .field_init {
            return t.transform_field_init_expr(id, node)
        }
        .index {
            return t.transform_index_expr(id, node)
        }
        .string_interp {
            return t.transform_string_interp(id, node)
        }
        .selector {
            return t.transform_selector_expr(id, node)
        }
        .or_expr {
            return t.transform_or_expr(id, node)
        }
        .as_expr {
            return t.transform_as_expr(id, node)
        }
        .prefix {
            return t.transform_prefix_expr(id, node)
        }
        .paren {
            return t.transform_paren_expr(id, node)
        }
        .postfix {
            return t.transform_postfix_expr(id, node)
        }
        .cast_expr {
            return t.transform_cast_expr(id, node)
        }
        .array_literal {
            return t.transform_array_literal(id, node)
        }
        .array_init {
            return t.transform_array_init_expr(id, node)
        }
        .map_init {
            return t.transform_map_init(id, node)
        }
        .sql_expr {
            return t.transform_sql_expr(id, node)
        }
        .in_expr {
            return t.transform_in_expr(id, node)
        }
        .is_expr {
            return t.transform_is_expr(id, node)
        }
        .match_stmt {
            return t.lower_one_match(node)
        }
        .block {
            return t.transform_block_expr(id, node)
        }
        .lock_expr {
            return t.transform_lock_expr(id, node)
        }
        .typeof_expr {
            return t.transform_typeof_expr(id, node)
        }
        .ident {
            return t.transform_ident_expr(id, node)
        }
        .assoc {
            return t.transform_assoc_expr(id, node)
        }
        .fn_literal {
            return t.lift_fn_literal(id, node)
        }
        .lambda_expr, .spawn_expr, .dump_expr, .range, .select_stmt, .select_branch {
            return t.transform_children_expr(id, node)
        }
        .int_literal, .float_literal, .bool_literal, .char_literal, .string_literal, .nil_literal,
        .none_expr, .enum_val, .sizeof_expr, .offsetof_expr {
            // leaf/simple nodes - pass through unchanged
            return id
        }
        else {
            return id
        }
    }
}

// transform_lvalue transforms transform lvalue data for transform.
pub fn (mut t Transformer) transform_lvalue(id flat.NodeId) flat.NodeId {
    if int(id) < 0 {
        return id
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            return id
        }
        .selector {
            if node.children_count == 0 {
                return id
            }
            if t.selector_chain_has_sum_shared_field(id) {
                value := t.transform_selector_expr(id, node)
                mut value_type := t.node_type(id)
                if value_type.len == 0 {
                    value_type = t.node_type(value)
                }
                return t.stable_transformed_expr_for_reuse(value, value_type, 'lvalue')
            }
            full_key := t.expr_key(id)
            if t.has_smartcast(full_key) {
                return t.transform_selector_expr(id, node)
            }
            base_id := t.a.child(&node, 0)
            base_key := t.expr_key(base_id)
            if t.has_smartcast(base_key) {
                return t.transform_selector_expr(id, node)
            }
            base := t.transform_lvalue(t.a.child(&node, 0))
            mut new_children := []flat.NodeId{cap: int(node.children_count)}
            new_children << base
            for i in 1 .. node.children_count {
                new_children << t.transform_expr(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:           .selector
                op:             node.op
                children_start: start
                children_count: flat.child_count(new_children.len)
                pos:            node.pos
                value:          node.value
                typ:            node.typ
            })
        }
        .index {
            if node.children_count == 0 {
                return id
            }
            mut new_children := []flat.NodeId{cap: int(node.children_count)}
            new_children << t.transform_expr(t.a.child(&node, 0))
            for i in 1 .. node.children_count {
                new_children << t.transform_expr(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:           .index
                op:             node.op
                children_start: start
                children_count: flat.child_count(new_children.len)
                pos:            node.pos
                value:          node.value
                typ:            node.typ
            })
        }
        .prefix {
            if node.op == .mul && node.children_count > 0 {
                child := t.transform_expr(t.a.child(&node, 0))
                start := t.a.children.len
                t.a.children << child
                return t.a.add_node(flat.Node{
                    kind:           .prefix
                    op:             node.op
                    children_start: start
                    children_count: 1
                    pos:            node.pos
                    value:          node.value
                    typ:            node.typ
                })
            }
            return t.transform_expr(id)
        }
        .paren {
            if node.children_count == 0 {
                return id
            }
            child := t.transform_lvalue(t.a.child(&node, 0))
            start := t.a.children.len
            t.a.children << child
            return t.a.add_node(flat.Node{
                kind:           .paren
                op:             node.op
                children_start: start
                children_count: 1
                pos:            node.pos
                value:          node.value
                typ:            node.typ
            })
        }
        else {
            return t.transform_expr(id)
        }
    }
}

// --- stmt handlers (skeleton - identity transforms with child recursion) ---

// transform_return_stmt transforms transform return stmt data for transform.
fn (mut t Transformer) transform_return_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    if expanded := t.try_expand_return_if(id, node) {
        return expanded
    }
    if expanded := t.try_expand_return_match(id, node) {
        return expanded
    }
    if direct := t.try_return_direct_optional_expr(node) {
        return direct
    }
    if expanded := t.try_expand_return_optional_expr(node) {
        return expanded
    }
    if node.children_count == 1 {
        child_id := t.a.child(&node, 0)
        if t.is_optional_type_name(t.cur_fn_ret_type) && t.return_expr_is_err(child_id) {
            return t.with_pending_before(t.make_none_return_stmt())
        }
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        if converted := t.fixed_array_return_value(child_id) {
            new_children << converted
        } else if copied := t.heap_copy_local_address_return(child_id) {
            new_children << copied
        } else if t.cur_fn_ret_type.len > 0 && t.cur_fn_ret_type !in t.sum_types
            && !t.is_optional_type_name(t.cur_fn_ret_type) {
            new_children << t.transform_expr_for_type(child_id, t.cur_fn_ret_type)
        } else {
            new_children << t.wrap_sum_return_expr(child_id)
        }
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    new_id := t.a.add_node(flat.Node{
        kind:           .return_stmt
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
    return t.with_pending_before(new_id)
}

// heap_copy_local_address_return supports heap copy local address return handling for Transformer.
fn (mut t Transformer) heap_copy_local_address_return(child_id flat.NodeId) ?flat.NodeId {
    if !t.cur_fn_ret_type.starts_with('&') || int(child_id) < 0 {
        return none
    }
    node := t.a.nodes[int(child_id)]
    if node.kind != .prefix || node.op != .amp || node.children_count != 1 {
        return none
    }
    inner_id := t.a.child(&node, 0)
    inner := t.a.nodes[int(inner_id)]
    if inner.kind != .ident || inner.value.len == 0 {
        return none
    }
    local_type := t.var_type(inner.value)
    if local_type.len == 0 {
        return none
    }
    ret_base_type := t.cur_fn_ret_type[1..]
    if ret_base_type.len == 0 {
        return none
    }
    clean_local_type := t.normalize_type_alias(local_type)
    clean_ret_type := t.normalize_type_alias(ret_base_type)
    if clean_local_type != clean_ret_type && local_type != ret_base_type {
        return none
    }
    addr := t.make_prefix(.amp, t.make_ident(inner.value))
    size := t.make_sizeof_type(ret_base_type)
    dup := t.make_call_typed('memdup', arr2(addr, size), 'voidptr')
    return t.make_cast(t.cur_fn_ret_type, dup, t.cur_fn_ret_type)
}

// fixed_array_return_value supports fixed array return value handling for Transformer.
fn (mut t Transformer) fixed_array_return_value(child_id flat.NodeId) ?flat.NodeId {
    mut ret_type := t.cur_fn_ret_type
    if t.is_optional_type_name(ret_type) {
        ret_type = t.optional_base_type(ret_type)
    }
    // A function whose declared return type is itself a fixed array keeps
    // fixed-array (by-value) semantics; the C backend returns it via a wrapper
    // struct. Only a *dynamic* array return needs a fixed→dynamic conversion of a
    // fixed-array return value.
    if t.is_fixed_array_type(ret_type) {
        return none
    }
    return t.fixed_array_value_to_dynamic(child_id, ret_type)
}

// fixed_array_value_to_dynamic converts a fixed-array *value* (e.g. a fixed-array
// const or variable, not a literal — those have their own lowering) to a dynamic
// array when `target_type` is `[]T` with a matching element type. Returns none
// when no conversion is needed/possible.
fn (mut t Transformer) fixed_array_value_to_dynamic(value_id flat.NodeId, target_type string) ?flat.NodeId {
    array_type := target_type
    if !array_type.starts_with('[]') {
        return none
    }
    child_type := t.node_type(value_id)
    if !t.is_fixed_array_type(child_type) || fixed_array_elem_type(child_type) != array_type[2..] {
        return none
    }
    return t.fixed_array_value_to_array(value_id, child_type, array_type)
}

// transform_assign_stmt transforms transform assign stmt data for transform.
fn (mut t Transformer) transform_assign_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    if expanded := t.try_expand_multi_return_assign(node) {
        return expanded
    }
    if expanded := t.try_expand_plain_multi_assign(node) {
        return expanded
    }
    if lowered := t.try_lower_sum_shared_field_assign(node) {
        return lowered
    }
    if lowered := t.try_lower_optional_selector_lvalue_assign(node) {
        return lowered
    }
    if lowered := t.try_lower_pointer_value_assign(node) {
        return lowered
    }
    if lowered := t.try_lower_map_index_assign(node) {
        return lowered
    }
    // string `s += x` on a plain ident -> `s = string__plus(s, x)` (only when detectable as string)
    if expanded := t.try_lower_string_compound_assign(id, node) {
        return expanded
    }
    if expanded := t.try_lower_struct_compound_assign(node) {
        return expanded
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        if i % 2 == 0 {
            new_children << t.transform_lvalue(child_id)
        } else {
            lhs_id := t.a.child(&node, i - 1)
            lhs := t.a.nodes[int(lhs_id)]
            mut lhs_type := if lhs.kind in [.selector, .index] {
                t.lvalue_type(lhs_id)
            } else {
                t.original_expr_type(lhs_id)
            }
            if lhs_type.len == 0 {
                lhs_type = t.lvalue_type(lhs_id)
            }
            // A value local moved to the heap (its type became `&T`) is assigned by storing a
            // value through the pointer (cgen emits `*v = ...`), so coerce the RHS to the value
            // type `T`, not `&T`. Otherwise a heaped-local RHS (`v = w`, both `&T`) is copied as a
            // pointer — aliasing `w`'s object — instead of dereferenced to its value.
            if lhs.kind == .ident && lhs.value in t.heaped_amp_locals && lhs_type.starts_with('&') {
                lhs_type = lhs_type[1..]
            }
            sum_target := t.assignment_sum_target(lhs_id, child_id, lhs_type)
            if node.op == .assign && sum_target.len > 0 {
                new_children << t.wrap_sum_value(child_id, sum_target)
            } else {
                new_children << t.transform_expr_for_type(child_id, lhs_type)
            }
        }
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    new_id := 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
    })
    if node.kind == .assign && node.op == .left_shift_assign {
        t.annotate_left_shift_assign(new_id)
    }
    return t.with_pending_before(new_id)
}

fn (mut t Transformer) try_lower_optional_selector_lvalue_assign(node flat.Node) ?[]flat.NodeId {
    if node.kind != .selector_assign || node.children_count != 2 {
        return none
    }
    lhs_id := t.a.child(&node, 0)
    rhs_id := t.a.child(&node, 1)
    if int(lhs_id) < 0 || int(rhs_id) < 0 {
        return none
    }
    lowered_lhs, guard_source, guard_body, guard_mode := t.lower_optional_selector_lvalue(lhs_id) or {
        return none
    }
    mut result := []flat.NodeId{}
    t.drain_pending(mut result)
    not_ok := t.make_prefix(.not, t.make_selector(guard_source, 'ok', 'bool'))
    guard_stmts := t.optional_selector_lvalue_guard_stmts(guard_body, guard_mode, guard_source)
    result << t.make_if(not_ok, t.make_block(guard_stmts), t.make_empty())
    lhs_type := t.lvalue_type(lhs_id)
    sum_target := t.assignment_sum_target(lhs_id, rhs_id, lhs_type)
    rhs := if node.op == .assign && sum_target.len > 0 {
        t.wrap_sum_value(rhs_id, sum_target)
    } else {
        t.transform_expr_for_type(rhs_id, lhs_type)
    }
    t.drain_pending(mut result)
    result << t.make_assign_op(lowered_lhs, rhs, node.op)
    return result
}

fn (mut t Transformer) optional_selector_lvalue_guard_stmts(body_id flat.NodeId, mode string, guard_source flat.NodeId) []flat.NodeId {
    err_expr := t.make_selector(guard_source, 'err', 'IError')
    if mode == '!' || mode == '?' {
        if t.is_optional_type_name(t.cur_fn_ret_type) {
            return arr1(t.make_return(t.make_optional_none_with_err(t.cur_fn_ret_type, err_expr),
                t.cur_fn_ret_type))
        }
        return arr1(t.make_panic_stmt('option/result propagation failed'))
    }
    return t.lower_or_body_to_stmts_with_err_expr(body_id, '', '', mode, err_expr)
}

fn (mut t Transformer) lower_optional_selector_lvalue(id flat.NodeId) ?(flat.NodeId, flat.NodeId, flat.NodeId, string) {
    if int(id) < 0 {
        return none
    }
    node := t.a.nodes[int(id)]
    if node.kind != .selector || node.children_count == 0 || node.value.len == 0 {
        return none
    }
    base_id := t.a.child(&node, 0)
    base := t.a.nodes[int(base_id)]
    if base.kind == .or_expr && base.children_count >= 2 {
        return t.lower_optional_selector_lvalue_from_or(id, node, base)
    }
    if base.kind == .paren && base.children_count > 0 {
        inner_id := t.a.child(&base, 0)
        inner := t.a.nodes[int(inner_id)]
        if inner.kind == .or_expr && inner.children_count >= 2 {
            return t.lower_optional_selector_lvalue_from_or(id, node, inner)
        }
    }
    lowered_base, guard_source, guard_body, guard_mode := t.lower_optional_selector_lvalue(base_id) or {
        return none
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    new_children << lowered_base
    for i in 1 .. node.children_count {
        new_children << t.transform_expr(t.a.child(&node, i))
    }
    start := t.a.children.len
    for child in new_children {
        t.a.children << child
    }
    lowered := t.a.add_node(flat.Node{
        kind:           .selector
        op:             node.op
        children_start: start
        children_count: flat.child_count(new_children.len)
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
    return lowered, guard_source, guard_body, guard_mode
}

fn (mut t Transformer) lower_optional_selector_lvalue_from_or(id flat.NodeId, node flat.Node, base flat.Node) ?(flat.NodeId, flat.NodeId, flat.NodeId, string) {
    source_id := t.a.child(&base, 0)
    if !t.optional_selector_lvalue_source(source_id) {
        return none
    }
    expr_type, value_type := t.or_expr_types(source_id, base.typ)
    if !t.is_optional_type_name(expr_type) || value_type.len == 0 || value_type == 'void' {
        return none
    }
    source := t.transform_lvalue(source_id)
    value_base := t.make_selector(source, 'value', value_type)
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    new_children << value_base
    for i in 1 .. node.children_count {
        new_children << t.transform_expr(t.a.child(&node, i))
    }
    start := t.a.children.len
    for child in new_children {
        t.a.children << child
    }
    lhs_type := t.lvalue_type(id)
    lowered := t.a.add_node(flat.Node{
        kind:           .selector
        op:             if value_type.starts_with('&') { flat.Op.arrow } else { node.op }
        children_start: start
        children_count: flat.child_count(new_children.len)
        pos:            node.pos
        value:          node.value
        typ:            if lhs_type.len > 0 { lhs_type } else { node.typ }
    })
    return lowered, source, t.a.child(&base, 1), base.value
}

fn (t &Transformer) optional_selector_lvalue_source(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            return node.value.len > 0
        }
        .paren {
            if node.children_count == 0 {
                return false
            }
            return t.optional_selector_lvalue_source(t.a.child(&node, 0))
        }
        .selector {
            if node.children_count == 0 || node.value.len == 0 {
                return false
            }
            return t.optional_selector_lvalue_source(t.a.child(&node, 0))
        }
        else {
            return false
        }
    }
}

fn (mut t Transformer) try_lower_struct_compound_assign(node flat.Node) ?[]flat.NodeId {
    if node.kind != .assign || node.children_count != 2 {
        return none
    }
    op_name := compound_assign_struct_operator_symbol(node.op) or { return none }
    lhs_id := t.a.child(&node, 0)
    rhs_id := t.a.child(&node, 1)
    lhs := t.a.nodes[int(lhs_id)]
    if lhs.kind != .ident || lhs.value.len == 0 {
        return none
    }
    mut lhs_type := t.original_expr_type(lhs_id)
    if lhs_type.starts_with('&') {
        return none
    }
    struct_type := t.struct_lookup_name(lhs_type)
    if struct_type.len == 0 {
        return none
    }
    method_name := t.struct_operator_fn_name(struct_type, op_name) or { return none }
    rhs := t.transform_expr_for_type(rhs_id, lhs_type)
    call := t.make_call_typed(method_name, arr2(t.make_ident(lhs.value), rhs), lhs_type)
    return arr1(t.make_assign(t.make_ident(lhs.value), call))
}

fn compound_assign_struct_operator_symbol(op flat.Op) ?string {
    match op {
        .plus_assign { return '+' }
        .minus_assign { return '-' }
        .mul_assign { return '*' }
        .div_assign { return '/' }
        .mod_assign { return '%' }
        else {}
    }

    return none
}

// try_lower_sum_shared_field_assign
// supports helper handling in transform.
fn (mut t Transformer) try_lower_sum_shared_field_assign(node flat.Node) ?[]flat.NodeId {
    if node.kind !in [.assign, .selector_assign] || node.children_count != 2 {
        return none
    }
    lhs_id := t.a.child(&node, 0)
    rhs_id := t.a.child(&node, 1)
    if int(lhs_id) < 0 || int(rhs_id) < 0 {
        return none
    }
    lhs := t.a.nodes[int(lhs_id)]
    if lhs.kind != .selector || lhs.children_count == 0 || lhs.value.len == 0 {
        return none
    }
    base_id := t.a.child(&lhs, 0)
    mut base_type := t.node_type(base_id)
    if base_type.len == 0 {
        base_type = t.original_expr_type(base_id)
    }
    field_type := t.sum_shared_field_type_name(base_type, lhs.value) or { return none }
    mut base := t.transform_lvalue(base_id)
    mut sum_type := base_type
    if !t.is_stable_expr_for_reuse(base) {
        clean_sum := t.trim_pointer_type(sum_type)
        ptr_type := if sum_type.starts_with('&') { sum_type } else { '&${clean_sum}' }
        addr := if sum_type.starts_with('&') {
            base
        } else {
            mut addr_expr := t.make_prefix(.amp, base)
            t.a.nodes[int(addr_expr)].typ = ptr_type
            addr_expr
        }
        tmp_name := t.new_temp('sum_lhs')
        t.pending_stmts << t.make_decl_assign_typed(tmp_name, addr, ptr_type)
        base = t.make_ident(tmp_name)
        sum_type = ptr_type
    }
    mut rhs := if node.op == .assign {
        t.transform_expr_for_type(rhs_id, field_type)
    } else {
        t.transform_expr(rhs_id)
    }
    mut rhs_type := t.node_type(rhs)
    if rhs_type.len == 0 {
        rhs_type = t.node_type(rhs_id)
    }
    if rhs_type.len == 0 {
        rhs_type = field_type
    }
    rhs = t.stable_transformed_expr_for_reuse(rhs, rhs_type, 'sum_assign')
    resolved_sum := t.resolve_sum_name(t.trim_pointer_type(sum_type))
    variants := t.sum_types[resolved_sum] or { return none }
    stmt := t.build_sum_shared_field_assign_chain(base, sum_type, resolved_sum, variants,
        lhs.value, field_type, rhs, node.op, 0)
    return t.with_pending_before(stmt)
}

// build_sum_shared_field_assign_chain supports build_sum_shared_field_assign_chain handling.
fn (mut t Transformer) build_sum_shared_field_assign_chain(base flat.NodeId, sum_type string, resolved_sum string, variants []string, field string, field_type string, rhs flat.NodeId, op flat.Op, idx int) flat.NodeId {
    if idx >= variants.len {
        return t.make_empty()
    }
    variant := variants[idx]
    tag := t.make_selector_op(base, 'typ', 'int', if sum_type.starts_with('&') {
        .arrow
    } else {
        .dot
    })
    cond := t.make_infix(.eq, tag, t.make_int_literal(t.sum_type_index(resolved_sum, variant)))
    qv := t.resolve_variant(resolved_sum, variant)
    sum_field := t.sum_field_name(qv)
    use_ptr := t.variant_references_sum(qv, resolved_sum)
    variant_base := t.make_selector_op(base, sum_field, if use_ptr { '&${qv}' } else { qv }, if sum_type.starts_with('&') {
        .arrow
    } else {
        .dot
    })
    mut then_stmt := t.make_empty()
    if nested_field_type := t.sum_shared_field_type_name(qv, field) {
        nested_sum := t.resolve_sum_name(qv)
        if nested_variants := t.sum_types[nested_sum] {
            then_stmt = t.build_sum_shared_field_assign_chain(variant_base, qv, nested_sum,
                nested_variants, field, nested_field_type, rhs, op, 0)
        }
    } else {
        field_lhs := t.make_selector_op(variant_base, field, field_type, if use_ptr {
            .arrow
        } else {
            .dot
        })
        then_stmt = t.make_assign_op(field_lhs, rhs, op)
    }
    then_block := t.make_block(arr1(then_stmt))
    else_stmt := t.build_sum_shared_field_assign_chain(base, sum_type, resolved_sum, variants,
        field, field_type, rhs, op, idx + 1)
    return t.make_if(cond, then_block, else_stmt)
}

// assignment_sum_target supports assignment sum target handling for Transformer.
fn (t &Transformer) assignment_sum_target(lhs_id flat.NodeId, rhs_id flat.NodeId, lhs_type string) string {
    if lhs_type.starts_with('&') {
        return ''
    }
    if lhs_type.starts_with('[]') || t.is_fixed_array_type(lhs_type) {
        return ''
    }
    if t.is_sum_type_name(lhs_type) {
        return lhs_type
    }
    if int(lhs_id) < 0 || int(rhs_id) < 0 {
        return ''
    }
    lhs := t.a.nodes[int(lhs_id)]
    if lhs.kind != .selector || lhs.value.len == 0 {
        return ''
    }
    if lhs.value == 'obj' {
        sum_name := t.resolve_sum_name('ScopeObject')
        if t.is_sum_type_name(sum_name) {
            return sum_name
        }
    }
    rhs := t.a.nodes[int(rhs_id)]
    if inferred_sum := t.sum_type_for_field_variant(lhs.value, rhs_id, rhs) {
        return inferred_sum
    }
    if lhs.value == 'info' {
        if type_info_sum := t.type_info_sum_name() {
            return type_info_sum
        }
    }
    return ''
}

// type_info_sum_name returns type info sum name data for Transformer.
fn (t &Transformer) type_info_sum_name() ?string {
    for sum_name, _ in t.sum_types {
        if sum_name == 'TypeInfo' || sum_name.ends_with('.TypeInfo') {
            return sum_name
        }
    }
    return none
}

// try_lower_pointer_value_assign supports try lower pointer value assign handling for Transformer.
fn (mut t Transformer) try_lower_pointer_value_assign(node flat.Node) ?[]flat.NodeId {
    if node.kind != .assign || node.children_count != 2 {
        return none
    }
    lhs_id := t.a.child(&node, 0)
    lhs := t.a.nodes[int(lhs_id)]
    if lhs.kind != .ident || lhs.value.len == 0 {
        return none
    }
    mut lhs_type := t.var_type(lhs.value)
    if lhs_type.len == 0 {
        lhs_type = t.node_type(lhs_id)
    }
    if !lhs_type.starts_with('&') {
        return none
    }
    rhs_id := t.a.child(&node, 1)
    rhs_type := t.node_type(rhs_id)
    lhs_value_type := t.normalize_type_alias(lhs_type[1..])
    if node.op != .assign {
        if !t.pointer_value_lvalues[lhs.value] {
            return none
        }
        new_lhs := t.make_prefix(.mul, t.make_ident(lhs.value))
        return arr1(t.make_assign_op(new_lhs, t.transform_expr(rhs_id), node.op))
    }
    if rhs_type.len == 0
        || (rhs_type != lhs_value_type && !t.type_alias_targets_type(lhs_type[1..], rhs_type)) {
        return none
    }
    new_lhs := t.make_prefix(.mul, t.make_ident(lhs.value))
    return arr1(t.make_assign(new_lhs, t.transform_expr(rhs_id)))
}

// transform_expr_for_type transforms transform expr for type data for transform.
fn (mut t Transformer) transform_expr_for_type(id flat.NodeId, target_type string) flat.NodeId {
    if int(id) >= 0 && target_type.len > 0 {
        node := t.a.nodes[int(id)]
        if node.kind == .none_expr && t.is_ierror_type(target_type) {
            return t.make_struct_init('IError')
        }
        if target_type.starts_with('&') {
            if expr := t.transform_amp_struct_init_for_type(id, node, target_type) {
                return expr
            }
        }
        if expr := t.transform_interface_value_for_type(id, target_type) {
            return expr
        }
        if node.kind == .block {
            if lowered := t.transform_block_expr_for_type(id, node, target_type) {
                return lowered
            }
        }
        if node.kind == .if_expr {
            if lowered := t.try_expand_if_expr_value_for_type(id, node, target_type) {
                return lowered
            }
        }
        if node.kind == .match_stmt {
            if lowered := t.transform_match_expr_for_type(id, node, target_type) {
                return lowered
            }
        }
        if node.kind == .or_expr && !t.is_optional_type_name(target_type) {
            old_typ := node.typ
            t.a.nodes[int(id)].typ = target_type
            expr := t.transform_expr(id)
            t.a.nodes[int(id)].typ = old_typ
            return t.coerce_transformed_expr_to_type(expr, id, target_type)
        }
        if node.kind == .array_literal {
            if lowered := t.transform_fixed_array_literal_for_type(id, node, target_type) {
                return lowered
            }
            if lowered := t.transform_array_literal_for_type(id, node, target_type) {
                return lowered
            }
        }
        if node.kind == .array_init {
            if lowered := t.transform_empty_array_init_for_type(node, target_type) {
                return lowered
            }
        }
    }
    expr := t.transform_expr(id)
    return t.coerce_transformed_expr_to_type(expr, id, target_type)
}

// transform_block_expr_for_type transforms transform block expr for type data for transform.
fn (mut t Transformer) transform_block_expr_for_type(_id flat.NodeId, node flat.Node, target_type string) ?flat.NodeId {
    if node.kind != .block || node.children_count == 0 || target_type.len == 0 {
        return none
    }
    last_id := t.a.child(&node, node.children_count - 1)
    last := t.a.nodes[int(last_id)]
    tail_expr_id := if last.kind == .expr_stmt && last.children_count > 0 {
        t.a.child(&last, 0)
    } else if last.kind == .block && t.stmt_value_type(last_id).len > 0 {
        last_id
    } else if !t.is_stmt_kind(last.kind) {
        last_id
    } else {
        return none
    }
    mut prefix := []flat.NodeId{cap: int(node.children_count - 1)}
    for i in 0 .. node.children_count - 1 {
        prefix << t.a.child(&node, i)
    }
    mut new_children := t.transform_stmts(prefix)
    tail_expr := t.transform_expr_for_type(tail_expr_id, target_type)
    tail_stmt := t.make_expr_stmt(tail_expr)
    for stmt in t.with_pending_before(tail_stmt) {
        new_children << stmt
    }
    new_block := t.make_block(new_children)
    block_typ := t.stmt_value_type(new_block)
    t.a.nodes[int(new_block)].typ = if block_typ.len > 0 { block_typ } else { node.typ }
    return new_block
}

// transform_match_expr_for_type transforms transform match expr for type data for transform.
fn (mut t Transformer) transform_match_expr_for_type(_id flat.NodeId, node flat.Node, target_type string) ?flat.NodeId {
    if target_type.len == 0 || node.kind != .match_stmt {
        return none
    }
    mut actual_result_type := t.match_expr_type(node)
    if actual_result_type.len == 0 || actual_result_type == 'void' {
        actual_result_type = target_type
    }
    tmp_name := t.new_temp('match_val')
    outer_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()

    mut prelude := []flat.NodeId{}
    prelude << t.make_decl_assign_typed(tmp_name, t.zero_value_for_type(actual_result_type),
        actual_result_type)
    for stmt in t.build_match_value_stmts(node, tmp_name, actual_result_type) {
        prelude << stmt
    }

    t.pending_stmts = outer_pending
    for stmt in prelude {
        t.pending_stmts << stmt
    }
    tmp := t.make_ident(tmp_name)
    t.a.nodes[int(tmp)].typ = actual_result_type
    return tmp
}

// transform_amp_struct_init_for_type supports transform_amp_struct_init_for_type handling.
fn (mut t Transformer) transform_amp_struct_init_for_type(_id flat.NodeId, node flat.Node, target_type string) ?flat.NodeId {
    if node.kind != .prefix || node.op != .amp || node.children_count != 1 {
        return none
    }
    child_id := t.a.child(&node, 0)
    child := t.a.nodes[int(child_id)]
    if child.kind != .struct_init {
        return none
    }
    new_child := t.transform_struct_init(child_id, child)
    start := t.a.children.len
    t.a.children << new_child
    return t.a.add_node(flat.Node{
        kind:           .prefix
        op:             node.op
        children_start: start
        children_count: 1
        pos:            node.pos
        value:          node.value
        typ:            if target_type.len > 0 { target_type } else { node.typ }
    })
}

// coerce_transformed_expr_to_type converts coerce transformed expr to type data for transform.
fn (mut t Transformer) coerce_transformed_expr_to_type(expr flat.NodeId, source_id flat.NodeId, target_type string) flat.NodeId {
    mut target := t.normalize_type_alias(target_type)
    if target.len == 0 || int(expr) < 0 {
        return expr
    }
    mut expr_type := t.node_type(expr)
    if expr_type.len == 0 {
        expr_type = t.node_type(source_id)
    }
    if expr_type.len == 0 {
        expr_type = t.resolve_expr_type(source_id)
    }
    expr_type = t.normalize_type_alias(expr_type)
    mut optional_target := if t.is_optional_type_name(target_type) {
        t.qualify_optional_type(target_type)
    } else {
        target
    }
    optional_target = t.infer_typed_optional_target(optional_target, expr_type)
    if t.is_optional_type_name(optional_target) && !t.is_optional_type_name(expr_type) {
        source := if int(source_id) >= 0 { t.a.nodes[int(source_id)] } else { flat.Node{} }
        if source.kind != .none_expr {
            return t.make_optional_some(expr, optional_target)
        }
    }
    if expr_type.len == 0 || expr_type == target {
        return expr
    }
    if target.starts_with('&') {
        if t.expr_is_nil_like(source_id) {
            t.a.nodes[int(expr)].typ = target
            return expr
        }
        target_value_type := t.normalize_type_alias(target[1..])
        expr_value_type := if expr_type.starts_with('&') {
            t.normalize_type_alias(expr_type[1..])
        } else {
            expr_type
        }
        if t.is_sum_type_name(target_value_type)
            && t.find_sum_type_for_variant(t.trim_pointer_type(expr_type)).len > 0 {
            if t.resolve_sum_name(t.trim_pointer_type(expr_type)) == t.resolve_sum_name(target_value_type) {
                if expr_type.starts_with('&') {
                    return expr
                }
                if t.expr_can_take_address(expr) {
                    addr := t.make_prefix(.amp, expr)
                    t.a.nodes[int(addr)].typ = target
                    return addr
                }
                tmp_name := t.new_temp('sum_ref')
                t.pending_stmts << t.make_decl_assign_typed(tmp_name, expr, target_value_type)
                addr := t.make_prefix(.amp, t.make_ident(tmp_name))
                t.a.nodes[int(addr)].typ = target
                return addr
            }
            source := t.a.nodes[int(source_id)]
            wrap_source_id := if source.kind == .prefix && source.op == .amp
                && source.children_count > 0 {
                t.a.child(&source, 0)
            } else {
                source_id
            }
            wrapped := t.wrap_sum_value(wrap_source_id, target_value_type)
            tmp_name := t.new_temp('sum_ref')
            t.pending_stmts << t.make_decl_assign_typed(tmp_name, wrapped, target_value_type)
            addr := t.make_prefix(.amp, t.make_ident(tmp_name))
            t.a.nodes[int(addr)].typ = target
            return addr
        }
        if expr_value_type == target_value_type
            || t.type_alias_targets_type(target[1..], expr_value_type) {
            if expr_type.starts_with('&') {
                return expr
            }
            if t.expr_can_take_address(expr) {
                addr := t.make_prefix(.amp, expr)
                t.a.nodes[int(addr)].typ = target
                return addr
            }
            tmp_name := t.new_temp('addr')
            t.pending_stmts << t.make_decl_assign_typed(tmp_name, expr, expr_value_type)
            addr := t.make_prefix(.amp, t.make_ident(tmp_name))
            t.a.nodes[int(addr)].typ = target
            return addr
        }
        return expr
    }
    if expr_type.starts_with('&') {
        expr_value_type := t.normalize_type_alias(expr_type[1..])
        if expr_value_type == target || t.type_alias_targets_type(expr_type[1..], target) {
            deref := t.make_prefix(.mul, expr)
            t.a.nodes[int(deref)].typ = target
            return deref
        }
    }
    return expr
}

// is_ierror_type reports whether is ierror type applies in transform.
fn (t &Transformer) is_ierror_type(name string) bool {
    clean := t.trim_pointer_type(t.normalize_type_alias(name))
    return clean == 'IError' || clean.ends_with('.IError')
}

// expr_is_nil_like supports expr is nil like handling for Transformer.
fn (t &Transformer) expr_is_nil_like(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    if node.kind == .nil_literal {
        return true
    }
    if node.kind != .block || node.children_count == 0 {
        return false
    }
    last_id := t.a.child(&node, node.children_count - 1)
    last := t.a.nodes[int(last_id)]
    if last.kind == .expr_stmt && last.children_count > 0 {
        return t.expr_is_nil_like(t.a.child(&last, 0))
    }
    return t.expr_is_nil_like(last_id)
}

// infer_typed_optional_target resolves infer typed optional target information for transform.
fn (t &Transformer) infer_typed_optional_target(optional_target string, expr_type string) string {
    if expr_type.len == 0 {
        return optional_target
    }
    mut value_type := expr_type
    if !value_type.contains('.') {
        qualified := t.qualify_type(value_type)
        if qualified != value_type {
            value_type = qualified
        }
    }
    if !isnil(t.tc) {
        parsed := t.tc.parse_type(value_type)
        parsed_name := parsed.name()
        if parsed_name.len > 0 && parsed_name != 'unknown' {
            value_type = parsed_name
        }
    }
    if t.is_optional_type_name(optional_target) {
        base := t.optional_base_type(optional_target)
        if value_type.contains('.') && base == value_type.all_after_last('.') {
            return '?${value_type}'
        }
        return optional_target
    }
    if optional_target != 'Optional' || isnil(t.tc) {
        return optional_target
    }
    typ := t.tc.parse_type(value_type)
    if typ is types.Primitive || typ is types.Enum || typ is types.Void {
        return optional_target
    }
    return '?${value_type}'
}

// make_optional_some builds make optional some data for transform.
fn (mut t Transformer) make_optional_some(value flat.NodeId, optional_type string) flat.NodeId {
    ok_field := t.make_sum_literal_field('ok', t.make_bool_literal(true), 'bool')
    base_type := t.optional_base_type(optional_type)
    mut fields := []flat.NodeId{cap: 2}
    fields << ok_field
    if base_type.len > 0 && base_type != 'void' {
        fields << t.make_sum_literal_field('value', value, base_type)
    }
    start := t.a.children.len
    for field in fields {
        t.a.children << field
    }
    return t.a.add_node(flat.Node{
        kind:           .struct_init
        children_start: start
        children_count: flat.child_count(fields.len)
        value:          optional_type
        typ:            optional_type
    })
}

// make_optional_none builds make optional none data for transform.
fn (mut t Transformer) make_optional_none(optional_type string) flat.NodeId {
    ok_field := t.make_sum_literal_field('ok', t.make_bool_literal(false), 'bool')
    start := t.a.children.len
    t.a.children << ok_field
    return t.a.add_node(flat.Node{
        kind:           .struct_init
        children_start: start
        children_count: 1
        value:          optional_type
        typ:            optional_type
    })
}

// make_optional_none_with_err builds make optional none with err data for transform.
fn (mut t Transformer) make_optional_none_with_err(optional_type string, err_expr flat.NodeId) flat.NodeId {
    ok_field := t.make_sum_literal_field('ok', t.make_bool_literal(false), 'bool')
    err_field := t.make_sum_literal_field('err', err_expr, 'IError')
    start := t.a.children.len
    t.a.children << ok_field
    t.a.children << err_field
    return t.a.add_node(flat.Node{
        kind:           .struct_init
        children_start: start
        children_count: 2
        value:          optional_type
        typ:            optional_type
    })
}

// expr_can_take_address supports expr can take address handling for Transformer.
fn (t &Transformer) expr_can_take_address(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            return true
        }
        .index {
            // `a[lo..hi]` (an index node tagged `range`) yields a fresh array value, not an
            // addressable element, so its address can't be taken in place — runtime_addr
            // must materialize it to a temp first. Only plain element indexing `a[i]` is an
            // addressable lvalue.
            if node.value == 'range' {
                return false
            }
            return true
        }
        .selector {
            if node.children_count == 0 {
                return false
            }
            if t.selector_chain_has_sum_variant_field(id) {
                return false
            }
            return t.expr_can_take_address(t.a.child(&node, 0))
        }
        .prefix {
            return node.op == .mul
        }
        .paren {
            if node.children_count == 0 {
                return false
            }
            return t.expr_can_take_address(t.a.child(&node, 0))
        }
        else {
            return false
        }
    }
}

// type_alias_targets_type returns type alias targets type data for Transformer.
fn (t &Transformer) type_alias_targets_type(alias_name string, target_type string) bool {
    if alias_name.len == 0 || target_type.len == 0 || isnil(t.tc) {
        return false
    }
    for name, target in t.tc.type_aliases {
        if name == alias_name || name.all_after_last('.') == alias_name {
            if t.normalize_type_alias(target) == target_type {
                return true
            }
        }
    }
    return false
}

// try_lower_string_compound_assign
// supports helper handling in transform.
fn (mut t Transformer) try_lower_string_compound_assign(_id flat.NodeId, node flat.Node) ?[]flat.NodeId {
    if node.kind != .assign || node.op != .plus_assign || node.children_count != 2 {
        return none
    }
    lhs_id := t.a.child(&node, 0)
    lhs := t.a.nodes[int(lhs_id)]
    if lhs.kind != .ident {
        return none
    }
    rhs_id := t.a.child(&node, 1)
    rhs := t.a.nodes[int(rhs_id)]
    is_string := t.resolve_expr_type(lhs_id) == 'string' || rhs.kind == .string_literal
        || rhs.kind == .string_interp || t.resolve_expr_type(rhs_id) == 'string'
    if !is_string {
        return none
    }
    new_rhs := t.transform_expr(rhs_id)
    lhs_copy := t.make_ident(lhs.value)
    concat := t.make_call('string__plus', arr2(lhs_copy, new_rhs))
    new_lhs := t.make_ident(lhs.value)
    return arr1(t.make_assign(new_lhs, concat))
}

// transform_decl_assign_stmt transforms transform decl assign stmt data for transform.
fn (mut t Transformer) transform_decl_assign_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    mut has_empty_child := false
    for i in 0 .. node.children_count {
        if int(t.a.child(&node, i)) < 0 {
            has_empty_child = true
        }
    }
    if has_empty_child {
        mut parts := []string{}
        for i in 0 .. node.children_count {
            child_id := t.a.child(&node, i)
            if int(child_id) < 0 {
                parts << '${i}:empty'
            } else {
                child := t.a.nodes[int(child_id)]
                parts << '${i}:${child.kind}:${child.value}:${child.typ}'
            }
        }
        panic('internal error: empty decl_assign child in ${t.cur_fn_name}: count=${node.children_count} typ=${node.typ} value=${node.value} children=${parts.join('|')}')
    }
    mut inferred_typ := ''
    if node.children_count > 2 && !isnil(t.tc) {
        rhs_id := t.a.child(&node, 1)
        if rhs_types := t.multi_return_types_for_expr(rhs_id, node.children_count - 1) {
            for j, field_type in rhs_types {
                lhs_idx := if j == 0 { 0 } else { j + 1 }
                if lhs_idx >= node.children_count {
                    continue
                }
                lhs := t.a.child_node(&node, lhs_idx)
                if lhs.kind == .ident && lhs.value.len > 0 && lhs.value != '_' {
                    t.set_var_type(lhs.value, t.normalize_type_alias(field_type.name()))
                }
            }
        }
    }
    if expanded := t.try_expand_multi_return_decl(node) {
        return expanded
    }
    if expanded := t.try_expand_plain_multi_decl(node) {
        return expanded
    }
    // Track the variable type for the common 2-child case.
    if node.children_count == 2 {
        lhs := t.a.child_node(&node, 0)
        if lhs.kind == .ident && lhs.value.len > 0 {
            mut typ := t.infer_decl_type(node)
            rhs_id := t.a.child(&node, 1)
            rhs := t.a.nodes[int(rhs_id)]
            if rhs.kind == .call {
                generic_typ := t.concrete_generic_call_return_type(rhs_id, rhs)
                if generic_typ.len > 0 {
                    typ = generic_typ
                }
            }
            if rhs.kind == .call && t.is_strings_builder_new_call(rhs_id, rhs) {
                typ = 'strings.Builder'
            } else if rhs.kind == .if_expr {
                if_typ := t.if_expr_result_type(rhs_id, rhs)
                if if_typ.len > 0 {
                    typ = if_typ
                }
            } else if rhs.kind == .match_stmt {
                match_typ := t.match_expr_type(rhs)
                if match_typ.len > 0 {
                    typ = match_typ
                }
            } else if rhs.kind == .block {
                block_typ := t.stmt_value_type(rhs_id)
                if block_typ.len > 0 {
                    typ = block_typ
                }
            } else if rhs.kind == .or_expr && rhs.children_count > 0 {
                or_source_id := t.a.child(&rhs, 0)
                if info := t.map_index_info(or_source_id) {
                    typ = info.value_type
                } else if info := t.array_index_info(or_source_id) {
                    typ = info.value_type
                } else {
                    or_body_id := if rhs.children_count > 1 {
                        t.a.child(&rhs, 1)
                    } else {
                        flat.empty_node
                    }
                    fallback_type := if typ.len > 0 { typ } else { t.stmt_value_type(or_body_id) }
                    expr_type, value_type := t.or_expr_types(or_source_id, fallback_type)
                    if t.is_optional_type_name(expr_type) && value_type.len > 0
                        && value_type != 'void' {
                        typ = value_type
                    }
                }
            }
            if node.typ.len == 0 {
                if rhs.kind == .array_literal && t.is_fixed_array_type(typ) {
                    typ = '[]${fixed_array_elem_type(typ)}'
                    t.a.nodes[int(rhs_id)].typ = typ
                }
            }
            if typ.len > 0 {
                t.set_var_type(lhs.value, typ)
                inferred_typ = typ
            }
        }
    }
    // A value local whose address escapes (`p := &v` with `p` returned) is moved to the heap
    // at its own declaration so writes after the alias are visible to the caller. Must run
    // before the `p := &v` alias is transformed (the source is declared first).
    if node.children_count == 2 {
        src := t.a.child_node(&node, 0)
        if src.kind == .ident && src.value in t.escaping_amp_sources
            && src.value !in t.heaped_amp_locals && t.heapable_value_type(inferred_typ) {
            return t.heap_escaping_source_decl(node, src.value, inferred_typ)
        }
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        if i == 0 || (node.children_count > 2 && i > 1) {
            new_children << t.transform_lvalue(child_id)
        } else if node.children_count == 2 && t.try_heap_escaping_amp(node, child_id) {
            new_children << t.heap_escaping_amp_rhs(child_id)
            // When `v` was heap-moved it is already a `&T`, so `p := &v` is really `p := v`
            // (a `&T`), not `&&T` as the literal `&v` would infer. Adopt the source's pointer
            // type for `p` so its declaration and later uses are consistent.
            amp := t.a.nodes[int(child_id)]
            if amp.children_count > 0 {
                amp_src := t.a.nodes[int(t.a.child(&, 0))]
                if amp_src.kind == .ident && amp_src.value in t.heaped_amp_locals {
                    inferred_typ = t.var_type(amp_src.value)
                    t.set_var_type(t.a.nodes[int(t.a.child(&node, 0))].value, inferred_typ)
                }
            }
        } else {
            lhs_id := t.a.child(&node, 0)
            lhs_type := if inferred_typ.len > 0 {
                inferred_typ
            } else if node.typ.len > 0 {
                node.typ
            } else {
                t.lvalue_type(lhs_id)
            }
            sum_target := t.assignment_sum_target(lhs_id, child_id, lhs_type)
            if sum_target.len > 0 && !t.expr_has_smartcast(child_id) {
                new_children << t.wrap_sum_value(child_id, sum_target)
            } else {
                new_children << t.transform_expr_for_type(child_id, lhs_type)
            }
        }
    }
    if node.children_count == 2 && node.typ.len == 0 {
        lhs := t.a.nodes[int(new_children[0])]
        if lhs.kind == .ident && lhs.value.len > 0 {
            rhs_typ := t.node_type(new_children[1])
            if decl_type_is_usable(rhs_typ)
                && (inferred_typ.len == 0 || inferred_typ in ['array', 'map', 'unknown']) {
                t.set_var_type(lhs.value, rhs_typ)
                inferred_typ = rhs_typ
            }
        }
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    new_id := t.a.add_node(flat.Node{
        kind:           .decl_assign
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            if inferred_typ.len > 0 { inferred_typ } else { node.typ }
    })
    return t.with_pending_before(new_id)
}

fn (mut t Transformer) try_expand_plain_multi_decl(node flat.Node) ?[]flat.NodeId {
    if node.kind != .decl_assign || node.children_count < 4 || node.children_count % 2 != 0 {
        return none
    }
    mut result := []flat.NodeId{}
    for i := 0; i < node.children_count; i += 2 {
        lhs_id := t.a.child(&node, i)
        rhs_id := t.a.child(&node, i + 1)
        lhs := t.a.nodes[int(lhs_id)]
        rhs_node := t.a.nodes[int(rhs_id)]
        generic_rhs_typ := if rhs_node.kind == .call {
            t.concrete_generic_call_return_type(rhs_id, rhs_node)
        } else {
            ''
        }
        rhs := t.transform_expr(rhs_id)
        t.drain_pending(mut result)
        if lhs.kind != .ident || lhs.value == '_' {
            continue
        }
        rhs_authority := t.decl_rhs_type(rhs_id)
        mut typ := if t.is_fn_pointer_type_name(rhs_authority) { rhs_authority } else { '' }
        if typ.len == 0 {
            typ = generic_rhs_typ
        }
        if typ.len == 0 {
            typ = t.node_type(rhs)
        }
        if typ.len == 0 {
            typ = t.node_type(rhs_id)
        }
        if typ.len == 0 {
            typ = rhs_authority
        }
        if typ.len == 0 && lhs.typ.len > 0 {
            typ = lhs.typ
        }
        if typ.len > 0 {
            typ = t.normalize_type_alias(typ)
            t.set_var_type(lhs.value, typ)
            result << t.make_decl_assign_typed(lhs.value, rhs, typ)
        } else {
            result << t.make_decl_assign(lhs.value, rhs)
        }
    }
    return result
}

// expr_has_smartcast converts expr has smartcast data for transform.
fn (t &Transformer) expr_has_smartcast(id flat.NodeId) bool {
    key := t.expr_key(id)
    return t.has_smartcast(key)
}

// try_expand_multi_return_decl supports try expand multi return decl handling for Transformer.
fn (mut t Transformer) try_expand_multi_return_decl(node flat.Node) ?[]flat.NodeId {
    if node.kind != .decl_assign || node.children_count < 3 || isnil(t.tc) {
        return none
    }
    rhs_id := t.a.child(&node, 1)
    rhs := t.a.nodes[int(rhs_id)]
    lhs_ids := t.multi_assign_lhs_ids(node)
    if rhs.kind == .if_expr {
        return t.expand_multi_return_if_decl(rhs_id, rhs, lhs_ids)
    }
    if rhs_types := t.multi_return_types_for_expr(rhs_id, lhs_ids.len) {
        tmp_name := t.new_temp('multi_ret')
        mut result := []flat.NodeId{}
        new_rhs := t.transform_expr(rhs_id)
        t.drain_pending(mut result)
        result << t.make_decl_assign_typed(tmp_name, new_rhs, t.multi_return_type_name(rhs_types))
        for j, field_type in rhs_types {
            if j >= lhs_ids.len {
                continue
            }
            lhs_id := lhs_ids[j]
            lhs := t.a.nodes[int(lhs_id)]
            if lhs.kind != .ident || lhs.value == '_' {
                continue
            }
            field_name := 'arg${j}'
            field_type_name := field_type.name()
            field := t.make_selector(t.make_ident(tmp_name), field_name, field_type_name)
            t.set_var_type(lhs.value, t.normalize_type_alias(field_type_name))
            result << t.make_decl_assign_typed(lhs.value, field, field_type_name)
        }
        return result
    }
    return none
}

// try_expand_multi_return_assign supports try expand multi return assign handling for Transformer.
fn (mut t Transformer) try_expand_multi_return_assign(node flat.Node) ?[]flat.NodeId {
    if node.kind != .assign || node.children_count < 3 || isnil(t.tc) {
        return none
    }
    rhs_id := t.a.child(&node, 1)
    rhs := t.a.nodes[int(rhs_id)]
    lhs_ids := t.multi_assign_lhs_ids(node)
    if rhs.kind == .if_expr {
        return t.expand_multi_return_if_assign(rhs_id, rhs, lhs_ids)
    }
    if rhs_types := t.multi_return_types_for_expr(rhs_id, lhs_ids.len) {
        tmp_name := t.new_temp('multi_ret')
        mut result := []flat.NodeId{}
        new_rhs := t.transform_expr(rhs_id)
        t.drain_pending(mut result)
        result << t.make_decl_assign_typed(tmp_name, new_rhs, t.multi_return_type_name(rhs_types))
        for j, field_type in rhs_types {
            if j >= lhs_ids.len {
                continue
            }
            lhs_id := lhs_ids[j]
            lhs := t.a.nodes[int(lhs_id)]
            if lhs.kind == .ident && lhs.value == '_' {
                continue
            }
            field_name := 'arg${j}'
            field_type_name := field_type.name()
            field := t.make_selector(t.make_ident(tmp_name), field_name, field_type_name)
            result << t.make_assign(t.transform_lvalue(lhs_id), field)
        }
        return result
    }
    return none
}

// try_expand_plain_multi_assign supports try expand plain multi assign handling for Transformer.
fn (mut t Transformer) try_expand_plain_multi_assign(node flat.Node) ?[]flat.NodeId {
    if node.kind != .assign || node.op != .assign || node.children_count < 4
        || node.children_count % 2 != 0 {
        return none
    }
    mut result := []flat.NodeId{}
    mut lhs_ids := []flat.NodeId{}
    mut tmp_names := []string{}
    for i := 0; i < node.children_count; i += 2 {
        lhs_id := t.a.child(&node, i)
        rhs_id := t.a.child(&node, i + 1)
        lhs_ids << lhs_id
        lhs_type := t.lvalue_type(lhs_id)
        rhs := if lhs_type.len > 0 {
            t.transform_expr_for_type(rhs_id, lhs_type)
        } else {
            t.transform_expr(rhs_id)
        }
        t.drain_pending(mut result)
        tmp_name := t.new_temp('assign')
        tmp_type := if lhs_type.len > 0 { lhs_type } else { t.node_type(rhs_id) }
        result << t.make_decl_assign_typed(tmp_name, rhs, tmp_type)
        tmp_names << tmp_name
    }
    for i, lhs_id in lhs_ids {
        lhs := t.a.nodes[int(lhs_id)]
        if lhs.kind == .ident && lhs.value == '_' {
            continue
        }
        result << t.make_assign(t.transform_lvalue(lhs_id), t.make_ident(tmp_names[i]))
    }
    return result
}

// multi_assign_lhs_ids supports multi assign lhs ids handling for Transformer.
fn (t &Transformer) multi_assign_lhs_ids(node flat.Node) []flat.NodeId {
    mut lhs_ids := []flat.NodeId{}
    if node.children_count > 0 {
        lhs_ids << t.a.child(&node, 0)
    }
    for i in 2 .. node.children_count {
        lhs_ids << t.a.child(&node, i)
    }
    return lhs_ids
}

// multi_return_types_for_expr supports multi return types for expr handling for Transformer.
fn (t &Transformer) multi_return_types_for_expr(id flat.NodeId, expected_count int) ?[]types.Type {
    if int(id) < 0 || isnil(t.tc) {
        return none
    }
    if typ := t.tc.expr_type(id) {
        if items := multi_return_types_from_type(typ, expected_count) {
            return items
        }
    }
    node := t.a.nodes[int(id)]
    if node.kind == .or_expr && node.children_count > 0 {
        return t.multi_return_types_for_expr(t.a.child(&node, 0), expected_count)
    }
    if node.kind == .match_stmt {
        return t.match_multi_return_types(node, expected_count)
    }
    if node.kind == .expr_stmt {
        return t.expr_stmt_multi_return_types(node, expected_count)
    }
    if node.kind == .block {
        return t.block_multi_return_types(node, expected_count)
    }
    mut typ_name := node.typ
    if node.kind == .call {
        ret := t.get_call_return_type(id, node)
        if ret.len > 0 {
            typ_name = ret
        }
    } else if typ_name.len == 0 {
        typ_name = t.resolve_expr_type(id)
    }
    if typ_name.len == 0 {
        if node.kind == .call {
            return t.find_multi_return_call_types(node, expected_count)
        }
        return none
    }
    typ := t.tc.parse_type(typ_name)
    if items := multi_return_types_from_type(typ, expected_count) {
        return items
    }
    if node.kind == .call {
        return t.find_multi_return_call_types(node, expected_count)
    }
    return none
}

fn (t &Transformer) match_multi_return_types(node flat.Node, expected_count int) ?[]types.Type {
    if node.children_count < 2 {
        return none
    }
    for i in 1 .. node.children_count {
        branch := t.a.child_node(&node, i)
        if branch.kind != .match_branch {
            continue
        }
        body_start := if branch.value == 'else' { 0 } else { t.count_conds(*branch) }
        if branch.children_count <= body_start {
            continue
        }
        tail_id := t.a.child(branch, branch.children_count - 1)
        if items := t.multi_return_types_for_expr(tail_id, expected_count) {
            return items
        }
    }
    return none
}

fn (t &Transformer) expr_stmt_multi_return_types(node flat.Node, expected_count int) ?[]types.Type {
    if expected_count <= 0 || node.children_count != expected_count {
        return none
    }
    mut result := []types.Type{cap: expected_count}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        mut typ_name := t.node_type(child_id)
        if typ_name.len == 0 {
            typ_name = t.resolve_expr_type(child_id)
        }
        if typ_name.len == 0 {
            return none
        }
        result << t.tc.parse_type(typ_name)
    }
    return result
}

fn (t &Transformer) block_multi_return_types(node flat.Node, expected_count int) ?[]types.Type {
    if expected_count <= 0 || node.children_count != expected_count {
        return none
    }
    mut result := []types.Type{cap: expected_count}
    for i in 0 .. node.children_count {
        stmt_id := t.a.child(&node, i)
        stmt := t.a.nodes[int(stmt_id)]
        if stmt.kind != .expr_stmt || stmt.children_count != 1 {
            return none
        }
        child_id := t.a.child(&stmt, 0)
        mut typ_name := t.node_type(child_id)
        if typ_name.len == 0 {
            typ_name = t.resolve_expr_type(child_id)
        }
        if typ_name.len == 0 {
            return none
        }
        result << t.tc.parse_type(typ_name)
    }
    return result
}

// multi_return_types_from_type converts multi return types from type data for transform.
fn multi_return_types_from_type(typ types.Type, expected_count int) ?[]types.Type {
    if typ is types.MultiReturn {
        if expected_count <= 0 || typ.types.len == expected_count {
            items := typ.types.clone()
            return items
        }
        return none
    }
    if typ is types.OptionType {
        return multi_return_types_from_type(typ.base_type, expected_count)
    }
    if typ is types.ResultType {
        return multi_return_types_from_type(typ.base_type, expected_count)
    }
    return none
}

// find_multi_return_call_types resolves find multi return call types information for transform.
fn (t &Transformer) find_multi_return_call_types(node flat.Node, expected_count int) ?[]types.Type {
    if node.kind != .call || node.children_count == 0 || isnil(t.tc) {
        return none
    }
    fn_node := t.a.child_node(&node, 0)
    mut candidates := []string{}
    if fn_node.kind == .ident {
        candidates << fn_node.value
        if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
            candidates << '${t.cur_module}.${fn_node.value}'
        }
    } else if fn_node.kind == .selector {
        if fn_node.children_count > 0 {
            base_id := t.a.child(fn_node, 0)
            mut base_type := t.resolve_expr_type(base_id)
            if base_type.starts_with('&') {
                base_type = base_type[1..]
            }
            if base_type.len > 0 {
                candidates << '${base_type}.${fn_node.value}'
                if base_type.contains('.') {
                    candidates << '${base_type.all_after_last('.')}.${fn_node.value}'
                }
            }
        }
        candidates << '.${fn_node.value}'
    }
    for candidate in candidates {
        if ret := t.tc.fn_ret_types[candidate] {
            if items := multi_return_types_from_type(ret, expected_count) {
                return items
            }
        }
    }
    for candidate in candidates {
        for key, ret in t.tc.fn_ret_types {
            matches := if candidate.starts_with('.') {
                key.ends_with(candidate)
            } else {
                key == candidate || key.ends_with('.${candidate}')
            }
            if matches {
                if items := multi_return_types_from_type(ret, expected_count) {
                    return items
                }
            }
        }
    }
    return none
}

// multi_return_type_name supports multi return type name handling for Transformer.
fn (t &Transformer) multi_return_type_name(items []types.Type) string {
    mut names := []string{cap: items.len}
    for item in items {
        names << item.name()
    }
    return '(${names.join(', ')})'
}

// expand_multi_return_if_decl builds expand multi return if decl data for transform.
fn (mut t Transformer) expand_multi_return_if_decl(_rhs_id flat.NodeId, rhs flat.Node, lhs_ids []flat.NodeId) ?[]flat.NodeId {
    if lhs_ids.len == 0 {
        return none
    }
    value_types := t.infer_multi_if_value_types(rhs, lhs_ids.len)
    mut result := []flat.NodeId{}
    for i, lhs_id in lhs_ids {
        lhs := t.a.nodes[int(lhs_id)]
        if lhs.kind != .ident || lhs.value == '_' {
            continue
        }
        typ := if i < value_types.len { value_types[i] } else { 'int' }
        result << t.make_decl_assign_typed(lhs.value, t.zero_value_for_type(typ), typ)
    }
    if_stmts := t.expand_multi_return_if_assign(_rhs_id, rhs, lhs_ids) or { return none }
    for stmt in if_stmts {
        result << stmt
    }
    return result
}

// expand_multi_return_if_assign builds expand multi return if assign data for transform.
fn (mut t Transformer) expand_multi_return_if_assign(_rhs_id flat.NodeId, rhs flat.Node, lhs_ids []flat.NodeId) ?[]flat.NodeId {
    if rhs.kind != .if_expr || lhs_ids.len == 0 {
        return none
    }
    return t.lower_multi_if_assign(rhs, lhs_ids)
}

// lower_multi_if_assign builds lower multi if assign data for transform.
fn (mut t Transformer) lower_multi_if_assign(node flat.Node, lhs_ids []flat.NodeId) []flat.NodeId {
    if node.children_count < 2 {
        return []
    }
    cond_id := t.a.child(&node, 0)
    then_id := t.a.child(&node, 1)
    mut result := []flat.NodeId{}
    new_cond := t.transform_expr(cond_id)
    t.drain_pending(mut result)
    then_block := t.multi_if_assign_block(then_id, lhs_ids)
    mut else_block := t.make_empty()
    if node.children_count >= 3 {
        else_id := t.a.child(&node, 2)
        else_node := t.a.nodes[int(else_id)]
        if else_node.kind == .if_expr {
            else_stmts := t.lower_multi_if_assign(else_node, lhs_ids)
            else_block = t.make_block(else_stmts)
        } else {
            else_block = t.multi_if_assign_block(else_id, lhs_ids)
        }
    }
    result << t.make_if(new_cond, then_block, else_block)
    return result
}

// multi_if_assign_block supports multi if assign block handling for Transformer.
fn (mut t Transformer) multi_if_assign_block(block_id flat.NodeId, lhs_ids []flat.NodeId) flat.NodeId {