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
}

// arr4 supports arr4 handling for transform.
fn arr4(a flat.NodeId, b flat.NodeId, c flat.NodeId, d flat.NodeId) []flat.NodeId {
    mut r := []flat.NodeId{}
    r << a
    r << b
    r << c
    r << d
    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
    cur_fn_is_generic     bool
    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
    node_module_map_cache  map[int]string
    node_module_map_nodes  int = -1
}

// 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)
    augmented_used_fns = t.used_fns.clone()
    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 t.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) mark_fn_used_name(name string) {
    if name.len == 0 {
        return
    }
    t.used_fns[name] = true
    t.used_fns[c_name(name)] = true
    if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
        needs_module_prefix := !name.contains('.') || local_method_fn_name_needs_module_prefix(name)
        if needs_module_prefix && !name.starts_with('${t.cur_module}.') {
            qname := '${t.cur_module}.${name}'
            t.used_fns[qname] = true
            t.used_fns[c_name(qname)] = true
        }
    }
}

fn local_method_fn_name_needs_module_prefix(name string) bool {
    if !name.contains('.') {
        return false
    }
    receiver_name := name.all_before('.')
    if receiver_name.len == 0 {
        return false
    }
    first := receiver_name[0]
    return first >= `A` && first <= `Z`
}

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, …) and
// operates on its own cloned AST `ast` and forked TypeChecker `wtc`. All
// per-function mutable state, helper-root tracking, used-fn additions, 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.used_fns = t.used_fns.clone()
    w.alias_cache = &AliasCache{}
    w.sum_cache = &AliasCache{}
    w.generic_fn_decls_cache = map[string]GenericFnDecl{}
    w.generic_fn_decls_ready = false
    w.node_module_map_cache = map[int]string{}
    w.node_module_map_nodes = -1
    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.used_fns = t.used_fns.clone()
    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
}

fn (mut t Transformer) merge_worker_used_fns(w &Transformer) {
    for name, used in w.used_fns {
        if used {
            t.used_fns[name] = true
        }
    }
}

// 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
        }
    }
    for name, used in w.used_fns {
        if used {
            t.used_fns[name] = true
        }
    }
}

// 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)
        parts << t.transform_string_interp_part(child_id)
    }
    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)
}

fn (mut t Transformer) transform_string_interp_part(child_id flat.NodeId) flat.NodeId {
    mut expr_id := child_id
    mut format := ''
    child := t.a.nodes[int(child_id)]
    if child.kind == .directive && child.value == 'string_interp_format' && child.children_count > 0 {
        expr_id = t.a.child(&child, 0)
        format = child.typ
    }
    transformed := t.transform_expr(expr_id)
    mut typ := t.node_type(transformed)
    if typ.len == 0 {
        typ = t.reliable_stringify_type(transformed)
    }
    if typ.len == 0 {
        typ = t.reliable_stringify_type(expr_id)
    }
    if typ.len == 0 {
        typ = t.node_type(expr_id)
    }
    if typ.len == 0 {
        typ = 'string'
    }
    return t.wrap_formatted_string_conversion(transformed, typ, format)
}

// 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
    old_is_generic := t.cur_fn_is_generic
    t.cur_fn_is_generic = t.fn_decl_has_unresolved_generics(fn_node, t.cur_module)
    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()
    t.cur_fn_is_generic = old_is_generic
}

// 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 post_if_smartcasts := 0
    defer {
        for _ in 0 .. post_if_smartcasts {
            t.pop_smartcast()
        }
    }
    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
        }
        for info in t.post_if_exit_smartcasts(id) {
            t.push_smartcast(info.expr_name, info.variant_name, info.sum_type_name)
            post_if_smartcasts++
        }
        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)
        }
        .comptime_if {
            return t.transform_comptime_if_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)
        new_children << t.transform_return_child(child_id, i, int(node.children_count))
    }
    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)
}

fn (mut t Transformer) return_values_with_extra(first_id flat.NodeId, extra_ids []flat.NodeId) []flat.NodeId {
    total := extra_ids.len + 1
    mut vals := []flat.NodeId{cap: total}
    vals << t.transform_return_child(first_id, 0, total)
    for i, extra_id in extra_ids {
        vals << t.transform_return_child(extra_id, i + 1, total)
    }
    return vals
}

fn (mut t Transformer) transform_return_child(child_id flat.NodeId, child_index int, total_children int) flat.NodeId {
    if converted := t.fixed_array_return_value(child_id) {
        return converted
    }
    if copied := t.heap_copy_local_address_return(child_id) {
        return copied
    }
    target_type := t.return_child_target_type(child_index, total_children)
    if target_type.len > 0 && target_type !in t.sum_types && !t.is_optional_type_name(target_type) {
        return t.transform_expr_for_type(child_id, target_type)
    }
    return t.wrap_sum_return_expr(child_id)
}

fn (t &Transformer) return_child_target_type(child_index int, total_children int) string {
    if total_children > 1 && !isnil(t.tc) && t.cur_fn_ret_type.len > 0 {
        if items := multi_return_types_from_type(t.tc.parse_type(t.cur_fn_ret_type), total_children) {
            if child_index >= 0 && child_index < items.len {
                return items[child_index].name()
            }
        }
    }
    return t.cur_fn_ret_type
}

// 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.var_type(lhs.value)
    if lhs_type.len == 0 {
        lhs_type = t.original_expr_type(lhs_id)
    }
    if lhs_type.starts_with('&') {
        return none
    }
    mut operator_type := t.struct_lookup_name(lhs_type)
    if operator_type.len == 0 {
        if _ := t.struct_operator_fn_name(lhs_type, op_name) {
            operator_type = lhs_type
        }
    }
    if operator_type.len == 0 {
        return none
    }
    method_name := t.struct_operator_fn_name(operator_type, op_name) or { return none }
    rhs := t.transform_expr_for_type(rhs_id, lhs_type)
    t.mark_fn_used_name(method_name)
    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 == .postfix && node.op == .not && node.children_count == 1 {
            child_id := t.a.child(&node, 0)
            child := t.a.nodes[int(child_id)]
            if child.kind == .array_literal {
                if lowered := t.transform_fixed_array_literal_for_type(child_id, child, target_type) {
                    return lowered
                }
            }
        }
        if node.kind == .array_init {
            if lowered := t.transform_empty_array_init_for_type(node, target_type) {
                return lowered
            }
        }
        if node.kind == .map_init {
            clean_target := t.clean_map_type(target_type)
            if clean_target.starts_with('map[') {
                mut map_node := node
                map_node.value = clean_target
                map_node.typ = clean_target
                return t.lower_map_init_to_runtime(id, map_node)
            }
        }
        if target_type in ['f32', 'f64'] && node.kind == .infix
            && node.op in [.plus, .minus, .mul, .div] && node.children_count >= 2 {
            lhs := t.transform_expr_for_type(t.a.child(&node, 0), target_type)
            rhs := t.transform_expr_for_type(t.a.child(&node, 1), target_type)
            start := t.a.children.len
            t.a.children << lhs
            t.a.children << rhs
            return t.a.add_node(flat.Node{
                kind:           .infix
                op:             node.op
                children_start: start
                children_count: 2
                pos:            node.pos
                value:          node.value
                typ:            target_type
            })
        }
    }
    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 in ['f32', 'f64'] && t.is_integer_type_name(expr_type) {
        return t.make_cast(target, expr, target)
    }
    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 {
                call_typ := t.node_type(rhs_id)
                if decl_type_is_usable(call_typ) {
                    typ = call_typ
                } else if !decl_type_is_usable(typ) {
                    raw_call_typ := t.get_call_return_type(rhs_id, rhs)
                    if raw_call_typ.len > 0 {
                        typ = raw_call_typ
                    }
                }
                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 && !decl_type_is_usable(node.typ) {
        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 {
    block := t.a.nodes[int(block_id)]
    parts := t.tuple_block_parts(block_id, lhs_ids.len) or { return t.transform_expr(block_id) }
    mut stmts := t.transform_stmts(parts.prefix)
    for i, value_id in parts.values {
        value := t.transform_expr(value_id)
        t.drain_pending(mut stmts)
        if i >= lhs_ids.len {
            stmts << t.make_expr_stmt(value)
            continue
        }
        lhs_id := lhs_ids[i]
        lhs := t.a.nodes[int(lhs_id)]
        if lhs.kind == .ident && lhs.value == '_' {
            stmts << t.make_expr_stmt(value)
            continue
        }
        stmts << t.make_assign(t.transform_lvalue(lhs_id), value)
    }
    if block.kind == .block {
        return t.make_block(stmts)
    }
    return t.make_block(stmts)
}

// tuple_block_parts supports tuple block parts handling for Transformer.
fn (t &Transformer) tuple_block_parts(block_id flat.NodeId, count int) ?TupleBlockParts {
    if int(block_id) < 0 || count <= 0 {
        return none
    }
    block := t.a.nodes[int(block_id)]
    if block.kind != .block {
        return none
    }
    children := t.a.children_of(&block).clone()
    if children.len == 0 {
        return none
    }
    last_id := children[children.len - 1]
    last := t.a.nodes[int(last_id)]
    if last.kind == .block {
        if nested := t.tuple_block_parts(last_id, count) {
            if nested.prefix.len == 0 && nested.values.len == count {
                return TupleBlockParts{
                    prefix: children[..children.len - 1].clone()
                    values: nested.values.clone()
                }
            }
        }
    }
    mut values := []flat.NodeId{}
    mut prefix_end := children.len
    for i := children.len - 1; i >= 0; i-- {
        child_id := children[i]
        child := t.a.nodes[int(child_id)]
        if child.kind != .expr_stmt || child.children_count == 0 {
            break
        }
        values.prepend(t.a.child(&child, 0))
        prefix_end = i
        if values.len == count {
            return TupleBlockParts{
                prefix: children[..prefix_end].clone()
                values: values.clone()
            }
        }
    }
    return none
}

// infer_multi_if_value_types resolves infer multi if value types information for transform.
fn (t &Transformer) infer_multi_if_value_types(node flat.Node, count int) []string {
    mut result := []string{cap: count}
    if node.kind != .if_expr || node.children_count < 2 {
        return result
    }
    then_id := t.a.child(&node, 1)
    if parts := t.tuple_block_parts(then_id, count) {
        for value_id in parts.values {
            mut typ := t.tuple_value_type(value_id)
            if typ.len == 0 {
                typ = 'int'
            }
            result << typ
        }
    }
    for result.len < count {
        result << 'int'
    }
    return result
}

// tuple_value_type supports tuple value type handling for Transformer.
fn (t &Transformer) tuple_value_type(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .cast_expr {
            return node.value
        }
        .prefix {
            if node.children_count > 0 {
                inner := t.tuple_value_type(t.a.child(&node, 0))
                if node.op == .amp && inner.len > 0 {
                    return '&${inner}'
                }
                if node.op == .mul && inner.starts_with('&') {
                    return inner[1..]
                }
            }
            return ''
        }
        .paren {
            if node.children_count > 0 {
                return t.tuple_value_type(t.a.child(&node, 0))
            }
            return ''
        }
        else {
            mut typ := t.resolve_expr_type(id)
            if typ.len == 0 {
                typ = t.node_type(id)
            }
            return typ
        }
    }
}

// transform_expr_stmt transforms transform expr stmt data for transform.
fn (mut t Transformer) transform_expr_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    child_id := t.a.children[node.children_start]
    child := t.a.nodes[int(child_id)]
    if child.kind == .call && t.is_disabled_fn_call(child_id, child) {
        return []flat.NodeId{}
    }
    if child.kind == .or_expr && !t.is_map_index_or_expr(child) {
        _ = t.lower_or_expr_to_temp(child_id, child)
        mut result := []flat.NodeId{}
        t.drain_pending(mut result)
        return result
    }
    if child.kind == .lock_expr {
        return t.transform_lock_stmt(child_id, child)
    }
    if lowered := t.try_lower_map_index_append_stmt(child_id) {
        return lowered
    }
    if lowered := t.try_lower_map_index_postfix_stmt(child_id) {
        return lowered
    }
    if lowered := t.try_lower_array_append_stmt(child_id) {
        return lowered
    }
    if lowered := t.try_lower_flag_enum_stmt(child_id) {
        return arr1(lowered)
    }
    new_child := t.transform_expr(child_id)
    start := t.a.children.len
    t.a.children << new_child
    new_id := t.a.add_node(flat.Node{
        kind:           .expr_stmt
        op:             node.op
        children_start: start
        children_count: 1
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
    return t.with_pending_before(new_id)
}

// transform_lock_stmt transforms transform lock stmt data for transform.
fn (mut t Transformer) transform_lock_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    body_id := t.a.child(&node, node.children_count - 1)
    if int(body_id) < 0 {
        return arr1(id)
    }
    body := t.a.nodes[int(body_id)]
    if body.kind == .block {
        return t.transform_stmts(t.a.children_of(&body))
    }
    if t.is_stmt_kind_id(node_kind_id(body)) {
        return t.transform_stmt(body_id)
    }
    new_child := t.transform_expr(body_id)
    return t.with_pending_before(t.make_expr_stmt(new_child))
}

// transform_for_stmt transforms transform for stmt data for transform.
fn (mut t Transformer) transform_for_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    return t.transform_for_body(id, node)
}

// transform_for_in_stmt transforms transform for in stmt data for transform.
fn (mut t Transformer) transform_for_in_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    return t.transform_for_in_body(id, node)
}

// transform_block_stmt transforms transform block stmt data for transform.
fn (mut t Transformer) transform_block_stmt(_id flat.NodeId, node flat.Node) []flat.NodeId {
    mut child_ids := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_ids << t.a.children[node.children_start + i]
    }
    new_children := t.transform_stmts(child_ids)
    new_block := t.make_block(new_children)
    return arr1(new_block)
}

fn (mut t Transformer) transform_comptime_if_stmt(_id flat.NodeId, node flat.Node) []flat.NodeId {
    take_then := t.comptime_type_condition_value(node.value) or { return arr1(_id) }
    branch_index := if take_then { 0 } else { 1 }
    if branch_index >= node.children_count {
        return []flat.NodeId{}
    }
    branch_id := t.a.child(&node, branch_index)
    branch := t.a.nodes[int(branch_id)]
    if branch.kind == .block {
        return t.transform_stmts(t.a.children_of(&branch))
    }
    return t.transform_stmt(branch_id)
}

fn comptime_condition_matching_paren(s string, start int) int {
    mut paren_depth := 0
    mut bracket_depth := 0
    for i in start .. s.len {
        match s[i] {
            `(` {
                paren_depth++
            }
            `)` {
                paren_depth--
                if paren_depth == 0 && bracket_depth == 0 {
                    return i
                }
            }
            `[` {
                bracket_depth++
            }
            `]` {
                bracket_depth--
            }
            else {}
        }
    }
    return s.len
}

fn comptime_condition_strip_outer_parens(cond string) string {
    mut clean := cond.trim_space()
    for clean.len >= 2 && clean.starts_with('(') {
        end := comptime_condition_matching_paren(clean, 0)
        if end != clean.len - 1 {
            break
        }
        clean = clean[1..clean.len - 1].trim_space()
    }
    return clean
}

fn comptime_condition_top_level_index(s string, needle string) int {
    if needle.len == 0 || s.len < needle.len {
        return -1
    }
    mut paren_depth := 0
    mut bracket_depth := 0
    for i := 0; i <= s.len - needle.len; i++ {
        match s[i] {
            `(` {
                paren_depth++
            }
            `)` {
                if paren_depth > 0 {
                    paren_depth--
                }
            }
            `[` {
                bracket_depth++
            }
            `]` {
                if bracket_depth > 0 {
                    bracket_depth--
                }
            }
            else {}
        }

        if paren_depth == 0 && bracket_depth == 0 && s[i..i + needle.len] == needle {
            return i
        }
    }
    return -1
}

fn (mut t Transformer) comptime_type_condition_value(cond string) ?bool {
    clean := comptime_condition_strip_outer_parens(cond)
    if clean == 'true' {
        return true
    }
    if clean == 'false' {
        return false
    }
    or_idx := comptime_condition_top_level_index(clean, '||')
    if or_idx >= 0 {
        left := t.comptime_type_condition_value(clean[..or_idx]) or { return none }
        if left {
            return true
        }
        return t.comptime_type_condition_value(clean[or_idx + 2..])
    }
    and_idx := comptime_condition_top_level_index(clean, '&&')
    if and_idx >= 0 {
        left := t.comptime_type_condition_value(clean[..and_idx]) or { return none }
        if !left {
            return false
        }
        return t.comptime_type_condition_value(clean[and_idx + 2..])
    }
    for op in [' !is ', ' is '] {
        op_idx := comptime_condition_top_level_index(clean, op)
        if op_idx >= 0 {
            left := clean[..op_idx].trim_space()
            right := clean[op_idx + op.len..].trim_space()
            matches := t.comptime_type_matches(left, right) or { return none }
            return if op == ' is ' { matches } else { !matches }
        }
    }
    if clean.starts_with('!') {
        value := t.comptime_type_condition_value(clean[1..]) or { return none }
        return !value
    }
    return none
}

fn (mut t Transformer) comptime_type_matches(actual string, expected string) ?bool {
    clean_actual := actual.trim_space()
    clean_expected := expected.trim_space()
    if clean_actual.len == 0 || clean_expected.len == 0
        || is_generic_fn_placeholder_name(clean_actual) {
        return none
    }
    normalized := t.normalize_type_alias(clean_actual)
    match clean_expected {
        '$array' {
            return normalized.starts_with('[]') || transform_type_text_is_fixed_array(normalized)
        }
        '$map' {
            return normalized.starts_with('map[')
        }
        '$function' {
            return normalized.starts_with('fn(') || normalized.starts_with('fn (')
        }
        '$option' {
            return normalized.starts_with('?')
        }
        '$int' {
            if typ := types.builtin_type(normalized) {
                return typ.is_integer()
            }
            return false
        }
        '$float' {
            if typ := types.builtin_type(normalized) {
                return typ.is_float()
            }
            return false
        }
        '$struct' {
            return !isnil(t.tc) && normalized in t.tc.structs
        }
        '$enum' {
            return !isnil(t.tc) && normalized in t.tc.enum_names
        }
        '$alias' {
            if isnil(t.tc) {
                return false
            }
            if clean_actual in t.tc.type_aliases {
                return true
            }
            if !clean_actual.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
                && t.cur_module != 'builtin' {
                return '${t.cur_module}.${clean_actual}' in t.tc.type_aliases
            }
            return false
        }
        '$sumtype' {
            return !isnil(t.tc) && normalized in t.tc.sum_types
        }
        '$interface' {
            return !isnil(t.tc) && normalized in t.tc.interface_names
        }
        else {}
    }

    return normalized == t.normalize_type_alias(clean_expected)
}

fn transform_type_text_is_fixed_array(typ string) bool {
    if typ.starts_with('[]') || typ.starts_with('[?') {
        return false
    }
    if typ.starts_with('[') {
        end := typ.index_u8(`]`)
        return end > 1
    }
    return typ.contains('[') && typ.ends_with(']') && is_decimal_text(fixed_array_len_text(typ))
}

// transform_block_expr transforms transform block expr data for transform.
fn (mut t Transformer) transform_block_expr(_id flat.NodeId, node flat.Node) flat.NodeId {
    mut child_ids := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_ids << t.a.children[node.children_start + i]
    }
    new_children := t.transform_stmts(child_ids)
    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_lock_expr transforms transform lock expr data for transform.
fn (mut t Transformer) transform_lock_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    body_id := t.a.child(&node, node.children_count - 1)
    if int(body_id) < 0 {
        return id
    }
    body := t.a.nodes[int(body_id)]
    if body.kind == .block {
        mut new_block := t.transform_block_expr(body_id, body)
        block_typ := t.stmt_value_type(new_block)
        if node.typ == 'void' || block_typ == 'void' {
            mut children := t.a.children_of(&t.a.nodes[int(new_block)]).clone()
            children << t.make_expr_stmt(t.make_int_literal(0))
            new_block = t.make_block(children)
            t.a.nodes[int(new_block)].typ = 'int'
        } else {
            t.a.nodes[int(new_block)].typ = node.typ
        }
        return new_block
    }
    return t.transform_expr(body_id)
}

// transform_if_stmt transforms transform if stmt data for transform.
fn (mut t Transformer) transform_if_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if expanded := t.try_expand_if_guard(id, node) {
        return expanded
    }
    new_id := t.transform_if_branches_with_smartcast(id, node)
    return t.with_pending_before(new_id)
}

// transform_defer_stmt transforms transform defer stmt data for transform.
fn (mut t Transformer) transform_defer_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    body_id := t.a.child(&node, 0)
    if int(body_id) < 0 {
        return arr1(id)
    }
    body := t.a.nodes[int(body_id)]
    new_body := if body.kind == .block {
        t.transform_block_expr(body_id, body)
    } else if t.is_stmt_kind_id(node_kind_id(body)) {
        t.make_block(t.transform_stmt(body_id))
    } else {
        t.make_block(arr1(t.transform_expr(body_id)))
    }
    start := t.a.children.len
    t.a.children << new_body
    new_id := t.a.add_node(flat.Node{
        kind:           .defer_stmt
        children_start: start
        children_count: 1
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
    return arr1(new_id)
}

// Generic handler: rebuild a node with all children recursively transformed.
fn (mut t Transformer) transform_children_stmt(id flat.NodeId, node flat.Node) []flat.NodeId {
    if node.children_count == 0 {
        return arr1(id)
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        child := t.a.nodes[int(child_id)]
        if t.is_stmt_kind_id(node_kind_id(child)) {
            expanded := t.transform_stmt(child_id)
            for eid in expanded {
                new_children << eid
            }
        } else {
            new_children << t.transform_expr(child_id)
        }
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    count := new_children.len
    new_id := t.a.add_node(flat.Node{
        kind:           node.kind
        op:             node.op
        children_start: start
        children_count: flat.child_count(count)
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
    return arr1(new_id)
}

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

// transform_children_expr transforms transform children expr data for transform.
fn (mut t Transformer) transform_children_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    mut changed := false
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        if int(child_id) < 0 {
            new_children << child_id
            continue
        }
        child := t.a.nodes[int(child_id)]
        if t.is_stmt_kind_id(node_kind_id(child)) {
            expanded := t.transform_stmt(child_id)
            if expanded.len == 1 {
                new_children << expanded[0]
                if expanded[0] != child_id {
                    changed = true
                }
            } else {
                new_children << t.make_block(expanded)
                changed = true
            }
        } else {
            nc := t.transform_expr(child_id)
            new_children << nc
            if nc != child_id {
                changed = true
            }
        }
    }
    if !changed {
        return id
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    return t.a.add_node(flat.Node{
        kind:           node.kind
        op:             node.op
        children_start: start
        children_count: flat.child_count(new_children.len)
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
}

// transform_infix_expr transforms transform infix expr data for transform.
fn (mut t Transformer) transform_infix_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count < 2 {
        return id
    }
    if node.op == .logical_and {
        return t.transform_and_chain_smartcasts(id)
    }
    if node.op == .left_shift {
        lhs_id := t.a.children[node.children_start]
        rhs_id := t.a.children[node.children_start + 1]
        new_lhs := t.transform_expr(lhs_id)
        new_rhs := t.transform_expr(rhs_id)
        start := t.a.children.len
        t.a.children << new_lhs
        t.a.children << new_rhs
        new_id := t.a.add_node(flat.Node{
            kind:           .infix
            op:             node.op
            children_start: start
            children_count: 2
            pos:            node.pos
            value:          node.value
            typ:            node.typ
        })
        t.annotate_left_shift(new_id)
        return new_id
    }
    if str_result := t.transform_infix_string_ops(id, node) {
        return str_result
    }
    if array_result := t.transform_infix_array_ops(id, node) {
        return array_result
    }
    if map_result := t.transform_infix_map_ops(id, node) {
        return map_result
    }
    if optional_result := t.transform_infix_optional_none_ops(id, node) {
        return optional_result
    }
    if sum_result := t.transform_infix_sum_ops(id, node) {
        return sum_result
    }
    if struct_result := t.transform_infix_struct_ops(id, node) {
        return struct_result
    }
    lhs_id := t.a.children[node.children_start]
    rhs_id := t.a.children[node.children_start + 1]
    new_lhs := t.transform_expr(lhs_id)
    new_rhs := t.transform_expr(rhs_id)
    if struct_result := t.transform_transformed_struct_eq(node, new_lhs, new_rhs) {
        return struct_result
    }
    if new_lhs == lhs_id && new_rhs == rhs_id {
        // Nothing was lowered (the common case for plain arithmetic): reuse the original
        // node instead of allocating an identical copy. Under -gc none these copies are
        // never freed, so avoiding them cuts both transform time and peak RAM.
        return id
    }
    start := t.a.children.len
    t.a.children << new_lhs
    t.a.children << new_rhs
    return t.a.add_node(flat.Node{
        kind:           .infix
        op:             node.op
        children_start: start
        children_count: 2
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
}

// transform_call_expr transforms transform call expr data for transform.
fn (mut t Transformer) transform_call_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    call_id := t.normalize_generic_call_expr(id, node)
    mut call_node := t.a.nodes[int(call_id)]
    mut resolved_typ := t.concrete_generic_call_return_type(call_id, call_node)
    if resolved_typ.len == 0 && call_node.typ.len > 0 {
        call_typ := t.normalize_type_alias(call_node.typ)
        if call_typ !in ['array', 'map', 'unknown'] {
            resolved_typ = call_typ
        }
    }
    if resolved_typ.len == 0 {
        resolved_typ = t.new_map_call_type(call_node)
    }
    if resolved_typ.len == 0 {
        resolved_typ = t.get_call_return_type(call_id, call_node)
    }
    if resolved_typ.len == 0 {
        resolved_typ = t.current_call_return_type(call_node)
    }
    if resolved_typ.len > 0 {
        t.a.nodes[int(call_id)].typ = resolved_typ
        call_node.typ = resolved_typ
    }
    if t.is_disabled_fn_call(call_id, call_node) {
        if resolved_typ.len == 0 || resolved_typ == 'void' {
            return t.make_empty()
        }
        return t.zero_value_for_type(resolved_typ)
    }
    if lowered := t.try_lower_builtin_call(call_id, call_node) {
        return lowered
    }
    if lowered := t.try_lower_array_repeat_call(call_id, call_node) {
        return lowered
    }
    if lowered := t.try_lower_join_path_call(call_id, call_node) {
        return lowered
    }
    return t.transform_call_args(call_id, call_node)
}

// is_disabled_fn_name reports whether is disabled fn name applies in transform.
fn (t &Transformer) is_disabled_fn_name(name string) bool {
    if name in t.a.disabled_fns {
        return true
    }
    if !name.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
        && t.cur_module != 'builtin' {
        return '${t.cur_module}.${name}' in t.a.disabled_fns
    }
    return false
}

// is_disabled_fn_call reports whether is disabled fn call applies in transform.
fn (t &Transformer) is_disabled_fn_call(id flat.NodeId, node flat.Node) bool {
    name := t.call_name_for_node(id, node)
    return t.is_disabled_fn_name(name)
}

// is_strings_builder_new_call reports whether is strings builder new call applies in transform.
fn (t &Transformer) is_strings_builder_new_call(id flat.NodeId, node flat.Node) bool {
    // Only `strings.new_builder` returns a `strings.Builder` (an alias for `[]u8`).
    // A bare `new_builder` must NOT be assumed to be the strings one: other modules
    // (e.g. `builder.new_builder`) and user code define their own `new_builder` that
    // return unrelated struct types. Resolve the call to its qualified name and only
    // match when it is genuinely the strings module's function.
    call_name := t.call_name_for_node(id, node)
    if call_name == 'strings.new_builder' {
        return true
    }
    if node.children_count == 0 {
        return false
    }
    fn_id := t.a.child(&node, 0)
    if int(fn_id) < 0 {
        return false
    }
    fn_node := t.a.nodes[int(fn_id)]
    if fn_node.kind == .ident {
        return fn_node.value == 'strings.new_builder'
    }
    if fn_node.kind == .selector && fn_node.value == 'new_builder' && fn_node.children_count > 0 {
        base := t.a.child_node(&fn_node, 0)
        return base.kind == .ident && base.value == 'strings'
    }
    return false
}

// transform_if_expr transforms transform if expr data for transform.
fn (mut t Transformer) transform_if_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if lowered := t.try_expand_if_expr_value(id, node) {
        return lowered
    }
    return t.transform_if_branches_with_smartcast(id, node)
}

// transform_struct_init transforms transform struct init data for transform.
fn (mut t Transformer) transform_struct_init(id flat.NodeId, node flat.Node) flat.NodeId {
    return t.transform_struct_fields(id, node)
}

// transform_index_expr transforms transform index expr data for transform.
fn (mut t Transformer) transform_index_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    if lowered := t.try_lower_map_index_expr(id, node) {
        return lowered
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    mut changed := false
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        mut new_child := t.transform_expr(child_id)
        if i == 0 {
            base := t.a.nodes[int(new_child)]
            if base.kind == .cast_expr {
                base_type := t.node_type(new_child)
                new_child = t.make_paren(new_child)
                if base_type.len > 0 {
                    t.a.nodes[int(new_child)].typ = base_type
                }
            }
        }
        if new_child != child_id {
            changed = true
        }
        new_children << new_child
    }
    // Children unchanged: update the type annotation in place (applying the same
    // `typ = node.value when empty` fixup the rebuild would) instead of copying the node.
    mut index_typ := node.typ
    elem_type := t.index_expr_type(id, node)
    if elem_type == 'u8' || (index_typ.len == 0 && elem_type.len > 0) {
        index_typ = elem_type
    } else if index_typ.len == 0 && node.value.len > 0 {
        index_typ = node.value
    }
    if !changed {
        if index_typ.len > 0 {
            t.a.nodes[int(id)].typ = index_typ
        }
        return id
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    new_id := t.a.add_node(flat.Node{
        kind:           .index
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            index_typ
    })
    return new_id
}

// transform_string_interp transforms transform string interp data for transform.
fn (mut t Transformer) transform_string_interp(_id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return t.make_string_literal('')
    }
    // Some parts (arrays, optionals) lower into a prelude pushed onto pending_stmts, which
    // runs before the containing statement. If such a part follows a part with side effects,
    // keeping the earlier part inline in the string__plus chain would evaluate it after the
    // hoisted prelude, reversing source order. So once any part hoists statements, bind every
    // part to a temp in source order; while nothing hoists, keep the cheap inline form.
    outer_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    mut inline_parts := []flat.NodeId{cap: int(node.children_count)}
    mut temps := []flat.NodeId{cap: int(node.children_count)}
    mut hoisting := false
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        part := t.transform_string_interp_part(child_id)
        mut part_stmts := []flat.NodeId{}
        t.drain_pending(mut part_stmts)
        if !hoisting && part_stmts.len == 0 {
            inline_parts << part
            continue
        }
        if !hoisting {
            hoisting = true
            // Earlier parts had no prelude; bind them to temps first so their side effects
            // still happen before this part's hoisted statements.
            for earlier in inline_parts {
                earlier_name := t.new_temp('interp_part')
                t.pending_stmts << t.make_decl_assign_typed(earlier_name, earlier, 'string')
                temps << t.make_ident(earlier_name)
            }
        }
        for st in part_stmts {
            t.pending_stmts << st
        }
        name := t.new_temp('interp_part')
        t.pending_stmts << t.make_decl_assign_typed(name, part, 'string')
        temps << t.make_ident(name)
    }
    // The interp's own statements must run after any pending the surrounding context queued.
    mut interp_stmts := []flat.NodeId{}
    t.drain_pending(mut interp_stmts)
    for st in outer_pending {
        t.pending_stmts << st
    }
    for st in interp_stmts {
        t.pending_stmts << st
    }
    parts := if hoisting { temps } else { inline_parts }
    mut result := if parts.len == 0 { t.make_string_literal('') } else { parts[0] }
    for i in 1 .. parts.len {
        result = t.string_plus(result, parts[i])
    }
    t.a.nodes[int(result)].typ = 'string'
    return result
}

// transform_selector_expr transforms transform selector expr data for transform.
fn (mut t Transformer) transform_selector_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    if node.value in t.sum_variant_fields {
        return id
    }
    base_id0 := t.a.child(&node, 0)
    if variant_type := t.generated_variant_access_type(base_id0) {
        new_base := t.transform_expr(base_id0)
        clean_variant_type := t.trim_pointer_type(variant_type)
        sel_typ := if node.typ.len > 0 {
            node.typ
        } else if ftyp := t.lookup_struct_field_type(clean_variant_type, node.value) {
            ftyp
        } else {
            t.resolve_selector_type(node)
        }
        return t.make_selector_op(new_base, node.value, sel_typ, if variant_type.starts_with('&') {
            .arrow
        } else {
            node.op
        })
    }
    base_node0 := t.a.nodes[int(base_id0)]
    if base_node0.kind == .typeof_expr {
        if node.value == 'name' {
            return t.transform_typeof_expr(base_id0, base_node0)
        }
        if node.value == 'idx' {
            return t.transform_typeof_idx_expr(base_node0)
        }
    }
    if fixed_len := t.transform_fixed_array_len(id, node) {
        return fixed_len
    }
    full_key := t.expr_key(id)
    if full_key.len > 0 {
        contexts := t.smartcasts_for(full_key)
        if contexts.len > 0 {
            plain := t.make_plain_selector_expr(id, node)
            return t.apply_smartcast_contexts(plain, t.original_expr_type(id), contexts)
        }
    }
    base_id := base_id0
    sc_key := t.expr_key(base_id)
    if sc_key.len > 0 {
        contexts := t.smartcasts_for(sc_key)
        if contexts.len > 0 {
            plain_base := t.make_plain_expr_for_smartcast(base_id)
            variant_sel := t.apply_smartcast_contexts(plain_base, t.original_expr_type(base_id),
                contexts)
            variant_type := t.node_type(variant_sel)
            if shared_typ := t.sum_shared_field_type_name(variant_type, node.value) {
                return t.lower_sum_shared_field_selector(variant_sel, variant_type, node.value,
                    shared_typ)
            }
            sel_start := t.a.children.len
            t.a.children << variant_sel
            sel_typ := if node.typ.len > 0 { node.typ } else { t.resolve_selector_type(node) }
            return t.a.add_node(flat.Node{
                kind:           .selector
                op:             if node.op == .arrow || variant_type.starts_with('&') {
                    flat.Op.arrow
                } else {
                    flat.Op.dot
                }
                children_start: sel_start
                children_count: 1
                pos:            node.pos
                value:          node.value
                typ:            sel_typ
            })
        }
    }
    base_type0 := t.node_type(base_id)
    base_clean := if base_type0.starts_with('&') { base_type0[1..] } else { base_type0 }
    if info := t.lookup_struct_info(base_clean) {
        has_direct_field := (t.struct_field_type(info, node.value) or { '' }).len > 0
        if !has_direct_field {
            if embedded := t.embedded_field_for_promoted_field(info, node.value) {
                new_base := t.transform_expr(base_id)
                embedded_op := if base_type0.starts_with('&') { flat.Op.arrow } else { flat.Op.dot }
                embedded_sel := t.make_selector_op(new_base, embedded.name, embedded.typ,
                    embedded_op)
                sel_typ := if node.typ.len > 0 { node.typ } else { t.resolve_selector_type(node) }
                final_op := if embedded.typ.starts_with('&') { flat.Op.arrow } else { flat.Op.dot }
                return t.make_selector_op(embedded_sel, node.value, sel_typ, final_op)
            }
        }
    }
    if shared_typ := t.sum_shared_field_type_name(base_type0, node.value) {
        transformed_base := t.transform_expr(base_id)
        transformed_base_type := t.node_type(transformed_base)
        clean_transformed_base_type := if transformed_base_type.starts_with('&') {
            transformed_base_type[1..]
        } else {
            transformed_base_type
        }
        if clean_transformed_base_type.len > 0
            && t.normalize_type_alias(clean_transformed_base_type) != t.normalize_type_alias(base_type0) {
            if ftyp := t.lookup_struct_field_type(clean_transformed_base_type, node.value) {
                new_base := t.selector_base_for_field(transformed_base, transformed_base_type)
                return t.make_selector_op(new_base, node.value, if node.typ.len > 0 {
                    node.typ
                } else {
                    ftyp
                }, if transformed_base_type.starts_with('&') {
                    .arrow
                } else {
                    .dot
                })
            }
            if new_shared_typ := t.sum_shared_field_type_name(transformed_base_type, node.value) {
                new_base := t.selector_base_for_field(transformed_base, transformed_base_type)
                return t.lower_sum_shared_field_selector(new_base, transformed_base_type,
                    node.value, new_shared_typ)
            }
        }
        new_base := t.selector_base_for_field(transformed_base, base_type0)
        return t.lower_sum_shared_field_selector(new_base, base_type0, node.value, shared_typ)
    }
    new_base := t.transform_expr(base_id)
    mut changed := new_base != base_id
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    new_children << new_base
    for i in 1 .. node.children_count {
        child_id := t.a.child(&node, i)
        nc := t.transform_expr(child_id)
        if nc != child_id {
            changed = true
        }
        new_children << nc
    }
    sel_typ := if node.typ.len > 0 { node.typ } else { t.resolve_selector_type(node) }
    base_type := t.node_type(base_id)
    sel_op := if node.op == .arrow || base_type.starts_with('&') { flat.Op.arrow } else { node.op }
    if !changed && sel_op == node.op {
        // Children and op unchanged; only the type annotation may differ. Update it in
        // place rather than allocating an identical copy (cuts -gc none peak RAM). (`op`
        // is an immutable Node field, so a differing op still needs a fresh node below.)
        t.a.nodes[int(id)].typ = sel_typ
        return id
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    return t.a.add_node(flat.Node{
        kind:           .selector
        op:             sel_op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            sel_typ
    })
}

// make_plain_selector_expr builds make plain selector expr data for transform.
fn (mut t Transformer) make_plain_selector_expr(_id flat.NodeId, node flat.Node) flat.NodeId {
    base_id := t.a.child(&node, 0)
    base_type := t.node_type(base_id)
    new_base := t.selector_base_for_field(t.transform_expr(base_id), base_type)
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    new_children << new_base
    for i in 1 .. node.children_count {
        child_id := t.a.child(&node, i)
        new_children << t.transform_expr(child_id)
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    sel_typ := if node.typ.len > 0 { node.typ } else { t.resolve_selector_type(node) }
    sel_op := if node.op == .arrow || base_type.starts_with('&') { flat.Op.arrow } else { node.op }
    return t.a.add_node(flat.Node{
        kind:           .selector
        op:             sel_op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            sel_typ
    })
}

// make_plain_expr_for_smartcast builds make plain expr for smartcast data for transform.
fn (mut t Transformer) make_plain_expr_for_smartcast(id flat.NodeId) flat.NodeId {
    if int(id) < 0 {
        return id
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            expr := t.make_ident(node.value)
            typ := t.original_expr_type(id)
            if typ.len > 0 {
                t.a.nodes[int(expr)].typ = typ
            }
            return expr
        }
        .selector {
            return t.make_plain_selector_expr(id, node)
        }
        .index {
            mut new_children := []flat.NodeId{cap: int(node.children_count)}
            for i in 0 .. node.children_count {
                new_children << t.transform_expr(t.a.child(&node, i))
            }
            start := t.a.children.len
            for nc in new_children {
                t.a.children << nc
            }
            return t.a.add_node(flat.Node{
                kind:           .index
                op:             node.op
                children_start: start
                children_count: node.children_count
                pos:            node.pos
                value:          node.value
                typ:            if node.typ.len > 0 { node.typ } else { node.value }
            })
        }
        else {
            return t.transform_expr(id)
        }
    }
}

// selector_base_for_field supports selector base for field handling for Transformer.
fn (mut t Transformer) selector_base_for_field(base flat.NodeId, typ string) flat.NodeId {
    if int(base) < 0 {
        return base
    }
    node := t.a.nodes[int(base)]
    if node.kind in [.if_expr, .block] {
        return t.stable_transformed_expr_for_reuse(base, typ, 'sel_base')
    }
    return base
}

// sum_shared_field_type_name supports sum shared field type name handling for Transformer.
fn (t &Transformer) sum_shared_field_type_name(sum_type string, field string) ?string {
    clean_sum := if sum_type.starts_with('&') { sum_type[1..] } else { sum_type }
    resolved_sum := t.resolve_sum_name(clean_sum)
    variants := t.sum_types[resolved_sum] or { return none }
    mut common := ''
    for variant in variants {
        ftyp := t.sum_variant_field_type_name(variant, field) or { return none }
        if common.len == 0 {
            common = ftyp
            continue
        }
        if t.normalize_type_alias(common) != t.normalize_type_alias(ftyp) {
            return none
        }
    }
    if common.len == 0 {
        return none
    }
    return common
}

// sum_variant_field_type_name supports sum variant field type name handling for Transformer.
fn (t &Transformer) sum_variant_field_type_name(variant string, field string) ?string {
    if ftyp := t.lookup_struct_field_type(variant, field) {
        return ftyp
    }
    if ftyp := t.sum_shared_field_type_name(variant, field) {
        return ftyp
    }
    return none
}

// lower_sum_shared_field_selector builds lower sum shared field selector data for transform.
fn (mut t Transformer) lower_sum_shared_field_selector(base flat.NodeId, sum_type string, field string, field_type string) flat.NodeId {
    clean_sum := if sum_type.starts_with('&') { sum_type[1..] } else { sum_type }
    resolved_sum := t.resolve_sum_name(clean_sum)
    variants := t.sum_types[resolved_sum] or { return base }
    return t.build_sum_shared_field_chain(base, sum_type, resolved_sum, variants, field,
        field_type, 0)
}

// build_sum_shared_field_chain builds sum shared field chain data for transform.
fn (mut t Transformer) build_sum_shared_field_chain(base flat.NodeId, sum_type string, resolved_sum string, variants []string, field string, field_type string, idx int) flat.NodeId {
    if idx >= variants.len {
        return t.zero_value_for_type(field_type)
    }
    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
    })
    value := if _ := t.sum_shared_field_type_name(qv, field) {
        t.lower_sum_shared_field_selector(variant_base, qv, field, field_type)
    } else {
        t.make_selector_op(variant_base, field, field_type, if use_ptr { .arrow } else { .dot })
    }
    then_block := t.make_block(arr1(t.make_expr_stmt(value)))
    else_expr := t.build_sum_shared_field_chain(base, sum_type, resolved_sum, variants, field,
        field_type, idx + 1)
    else_block := t.make_block(arr1(t.make_expr_stmt(else_expr)))
    start := t.a.children.len
    t.a.children << cond
    t.a.children << then_block
    t.a.children << else_block
    return t.a.add_node(flat.Node{
        kind:           .if_expr
        children_start: start
        children_count: 3
        typ:            field_type
    })
}

// transform_or_expr transforms transform or expr data for transform.
fn (mut t Transformer) transform_or_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count < 2 {
        return id
    }
    if t.is_map_index_or_expr(node) {
        return t.transform_map_index_or_expr(id, node)
    }
    if t.is_array_index_or_expr(node) {
        return t.transform_array_index_or_expr(id, node)
    }
    if t.is_string_slice_or_expr(node) {
        return t.transform_string_slice_or_expr(id, node)
    }
    if t.is_enum_from_string_or_expr(node) {
        return t.transform_enum_from_string_or_expr(id, node)
    }
    return t.lower_or_expr_to_temp(id, node)
}

// transform_prefix_expr transforms transform prefix expr data for transform.
fn (mut t Transformer) transform_prefix_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    if node.op == .mul && node.children_count == 1 {
        child_id := t.a.child(&node, 0)
        child := t.a.nodes[int(child_id)]
        mut child_type := t.node_type(child_id)
        if child_type.len == 0 {
            child_type = t.original_expr_type(child_id)
        }
        if child.kind != .cast_expr && child_type.len > 0 && !child_type.starts_with('&') {
            return t.transform_expr(child_id)
        }
    }
    if node.op == .amp && node.children_count == 1 {
        child_id := t.a.child(&node, 0)
        child := t.a.nodes[int(child_id)]
        if child.kind == .struct_init {
            // `&T{...}` (address of a struct literal) is ALWAYS a heap allocation in V,
            // in any context — not just in a return. Keeping it as a `.prefix .amp`
            // struct_init routes it through cgen's gen_heap_struct_init; otherwise the
            // generic fall-through lowers it to `&<stack temp>`, which dangles once the
            // frame dies (e.g. `arr << &T{...}` storing a stack pointer in the array).
            if expr := t.transform_amp_struct_init_for_type(id, node, node.typ) {
                return expr
            }
        }
        if expr := t.transform_amp_assoc_expr_for_type(id, node, node.typ) {
            return expr
        }
        if child.kind == .cast_expr && child.children_count > 0 {
            cast_arg_id := t.a.child(&child, 0)
            target_sum := t.resolve_sum_name(t.normalize_type_alias(child.value))
            if target_sum.len > 0 && target_sum in t.sum_types {
                cast_arg := t.a.nodes[int(cast_arg_id)]
                if cast_arg.kind == .nil_literal {
                    return t.make_cast('&${child.value}', t.transform_expr(cast_arg_id),
                        '&${child.value}')
                }
                wrapped := t.wrap_sum_value(cast_arg_id, target_sum)
                addr := t.make_prefix(.amp, wrapped)
                t.a.nodes[int(addr)].typ = if node.typ.len > 0 { node.typ } else { '&${target_sum}' }
                return addr
            }
            // `&InterfaceType(x)` (e.g. `&PRNG(rng)`): box the concrete into a
            // heap-allocated interface so the resulting pointer stays valid, rather
            // than emitting a plain `(Interface*)x` reinterpret cast.
            iface := t.resolve_interface_type_name(child.value)
            if iface.len > 0 && iface.all_after_last('.') != 'IError' {
                if boxed := t.transform_interface_value_for_type(cast_arg_id, '&${child.value}') {
                    return boxed
                }
            }
            cast_arg := t.a.nodes[int(cast_arg_id)]
            if cast_arg.kind == .nil_literal {
                return t.make_cast('&${child.value}', t.transform_expr(cast_arg_id),
                    '&${child.value}')
            }
            return t.make_cast('&${child.value}', t.transform_expr(cast_arg_id), '&${child.value}')
        }
        if child.kind == .or_expr && child.children_count >= 2
            && t.or_body_is_nil(t.a.child(&child, 1)) {
            index_id := t.a.child(&child, 0)
            if info := t.map_index_info(index_id) {
                map_expr := t.stable_expr_for_reuse(info.base_id)
                key_name := t.new_temp('map_key')
                t.pending_stmts << t.make_decl_assign_typed(key_name,
                    t.transform_expr(info.key_id), info.key_type)
                ptr := t.make_map_get_check_expr(map_expr, info.base_type, key_name)
                return t.make_cast('&${info.value_type}', ptr, '&${info.value_type}')
            }
        }
        if child.kind == .call && child.children_count == 2 {
            callee := t.a.child_node(&child, 0)
            arg_id := t.a.child(&child, 1)
            arg := t.a.nodes[int(arg_id)]
            if callee.kind == .selector && callee.children_count > 0
                && (arg.kind == .nil_literal || callee.value.len > 0) {
                base := t.a.child_node(callee, 0)
                if base.kind == .ident && callee.value.len > 0
                    && (base.value == 'C' || (callee.value[0] >= `A` && callee.value[0] <= `Z`)) {
                    target_type := '${base.value}.${callee.value}'
                    return t.make_cast('&${target_type}', t.transform_expr(arg_id),
                        '&${target_type}')
                }
            }
        }
        if child.kind == .selector && (t.selector_chain_has_sum_shared_field(child_id)
            || t.selector_chain_has_sum_variant_field(child_id)) {
            value := t.transform_expr(child_id)
            mut value_type := t.node_type(child_id)
            if value_type.len == 0 {
                value_type = t.node_type(value)
            }
            stable := t.stable_transformed_expr_for_reuse(value, value_type, 'addr')
            addr := t.make_prefix(.amp, stable)
            if value_type.len > 0 {
                t.a.nodes[int(addr)].typ = '&${value_type}'
            }
            return addr
        }
        if child.kind == .ident && child.value.len > 0 && t.has_smartcast(child.value)
            && node.typ.starts_with('&') && t.is_sum_type_name(node.typ[1..]) {
            sum_type := node.typ[1..]
            wrapped := t.wrap_sum_value(child_id, sum_type)
            tmp_name := t.new_temp('sum_ref')
            t.pending_stmts << t.make_decl_assign_typed(tmp_name, wrapped, sum_type)
            addr := t.make_prefix(.amp, t.make_ident(tmp_name))
            t.a.nodes[int(addr)].typ = node.typ
            return addr
        }
        value := t.transform_expr(child_id)
        if !t.expr_can_take_address(value) {
            mut value_type := t.node_type(child_id)
            if value_type.len == 0 {
                value_type = t.node_type(value)
            }
            stable := t.stable_transformed_expr_for_reuse(value, value_type, 'addr')
            addr := t.make_prefix(.amp, stable)
            if value_type.len > 0 {
                t.a.nodes[int(addr)].typ = '&${value_type}'
            }
            return addr
        }
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        mut new_child := t.transform_expr(child_id)
        if node.op == .not {
            child := t.a.nodes[int(new_child)]
            if child.kind == .infix {
                new_child = t.make_paren(new_child)
            }
        }
        new_children << new_child
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    new_id := t.a.add_node(flat.Node{
        kind:           .prefix
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
    if node.children_count == 1 {
        child_type := t.node_type(new_children[0])
        if node.op == .amp && child_type.len > 0 {
            t.a.nodes[int(new_id)].typ = '&${child_type}'
        } else if node.op == .mul && child_type.starts_with('&') {
            t.a.nodes[int(new_id)].typ = child_type[1..]
        }
    }
    return new_id
}

// transform_amp_sum_cast_from_as_expr supports transform_amp_sum_cast_from_as_expr handling.
fn (mut t Transformer) transform_amp_sum_cast_from_as_expr(cast_node flat.Node, cast_arg_id flat.NodeId) ?flat.NodeId {
    target_sum := t.resolve_sum_name(cast_node.value)
    if target_sum.len == 0 || target_sum !in t.sum_types || int(cast_arg_id) < 0 {
        return none
    }
    mut arg_id := cast_arg_id
    for {
        arg0 := t.a.nodes[int(arg_id)]
        if arg0.kind != .paren || arg0.children_count == 0 {
            break
        }
        arg_id = t.a.child(&arg0, 0)
    }
    arg := t.a.nodes[int(arg_id)]
    if arg.kind != .as_expr || arg.children_count == 0 || arg.value.len == 0 {
        return none
    }
    source_id := t.a.child(&arg, 0)
    mut source_type := t.node_type(source_id)
    if source_type.len == 0 {
        source_type = t.original_expr_type(source_id)
    }
    mut source_sum := t.resolve_sum_name(t.trim_pointer_type(source_type))
    mut use_plain_source := false
    if source_sum.len == 0 || source_sum !in t.sum_types {
        raw_source_type := t.raw_expr_type_without_smartcast(source_id)
        raw_source_sum := t.resolve_sum_name(t.trim_pointer_type(raw_source_type))
        if raw_source_sum.len > 0 && raw_source_sum in t.sum_types {
            source_type = raw_source_type
            source_sum = raw_source_sum
            use_plain_source = true
        }
    }
    if source_sum.len == 0 || source_sum !in t.sum_types {
        return none
    }
    variant := t.resolve_variant(source_sum, arg.value)
    if variant.len == 0 || !t.variant_references_sum(variant, source_sum) {
        return none
    }
    source := if use_plain_source {
        t.make_plain_expr_for_smartcast(source_id)
    } else {
        t.transform_expr(source_id)
    }
    field_name := t.sum_field_name(variant)
    field_sel := t.make_selector_op(source, field_name, '&${variant}', if source_type.starts_with('&') {
        .arrow
    } else {
        .dot
    })
    return t.make_cast('&${cast_node.value}', field_sel, '&${cast_node.value}')
}

// raw_expr_type_without_smartcast
// supports helper handling in transform.
fn (t &Transformer) raw_expr_type_without_smartcast(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            typ := t.normalize_type_alias(t.var_type(node.value))
            if typ.len > 0 {
                return typ
            }
            return t.normalize_type_alias(node.typ)
        }
        .selector {
            return t.raw_selector_type_without_smartcast(id)
        }
        else {
            return t.normalize_type_alias(node.typ)
        }
    }
}

// raw_selector_type_without_smartcast supports raw_selector_type_without_smartcast handling.
fn (t &Transformer) raw_selector_type_without_smartcast(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    if node.kind != .selector || node.children_count == 0 {
        return ''
    }
    base_id := t.a.child(&node, 0)
    mut base_type := t.raw_expr_type_without_smartcast(base_id)
    if base_type.len == 0 {
        base_type = t.original_expr_type(base_id)
    }
    if ftyp := t.lookup_struct_field_type(base_type, node.value) {
        return ftyp
    }
    return t.normalize_type_alias(node.typ)
}

// selector_chain_has_sum_shared_field supports selector_chain_has_sum_shared_field handling.
fn (t &Transformer) selector_chain_has_sum_shared_field(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    if node.kind != .selector || node.children_count == 0 {
        return false
    }
    base_id := t.a.child(&node, 0)
    base_type := t.node_type(base_id)
    if _ := t.sum_shared_field_type_name(base_type, node.value) {
        return true
    }
    return t.selector_chain_has_sum_shared_field(base_id)
}

// selector_chain_has_sum_variant_field supports selector_chain_has_sum_variant_field handling.
fn (t &Transformer) selector_chain_has_sum_variant_field(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    if node.kind != .selector || node.children_count == 0 {
        return false
    }
    base_id := t.a.child(&node, 0)
    base_type := t.node_type(base_id)
    if t.sum_has_variant_field(base_type, node.value) {
        return true
    }
    return t.selector_chain_has_sum_variant_field(base_id)
}

// sum_has_variant_field converts sum has variant field data for transform.
fn (t &Transformer) sum_has_variant_field(sum_type string, field string) bool {
    clean_sum := if sum_type.starts_with('&') { sum_type[1..] } else { sum_type }
    resolved_sum := t.resolve_sum_name(clean_sum)
    variants := t.sum_types[resolved_sum] or { return false }
    for variant in variants {
        if _ := t.sum_variant_field_type_name(variant, field) {
            return true
        }
    }
    return false
}

// transform_paren_expr transforms transform paren expr data for transform.
fn (mut t Transformer) transform_paren_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    child_id := t.a.child(&node, 0)
    new_child := t.transform_expr(child_id)
    start := t.a.children.len
    t.a.children << new_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
    })
}

// transform_postfix_expr transforms transform postfix expr data for transform.
fn (mut t Transformer) transform_postfix_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    child_id := t.a.child(&node, 0)
    child := t.a.nodes[int(child_id)]
    if node.op == .not && child.kind == .array_literal {
        node_type := t.node_type(id)
        if lowered := t.transform_fixed_array_literal_for_type(child_id, child, node_type) {
            return lowered
        }
    }
    new_child := if child.kind == .ident && t.pointer_value_lvalues[child.value] {
        t.make_paren(t.make_prefix(.mul, t.make_ident(child.value)))
    } else {
        t.transform_expr(child_id)
    }
    start := t.a.children.len
    t.a.children << new_child
    return t.a.add_node(flat.Node{
        kind:           .postfix
        op:             node.op
        children_start: start
        children_count: 1
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
}

// transform_cast_expr transforms transform cast expr data for transform.
fn (mut t Transformer) transform_cast_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.children_count == 0 {
        return id
    }
    target_type := t.normalize_type_alias(node.value)
    if target_type.starts_with('&') && !t.is_interface_type(target_type) {
        mut new_children := []flat.NodeId{cap: int(node.children_count)}
        for i in 0 .. node.children_count {
            child_id := t.a.child(&node, i)
            new_children << t.transform_expr(child_id)
        }
        start := t.a.children.len
        for nc in new_children {
            t.a.children << nc
        }
        return t.a.add_node(flat.Node{
            kind:           .cast_expr
            op:             node.op
            children_start: start
            children_count: node.children_count
            pos:            node.pos
            value:          node.value
            typ:            node.typ
        })
    }
    if t.is_optional_type_name(node.value) {
        child_id := t.a.child(&node, 0)
        expr := t.transform_expr(child_id)
        mut expr_type := t.node_type(expr)
        if expr_type.len == 0 {
            expr_type = t.resolve_expr_type(child_id)
        }
        if t.is_optional_type_name(expr_type) {
            return t.coerce_transformed_expr_to_type(expr, child_id, node.value)
        }
        return t.make_optional_some(expr, t.qualify_optional_type(node.value))
    }
    if t.is_sum_type_name(target_type) {
        return t.wrap_sum_value(t.a.child(&node, 0), target_type)
    }
    // An explicit cast to an interface (`Animal(dog)`, `&PRNG(rng)`) boxes the
    // concrete value into the interface representation, just like an implicit
    // conversion does.
    if t.is_interface_type(target_type) {
        if boxed := t.transform_interface_value_for_type(t.a.child(&node, 0), node.value) {
            return boxed
        }
    }
    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 target_type in ['f32', 'f64'] {
            new_children << t.transform_expr_for_type(child_id, target_type)
        } else {
            new_children << t.transform_expr(child_id)
        }
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    return t.a.add_node(flat.Node{
        kind:           .cast_expr
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
}

// transform_array_literal transforms transform array literal data for transform.
fn (mut t Transformer) transform_array_literal(id flat.NodeId, node flat.Node) flat.NodeId {
    lowered := t.lower_array_literal_to_runtime(id, node)
    if lowered != id {
        return lowered
    }
    if node.children_count == 0 {
        return id
    }
    mut new_children := []flat.NodeId{cap: int(node.children_count)}
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        new_children << t.transform_expr(child_id)
    }
    start := t.a.children.len
    for nc in new_children {
        t.a.children << nc
    }
    return t.a.add_node(flat.Node{
        kind:           .array_literal
        op:             node.op
        children_start: start
        children_count: node.children_count
        pos:            node.pos
        value:          node.value
        typ:            node.typ
    })
}

// transform_map_init transforms transform map init data for transform.
fn (mut t Transformer) transform_map_init(id flat.NodeId, node flat.Node) flat.NodeId {
    return t.transform_map_init_expr(id, node)
}

// transform_typeof_expr transforms transform typeof expr data for transform.
fn (mut t Transformer) transform_typeof_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    if node.value.len > 0 {
        return t.make_string_literal(node.value)
    }
    if node.children_count == 0 {
        return id
    }
    expr_id := t.a.child(&node, 0)
    expr := t.a.nodes[int(expr_id)]
    if expr.kind == .int_literal {
        return t.make_string_literal('int literal')
    }
    mut typ := t.node_type(expr_id)
    if typ.len == 0 {
        typ = t.reliable_stringify_type(expr_id)
    }
    if typ.len == 0 {
        typ = t.resolve_expr_type(expr_id)
    }
    if typ.len == 0 {
        typ = 'unknown'
    }
    return t.make_string_literal(typ)
}

fn (mut t Transformer) transform_typeof_idx_expr(node flat.Node) flat.NodeId {
    type_name := t.typeof_type_name(node)
    return t.make_int_literal(t.type_index_for_type_name(type_name))
}

fn (t &Transformer) typeof_type_name(node flat.Node) string {
    if node.value.len > 0 {
        return node.value
    }
    if node.children_count == 0 {
        return ''
    }
    expr_id := t.a.child(&node, 0)
    mut typ := t.node_type(expr_id)
    if typ.len == 0 {
        typ = t.reliable_stringify_type(expr_id)
    }
    if typ.len == 0 {
        typ = t.resolve_expr_type(expr_id)
    }
    return typ
}

fn (t &Transformer) type_index_for_type_name(type_name string) int {
    if type_name.len == 0 {
        return 0
    }
    mut variants := []string{cap: 2}
    variants << type_name
    normalized := t.normalize_type_in_module(type_name, t.cur_module)
    if normalized.len > 0 && normalized !in variants {
        variants << normalized
    }
    mut sum_names := []string{}
    if t.cur_module.len > 0 {
        sum_names << '${t.cur_module}.Primitive'
    }
    sum_names << 'orm.Primitive'
    sum_names << 'Primitive'
    for sum_name in sum_names {
        if sum_name !in t.sum_types {
            continue
        }
        for variant in variants {
            idx := t.sum_type_index(sum_name, variant)
            if idx != 0 {
                return idx
            }
        }
    }
    for variant in variants {
        sum_name := t.find_sum_type_for_variant(variant)
        if sum_name.len > 0 {
            idx := t.sum_type_index(sum_name, variant)
            if idx != 0 {
                return idx
            }
        }
    }
    return 0
}

// transform_ident_expr transforms transform ident expr data for transform.
fn (mut t Transformer) transform_ident_expr(id flat.NodeId, node flat.Node) flat.NodeId {
    match node.value {
        '@VMODROOT' {
            return t.make_string_literal(t.vmod_root())
        }
        else {
            if smartcasted := t.smartcast_ident_value(node.value) {
                return smartcasted
            }
            // Idents are the most common node; re-annotating them in place (rather than
            // allocating a fresh node) avoids cascading rebuilds of every enclosing
            // expression and the associated allocations (critical under -gc none).
            if !t.in_call_callee {
                if fn_name := t.resolve_fn_value_ident(node.value) {
                    t.a.nodes[int(id)].value = fn_name
                    return id
                }
            }
            typ := t.var_type(node.value)
            if typ.len > 0 && typ != node.typ {
                t.a.nodes[int(id)].typ = typ
            }
            return id
        }
    }
}

// smartcast_ident_value supports smartcast ident value handling for Transformer.
fn (mut t Transformer) smartcast_ident_value(name string) ?flat.NodeId {
    if t.smartcast_stack.len == 0 {
        return none
    }
    contexts := t.smartcasts_for(name)
    if contexts.len == 0 {
        return none
    }
    return t.apply_smartcast_contexts(t.make_ident(name), t.var_type(name), contexts)
}

// apply_smartcast_contexts supports apply smartcast contexts handling for Transformer.
fn (mut t Transformer) apply_smartcast_contexts(base flat.NodeId, typ string, contexts []SmartcastContext) flat.NodeId {
    mut current := base
    mut current_type := typ
    for i, sc in contexts {
        if t.is_interface_type_name(sc.sum_type_name) {
            qv := t.interface_variant_type(sc.variant_name)
            field_op := if current_type.starts_with('&') { flat.Op.arrow } else { flat.Op.dot }
            object := t.make_selector_op(current, '_object', 'voidptr', field_op)
            cast := t.make_cast('&${qv}', object, '&${qv}')
            current = t.make_prefix(.mul, cast)
            t.a.nodes[int(current)].typ = qv
            current_type = qv
            continue
        }
        qv := t.resolve_variant(sc.sum_type_name, sc.variant_name)
        if t.expr_is_variant_access(current, qv) {
            current_type = qv
            continue
        }
        field := t.sum_field_name(qv)
        use_ptr := t.variant_references_sum(qv, sc.sum_type_name)
        field_typ := if use_ptr { '&${qv}' } else { qv }
        field_op := if current_type.starts_with('&') { flat.Op.arrow } else { flat.Op.dot }
        field_sel := t.make_selector_op(current, field, field_typ, field_op)
        if use_ptr && i == contexts.len - 1 {
            current = t.make_prefix(.mul, field_sel)
            t.a.nodes[int(current)].typ = qv
            current_type = qv
        } else {
            current = field_sel
            current_type = field_typ
        }
    }
    return current
}

// expr_is_variant_access supports expr is variant access handling for Transformer.
fn (t &Transformer) expr_is_variant_access(id flat.NodeId, variant string) bool {
    if int(id) < 0 || variant.len == 0 {
        return false
    }
    node := t.a.nodes[int(id)]
    field := t.sum_field_name(variant)
    match node.kind {
        .selector {
            return node.value == field
        }
        .prefix {
            if node.op == .mul && node.children_count > 0 {
                return t.expr_is_variant_access(t.a.child(&node, 0), variant)
            }
            return false
        }
        .paren {
            if node.children_count > 0 {
                return t.expr_is_variant_access(t.a.child(&node, 0), variant)
            }
            return false
        }
        else {
            return false
        }
    }
}

// is_sum_variant_field_name reports whether is sum variant field name applies in transform.
fn (t &Transformer) is_sum_variant_field_name(name string) bool {
    return name in t.sum_variant_fields
}

// variant_type_from_sum_field_name converts variant type from sum field name data for transform.
fn (t &Transformer) variant_type_from_sum_field_name(name string) ?string {
    if variant := t.sum_variant_fields[name] {
        return variant
    }
    return none
}

// generated_variant_access_type supports generated variant access type handling for Transformer.
fn (t &Transformer) generated_variant_access_type(id flat.NodeId) ?string {
    if int(id) < 0 {
        return none
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .selector {
            variant := t.variant_type_from_sum_field_name(node.value) or { return none }
            if node.typ.starts_with('&') {
                return node.typ
            }
            return variant
        }
        .prefix {
            if node.op == .mul && node.children_count > 0 {
                variant := t.generated_variant_access_type(t.a.child(&node, 0)) or { return none }
                return t.trim_pointer_type(variant)
            }
            return none
        }
        .paren {
            if node.children_count > 0 {
                return t.generated_variant_access_type(t.a.child(&node, 0))
            }
            return none
        }
        else {
            return none
        }
    }
}

// original_expr_type supports original expr type handling for Transformer.
fn (t &Transformer) original_expr_type(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            typ := t.normalize_type_alias(t.var_type(node.value))
            if typ.len > 0 {
                return typ
            }
            if node.typ.len > 0 {
                return t.normalize_type_alias(node.typ)
            }
            return ''
        }
        .selector {
            if node.typ.len > 0 {
                return t.normalize_type_alias(node.typ)
            }
            return t.resolve_selector_type(node)
        }
        else {
            if node.typ.len > 0 {
                return t.normalize_type_alias(node.typ)
            }
            return t.resolve_expr_type(id)
        }
    }
}

// smartcasts_for supports smartcasts for handling for Transformer.
fn (t &Transformer) smartcasts_for(expr_name string) []SmartcastContext {
    if expr_name.len == 0 || t.smartcast_stack.len == 0 {
        return []SmartcastContext{}
    }
    mut result := []SmartcastContext{cap: 1}
    for sc in t.smartcast_stack {
        if sc.expr_name == expr_name {
            result << sc
        }
    }
    return result
}

// has_smartcast reports whether has smartcast applies in transform.
fn (t &Transformer) has_smartcast(expr_name string) bool {
    if expr_name.len == 0 || t.smartcast_stack.len == 0 {
        return false
    }
    for sc in t.smartcast_stack {
        if sc.expr_name == expr_name {
            return true
        }
    }
    return false
}

// resolve_fn_value_ident resolves resolve fn value ident information for transform.
fn (t &Transformer) resolve_fn_value_ident(name string) ?string {
    if name.len == 0 || name.contains('.') || t.var_type(name).len > 0 {
        return none
    }
    mut candidates := []string{}
    if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
        candidates << '${t.cur_module}.${name}'
    }
    candidates << name
    for candidate in candidates {
        if candidate in t.fn_ret_types {
            return candidate
        }
        if !isnil(t.tc) && (candidate in t.tc.fn_ret_types || candidate in t.tc.fn_param_types) {
            return candidate
        }
    }
    return none
}

// --- helper methods ---

// new_temp supports new temp handling for Transformer.
pub fn (mut t Transformer) new_temp(prefix string) string {
    name := '__${prefix}_${t.temp_counter}'
    t.temp_counter++
    return name
}

// make_ident builds make ident data for transform.
pub fn (mut t Transformer) make_ident(name string) flat.NodeId {
    id := t.a.add_val(.ident, name)
    typ := t.var_type(name)
    if typ.len > 0 {
        t.a.nodes[int(id)].typ = typ
    }
    return id
}

// make_decl_assign builds make decl assign data for transform.
pub fn (mut t Transformer) make_decl_assign(name string, rhs flat.NodeId) flat.NodeId {
    lhs := t.make_ident(name)
    start := t.a.children.len
    t.a.children << lhs
    t.a.children << rhs
    return t.a.add_node(flat.Node{
        kind:           .decl_assign
        children_start: start
        children_count: 2
    })
}

// make_expr_stmt builds make expr stmt data for transform.
pub fn (mut t Transformer) make_expr_stmt(expr flat.NodeId) flat.NodeId {
    start := t.a.children.len
    t.a.children << expr
    return t.a.add_node(flat.Node{
        kind:           .expr_stmt
        children_start: start
        children_count: 1
    })
}

// make_assign builds make assign data for transform.
pub fn (mut t Transformer) make_assign(lhs flat.NodeId, rhs flat.NodeId) flat.NodeId {
    return t.make_assign_op(lhs, rhs, .assign)
}

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

// make_block builds make block data for transform.
pub fn (mut t Transformer) make_block(stmts []flat.NodeId) flat.NodeId {
    start := t.a.children.len
    for id in stmts {
        t.a.children << id
    }
    return t.a.add_node(flat.Node{
        kind:           .block
        children_start: start
        children_count: flat.child_count(stmts.len)
    })
}

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

// make_prefix builds make prefix data for transform.
pub fn (mut t Transformer) make_prefix(op flat.Op, expr flat.NodeId) flat.NodeId {
    start := t.a.children.len
    t.a.children << expr
    return t.a.add_node(flat.Node{
        kind:           .prefix
        op:             op
        children_start: start
        children_count: 1
    })
}

// make_paren builds make paren data for transform.
pub fn (mut t Transformer) make_paren(expr flat.NodeId) flat.NodeId {
    start := t.a.children.len
    t.a.children << expr
    return t.a.add_node(flat.Node{
        kind:           .paren
        children_start: start
        children_count: 1
    })
}

// make_if builds make if data for transform.
pub fn (mut t Transformer) make_if(cond flat.NodeId, then_block flat.NodeId, else_block flat.NodeId) flat.NodeId {
    start := t.a.children.len
    t.a.children << cond
    t.a.children << then_block
    if int(else_block) >= 0 {
        t.a.children << else_block
        return t.a.add_node(flat.Node{
            kind:           .if_expr
            children_start: start
            children_count: 3
        })
    }
    return t.a.add_node(flat.Node{
        kind:           .if_expr
        children_start: start
        children_count: 2
    })
}

// push_smartcast updates push smartcast state for Transformer.
pub fn (mut t Transformer) push_smartcast(expr_name string, variant string, sum_type string) {
    t.smartcast_stack << SmartcastContext{
        expr_name:     expr_name
        variant_name:  variant
        sum_type_name: sum_type
    }
}

// pop_smartcast updates pop smartcast state for Transformer.
pub fn (mut t Transformer) pop_smartcast() {
    if t.smartcast_stack.len > 0 {
        t.smartcast_stack.delete_last()
    }
}

// find_smartcast resolves find smartcast information for transform.
pub fn (t &Transformer) find_smartcast(expr_name string) ?SmartcastContext {
    // Search from top of stack (most recent) to bottom
    mut i := t.smartcast_stack.len - 1
    for i >= 0 {
        if t.smartcast_stack[i].expr_name == expr_name {
            return t.smartcast_stack[i]
        }
        i--
    }
    return none
}

// expr_key supports expr key handling for Transformer.
fn (t &Transformer) expr_key(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    if node.kind == .ident {
        return node.value
    }
    if node.kind == .selector && node.children_count >= 1 {
        base_id := t.a.child(&node, 0)
        base_key := t.expr_key(base_id)
        if base_key.len > 0 {
            return '${base_key}.${node.value}'
        }
    }
    if node.kind == .index && node.children_count >= 2 {
        base_key := t.expr_key(t.a.child(&node, 0))
        index_key := t.expr_key_part(t.a.child(&node, 1))
        if base_key.len > 0 && index_key.len > 0 {
            return '${base_key}[${index_key}]'
        }
    }
    if node.kind in [.as_expr, .paren] && node.children_count >= 1 {
        return t.expr_key(t.a.child(&node, 0))
    }
    return ''
}

// expr_key_part supports expr key part handling for Transformer.
fn (t &Transformer) expr_key_part(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            return node.value
        }
        .int_literal, .string_literal, .char_literal, .enum_val {
            return node.value
        }
        else {
            return t.expr_key(id)
        }
    }
}

// qualify_variant supports qualify variant handling for Transformer.
fn (t &Transformer) qualify_variant(variant string, sum_type_name string) string {
    if variant.contains('.') {
        return variant
    }
    resolved_sum := t.resolve_sum_name(sum_type_name)
    if resolved_variant := t.sum_variant_name(resolved_sum, variant) {
        return resolved_variant
    }
    if sum_type_name.contains('.') {
        mod := sum_type_name.all_before_last('.')
        return '${mod}.${variant}'
    }
    return variant
}

// sum_variant_name supports sum variant name handling for Transformer.
fn (t &Transformer) sum_variant_name(sum_name string, variant string) ?string {
    resolved_sum := t.resolve_sum_name(sum_name)
    variants := t.sum_types[resolved_sum] or { return none }
    for v in variants {
        if t.variant_names_match(v, variant) {
            return v
        }
    }
    return none
}

fn (t &Transformer) variant_names_match(a string, b string) bool {
    return a == b || t.variant_short_name(a) == t.variant_short_name(b)
}

fn (t &Transformer) variant_short_name(name string) string {
    return variant_short_name_text(name)
}

fn variant_short_name_text(name string) string {
    if name.starts_with('&') {
        return '&' + variant_short_name_text(name[1..])
    }
    if name.starts_with('[]') {
        return '[]' + variant_short_name_text(name[2..])
    }
    if name.starts_with('map[') {
        bracket_end := name.index(']') or { return name }
        key := name[4..bracket_end]
        value := name[bracket_end + 1..]
        return 'map[${variant_short_name_text(key)}]${variant_short_name_text(value)}'
    }
    return if name.contains('.') { name.all_after_last('.') } else { name }
}

// sum_field_name supports sum field name handling for Transformer.
fn (t &Transformer) sum_field_name(variant string) string {
    if variant.starts_with('&') {
        return t.sum_field_name(variant[1..])
    }
    if variant.starts_with('ptr') && variant.len > 3 && variant[3..].contains('.') {
        return t.sum_field_name(variant[3..])
    }
    if variant.starts_with('ptr') && variant.len > 3 && variant[3..].contains('__') {
        return t.sum_field_name(variant[3..].replace('__', '.'))
    }
    if variant.starts_with('[]') {
        return '_Array_${c_name(variant[2..])}'
    }
    if variant.starts_with('map[') {
        return '_Map_${c_name(variant[4..].replace(']', '_'))}'
    }
    return match variant {
        'int' { '_int' }
        'i8' { '_i8' }
        'i16' { '_i16' }
        'i64' { '_i64' }
        'u8', 'byte' { '_u8' }
        'u16' { '_u16' }
        'u32' { '_u32' }
        'u64' { '_u64' }
        'f32' { '_f32' }
        'f64' { '_f64' }
        'bool' { '_bool' }
        'string' { '_string' }
        else { c_name(variant) }
    }
}

// variant_references_sum supports variant references sum handling for Transformer.
fn (t &Transformer) variant_references_sum(variant string, sum_name string) bool {
    _ = t
    _ = variant
    _ = sum_name
    return true
}

// tc_variant_refs_sum_inner supports tc variant refs sum inner handling for Transformer.
fn (t &Transformer) tc_variant_refs_sum_inner(variant string, sum_name string, mut visited map[string]bool) bool {
    if variant == sum_name || variant.all_after_last('.') == sum_name.all_after_last('.') {
        return true
    }
    if variant in visited {
        return false
    }
    visited[variant] = true
    mut lookup := variant
    if lookup !in t.tc.structs && !lookup.contains('.') && sum_name.contains('.') {
        qlookup := '${sum_name.all_before_last('.')}.${lookup}'
        if qlookup in t.tc.structs {
            lookup = qlookup
        }
    }
    if lookup !in t.tc.structs && lookup.contains('.') {
        short := lookup.all_after_last('.')
        if short in t.tc.structs {
            lookup = short
        }
    }
    if lookup in t.tc.structs {
        for f in t.tc.structs[lookup] {
            if t.tc_type_references_sum(f.typ, sum_name, mut visited) {
                return true
            }
        }
    }
    return false
}

// tc_type_references_sum supports tc type references sum handling for Transformer.
fn (t &Transformer) tc_type_references_sum(typ types.Type, sum_name string, mut visited map[string]bool) bool {
    clean := types.unwrap_pointer(typ)
    if clean is types.Struct && clean.name == sum_name {
        return true
    }
    if clean is types.SumType && clean.name == sum_name {
        return true
    }
    if clean is types.SumType {
        return true
    }
    if clean is types.Struct {
        if t.tc_variant_refs_sum_inner(clean.name, sum_name, mut visited) {
            return true
        }
    }
    if clean is types.Array {
        return t.tc_type_references_sum(clean.elem_type, sum_name, mut visited)
    }
    return false
}

// variant_refs_sum_inner supports variant refs sum inner handling for Transformer.
fn (t &Transformer) variant_refs_sum_inner(variant string, sum_name string, mut visited map[string]bool) bool {
    short_v := if variant.contains('.') { variant.all_after_last('.') } else { variant }
    short_s := if sum_name.contains('.') { sum_name.all_after_last('.') } else { sum_name }
    if short_v == short_s {
        return true
    }
    if variant in visited {
        return false
    }
    visited[variant] = true
    qualified := if sum_name.contains('.') && !variant.contains('.') {
        '${sum_name.all_before_last('.')}.${variant}'
    } else {
        variant
    }
    lookup := if qualified in t.structs {
        qualified
    } else if variant in t.structs {
        variant
    } else {
        short_v
    }
    if lookup in t.structs {
        for f in t.structs[lookup].fields {
            if f.typ.starts_with('&') || f.typ.starts_with('[]') {
                continue
            }
            ftyp := f.typ
            short_f := if ftyp.contains('.') { ftyp.all_after_last('.') } else { ftyp }
            if ftyp == sum_name || short_f == short_s {
                return true
            }
            qftyp := if sum_name.contains('.') && !ftyp.contains('.') {
                '${sum_name.all_before_last('.')}.${ftyp}'
            } else {
                ftyp
            }
            if qftyp in t.sum_types {
                return true
            }
            if ftyp in t.structs || short_f in t.structs || qftyp in t.structs {
                inner_lookup := if ftyp in t.structs {
                    ftyp
                } else if short_f in t.structs {
                    short_f
                } else {
                    qftyp
                }
                if t.variant_refs_sum_inner(inner_lookup, sum_name, mut visited) {
                    return true
                }
            }
        }
    }
    return false
}

// drain_pending supports drain pending handling for Transformer.
pub fn (mut t Transformer) drain_pending(mut result []flat.NodeId) {
    for id in t.pending_stmts {
        result << id
    }
    t.pending_stmts.clear()
}

// with_pending_before supports with pending before handling for Transformer.
fn (mut t Transformer) with_pending_before(stmt flat.NodeId) []flat.NodeId {
    mut result := []flat.NodeId{}
    t.drain_pending(mut result)
    result << stmt
    return result
}

// is_stmt_kind_id reports whether is stmt kind id applies in transform.
fn (t &Transformer) is_stmt_kind_id(kind_id int) bool {
    return kind_id == 39 || kind_id == 40 || kind_id == 41 || kind_id == 42 || kind_id == 43
        || kind_id == 44 || kind_id == 45 || kind_id == 46 || kind_id == 47 || kind_id == 48
        || kind_id == 49 || kind_id == 50 || kind_id == 52 || kind_id == 53 || kind_id == 54
        || kind_id == 55 || kind_id == 15 || kind_id == 56 || kind_id == 57 || kind_id == 60
}

// is_stmt_kind reports whether is stmt kind applies in transform.
fn (t &Transformer) is_stmt_kind(kind flat.NodeKind) bool {
    return t.is_stmt_kind_id(int(kind))
}

// --- type resolution helpers (will move to types.v later) ---

// infer_decl_type resolves infer decl type information for transform.
fn (t &Transformer) infer_decl_type(node &flat.Node) string {
    if node.typ.len > 0 {
        return node.typ
    }
    if node.children_count >= 2 {
        rhs_id := t.a.child(node, 1)
        return t.decl_rhs_type(rhs_id)
    }
    return ''
}

// resolve_expr_type resolves resolve expr type information for transform.
fn (t &Transformer) resolve_expr_type(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .ident {
            if sc := t.find_smartcast(node.value) {
                return t.smartcast_target_type(sc)
            }
            local_type := t.normalize_type_alias(t.var_type(node.value))
            if local_type.len > 0 {
                return local_type
            }
            if global_type := t.globals[node.value] {
                return t.normalize_type_alias(global_type)
            }
            if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
                qglobal := '${t.cur_module}.${node.value}'
                if global_type := t.globals[qglobal] {
                    return t.normalize_type_alias(global_type)
                }
            }
            if !isnil(t.tc) {
                if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
                    qname := '${t.cur_module}.${node.value}'
                    if name := t.const_type_name(qname) {
                        return name
                    }
                }
                if name := t.const_type_name(node.value) {
                    return name
                }
            }
            return ''
        }
        .call {
            concrete_typ := t.concrete_node_type_name(node)
            if concrete_typ.len > 0 {
                return concrete_typ
            }
            new_map_typ := t.new_map_call_type(node)
            if new_map_typ.len > 0 {
                return new_map_typ
            }
            if node.typ.len > 0 {
                typ := t.normalize_type_alias(node.typ)
                if typ !in ['array', 'map', 'unknown'] {
                    return typ
                }
            }
            mut ret := t.get_call_return_type(id, node)
            if ret.len == 0 {
                ret = t.current_call_return_type(node)
            }
            if ret.len > 0 {
                return ret
            }
            return ''
        }
        .cast_expr {
            if node.value.len > 0 {
                return node.value
            }
            return node.typ
        }
        .array_literal {
            if node.typ.len > 0 {
                typ := t.normalize_type_alias(node.typ)
                if typ != 'array' {
                    return typ
                }
            }
            if node.children_count > 0 {
                elem_type := t.node_type(t.a.child(&node, 0))
                if elem_type.len > 0 {
                    return '[]${elem_type}'
                }
            }
            return '[]int'
        }
        .array_init {
            if node.value.starts_with('[]') {
                return '[]${node.value}'
            }
            if node.typ.len > 0 {
                typ := t.normalize_type_alias(node.typ)
                if typ != 'array' {
                    return typ
                }
            }
            if t.is_fixed_array_type(node.value) {
                return node.value
            }
            if node.value.len > 0 {
                return '[]${node.value}'
            }
            return '[]int'
        }
        .map_init {
            if node.value.len > 0 {
                return node.value
            }
            if node.children_count >= 2 {
                key_type := t.node_type(t.a.child(&node, 0))
                value_type := t.node_type(t.a.child(&node, 1))
                if key_type.len > 0 && value_type.len > 0 {
                    return 'map[${key_type}]${value_type}'
                }
            }
            return ''
        }
        .selector {
            if t.smartcast_stack.len == 0 {
                typ := t.concrete_node_type_name(node)
                if typ.len > 0 {
                    return typ
                }
            }
            if !isnil(t.tc) && node.children_count > 0 {
                base := t.a.child_node(&node, 0)
                if base.kind == .ident {
                    qname := '${base.value}.${node.value}'
                    if name := t.const_type_name(qname) {
                        return name
                    }
                }
            }
            return t.resolve_selector_type(node)
        }
        .index {
            return t.index_expr_type(id, node)
        }
        .paren {
            if node.children_count > 0 {
                return t.node_type(t.a.child(&node, 0))
            }
            return ''
        }
        .prefix {
            if node.children_count > 0 {
                child_type := t.node_type(t.a.child(&node, 0))
                if node.op == .amp && child_type.len > 0 {
                    return '&${child_type}'
                }
                if node.op == .mul && child_type.starts_with('&') {
                    return child_type[1..]
                }
                if node.op == .not {
                    return 'bool'
                }
                if node.op in [.plus, .minus, .bit_not] {
                    return child_type
                }
            }
            return ''
        }
        .block {
            return t.stmt_value_type(id)
        }
        .bool_literal {
            return 'bool'
        }
        .float_literal {
            return 'f64'
        }
        .char_literal {
            return 'rune'
        }
        .string_literal, .string_interp {
            return 'string'
        }
        .int_literal {
            return 'int'
        }
        .nil_literal {
            return 'voidptr'
        }
        .none_expr {
            return '?void'
        }
        .infix {
            if node.children_count >= 2 {
                if node.op in [.eq, .ne, .lt, .gt, .le, .ge, .logical_and, .logical_or] {
                    return 'bool'
                }
                lhs_type := t.node_type(t.a.child(&node, 0))
                ret_type := t.infix_struct_operator_result_type(node, lhs_type)
                if ret_type.len > 0 {
                    return ret_type
                }
                if node.op == .plus && lhs_type == 'string' {
                    return 'string'
                }
                rhs_type := t.node_type(t.a.child(&node, 1))
                if node.op == .plus && rhs_type == 'string' {
                    return 'string'
                }
                if node.op in [.plus, .minus] && lhs_type.starts_with('&')
                    && t.is_integer_type_name(rhs_type) {
                    return lhs_type
                }
                if node.op == .plus && rhs_type.starts_with('&') && t.is_integer_type_name(lhs_type) {
                    return rhs_type
                }
                if node.op in [.plus, .minus, .mul, .div, .mod, .amp, .pipe, .xor] {
                    if lhs_type.len > 0 && rhs_type.len > 0 && t.is_numeric_stringify_type(lhs_type)
                        && t.is_numeric_stringify_type(rhs_type) {
                        return promote_numeric_stringify_type(lhs_type, rhs_type)
                    }
                    if lhs_type.len > 0 && t.is_numeric_stringify_type(lhs_type) {
                        return lhs_type
                    }
                    if rhs_type.len > 0 && t.is_numeric_stringify_type(rhs_type) {
                        return rhs_type
                    }
                }
            }
            return ''
        }
        .or_expr {
            if node.children_count > 0 {
                inner_type := t.resolve_expr_type(t.a.child(&node, 0))
                if inner_type.starts_with('!') {
                    return inner_type[1..]
                }
                if inner_type.starts_with('?') {
                    return inner_type[1..]
                }
                return inner_type
            }
            return ''
        }
        .if_expr {
            return t.if_expr_result_type(id, node)
        }
        .match_stmt {
            return t.match_expr_type(node)
        }
        else {
            return ''
        }
    }
}

fn (t &Transformer) current_call_return_type(node flat.Node) string {
    if node.children_count > 0 {
        fn_node := t.a.child_node(&node, 0)
        if fn_node.kind == .ident {
            local_type := t.var_type(fn_node.value)
            if local_type.len > 0 {
                if ret := t.local_fn_value_return_type_from_type(local_type) {
                    return t.call_return_type_name(ret, node)
                }
            } else {
                if ret := t.local_fn_decl_return_type(fn_node.value) {
                    return t.call_return_type_name(ret, node)
                }
            }
        }
    }
    name := t.resolve_call_name(node)
    if name.len == 0 {
        return ''
    }
    if ret := t.fn_ret_types[name] {
        return t.call_return_type_name(ret, node)
    }
    if !isnil(t.tc) {
        if ret := t.tc.fn_ret_types[name] {
            return t.call_return_type_name(ret.name(), node)
        }
    }
    if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
        qname := '${t.cur_module}.${name}'
        if ret := t.fn_ret_types[qname] {
            return t.call_return_type_name(ret, node)
        }
        if !isnil(t.tc) {
            if ret := t.tc.fn_ret_types[qname] {
                return t.call_return_type_name(ret.name(), node)
            }
        }
    }
    return ''
}

fn (t &Transformer) is_local_fn_value_call(node flat.Node) bool {
    if node.kind != .call || node.children_count == 0 {
        return false
    }
    fn_id := t.a.child(&node, 0)
    if int(fn_id) < 0 {
        return false
    }
    fn_node := t.a.nodes[int(fn_id)]
    if fn_node.kind != .ident || fn_node.value.len == 0 {
        return false
    }
    local_type := t.var_type(fn_node.value)
    return local_type.starts_with('fn ') || t.is_fn_pointer_type_name(local_type)
}

// const_type_name supports const type name handling for Transformer.
fn (t &Transformer) const_type_name(name string) ?string {
    if isnil(t.tc) || name.len == 0 {
        return none
    }
    key := t.const_type_key(name) or { return none }
    typ := t.tc.const_types[key] or { return none }
    if tname := t.const_entry_type_name(key, typ) {
        return tname
    }
    return none
}

// const_type_key supports const type key handling for Transformer.
fn (t &Transformer) const_type_key(name string) ?string {
    if name.len == 0 || isnil(t.tc) {
        return none
    }
    if name in t.tc.const_types {
        return name
    }
    if key := t.const_suffixes[name] {
        if key.len > 0 {
            return key
        }
    }
    return none
}

// const_entry_type_name supports const entry type name handling for Transformer.
fn (t &Transformer) const_entry_type_name(name string, typ types.Type) ?string {
    tname := t.normalize_type_alias(typ.name())
    if tname.len > 0 && tname != 'unknown' {
        if t.is_fixed_array_type(tname) {
            if expr_id := t.tc.const_exprs[name] {
                expr := t.a.nodes[int(expr_id)]
                if expr.kind == .call {
                    return '[]${fixed_array_elem_type(tname)}'
                }
            }
        }
        return tname
    }
    if name.ends_with('.scanner_matcher') {
        mod_name := name.all_before_last('.')
        return '${mod_name}.KeywordsMatcherTrie'
    }
    if expr_id := t.tc.const_exprs[name] {
        if etyp := t.tc.expr_type(expr_id) {
            ename := t.normalize_type_alias(etyp.name())
            if ename.len > 0 && ename != 'unknown' {
                return ename
            }
        }
        ename := t.resolve_expr_type(expr_id)
        if ename.len > 0 && ename != 'unknown' {
            return ename
        }
    }
    return none
}

// match_expr_type supports match expr type handling for Transformer.
fn (t &Transformer) match_expr_type(node flat.Node) string {
    if node.kind != .match_stmt || node.children_count < 2 {
        return ''
    }
    match_expr_id := t.a.child(&node, 0)
    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
        }
        contexts := t.match_branch_type_contexts(match_expr_id, *branch)
        for j := branch.children_count - 1; j >= body_start; j-- {
            stmt_id := t.a.child(branch, j)
            typ := if contexts.len > 0 {
                t.stmt_value_type_with_smartcasts(stmt_id, contexts)
            } else {
                t.stmt_value_type(stmt_id)
            }
            if typ.len > 0 {
                return typ
            }
        }
    }
    return ''
}

// match_branch_type_contexts supports match branch type contexts handling for Transformer.
fn (t &Transformer) match_branch_type_contexts(match_expr_id flat.NodeId, branch flat.Node) []SmartcastContext {
    if branch.value == 'else' {
        return []SmartcastContext{}
    }
    n_conds := t.count_conds(branch)
    if n_conds != 1 {
        return []SmartcastContext{}
    }
    cond_val_id := t.a.child(&branch, 0)
    variant_name := t.match_type_pattern(cond_val_id) or { return []SmartcastContext{} }
    subj := t.expr_key(match_expr_id)
    sum_name := t.sum_type_for_is_expr(t.original_expr_type(match_expr_id), variant_name)
    if subj.len == 0 || sum_name.len == 0 {
        return []SmartcastContext{}
    }
    return [
        SmartcastContext{
            expr_name:     subj
            variant_name:  variant_name
            sum_type_name: sum_name
        },
    ]
}

// stmt_value_type supports stmt value type handling for Transformer.
fn (t &Transformer) stmt_value_type(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := t.a.nodes[int(id)]
    match node.kind {
        .expr_stmt {
            if node.children_count > 0 {
                return t.node_type(t.a.child(&node, node.children_count - 1))
            }
            return ''
        }
        .block {
            for i := node.children_count - 1; i >= 0; i-- {
                typ := t.stmt_value_type(t.a.child(&node, i))
                if typ.len > 0 {
                    return typ
                }
            }
            return ''
        }
        else {
            return t.node_type(id)
        }
    }
}

// --- match lowering (existing, will move to expr.v later) ---

// lower_match_stmts builds lower match stmts data for transform.
fn (mut t Transformer) lower_match_stmts() {
    for i, node in t.a.nodes {
        if node.kind == .match_stmt {
            if_id := t.lower_one_match(node)
            t.a.nodes[i] = t.a.nodes[int(if_id)]
        } else if node.kind == .expr_stmt && node.children_count == 1 {
            child_id := t.a.child(&node, 0)
            child := t.a.nodes[int(child_id)]
            if child.kind == .match_stmt {
                if_id := t.lower_one_match(child)
                t.a.nodes[i] = flat.Node{
                    kind:           .expr_stmt
                    children_start: t.a.children.len
                    children_count: 1
                }
                t.a.children << if_id
            }
        }
    }
}

// lower_one_match builds lower one match data for transform.
fn (mut t Transformer) lower_one_match(node flat.Node) flat.NodeId {
    match_expr_id := t.a.child(&node, 0)
    match_expr := t.a.nodes[int(match_expr_id)]
    result_type := t.match_expr_type(node)

    needs_temp := match_expr.kind !in [.ident, .int_literal, .bool_literal, .string_literal,
        .char_literal]

    mut actual_expr_id := match_expr_id
    mut prefix_id := flat.empty_node

    if needs_temp {
        tmp_name := '__match_tmp_${int(match_expr_id)}'
        match_type := t.node_type(match_expr_id)
        transformed_match_expr := t.transform_expr(match_expr_id)
        tmp_ident := t.a.add_val(.ident, tmp_name)
        t.a.nodes[int(tmp_ident)].typ = match_type
        decl_start := t.a.children.len
        t.a.children << tmp_ident
        t.a.children << transformed_match_expr
        prefix_id = t.a.add_node(flat.Node{
            kind:           .decl_assign
            children_start: decl_start
            children_count: 2
            typ:            match_type
        })
        actual_expr_id = t.a.add_val(.ident, tmp_name)
        t.a.nodes[int(actual_expr_id)].typ = match_type
    }

    mut branches := []flat.NodeId{}
    for i in 1 .. node.children_count {
        branches << t.a.child(&node, i)
    }
    if_id := t.build_match_chain(actual_expr_id, match_expr_id, branches, 0)

    if needs_temp {
        block_start := t.a.children.len
        t.a.children << prefix_id
        t.a.children << if_id
        block_id := t.a.add_node(flat.Node{
            kind:           .block
            children_start: block_start
            children_count: 2
            typ:            result_type
        })
        return block_id
    }
    if result_type.len > 0 {
        t.a.nodes[int(if_id)].typ = result_type
    }
    return if_id
}

// build_match_chain builds match chain data for transform.
fn (mut t Transformer) build_match_chain(match_expr_id flat.NodeId, orig_expr_id flat.NodeId, branches []flat.NodeId, idx int) flat.NodeId {
    if idx >= branches.len {
        return t.a.add(flat.NodeKind.empty)
    }
    branch := t.a.nodes[int(branches[idx])]
    is_else := branch.value == 'else'

    // count_conds scans the branch's condition children; compute it once and reuse
    // (build_match_chain runs per branch, and the compiler has very large matches).
    n_conds := if is_else { 0 } else { t.count_conds(branch) }
    body_start_idx := n_conds
    if !is_else && n_conds > 1 && t.match_branch_all_type_patterns(branch) {
        return t.build_match_type_branch_chain(match_expr_id, orig_expr_id, branch, branches, idx,
            0)
    }
    // Push a smartcast around the body transform when this branch matches a
    // single sum-type variant, so selectors inside the body get narrowed.
    mut sc_pushed := 0
    if !is_else {
        if n_conds == 1 {
            cond_val_id := t.a.child(&branch, 0)
            if variant_name := t.match_type_pattern(cond_val_id) {
                subj := t.expr_key(match_expr_id)
                sum_name := t.sum_type_for_is_expr(t.original_expr_type(match_expr_id),
                    variant_name)
                if subj.len > 0 && sum_name.len > 0 {
                    t.push_smartcast(subj, variant_name, sum_name)
                    sc_pushed++
                }
                orig_subj := t.expr_key(orig_expr_id)
                if orig_subj.len > 0 && orig_subj != subj && sum_name.len > 0 {
                    t.push_smartcast(orig_subj, variant_name, sum_name)
                    sc_pushed++
                }
            }
        }
    }
    mut body_ids := []flat.NodeId{}
    for i in body_start_idx .. branch.children_count {
        body_ids << t.a.child(&branch, i)
    }
    new_body := t.transform_stmts(body_ids)
    for _ in 0 .. sc_pushed {
        t.pop_smartcast()
    }
    body_block := t.make_block(new_body)

    if is_else {
        return body_block
    }

    outer_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    cond_id := t.build_match_cond(match_expr_id, branch)
    mut cond_prelude := []flat.NodeId{}
    t.drain_pending(mut cond_prelude)
    t.pending_stmts = outer_pending

    mut if_ids := []flat.NodeId{}
    if_ids << cond_id
    if_ids << body_block
    if idx + 1 < branches.len {
        else_part := t.build_match_chain(match_expr_id, orig_expr_id, branches, idx + 1)
        if_ids << else_part
    }

    if_start := t.a.children.len
    for id in if_ids {
        t.a.children << id
    }
    if_id := t.a.add_node(flat.Node{
        kind:           .if_expr
        children_start: if_start
        children_count: flat.child_count(if_ids.len)
    })
    if cond_prelude.len > 0 {
        cond_prelude << if_id
        return t.make_block(cond_prelude)
    }
    return if_id
}

// build_match_value_stmts builds match value stmts data for transform.
fn (mut t Transformer) build_match_value_stmts(node flat.Node, target_name string, target_type string) []flat.NodeId {
    match_expr_id := t.a.child(&node, 0)
    match_expr := t.a.nodes[int(match_expr_id)]
    needs_temp := match_expr.kind !in [.ident, .int_literal, .bool_literal, .string_literal,
        .char_literal]

    mut actual_expr_id := match_expr_id
    mut result := []flat.NodeId{}
    if needs_temp {
        tmp_name := '__match_tmp_${int(match_expr_id)}'
        match_type := t.node_type(match_expr_id)
        transformed_match_expr := t.transform_expr(match_expr_id)
        t.drain_pending(mut result)
        tmp_ident := t.a.add_val(.ident, tmp_name)
        t.a.nodes[int(tmp_ident)].typ = match_type
        result << t.make_decl_assign_typed(tmp_name, transformed_match_expr, match_type)
        actual_expr_id = t.a.add_val(.ident, tmp_name)
        t.a.nodes[int(actual_expr_id)].typ = match_type
    }

    mut branches := []flat.NodeId{}
    for i in 1 .. node.children_count {
        branches << t.a.child(&node, i)
    }
    result << t.build_match_value_chain(actual_expr_id, match_expr_id, branches, 0, target_name,
        target_type)
    return result
}

// build_match_value_chain builds match value chain data for transform.
fn (mut t Transformer) build_match_value_chain(match_expr_id flat.NodeId, orig_expr_id flat.NodeId, branches []flat.NodeId, idx int, target_name string, target_type string) flat.NodeId {
    if idx >= branches.len {
        return t.a.add(flat.NodeKind.empty)
    }
    branch := t.a.nodes[int(branches[idx])]
    is_else := branch.value == 'else'
    body_start_idx := if is_else { 0 } else { t.count_conds(branch) }
    if !is_else && t.match_branch_all_type_patterns(branch) && t.count_conds(branch) > 1 {
        return t.build_match_value_type_branch_chain(match_expr_id, orig_expr_id, branch, branches,
            idx, 0, target_name, target_type)
    }

    mut sc_pushed := 0
    if !is_else {
        n_conds := t.count_conds(branch)
        if n_conds == 1 {
            cond_val_id := t.a.child(&branch, 0)
            if variant_name := t.match_type_pattern(cond_val_id) {
                subj := t.expr_key(match_expr_id)
                sum_name := t.sum_type_for_is_expr(t.original_expr_type(match_expr_id),
                    variant_name)
                if subj.len > 0 && sum_name.len > 0 {
                    t.push_smartcast(subj, variant_name, sum_name)
                    sc_pushed++
                }
                orig_subj := t.expr_key(orig_expr_id)
                if orig_subj.len > 0 && orig_subj != subj && sum_name.len > 0 {
                    t.push_smartcast(orig_subj, variant_name, sum_name)
                    sc_pushed++
                }
            }
        }
    }

    mut body_ids := []flat.NodeId{}
    for i in body_start_idx .. branch.children_count {
        body_ids << t.a.child(&branch, i)
    }
    raw_body := t.make_block(body_ids)
    body_block := t.if_value_branch_block(raw_body, target_name, target_type)
    for _ in 0 .. sc_pushed {
        t.pop_smartcast()
    }

    if is_else {
        return body_block
    }
    outer_pending := t.pending_stmts.clone()
    t.pending_stmts.clear()
    cond_id := t.build_match_cond(match_expr_id, branch)
    mut cond_prelude := []flat.NodeId{}
    t.drain_pending(mut cond_prelude)
    t.pending_stmts = outer_pending
    mut if_ids := []flat.NodeId{}
    if_ids << cond_id
    if_ids << body_block
    if idx + 1 < branches.len {
        else_part := t.build_match_value_chain(match_expr_id, orig_expr_id, branches, idx + 1,
            target_name, target_type)
        if_ids << else_part
    }
    if_start := t.a.children.len
    for id in if_ids {
        t.a.children << id
    }
    if_id := t.a.add_node(flat.Node{
        kind:           .if_expr
        children_start: if_start
        children_count: flat.child_count(if_ids.len)
    })
    if cond_prelude.len > 0 {
        cond_prelude << if_id
        return t.make_block(cond_prelude)
    }
    return if_id
}

// build_match_value_type_branch_chain supports build_match_value_type_branch_chain handling.
fn (mut t Transformer) build_match_value_type_branch_chain(match_expr_id flat.NodeId, orig_expr_id flat.NodeId, branch flat.Node, branches []flat.NodeId, idx int, cond_idx int, target_name string, target_type string) flat.NodeId {
    n_conds := t.count_conds(branch)
    if cond_idx >= n_conds {
        return if idx + 1 < branches.len {
            t.build_match_value_chain(match_expr_id, orig_expr_id, branches, idx + 1, target_name,
                target_type)
        } else {
            t.a.add(flat.NodeKind.empty)
        }
    }
    cond_val_id := t.a.child(&branch, cond_idx)
    variant_name := t.match_type_pattern(cond_val_id) or {
        return t.build_match_value_chain(match_expr_id, orig_expr_id, branches, idx + 1,
            target_name, target_type)
    }
    is_start := t.a.children.len
    t.a.children << match_expr_id
    is_id := t.a.add_node(flat.Node{
        kind:           .is_expr
        value:          variant_name
        children_start: is_start
        children_count: 1
    })
    cond_id := t.transform_is_expr(is_id, t.a.nodes[int(is_id)])

    mut sc_pushed := 0
    subj := t.expr_key(match_expr_id)
    sum_name := t.sum_type_for_is_expr(t.original_expr_type(match_expr_id), variant_name)
    if subj.len > 0 && sum_name.len > 0 {
        t.push_smartcast(subj, variant_name, sum_name)
        sc_pushed++
    }
    orig_subj := t.expr_key(orig_expr_id)
    if orig_subj.len > 0 && orig_subj != subj && sum_name.len > 0 {
        t.push_smartcast(orig_subj, variant_name, sum_name)
        sc_pushed++
    }

    mut body_ids := []flat.NodeId{}
    for i in n_conds .. branch.children_count {
        body_ids << t.a.child(&branch, i)
    }
    raw_body := t.make_block(body_ids)
    body_block := t.if_value_branch_block(raw_body, target_name, target_type)
    for _ in 0 .. sc_pushed {
        t.pop_smartcast()
    }

    else_part := t.build_match_value_type_branch_chain(match_expr_id, orig_expr_id, branch,
        branches, idx, cond_idx + 1, target_name, target_type)
    start := t.a.children.len
    t.a.children << cond_id
    t.a.children << body_block
    t.a.children << else_part
    return t.a.add_node(flat.Node{
        kind:           .if_expr
        children_start: start
        children_count: 3
    })
}

// build_match_type_branch_chain builds match type branch chain data for transform.
fn (mut t Transformer) build_match_type_branch_chain(match_expr_id flat.NodeId, orig_expr_id flat.NodeId, branch flat.Node, branches []flat.NodeId, idx int, cond_idx int) flat.NodeId {
    n_conds := t.count_conds(branch)
    if cond_idx >= n_conds {
        return if idx + 1 < branches.len {
            t.build_match_chain(match_expr_id, orig_expr_id, branches, idx + 1)
        } else {
            t.a.add(flat.NodeKind.empty)
        }
    }
    cond_val_id := t.a.child(&branch, cond_idx)
    variant_name := t.match_type_pattern(cond_val_id) or {
        return t.build_match_chain(match_expr_id, orig_expr_id, branches, idx + 1)
    }
    is_start := t.a.children.len
    t.a.children << match_expr_id
    is_id := t.a.add_node(flat.Node{
        kind:           .is_expr
        value:          variant_name
        children_start: is_start
        children_count: 1
    })
    cond_id := t.transform_is_expr(is_id, t.a.nodes[int(is_id)])

    mut sc_pushed := 0
    subj := t.expr_key(match_expr_id)
    sum_name := t.sum_type_for_is_expr(t.original_expr_type(match_expr_id), variant_name)
    if subj.len > 0 && sum_name.len > 0 {
        t.push_smartcast(subj, variant_name, sum_name)
        sc_pushed++
    }
    orig_subj := t.expr_key(orig_expr_id)
    if orig_subj.len > 0 && orig_subj != subj && sum_name.len > 0 {
        t.push_smartcast(orig_subj, variant_name, sum_name)
        sc_pushed++
    }

    mut body_ids := []flat.NodeId{}
    for i in n_conds .. branch.children_count {
        body_ids << t.a.child(&branch, i)
    }
    body_block := t.make_block(t.transform_stmts(body_ids))
    for _ in 0 .. sc_pushed {
        t.pop_smartcast()
    }

    else_part := t.build_match_type_branch_chain(match_expr_id, orig_expr_id, branch, branches,
        idx, cond_idx + 1)
    start := t.a.children.len
    t.a.children << cond_id
    t.a.children << body_block
    t.a.children << else_part
    return t.a.add_node(flat.Node{
        kind:           .if_expr
        children_start: start
        children_count: 3
    })
}

// make_match_eq builds the equality test between a match subject and a branch
// value, lowering string comparisons to string__eq (the transformer owns string
// lowering; the backend no longer special-cases it).
fn (mut t Transformer) make_match_eq(lhs flat.NodeId, rhs flat.NodeId) flat.NodeId {
    if t.is_string_type(lhs) || t.is_string_type(rhs) {
        return t.make_call('string__eq', arr2(lhs, rhs))
    }
    start := t.a.children.len
    t.a.children << lhs
    t.a.children << rhs
    return t.a.add_node(flat.Node{
        kind:           .infix
        op:             .eq
        children_start: start
        children_count: 2
    })
}

// make_match_range builds make match range data for transform.
fn (mut t Transformer) make_match_range(lhs flat.NodeId, range_id flat.NodeId) flat.NodeId {
    range := t.a.nodes[int(range_id)]
    if range.children_count < 2 {
        return t.make_bool_literal(false)
    }
    low_id := t.a.children[range.children_start]
    high_id := t.a.children[range.children_start + 1]
    low := t.match_cond_value(lhs, low_id)
    high := t.match_cond_value(lhs, high_id)
    ge_cmp := t.make_infix(.ge, lhs, low)
    le_cmp := t.make_infix(.le, lhs, high)
    return t.make_infix(.logical_and, ge_cmp, le_cmp)
}

// match_cond_value supports match cond value handling for Transformer.
fn (mut t Transformer) match_cond_value(match_expr_id flat.NodeId, cond_val_id flat.NodeId) flat.NodeId {
    cond_val := t.a.nodes[int(cond_val_id)]
    if cond_val.kind == .enum_val {
        return t.transform_enum_shorthand(cond_val_id, cond_val, t.node_type(match_expr_id))
    }
    return t.transform_expr(cond_val_id)
}

// build_match_cond builds match cond data for transform.
fn (mut t Transformer) build_match_cond(match_expr_id flat.NodeId, branch flat.Node) flat.NodeId {
    n_conds := t.count_conds(branch)
    if n_conds == 1 {
        cond_val_id := t.a.child(&branch, 0)
        cond_val := t.a.nodes[int(cond_val_id)]
        if variant_name := t.match_type_pattern(cond_val_id) {
            is_start := t.a.children.len
            t.a.children << match_expr_id
            is_id := t.a.add_node(flat.Node{
                kind:           .is_expr
                value:          variant_name
                children_start: is_start
                children_count: 1
            })
            return t.transform_is_expr(is_id, t.a.nodes[int(is_id)])
        }
        if cond_val.kind == .range {
            return t.make_match_range(match_expr_id, cond_val_id)
        }
        return t.make_match_eq(match_expr_id, t.match_cond_value(match_expr_id, cond_val_id))
    }
    mut result := flat.empty_node
    for i in 0 .. n_conds {
        cond_val_id := t.a.child(&branch, i)
        cond_val := t.a.nodes[int(cond_val_id)]
        variant_name := t.match_type_pattern(cond_val_id) or { '' }
        cmp := if variant_name.len > 0 {
            is_start := t.a.children.len
            t.a.children << match_expr_id
            is_id := t.a.add_node(flat.Node{
                kind:           .is_expr
                value:          variant_name
                children_start: is_start
                children_count: 1
            })
            t.transform_is_expr(is_id, t.a.nodes[int(is_id)])
        } else if cond_val.kind == .range {
            t.make_match_range(match_expr_id, cond_val_id)
        } else {
            t.make_match_eq(match_expr_id, t.match_cond_value(match_expr_id, cond_val_id))
        }
        if int(result) < 0 {
            result = cmp
        } else {
            or_start := t.a.children.len
            t.a.children << result
            t.a.children << cmp
            result = t.a.add_node(flat.Node{
                kind:           .infix
                op:             .logical_or
                children_start: or_start
                children_count: 2
            })
        }
    }
    return result
}

// match_type_pattern supports match type pattern handling for Transformer.
fn (t &Transformer) match_type_pattern(cond_val_id flat.NodeId) ?string {
    if int(cond_val_id) < 0 {
        return none
    }
    pattern := t.type_pattern_name(cond_val_id)
    if pattern.len > 0 && t.is_sum_variant(pattern) {
        return pattern
    }
    return none
}

// match_branch_all_type_patterns supports match branch all type patterns handling for Transformer.
fn (t &Transformer) match_branch_all_type_patterns(branch flat.Node) bool {
    n_conds := t.count_conds(branch)
    if n_conds == 0 {
        return false
    }
    for i in 0 .. n_conds {
        cond_val_id := t.a.child(&branch, i)
        if _ := t.match_type_pattern(cond_val_id) {
            continue
        }
        return false
    }
    return true
}

// count_conds supports count conds handling for Transformer.
fn (t &Transformer) count_conds(branch flat.Node) int {
    if branch.value.len > 0 && branch.value != 'else' {
        if branch.value[0] >= `0` && branch.value[0] <= `9` {
            return branch.value.int()
        }
    }
    mut count := 0
    for i in 0 .. branch.children_count {
        child := t.a.child_node(&branch, i)
        if child.kind == .int_literal || child.kind == .ident || child.kind == .string_literal
            || child.kind == .enum_val || child.kind == .bool_literal || child.kind == .char_literal
            || child.kind == .selector || child.kind == .range || child.kind == .prefix {
            count++
        } else {
            break
        }
    }
    return count
}

// is_sum_variant reports whether is sum variant applies in transform.
pub fn (t &Transformer) is_sum_variant(name string) bool {
    short_name := t.variant_short_name(name)
    for _, variants in t.sum_types {
        for v in variants {
            short_v := t.variant_short_name(v)
            if v == name || short_v == short_name {
                return true
            }
        }
    }
    return false
}

// --- array append lowering (existing, will move to expr.v later) ---

// lower_array_appends builds lower array appends data for transform.
fn (mut t Transformer) lower_array_appends() {
    for i, node in t.a.nodes {
        if node.kind == .module_decl {
            t.cur_module = node.value
            continue
        }
        if node.kind == .fn_decl {
            t.reset_var_types()
            t.annotate_fn_body(node)
            continue
        }
        if node.kind == .decl_assign && node.children_count >= 2 {
            lhs := t.a.child_node(&node, 0)
            if lhs.kind == .ident && lhs.value.len > 0 {
                typ := t.infer_decl_type(node)
                if typ.len > 0 {
                    t.set_var_type(lhs.value, typ)
                }
            }
        }
        if node.kind == .expr_stmt && node.children_count == 1 {
            child_id := t.a.child(&node, 0)
            mut child := &t.a.nodes[int(child_id)]
            if child.kind == .infix && child.op == .left_shift {
                t.annotate_left_shift(child_id)
            }
        }
        if node.kind == .assign && node.op == .left_shift_assign && node.children_count >= 2 {
            lhs_id := t.a.child(&node, 0)
            lhs_type := t.lvalue_type(lhs_id)
            clean_lhs_type := t.clean_array_append_lhs_type(lhs_type)
            if clean_lhs_type.starts_with('[]') {
                rhs_id := t.a.child(&node, 1)
                rhs_type := t.lvalue_type(rhs_id)
                elem_type := clean_lhs_type[2..]
                val := if t.array_append_rhs_is_push_many(lhs_id, rhs_id, rhs_type, elem_type) {
                    'push_many'
                } else {
                    'push'
                }
                t.a.nodes[i] = flat.Node{
                    kind:           node.kind
                    op:             node.op
                    children_start: node.children_start
                    children_count: node.children_count
                    value:          val
                    typ:            elem_type
                }
            }
        }
    }
}

// annotate_fn_body supports annotate fn body handling for Transformer.
fn (mut t Transformer) annotate_fn_body(fn_node flat.Node) {
    for i in 0 .. fn_node.children_count {
        child_id := t.a.child(&fn_node, i)
        if int(child_id) < 0 {
            continue
        }
        child := t.a.nodes[int(child_id)]
        if child.kind == .param && child.value.len > 0 && child.typ.len > 0 {
            t.set_var_type(child.value, t.normalize_type_alias(child.typ))
        }
        if child.kind == .decl_assign && child.children_count >= 2 {
            lhs := t.a.child_node(&child, 0)
            if lhs.kind == .ident && lhs.value.len > 0 {
                typ := t.infer_decl_type(child)
                if typ.len > 0 {
                    t.set_var_type(lhs.value, typ)
                }
            }
        }
        if child.kind == .expr_stmt && child.children_count == 1 {
            inner_id := t.a.child(&child, 0)
            inner := t.a.nodes[int(inner_id)]
            if inner.kind == .infix && inner.op == .left_shift {
                t.annotate_left_shift(inner_id)
            }
        }
        t.annotate_block_stmts(child_id)
    }
}

// annotate_block_stmts supports annotate block stmts handling for Transformer.
fn (mut t Transformer) annotate_block_stmts(node_id flat.NodeId) {
    if int(node_id) < 0 {
        return
    }
    node := t.a.nodes[int(node_id)]
    for i in 0 .. node.children_count {
        child_id := t.a.child(&node, i)
        if int(child_id) < 0 {
            continue
        }
        child := t.a.nodes[int(child_id)]
        if child.kind == .decl_assign && child.children_count >= 2 {
            lhs := t.a.child_node(&child, 0)
            if lhs.kind == .ident && lhs.value.len > 0 {
                typ := t.infer_decl_type(child)
                if typ.len > 0 {
                    t.set_var_type(lhs.value, typ)
                }
            }
        }
        if child.kind == .expr_stmt && child.children_count == 1 {
            inner_id := t.a.child(&child, 0)
            inner := t.a.nodes[int(inner_id)]
            if inner.kind == .infix && inner.op == .left_shift {
                t.annotate_left_shift(inner_id)
            }
        }
        t.annotate_block_stmts(child_id)
    }
}

// annotate_left_shift supports annotate left shift handling for Transformer.
fn (mut t Transformer) annotate_left_shift(node_id flat.NodeId) {
    node := t.a.nodes[int(node_id)]
    if node.children_count < 2 {
        return
    }
    lhs_id := t.a.child(&node, 0)
    mut lhs_type := t.lvalue_type(lhs_id)
    if lhs_type == 'strings.Builder' || lhs_type == '&strings.Builder' || lhs_type == 'Builder'
        || lhs_type == '&Builder' {
        lhs_type = '[]u8'
    }
    clean_lhs_type := t.clean_array_append_lhs_type(lhs_type)
    if !clean_lhs_type.starts_with('[]') {
        return
    }
    rhs_id := t.a.child(&node, 1)
    rhs_type := t.lvalue_type(rhs_id)
    elem_type := clean_lhs_type[2..]
    if t.array_append_rhs_is_push_many(lhs_id, rhs_id, rhs_type, elem_type) {
        t.a.nodes[int(node_id)] = flat.Node{
            kind:           .infix
            op:             .left_shift
            children_start: node.children_start
            children_count: node.children_count
            value:          'push_many'
            typ:            elem_type
        }
    } else {
        t.a.nodes[int(node_id)] = flat.Node{
            kind:           .infix
            op:             .left_shift
            children_start: node.children_start
            children_count: node.children_count
            value:          'push'
            typ:            elem_type
        }
    }
}

// annotate_left_shift_assign supports annotate left shift assign handling for Transformer.
fn (mut t Transformer) annotate_left_shift_assign(node_id flat.NodeId) {
    node := t.a.nodes[int(node_id)]
    if node.kind != .assign || node.op != .left_shift_assign || node.children_count < 2 {
        return
    }
    lhs_id := t.a.child(&node, 0)
    lhs := t.a.nodes[int(lhs_id)]
    if lhs.kind != .ident {
        return
    }
    lhs_type := t.lvalue_type(lhs_id)
    clean_lhs_type := t.clean_array_append_lhs_type(lhs_type)
    if !clean_lhs_type.starts_with('[]') {
        return
    }
    rhs_id := t.a.child(&node, 1)
    rhs_type := t.lvalue_type(rhs_id)
    elem_type := clean_lhs_type[2..]
    val := if t.array_append_rhs_is_push_many(lhs_id, rhs_id, rhs_type, elem_type) {
        'push_many'
    } else {
        'push'
    }
    t.a.nodes[int(node_id)] = flat.Node{
        kind:           node.kind
        op:             node.op
        children_start: node.children_start
        children_count: node.children_count
        value:          val
        typ:            elem_type
    }
}

// --- public query helpers ---

// get_struct_info returns get struct info data for Transformer.
pub fn (t &Transformer) get_struct_info(name string) ?StructInfo {
    if info := t.structs[name] {
        return info
    }
    return none
}

// get_global_type returns get global type data for Transformer.
pub fn (t &Transformer) get_global_type(name string) ?string {
    if typ := t.globals[name] {
        return typ
    }
    return none
}