// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module transformer

import os
import strings
import time
import v2.ast
import v2.pref
import v2.token
import v2.types

const embed_file_helper_type_name = '__V2EmbedFileData'
const c_keywords = ['auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do', 'double',
    'else', 'enum', 'extern', 'float', 'for', 'goto', 'if', 'inline', 'int', 'long', 'register',
    'restrict', 'return', 'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef',
    'union', 'unsigned', 'void', 'volatile', 'while', '_Bool', '_Complex', '_Imaginary', 'unix',
    'linux']
const smartcast_search_limit = 128
const max_runtime_const_dep_expr_depth = 128

// Transformer performs AST-level transformations to simplify
// and normalize code before codegen. This avoids duplicating
// transformation logic across multiple backends (SSA, cleanc, etc.)
pub struct Transformer {
mut:
    pref &pref.Preferences = unsafe { nil }
    env  &types.Environment
    // flat_fb_counts tracks how often each cursor-transform arm falls back to
    // a legacy decode, keyed by arm name. Dumped via V2_FLAT_FB_STATS to
    // prioritize the remaining flat-native migration work.
    flat_fb_counts map[string]int
    // pending_flat_stmt_ids queues already-emitted flat stmt ids that
    // cursor-native arms hoist ahead of the statement being transformed —
    // the flat-side twin of `pending_stmts`. Hoisting arms must first flush
    // `pending_stmts` into this queue so the combined drain keeps the legacy
    // chronological order.
    pending_flat_stmt_ids []ast.FlatNodeId
    // Current scope for type lookups (walks up scope chain)
    scope &types.Scope = unsafe { nil }
    // Function root scope for registering transformer-created temp variables
    // This allows cleanc to look up temp variable types from the environment
    fn_root_scope &types.Scope = unsafe { nil }
    // Current module for scope lookups
    cur_module string
    // Temp variable counter for desugaring
    temp_counter int
    // Counter for synthesized positions (uses negative values to avoid collision)
    synth_pos_counter int = -1
    // Track needed auto-generated str functions (type_name -> elem_type for arrays)
    needed_str_fns map[string]string
    // Track needed auto-generated clone functions (fn_name -> struct_name)
    needed_clone_fns map[string]string
    // Track needed auto-generated array helper functions
    needed_array_contains_fns   map[string]ArrayMethodInfo
    needed_array_index_fns      map[string]ArrayMethodInfo
    needed_array_last_index_fns map[string]ArrayMethodInfo
    // Current function's return type name (for sum type wrapping in returns)
    cur_fn_ret_type_name string
    // Current function's concrete sum type return wrapper, when known from
    // the declared return type.
    cur_fn_return_sumtype_info ConcreteSumtypeWrapInfo
    // Tracks whether the current function returns Option/Result.
    // Some transformations use this to avoid wrapping plain sumtype returns.
    cur_fn_returns_option bool
    cur_fn_returns_result bool
    // When set, match branch values should be wrapped in this sum type
    // (used when a match expression is returned from a function with sum type return)
    sumtype_return_wrap string
    // When true, the last expression in each match branch is transformed as a
    // value. This is needed while expanding `return match`, before branch-local
    // returns are inserted.
    preserve_match_branch_value bool
    // Smart cast context stack - supports nested smart casts
    smartcast_stack       []SmartcastContext
    smartcast_expr_counts map[string]int
    // Functions that should be elided (conditional compilation, e.g. @[if verbose ?])
    elided_fns map[string]bool
    // Runtime const initializers grouped by module, preserving module discovery order.
    runtime_const_inits_by_mod  map[string][]RuntimeConstInit
    runtime_const_modules       []string
    runtime_const_init_fn_name  map[string]string
    runtime_const_known         map[string]bool
    runtime_const_storage_known map[string]bool
    // Resolved replacement for compile-time pseudo variable @VMODROOT.
    comptime_vmodroot string
    // Statements generated by expression-level expansions (e.g. filter/map)
    // that must be hoisted before the current statement in transform_stmts.
    pending_stmts []ast.Stmt
    // When true, skip lowering value-position IfExpr to temp variable.
    // Set during contexts that already handle IfExpr RHS (e.g. decl_assign).
    skip_if_value_lowering bool
    // For native backends: map interface variable names to their concrete type names.
    // When we see `shape1 := Shape(rect)`, record shape1 → "Rectangle".
    // Used to rewrite interface method calls to direct concrete calls.
    interface_concrete_types map[string]string
    // Track needed auto-generated sort comparator functions
    needed_sort_fns     map[string]SortComparatorInfo
    needed_enum_str_fns map[string]types.Enum
    // Track needed go wrapper functions (go call -> goroutine_create lowering)
    needed_go_wrappers map[string]GoWrapperInfo
    // Declared storage types for local variables in the current function.
    // These stay separate from checker/current expression types, which can be
    // narrowed by smartcasts while the variable is still stored as its declared type.
    local_decl_types                map[string]types.Type
    local_fn_pointer_return_types   map[string]types.Type
    local_receiver_generic_bindings map[string]map[string]types.Type
    // Track whether post-pass should inject the synthetic embed_file helper type.
    needed_embed_file_helper bool
    // Override array element types for variables whose checker-inferred type is wrong
    // (e.g. .map(fn_name) typed as []voidptr instead of []ReturnType)
    array_elem_type_overrides map[string]string
    // File set for resolving positions to line numbers (for assert messages)
    file_set &token.FileSet = unsafe { nil }
    // Current file and function name (for assert messages)
    cur_file_name                 string
    cur_fn_name_str               string
    cur_fn_recv_prefix            string // C prefix for current method's receiver type (e.g., "ui__Window")
    cur_fn_recv_param             string // Receiver parameter name (e.g., "w")
    cur_fn_recv_is_ptr            bool   // Receiver is passed as a C pointer in the current method
    cur_fn_generic_params         []string
    generic_var_type_params       map[string]string
    generic_fn_decl_names         map[string]bool
    generic_fn_decl_stmts         map[string][]ast.Stmt
    generic_fn_decl_body_cursors  map[string]ast.CursorList
    generic_fn_decl_index         map[string]ast.FnDecl
    generic_call_candidate_names  map[string]bool
    generic_fn_value_names        map[string]bool
    declared_method_fns           map[string]bool
    monomorphized_fn_bindings     map[string]map[string]types.Type
    cur_monomorphized_fn_bindings map[string]types.Type
    // @[live] hot code reloading: function names and source file
    live_fns         []LiveFn
    live_source_file string
    // Cached scope/method/fn_scope snapshots for lock-free parallel access.
    // Populated once in pre_pass from the shared Environment fields.
    cached_scopes               map[string]&types.Scope
    cached_scope_keys           []string
    cached_methods              map[string][]&types.Fn
    cached_method_keys          []string
    cached_fn_scopes            map[string]&types.Scope
    cached_fn_type_index        map[string]types.Type
    cached_fn_return_type_index map[string]types.Type
    cached_struct_field_types   map[string]types.Type
    // cached_method_base_index maps type_name -> generic-base method name ->
    // FnType, precomputed once from cached_methods. lookup_method_cached used to
    // linearly scan every method of a type and recompute its base name (via
    // generic_base_name_without_specialization) on every call site — O(calls x
    // methods) with a string scan inner loop, the single biggest transform cost.
    // This makes the lookup O(1). Flat map keyed by "type_name#base_name" -> the
    // types.Type sum (callers smartcast to FnType). Flat (not nested) so a lookup
    // doesn't copy an inner map, and stored as the sum (not the FnType variant)
    // because v2's own codegen mishandles a map valued by a bare sum-variant.
    cached_method_base_index map[string]types.Type
    // cached_method_keys_by_short buckets cached_method_keys by their short
    // (final `__`-segment) name. The fuzzy method-key fallback loops only ever
    // match a key whose short name equals the receiver's short name, so they can
    // scan just this bucket instead of every method key (O(all_keys) per call).
    cached_method_keys_by_short map[string][]string
    // cached_imported_module_scopes maps a module name -> the scopes of the
    // modules it imports (excluding self/C). lookup_imported_var_type used to
    // rebuild this set on every identifier lookup — objects.keys() + sort() +
    // a full scan of the module's symbol table for Module objects — which made
    // it one of the hottest functions during type propagation (O(idents x
    // objects) with a per-call sort). Precomputed once in cache_env_maps so the
    // lookup is a single map fetch plus a short scan over only the imports.
    cached_imported_module_scopes map[string][]&types.Scope
    // Accumulated synth types for deferred application (thread-safe).
    // Instead of writing directly to env.set_expr_type during parallel transform,
    // store here and apply after merge.
    synth_types map[int]types.Type
    // Generic monomorphization clones generic FnDecls per env.generic_types
    // binding before code generation, so backends receive concrete functions.
    monomorphized_specs map[string]bool
    // inject_changed_files records whether the last
    // inject_generic_struct_specializations call actually appended new struct
    // specializations (i.e. returned a modified file set). The monomorphize
    // fixpoint uses it to skip the next iteration's full-program collect scan
    // when nothing changed.
    inject_changed_files bool
    // last_mono_clones maps file index -> the FnDecl clone stmts that the most
    // recent monomorphize_pass appended to that file. The fixpoint rescans only
    // these freshly-materialized clones (the rest of the program was already
    // scanned) instead of re-walking all files. Empty when mono_pass added none.
    last_mono_clones                   map[int][]ast.Stmt
    last_struct_clones                 map[int][]ast.Stmt
    generic_spec_owner_file            map[string]int
    deferred_generic_call_specs        []DeferredGenericCallSpec
    generic_struct_specs               map[string]GenericStructSpec
    struct_field_generic_decl_types    map[string]types.Type
    struct_field_generic_decl_bindings map[string]map[string]types.Type
    struct_default_decl_infos          map[string]StructDefaultDeclInfo
    concrete_embedded_owner_names      map[string]map[string]string
    cur_generic_call_file_idx          int = -1
    cur_import_aliases                 map[string]string
    sum_type_decl_variant_names        map[string][]string
    // Cached at construction: avoids per-block t.pref nil/enum re-check in
    // hot loops (transform_stmts, IfGuardExpr handling, OrExpr expansion, etc).
    is_native_be               bool
    macos_tiny_candidate_graph bool
}

fn escape_c_keyword(name string) string {
    n := if name.len > 0 && name[0] == `@` { name[1..] } else { name }
    if n in c_keywords {
        return '_${n}'
    }
    return n
}

fn enum_member_ident(enum_type string, field_name string) string {
    escaped := if field_name.len > 0 && field_name[0] == `@` {
        'at_${field_name[1..]}'
    } else {
        escape_c_keyword(field_name)
    }
    return '${enum_type}__${escaped}'
}

fn (t &Transformer) enum_type_c_name_for_lookup(lookup_name string, typ types.Enum) string {
    if dunder := lookup_name.index('__') {
        mod_name := lookup_name[..dunder]
        last_dunder := lookup_name.last_index('__') or { dunder }
        if last_dunder >= 0 && last_dunder + 2 < lookup_name.len {
            type_name := lookup_name[last_dunder + 2..]
            if scope := t.get_module_scope(mod_name) {
                if direct_typ := scope.lookup_type(type_name) {
                    if direct_typ is types.Enum {
                        return lookup_name
                    }
                }
            }
        }
    }
    if dot := lookup_name.last_index('.') {
        mod_name := lookup_name[..dot]
        type_name := lookup_name[dot + 1..]
        if scope := t.get_module_scope(mod_name) {
            if direct_typ := scope.lookup_type(type_name) {
                if direct_typ is types.Enum {
                    return lookup_name.replace('.', '__')
                }
            }
        }
    }
    if typ.name != '' {
        return t.type_to_c_name(types.Type(typ))
    }
    return lookup_name.replace('.', '__')
}

fn (t &Transformer) enum_member_ident_for_lookup(lookup_name string, typ types.Enum, field_name string) string {
    return enum_member_ident(t.enum_type_c_name_for_lookup(lookup_name, typ), field_name)
}

fn (t &Transformer) skip_native_backend_transform_file(file ast.File) bool {
    if t.pref == unsafe { nil } {
        return false
    }
    own := match t.pref.backend {
        .arm64 { 'arm64' }
        .x64 { 'x64' }
        else { return false }
    }

    if !t.pref.single_backend && own != 'arm64' {
        return false
    }

    name := file.name.replace('\\', '/')
    if !name.contains('/v2/gen/') {
        return false
    }
    for backend_mod in ['cleanc', 'eval', 'v', 'c', 'x64', 'arm64'] {
        if backend_mod != own && name.contains('/v2/gen/${backend_mod}/') {
            return true
        }
    }
    return false
}

struct LiveFn {
    decl_name    string // e.g., 'frame' or 'update_model'
    mangled_name string // e.g., 'frame' or 'Game__update_model'
    is_method    bool
    recv_type    string // e.g., 'Game' (empty for non-methods)
}

// SmartcastContext holds info about a single smartcast
struct SmartcastContext {
    expr         string // The expression being smart-cast (e.g., "w.valera")
    variant      string // The variant type name for union member access (e.g., "int", "Kek", "Array_Attribute")
    variant_full string // The full variant name for type casts (e.g., "ast__Kek", "Array_ast__Attribute")
    sumtype      string // The sum type name (e.g., "Valera")
}

struct ArrayMethodInfo {
    array_type string
    elem_type  string
    is_fixed   bool
    fixed_len  int
}

// GoWrapperInfo tracks information needed to synthesize a go-wrapper function.
// For `go foo(a, b)`, we generate a wrapper that packs args and calls
// goroutines__goroutine_create, and a trampoline that unpacks args and calls foo.
struct GoWrapperInfo {
    fn_name      string   // C-mangled function name (e.g. "main__foo")
    wrapper_name string   // Wrapper function name (e.g. "__go_wrap_main__foo")
    param_names  []string // Parameter names
    param_types  []string // Parameter C type names
}

fn builder_write_string_stmt(sb_ref ast.Expr, s ast.Expr) ast.Stmt {
    return ast.Stmt(ast.ExprStmt{
        expr: ast.Expr(ast.CallExpr{
            lhs:  ast.Expr(ast.Ident{
                name: 'strings__Builder__write_string'
            })
            args: [sb_ref, s]
        })
    })
}

struct RuntimeConstInit {
    name        string
    expr        ast.Expr
    expr_cursor ast.Cursor
}

struct SortComparatorInfo {
    elem_type  string      // C type name of array element
    compare_op token.Token // .lt or .gt for the original comparison
    // For field access: a.field < b.field
    field_name string // empty for simple element comparison
    field_path []string
    // For index access: a[0] < b[0]
    index_expr string // empty for non-index comparison, e.g. "0"
    // Whether the comparison value type is string (needs string__lt)
    is_string_cmp bool
}

pub fn Transformer.new_with_pref(env &types.Environment, p &pref.Preferences) &Transformer {
    mut t := new_transformer_base(env, p)
    if p != unsafe { nil } && p.vroot.len > 0 {
        t.comptime_vmodroot = p.vroot
        return t
    }
    cwd := os.getwd()
    if root := detect_vmodroot_from_path(cwd) {
        t.comptime_vmodroot = root
    }
    return t
}

fn new_transformer_base(env &types.Environment, p &pref.Preferences) &Transformer {
    mut t := &Transformer{
        pref:                               unsafe { p }
        env:                                unsafe { env }
        needed_str_fns:                     map[string]string{}
        needed_clone_fns:                   map[string]string{}
        needed_array_contains_fns:          map[string]ArrayMethodInfo{}
        needed_array_index_fns:             map[string]ArrayMethodInfo{}
        needed_array_last_index_fns:        map[string]ArrayMethodInfo{}
        needed_sort_fns:                    map[string]SortComparatorInfo{}
        needed_enum_str_fns:                map[string]types.Enum{}
        needed_go_wrappers:                 map[string]GoWrapperInfo{}
        local_decl_types:                   map[string]types.Type{}
        local_fn_pointer_return_types:      map[string]types.Type{}
        local_receiver_generic_bindings:    map[string]map[string]types.Type{}
        generic_var_type_params:            map[string]string{}
        generic_fn_decl_names:              map[string]bool{}
        generic_fn_decl_stmts:              map[string][]ast.Stmt{}
        generic_fn_decl_body_cursors:       map[string]ast.CursorList{}
        generic_fn_decl_index:              map[string]ast.FnDecl{}
        generic_call_candidate_names:       map[string]bool{}
        generic_fn_value_names:             map[string]bool{}
        declared_method_fns:                map[string]bool{}
        monomorphized_fn_bindings:          map[string]map[string]types.Type{}
        cur_monomorphized_fn_bindings:      map[string]types.Type{}
        runtime_const_inits_by_mod:         map[string][]RuntimeConstInit{}
        runtime_const_init_fn_name:         map[string]string{}
        runtime_const_known:                map[string]bool{}
        runtime_const_storage_known:        map[string]bool{}
        interface_concrete_types:           map[string]string{}
        smartcast_expr_counts:              map[string]int{}
        monomorphized_specs:                map[string]bool{}
        generic_spec_owner_file:            map[string]int{}
        deferred_generic_call_specs:        []DeferredGenericCallSpec{}
        generic_struct_specs:               map[string]GenericStructSpec{}
        struct_field_generic_decl_types:    map[string]types.Type{}
        struct_field_generic_decl_bindings: map[string]map[string]types.Type{}
        struct_default_decl_infos:          map[string]StructDefaultDeclInfo{}
        concrete_embedded_owner_names:      map[string]map[string]string{}
        cur_import_aliases:                 map[string]string{}
        sum_type_decl_variant_names:        map[string][]string{}
        is_native_be:                       p != unsafe { nil }
            && (p.backend == .arm64 || p.backend == .x64)
    }
    return t
}

pub fn (mut t Transformer) set_file_set(fs &token.FileSet) {
    t.file_set = unsafe { fs }
}

pub fn (mut t Transformer) enable_macos_tiny_candidate_graph() {
    t.macos_tiny_candidate_graph = true
}

// new_worker_clone creates a lightweight Transformer that shares read-only state
// (env, pref, elided_fns, comptime_vmodroot, file_set) but has its own
// accumulator maps for thread-safe per-file transformation.
// worker_idx offsets synth_pos_counter so workers don't generate conflicting IDs
// or collide with synth positions already created during whole-program prepare.
pub fn (t &Transformer) new_worker_clone(worker_idx int) &Transformer {
    return &Transformer{
        pref:                               unsafe { t.pref }
        env:                                unsafe { t.env }
        elided_fns:                         t.elided_fns.clone()
        comptime_vmodroot:                  t.comptime_vmodroot
        file_set:                           unsafe { t.file_set }
        cached_scopes:                      t.cached_scopes.clone()
        cached_scope_keys:                  t.cached_scope_keys
        cached_methods:                     t.cached_methods
        cached_fn_type_index:               t.cached_fn_type_index
        cached_fn_return_type_index:        t.cached_fn_return_type_index
        cached_imported_module_scopes:      t.cached_imported_module_scopes
        cached_struct_field_types:          t.cached_struct_field_types
        cached_method_base_index:           t.cached_method_base_index
        cached_method_keys_by_short:        t.cached_method_keys_by_short
        cached_method_keys:                 t.cached_method_keys
        cached_fn_scopes:                   t.cached_fn_scopes.clone()
        synth_types:                        t.synth_types.clone()
        synth_pos_counter:                  t.synth_pos_counter - (worker_idx * 100_000)
        needed_str_fns:                     map[string]string{}
        needed_clone_fns:                   map[string]string{}
        needed_array_contains_fns:          map[string]ArrayMethodInfo{}
        needed_array_index_fns:             map[string]ArrayMethodInfo{}
        needed_array_last_index_fns:        map[string]ArrayMethodInfo{}
        needed_sort_fns:                    map[string]SortComparatorInfo{}
        needed_enum_str_fns:                map[string]types.Enum{}
        needed_go_wrappers:                 map[string]GoWrapperInfo{}
        local_decl_types:                   map[string]types.Type{}
        local_fn_pointer_return_types:      map[string]types.Type{}
        local_receiver_generic_bindings:    map[string]map[string]types.Type{}
        generic_var_type_params:            map[string]string{}
        generic_fn_decl_body_cursors:       t.generic_fn_decl_body_cursors.clone()
        generic_fn_decl_index:              t.generic_fn_decl_index.clone()
        generic_call_candidate_names:       t.generic_call_candidate_names.clone()
        generic_fn_value_names:             t.generic_fn_value_names.clone()
        declared_method_fns:                t.declared_method_fns.clone()
        monomorphized_fn_bindings:          t.monomorphized_fn_bindings.clone()
        cur_monomorphized_fn_bindings:      map[string]types.Type{}
        runtime_const_inits_by_mod:         map[string][]RuntimeConstInit{}
        runtime_const_init_fn_name:         map[string]string{}
        runtime_const_known:                map[string]bool{}
        runtime_const_storage_known:        map[string]bool{}
        interface_concrete_types:           map[string]string{}
        smartcast_expr_counts:              map[string]int{}
        monomorphized_specs:                t.monomorphized_specs.clone()
        generic_spec_owner_file:            t.generic_spec_owner_file.clone()
        deferred_generic_call_specs:        []DeferredGenericCallSpec{}
        generic_struct_specs:               t.generic_struct_specs.clone()
        struct_field_generic_decl_types:    t.struct_field_generic_decl_types.clone()
        struct_field_generic_decl_bindings: t.struct_field_generic_decl_bindings.clone()
        struct_default_decl_infos:          t.struct_default_decl_infos.clone()
        concrete_embedded_owner_names:      t.concrete_embedded_owner_names.clone()
        cur_generic_call_file_idx:          t.cur_generic_call_file_idx
        cur_import_aliases:                 t.cur_import_aliases.clone()
        sum_type_decl_variant_names:        t.sum_type_decl_variant_names.clone()
        is_native_be:                       t.is_native_be
        macos_tiny_candidate_graph:         t.macos_tiny_candidate_graph
    }
}

// merge_worker merges accumulated state from a worker transformer into this one.
pub fn (mut t Transformer) merge_worker(w &Transformer) {
    for k, v in w.needed_str_fns {
        t.needed_str_fns[k] = v
    }
    for k, v in w.needed_clone_fns {
        t.needed_clone_fns[k] = v
    }
    for k, v in w.needed_array_contains_fns {
        t.needed_array_contains_fns[k] = v
    }
    for k, v in w.needed_array_index_fns {
        t.needed_array_index_fns[k] = v
    }
    for k, v in w.needed_array_last_index_fns {
        t.needed_array_last_index_fns[k] = v
    }
    for k, v in w.needed_sort_fns {
        t.needed_sort_fns[k] = v
    }
    for k, v in w.needed_enum_str_fns {
        t.needed_enum_str_fns[k] = v
    }
    for k, v in w.needed_go_wrappers {
        t.needed_go_wrappers[k] = v
    }
    for k, v in w.elided_fns {
        t.elided_fns[k] = v
    }
    if w.needed_embed_file_helper {
        t.needed_embed_file_helper = true
    }
    for k, v in w.interface_concrete_types {
        t.interface_concrete_types[k] = v
    }
    for k, v in w.array_elem_type_overrides {
        t.array_elem_type_overrides[k] = v
    }
    for lf in w.live_fns {
        t.live_fns << lf
    }
    if w.live_source_file.len > 0 {
        t.live_source_file = w.live_source_file
    }
    for k, v in w.cached_fn_scopes {
        t.cached_fn_scopes[k] = v
    }
    for k, v in w.synth_types {
        t.synth_types[k] = v
    }
}

// transform_file_standalone transforms a single file, for use in parallel workers.
pub fn (mut t Transformer) transform_file_pub(file ast.File) ast.File {
    return t.transform_file(file)
}

// transform_file_stmt_pub transforms one top-level statement in a file context,
// for use by the declaration-level parallel transformer.
pub fn (mut t Transformer) transform_file_stmt_pub(file ast.File, stmt ast.Stmt) []ast.Stmt {
    t.enter_file_context(file)
    return t.transform_stmts([stmt])
}

fn (mut t Transformer) enter_file_context(file ast.File) {
    // Set current file name for assert messages
    t.cur_file_name = file.name
    // Set current module for scope lookups
    t.cur_module = file.mod
    t.cur_import_aliases = import_aliases_for_generic_collect(file.imports)
    // Set module scope as starting point
    if scope := t.get_module_scope(file.mod) {
        t.scope = scope
    } else {
        t.scope = unsafe { nil }
    }
}

fn detect_vmodroot_from_path(path string) ?string {
    if path.len == 0 {
        return none
    }
    mut dir := path
    if !os.is_abs_path(dir) {
        cwd := os.getwd()
        if cwd.len > 0 {
            dir = os.join_path(cwd, dir)
        }
    }
    if !os.is_dir(dir) {
        dir = os.dir(dir)
    }
    for _ in 0 .. 16 {
        if os.is_file(os.join_path(dir, 'v.mod')) {
            return dir
        }
        parent := os.dir(dir)
        if parent == dir {
            break
        }
        dir = parent
    }
    return none
}

fn (t &Transformer) is_eval_backend() bool {
    return t.pref != unsafe { nil } && t.pref.backend == .eval
}

fn quote_v_string_literal(raw string) string {
    mut escaped := raw.replace('\\', '\\\\')
    escaped = escaped.replace("'", "\\'")
    return "'${escaped}'"
}

fn quote_v_bytes_literal(raw []u8) string {
    hex_digits := '0123456789abcdef'
    mut sb := strings.new_builder(raw.len * 4 + 2)
    sb.write_u8(`'`)
    for b in raw {
        if b >= ` ` && b <= `~` && b !in [`\\`, `'`] {
            sb.write_u8(b)
            continue
        }
        match b {
            `\n` {
                sb.write_string('\\n')
            }
            `\r` {
                sb.write_string('\\r')
            }
            `\t` {
                sb.write_string('\\t')
            }
            `\\` {
                sb.write_string('\\\\')
            }
            `'` {
                sb.write_string("\\'")
            }
            else {
                sb.write_string('\\x')
                sb.write_u8(hex_digits[b >> 4])
                sb.write_u8(hex_digits[b & 0x0f])
            }
        }
    }
    sb.write_u8(`'`)
    return sb.str()
}

fn embed_file_helper_type_expr(pos token.Pos) ast.Expr {
    return ast.Expr(ast.Ident{
        name: embed_file_helper_type_name
        pos:  pos
    })
}

fn is_embed_file_helper_type(typ types.Type) bool {
    return typ.name() == embed_file_helper_type_name
}

fn (t &Transformer) vmodroot_string_literal(pos token.Pos) ast.StringLiteral {
    return ast.StringLiteral{
        kind:  .v
        value: quote_v_string_literal(t.comptime_vmodroot)
        pos:   pos
    }
}

fn embed_file_string_arg(expr ast.Expr) ?string {
    match expr {
        ast.StringLiteral {
            if expr.value.len >= 2 {
                return expr.value[1..expr.value.len - 1]
            }
            return ''
        }
        ast.BasicLiteral {
            if expr.kind == .string {
                if expr.value.len >= 2 {
                    return expr.value[1..expr.value.len - 1]
                }
                return ''
            }
            return none
        }
        else {
            return none
        }
    }
}

fn (mut t Transformer) current_file_path(pos token.Pos) string {
    if !pos.is_valid() || t.file_set == unsafe { nil } {
        return t.cur_file_name
    }
    file := t.file_set.file(pos)
    position := file.position(pos)
    return position.filename
}

fn (mut t Transformer) resolve_embed_file_paths(raw_path string, pos token.Pos) (string, string) {
    mut rel_path := raw_path
    if rel_path.contains('@VMODROOT') {
        rel_path = rel_path.replace('@VMODROOT', t.comptime_vmodroot)
    }
    if rel_path.contains('@VEXEROOT') {
        mut vexeroot := ''
        if os.args.len > 0 && os.args[0].len > 0 {
            vexeroot = os.dir(os.real_path(os.args[0]))
        }
        if vexeroot == '' && t.pref != unsafe { nil } && t.pref.vroot.len > 0 {
            vexeroot = os.join_path(t.pref.vroot, 'cmd', 'v2')
        }
        if vexeroot != '' {
            rel_path = rel_path.replace('@VEXEROOT', vexeroot)
        }
    }
    if os.is_abs_path(rel_path) {
        return raw_path, os.real_path(rel_path)
    }
    source_path := t.current_file_path(pos)
    base_dir := if source_path != '' { os.dir(source_path) } else { os.getwd() }
    return raw_path, os.real_path(os.join_path_single(base_dir, rel_path))
}

// embed_file_init_parts is the side-effecting prologue of
// `transform_embed_file_comptime_expr` — resolves the raw path argument,
// reads the file bytes from disk, and sets `needed_embed_file_helper`.
// Returns `(rpath, apath, file_bytes)` on success, none on zero-arg /
// non-string-literal arg (the legacy returns the unchanged ComptimeExpr in
// that case). Extracted so the legacy helper and the flat-write direct-emit
// port (`transform_embed_file_comptime_expr_to_flat`) share the same I/O and
// state-mutation prologue — same template as sessions 4, 59, 60.
fn (mut t Transformer) embed_file_init_parts(expr ast.ComptimeExpr, args []ast.Expr) ?(string, string, []u8) {
    if args.len == 0 {
        return none
    }
    raw_path := embed_file_string_arg(args[0]) or { return none }
    return t.embed_file_init_parts_from_raw(raw_path, expr.pos)
}

fn (mut t Transformer) embed_file_init_parts_from_raw(raw_path string, pos token.Pos) (string, string, []u8) {
    rpath, apath := t.resolve_embed_file_paths(raw_path, pos)
    file_bytes := os.read_bytes(apath) or { panic('embed_file: failed to read `${apath}`: ${err}') }
    t.needed_embed_file_helper = true
    return rpath, apath, file_bytes
}

fn (mut t Transformer) transform_embed_file_comptime_expr(expr ast.ComptimeExpr, args []ast.Expr) ast.Expr {
    rpath, apath, file_bytes := t.embed_file_init_parts(expr, args) or { return expr }
    return ast.InitExpr{
        typ:    embed_file_helper_type_expr(expr.pos)
        fields: [
            ast.FieldInit{
                name:  '_data'
                value: ast.Expr(ast.StringLiteral{
                    kind:  .v
                    value: quote_v_bytes_literal(file_bytes)
                    pos:   expr.pos
                })
            },
            ast.FieldInit{
                name:  'len'
                value: ast.Expr(ast.BasicLiteral{
                    kind:  .number
                    value: file_bytes.len.str()
                    pos:   expr.pos
                })
            },
            ast.FieldInit{
                name:  'path'
                value: ast.Expr(ast.StringLiteral{
                    kind:  .v
                    value: quote_v_string_literal(rpath)
                    pos:   expr.pos
                })
            },
            ast.FieldInit{
                name:  'apath'
                value: ast.Expr(ast.StringLiteral{
                    kind:  .v
                    value: quote_v_string_literal(apath)
                    pos:   expr.pos
                })
            },
        ]
        pos:    expr.pos
    }
}

// push_smartcast adds a new smartcast context to the stack
fn (mut t Transformer) push_smartcast(expr string, variant string, sumtype string) {
    if expr == '' {
        return
    }
    qualified_sumtype := t.qualify_type_name(sumtype)
    t.push_smartcast_ctx(SmartcastContext{
        expr:         expr
        variant:      variant
        variant_full: variant // Default to same as variant
        sumtype:      qualified_sumtype
    })
}

// push_smartcast_full adds a smartcast context with separate short and full variant names
fn (mut t Transformer) push_smartcast_full(expr string, variant string, variant_full string, sumtype string) {
    if expr == '' {
        return
    }
    // Qualify the sumtype name so apply_smartcast_* can determine the module
    // the sumtype lives in. e.g. 'Stmt' → 'ast__Stmt' when in builder module.
    qualified_sumtype := t.qualify_type_name(sumtype)
    t.push_smartcast_ctx(SmartcastContext{
        expr:         expr
        variant:      variant
        variant_full: variant_full
        sumtype:      qualified_sumtype
    })
}

fn (mut t Transformer) push_smartcast_ctx(ctx SmartcastContext) {
    if ctx.expr == '' {
        return
    }
    t.smartcast_stack << ctx
    t.smartcast_expr_counts[ctx.expr] = t.smartcast_expr_counts[ctx.expr] + 1
}

fn (mut t Transformer) dec_smartcast_expr_count(expr string) {
    if expr == '' {
        return
    }
    count := t.smartcast_expr_counts[expr]
    if count <= 1 {
        t.smartcast_expr_counts.delete(expr)
    } else {
        t.smartcast_expr_counts[expr] = count - 1
    }
}

// pop_smartcast removes the most recent smartcast context from the stack
fn (mut t Transformer) pop_smartcast() {
    if t.smartcast_stack.len > 0 {
        ctx := t.smartcast_stack[t.smartcast_stack.len - 1]
        t.smartcast_stack = t.smartcast_stack[..t.smartcast_stack.len - 1]
        t.dec_smartcast_expr_count(ctx.expr)
    }
}

fn (mut t Transformer) truncate_smartcasts(depth int) {
    for t.smartcast_stack.len > depth {
        t.pop_smartcast()
    }
}

// SmartcastRemoveResult holds the removed context and its original index
struct SmartcastRemoveResult {
    ctx SmartcastContext
    idx int
}

// remove_smartcast_for_expr removes the smartcast context for a specific expression
// Returns the removed context or none if not found
fn (mut t Transformer) remove_smartcast_for_expr(expr_str string) ?SmartcastContext {
    if result := t.remove_smartcast_for_expr_with_idx(expr_str) {
        return result.ctx
    }
    return none
}

// remove_smartcast_for_expr_with_idx removes the smartcast context and returns both context and original index
fn (mut t Transformer) remove_smartcast_for_expr_with_idx(expr_str string) ?SmartcastRemoveResult {
    if expr_str == '' {
        return none
    }
    if t.smartcast_expr_counts[expr_str] == 0 {
        return none
    }
    mut i := t.smartcast_stack.len
    mut searched := 0
    for i > 0 && searched < smartcast_search_limit {
        i--
        searched++
        if t.smartcast_stack[i].expr == expr_str {
            ctx := t.smartcast_stack[i]
            // Remove this specific context by creating new slice without this element
            mut new_stack := []SmartcastContext{cap: t.smartcast_stack.len - 1}
            for j, c in t.smartcast_stack {
                if j != i {
                    new_stack << c
                }
            }
            t.smartcast_stack = new_stack
            t.dec_smartcast_expr_count(ctx.expr)
            return SmartcastRemoveResult{
                ctx: ctx
                idx: i
            }
        }
    }
    return none
}

// remove_smartcast_ctx_with_idx removes a specific smartcast context and returns
// the removed context with its original index.
fn (mut t Transformer) remove_smartcast_ctx_with_idx(ctx SmartcastContext) ?SmartcastRemoveResult {
    mut i := t.smartcast_stack.len
    mut searched := 0
    for i > 0 && searched < smartcast_search_limit {
        i--
        searched++
        cur := t.smartcast_stack[i]
        if cur.expr == ctx.expr && cur.variant == ctx.variant
            && cur.variant_full == ctx.variant_full {
            removed := cur
            mut new_stack := []SmartcastContext{cap: t.smartcast_stack.len - 1}
            for j, c in t.smartcast_stack {
                if j != i {
                    new_stack << c
                }
            }
            t.smartcast_stack = new_stack
            t.dec_smartcast_expr_count(removed.expr)
            return SmartcastRemoveResult{
                ctx: removed
                idx: i
            }
        }
    }
    return none
}

// remove_matching_smartcasts temporarily removes all exact copies of ctx.
fn (mut t Transformer) remove_matching_smartcasts(ctx SmartcastContext) []SmartcastRemoveResult {
    mut removed := []SmartcastRemoveResult{}
    if ctx.expr == '' || t.smartcast_stack.len == 0 {
        return removed
    }
    start := if t.smartcast_stack.len > smartcast_search_limit {
        t.smartcast_stack.len - smartcast_search_limit
    } else {
        0
    }
    mut new_stack := []SmartcastContext{cap: t.smartcast_stack.len}
    for i, cur in t.smartcast_stack {
        if i >= start && cur.expr == ctx.expr && cur.variant == ctx.variant
            && cur.variant_full == ctx.variant_full {
            removed << SmartcastRemoveResult{
                ctx: cur
                idx: i
            }
            t.dec_smartcast_expr_count(cur.expr)
            continue
        }
        new_stack << cur
    }
    t.smartcast_stack = new_stack
    return removed
}

// restore_smartcasts restores previously removed contexts in original order.
fn (mut t Transformer) restore_smartcasts(removed []SmartcastRemoveResult) {
    mut i := removed.len
    for i > 0 {
        i--
        entry := removed[i]
        t.insert_smartcast_at(entry.idx, entry.ctx)
    }
}

// insert_smartcast_at inserts a smartcast context at a specific position
fn (mut t Transformer) insert_smartcast_at(idx int, ctx SmartcastContext) {
    if ctx.expr == '' {
        return
    }
    if idx >= t.smartcast_stack.len {
        // Append at end
        t.smartcast_stack << ctx
        t.smartcast_expr_counts[ctx.expr] = t.smartcast_expr_counts[ctx.expr] + 1
    } else {
        // Insert at position
        mut new_stack := []SmartcastContext{cap: t.smartcast_stack.len + 1}
        for i, c in t.smartcast_stack {
            if i == idx {
                new_stack << ctx
            }
            new_stack << c
        }
        // If idx was 0 and loop didn't add, add at beginning
        if idx == 0 && new_stack.len == t.smartcast_stack.len {
            new_stack = [ctx]
            new_stack << t.smartcast_stack
        }
        t.smartcast_stack = new_stack
        t.smartcast_expr_counts[ctx.expr] = t.smartcast_expr_counts[ctx.expr] + 1
    }
}

// find_smartcast_for_expr finds the smartcast context that matches the given expression string
// Returns the context or none if not found
fn (t &Transformer) find_smartcast_for_expr(expr_str string) ?SmartcastContext {
    // Empty expression strings are ambiguous (from unhandled AST nodes like IndexExpr)
    // and must never match, as they would incorrectly apply smartcasts to unrelated
    // expressions (e.g., EmptyExpr in enum shorthands like `.assign`).
    if expr_str == '' {
        return none
    }
    if t.smartcast_expr_counts[expr_str] == 0 {
        return none
    }
    // Search from most recent to oldest (reverse order)
    mut i := t.smartcast_stack.len
    mut searched := 0
    for i > 0 && searched < smartcast_search_limit {
        i--
        searched++
        if t.smartcast_stack[i].expr == expr_str {
            return t.smartcast_stack[i]
        }
    }
    return none
}

fn (t &Transformer) smartcast_context_tag_value(ctx SmartcastContext) ?int {
    if ctx.sumtype.starts_with('__iface__') {
        return none
    }
    variants := t.get_sum_type_variants(ctx.sumtype)
    for candidate in [ctx.variant, ctx.variant_full] {
        if candidate == '' {
            continue
        }
        if matched := t.match_variant(candidate, variants) {
            for i, variant in variants {
                if variant == matched {
                    return i
                }
            }
        }
    }
    return none
}

fn (t &Transformer) find_sumtype_with_variant_at_tag(variant_name string, tag int) string {
    if variant_name == '' || tag < 0 {
        return ''
    }
    for st in ['Expr', 'Type', 'Stmt', 'ast__Expr', 'ast__Type', 'ast__Stmt'] {
        variants := t.get_sum_type_variants(st)
        if tag < variants.len
            && sum_type_variant_matches_for_sumtype(st, variants[tag], variant_name) {
            return st
        }
    }
    for mod_name, scope in t.cached_scopes {
        for type_name, typ in scope.types {
            if typ is types.SumType {
                st_name := if mod_name != '' && mod_name != 'main' && mod_name != 'builtin' {
                    '${mod_name}__${type_name}'
                } else {
                    type_name
                }
                variants := typ.get_variants()
                if tag < variants.len
                    && sum_type_variant_matches_for_sumtype(st_name, variants[tag].name(), variant_name) {
                    return st_name
                }
            }
        }
    }
    return ''
}

fn (t &Transformer) smartcast_context_from_tag_check(expr ast.InfixExpr) ?SmartcastContext {
    if expr.op != .eq || expr.lhs !is ast.SelectorExpr {
        return none
    }
    tag_sel := expr.lhs as ast.SelectorExpr
    if tag_sel.rhs.name != '_tag' {
        return none
    }
    if expr.rhs !is ast.BasicLiteral {
        return none
    }
    tag_lit := expr.rhs as ast.BasicLiteral
    if tag_lit.kind != .number {
        return none
    }
    tag := tag_lit.value.int()
    if tag < 0 {
        return none
    }
    sumtype_expr := tag_sel.lhs
    mut sumtype_name := t.get_sumtype_name_for_expr(sumtype_expr)
    if sumtype_name == '' {
        return none
    }
    mut variants := t.get_sum_type_variants(sumtype_name)
    if tag >= variants.len {
        storage_sumtype := t.find_sumtype_with_variant_at_tag(sumtype_name, tag)
        if storage_sumtype == '' {
            return none
        }
        sumtype_name = storage_sumtype
        variants = t.get_sum_type_variants(sumtype_name)
    }
    variant_name := variants[tag]
    variant_short := if variant_name.contains('__') {
        variant_name.all_after_last('__')
    } else {
        variant_name
    }
    sumtype_module := if sumtype_name.contains('__') {
        sumtype_name.all_before_last('__')
    } else {
        ''
    }
    variant_full := if variant_name.contains('__') || sumtype_module == ''
        || variant_short.starts_with('Array_') || variant_short.starts_with('Map_') {
        variant_name
    } else {
        '${sumtype_module}__${variant_short}'
    }
    expr_str := t.expr_to_string(sumtype_expr)
    if expr_str == '' {
        return none
    }
    return SmartcastContext{
        expr:         expr_str
        variant:      variant_full
        variant_full: variant_full
        sumtype:      sumtype_name
    }
}

fn (t &Transformer) smartcast_context_from_condition_term(term ast.InfixExpr) ?SmartcastContext {
    if ctx := t.smartcast_context_from_is_check(term) {
        return ctx
    }
    return t.smartcast_context_from_tag_check(term)
}

fn (mut t Transformer) transform_tag_check_lhs(lhs ast.Expr) ast.Expr {
    if lhs is ast.Ident {
        if t.smartcast_stack.len > 0 {
            ctx := t.smartcast_stack[t.smartcast_stack.len - 1]
            if ctx.expr == lhs.name && t.is_sum_type(ctx.variant) {
                return t.transform_expr(lhs)
            }
        }
        return ast.Expr(lhs)
    }
    return t.transform_expr(lhs)
}

fn smartcast_type_name_matches(candidate string, target string) bool {
    mut c := candidate.trim_space()
    mut t := target.trim_space()
    if c.starts_with('&') {
        c = c[1..]
    }
    if t.starts_with('&') {
        t = t[1..]
    }
    c = c.trim_right('*')
    t = t.trim_right('*')
    if c == '' || t == '' {
        return false
    }
    if c == t {
        return true
    }
    c_short := if c.contains('__') { c.all_after_last('__') } else { c }
    t_short := if t.contains('__') { t.all_after_last('__') } else { t }
    return c_short == t_short
}

fn (mut t Transformer) transform_tag_check_lhs_for_sumtype(lhs ast.Expr, sumtype_name string) ast.Expr {
    lhs_expr_str := t.expr_to_string(lhs)
    if lhs_expr_str != '' {
        if ctx := t.find_smartcast_for_expr(lhs_expr_str) {
            if !ctx.sumtype.starts_with('__iface__')
                && (smartcast_type_name_matches(ctx.variant, sumtype_name)
                || smartcast_type_name_matches(ctx.variant_full, sumtype_name)) {
                return t.apply_smartcast_direct_ctx(lhs, ctx)
            }
        }
    }
    return t.transform_tag_check_lhs(lhs)
}

// has_active_smartcast returns true if there's any active smartcast context
fn (t &Transformer) has_active_smartcast() bool {
    return t.smartcast_stack.len > 0
}

// cur_smartcast_expr returns the current (most recent) smartcast expression or empty string
fn (t &Transformer) cur_smartcast_expr() string {
    if t.smartcast_stack.len > 0 {
        return t.smartcast_stack[t.smartcast_stack.len - 1].expr
    }
    return ''
}

// cur_smartcast_variant returns the current (most recent) smartcast variant or empty string
fn (t &Transformer) cur_smartcast_variant() string {
    if t.smartcast_stack.len > 0 {
        return t.smartcast_stack[t.smartcast_stack.len - 1].variant
    }
    return ''
}

pub fn (mut t Transformer) set_synth_pos_counter(val int) {
    t.synth_pos_counter = val
}

// next_synth_pos returns a unique negative position for synthesized AST nodes
fn (mut t Transformer) next_synth_pos() token.Pos {
    id := t.synth_pos_counter
    t.synth_pos_counter -= 1
    return token.Pos{
        id:     id
        offset: 0
    }
}

fn (mut t Transformer) make_number_expr(value string) ast.Expr {
    pos := t.next_synth_pos()
    return ast.Expr(ast.BasicLiteral{
        kind:  .number
        value: value
        pos:   pos
    })
}

fn (mut t Transformer) make_infix_expr_at(op token.Token, lhs ast.Expr, rhs ast.Expr, pos token.Pos) ast.Expr {
    infix_pos := if pos.id != 0 || pos.offset != 0 {
        pos
    } else {
        t.next_synth_pos()
    }
    return ast.Expr(ast.InfixExpr{
        op:  op
        lhs: lhs
        rhs: rhs
        pos: infix_pos
    })
}

fn (mut t Transformer) make_infix_expr(op token.Token, lhs ast.Expr, rhs ast.Expr) ast.Expr {
    return t.make_infix_expr_at(op, lhs, rhs, token.Pos{})
}

// synth_selector creates a typed SelectorExpr with a unique synthesized position
// and registers its type in the environment so downstream passes can resolve it.
fn (mut t Transformer) open_scope() {
    t.scope = types.new_scope(t.scope)
}

// close_scope returns to the parent scope
fn (mut t Transformer) close_scope() {
    if t.scope != unsafe { nil } {
        t.scope = t.scope.parent
    }
}

// is_var_enum checks if a variable's type is an enum
fn (t &Transformer) is_var_enum(name string) ?string {
    typ := t.lookup_var_type(name) or { return none }
    if typ is types.Enum {
        return typ.name
    }
    return none
}

fn generic_ref_short_name(expr ast.Expr) string {
    if !expr_has_valid_data(expr) {
        return ''
    }
    return match expr {
        ast.Ident {
            expr.name
        }
        ast.SelectorExpr {
            expr.rhs.name
        }
        ast.GenericArgs {
            generic_ref_short_name(expr.lhs)
        }
        ast.GenericArgOrIndexExpr {
            generic_ref_short_name(expr.lhs)
        }
        ast.IndexExpr {
            generic_ref_short_name(expr.lhs)
        }
        ast.ParenExpr {
            generic_ref_short_name(expr.expr)
        }
        else {
            ''
        }
    }
}

fn generic_ref_short_name_cursor(expr ast.Cursor) string {
    if !expr.is_valid() {
        return ''
    }
    return match expr.kind() {
        .expr_ident {
            expr.name()
        }
        .expr_selector {
            rhs := expr.edge(1)
            if rhs.kind() == .expr_ident {
                rhs.name()
            } else {
                ''
            }
        }
        .expr_generic_args, .expr_generic_arg_or_index, .expr_index, .expr_paren {
            generic_ref_short_name_cursor(expr.edge(0))
        }
        else {
            ''
        }
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs(files []ast.File) {
    t.collect_generic_fn_decl_names(files)
    for file in files {
        for stmt in file.stmts {
            t.collect_generic_fn_value_refs_in_stmt(stmt, false)
        }
    }
    t.collect_generic_fn_value_dependencies()
}

fn (mut t Transformer) collect_generic_fn_value_refs_from_flat(flat &ast.FlatAst) {
    t.collect_generic_fn_decl_names_from_flat(flat)
    for i in 0 .. flat.files.len {
        stmts := flat.file_cursor(i).stmts()
        for j in 0 .. stmts.len() {
            t.collect_generic_fn_value_refs_in_stmt_cursor(stmts.at(j), false)
        }
    }
    t.collect_generic_fn_value_dependencies()
}

fn (mut t Transformer) collect_generic_fn_decl_names(files []ast.File) {
    for file in files {
        for stmt in file.stmts {
            t.collect_generic_fn_decl_names_in_stmt(stmt)
        }
    }
}

fn (mut t Transformer) collect_generic_fn_decl_names_from_flat(flat &ast.FlatAst) {
    for i in 0 .. flat.files.len {
        stmts := flat.file_cursor(i).stmts()
        for j in 0 .. stmts.len() {
            t.collect_generic_fn_decl_names_in_stmt_cursor(stmts.at(j))
        }
    }
}

fn has_non_lifetime_generic_params_cursor(params ast.CursorList) bool {
    for i in 0 .. params.len() {
        if params.at(i).kind() != .expr_lifetime {
            return true
        }
    }
    return false
}

fn (mut t Transformer) collect_generic_fn_decl_names_in_stmt_cursor(stmt ast.Cursor) {
    if !stmt.is_valid() {
        return
    }
    match stmt.kind() {
        .stmt_comptime {
            t.collect_generic_fn_decl_names_in_stmt_cursor(stmt.edge(0))
        }
        .stmt_expr {
            t.collect_generic_fn_decl_names_in_expr_cursor(stmt.edge(0))
        }
        .stmt_fn_decl {
            generic_params := stmt.edge(1).list_at(0)
            body := stmt.list_at(3)
            if has_non_lifetime_generic_params_cursor(generic_params) {
                t.generic_fn_decl_names[stmt.name()] = true
                t.generic_fn_decl_body_cursors[stmt.name()] = body
            }
            for i in 0 .. body.len() {
                t.collect_generic_fn_decl_names_in_stmt_cursor(body.at(i))
            }
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_decl_names_in_expr_cursor(expr ast.Cursor) {
    if !expr.is_valid() {
        return
    }
    match expr.kind() {
        .expr_comptime {
            t.collect_generic_fn_decl_names_in_expr_cursor(expr.edge(0))
        }
        .expr_if {
            if expr.edge_count() > 2 {
                for i in 2 .. expr.edge_count() {
                    t.collect_generic_fn_decl_names_in_stmt_cursor(expr.edge(i))
                }
            }
            t.collect_generic_fn_decl_names_in_expr_cursor(expr.edge(1))
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_decl_names_in_stmt(stmt ast.Stmt) {
    if !stmt_has_valid_data(stmt) {
        return
    }
    match stmt {
        ast.ComptimeStmt {
            t.collect_generic_fn_decl_names_in_stmt(stmt.stmt)
        }
        ast.ExprStmt {
            t.collect_generic_fn_decl_names_in_expr(stmt.expr)
        }
        ast.FnDecl {
            if has_non_lifetime_generic_params(stmt.typ.generic_params) {
                t.generic_fn_decl_names[stmt.name] = true
                t.generic_fn_decl_stmts[stmt.name] = stmt.stmts
            }
            for body_stmt in stmt.stmts {
                t.collect_generic_fn_decl_names_in_stmt(body_stmt)
            }
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_decl_names_in_expr(expr ast.Expr) {
    if !expr_has_valid_data(expr) {
        return
    }
    match expr {
        ast.ComptimeExpr {
            t.collect_generic_fn_decl_names_in_expr(expr.expr)
        }
        ast.IfExpr {
            for stmt in expr.stmts {
                t.collect_generic_fn_decl_names_in_stmt(stmt)
            }
            t.collect_generic_fn_decl_names_in_expr(expr.else_expr)
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_value_dependencies() {
    mut processed := map[string]bool{}
    for {
        mut progressed := false
        for name, _ in t.generic_fn_value_names {
            if name in processed {
                continue
            }
            processed[name] = true
            progressed = true
            if body := t.generic_fn_decl_body_cursors[name] {
                t.collect_generic_fn_value_refs_in_stmt_list_cursor(body, true)
            } else if stmts := t.generic_fn_decl_stmts[name] {
                t.collect_generic_fn_value_refs_in_stmts(stmts, true)
            }
        }
        if !progressed {
            break
        }
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_stmts(stmts []ast.Stmt, include_generic_calls bool) {
    for stmt in stmts {
        t.collect_generic_fn_value_refs_in_stmt(stmt, include_generic_calls)
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_expr_cursor(expr ast.Cursor, include_generic_calls bool, in_call_lhs bool) {
    if !expr.is_valid() {
        return
    }
    match expr.kind() {
        .expr_array_init {
            for i in 5 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(2), include_generic_calls,
                false)
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(3), include_generic_calls,
                false)
        }
        .expr_as_cast {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
        }
        .expr_assoc {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
            for i in 2 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i).edge(0),
                    include_generic_calls, false)
            }
        }
        .expr_call {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                true)
            for i in 1 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
        }
        .expr_call_or_cast {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_cast {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_comptime, .expr_modifier, .expr_postfix, .expr_prefix, .expr_sql {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
        }
        .expr_fn_literal {
            captured_len := expr.extra_int()
            for i in 0 .. captured_len {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1 + i),
                    include_generic_calls, false)
            }
            for i in (1 + captured_len) .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(i), include_generic_calls)
            }
        }
        .expr_generic_args {
            base_name := generic_ref_short_name_cursor(expr.edge(0))
            if (include_generic_calls || !in_call_lhs) && base_name in t.generic_fn_decl_names {
                t.generic_fn_value_names[base_name] = true
            }
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                in_call_lhs)
            for i in 1 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
        }
        .expr_generic_arg_or_index {
            base_name := generic_ref_short_name_cursor(expr.edge(0))
            if (include_generic_calls || !in_call_lhs) && base_name in t.generic_fn_decl_names {
                t.generic_fn_value_names[base_name] = true
            }
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                in_call_lhs)
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_if {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
            for i in 2 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(i), include_generic_calls)
            }
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_if_guard {
            t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(0), include_generic_calls)
        }
        .expr_index {
            base_name := generic_ref_short_name_cursor(expr.edge(0))
            if (include_generic_calls || !in_call_lhs) && base_name in t.generic_fn_decl_names {
                t.generic_fn_value_names[base_name] = true
            }
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                in_call_lhs)
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_infix, .expr_range {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_init {
            for i in 1 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i).edge(0),
                    include_generic_calls, false)
            }
        }
        .expr_keyword_operator, .expr_tuple {
            for i in 0 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
        }
        .expr_lambda {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
        }
        .expr_lock {
            packed := u32(expr.extra_int())
            lock_len := int(packed & 0xFFFF)
            rlock_len := int((packed >> 16) & 0xFFFF)
            for i in 0 .. lock_len {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
            for i in lock_len .. (lock_len + rlock_len) {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
            for i in (lock_len + rlock_len) .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(i), include_generic_calls)
            }
        }
        .expr_map_init {
            keys_len := expr.extra_int()
            for i in 0 .. keys_len {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1 + i),
                    include_generic_calls, false)
            }
            for i in (1 + keys_len) .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(i), include_generic_calls,
                    false)
            }
        }
        .expr_match {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
            for i in 1 .. expr.edge_count() {
                branch := expr.edge(i)
                conds := branch.list_at(0)
                for j in 0 .. conds.len() {
                    t.collect_generic_fn_value_refs_in_expr_cursor(conds.at(j),
                        include_generic_calls, false)
                }
                stmts := branch.list_at(1)
                for j in 0 .. stmts.len() {
                    t.collect_generic_fn_value_refs_in_stmt_cursor(stmts.at(j),
                        include_generic_calls)
                }
            }
        }
        .expr_or {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
            for i in 1 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(i), include_generic_calls)
            }
        }
        .expr_paren {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                in_call_lhs)
        }
        .expr_select {
            t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(0), include_generic_calls)
            for i in 2 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(i), include_generic_calls)
            }
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(1), include_generic_calls,
                false)
        }
        .expr_selector {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                in_call_lhs)
        }
        .expr_string_inter {
            inters := expr.list_at(1)
            for i in 0 .. inters.len() {
                inter := inters.at(i)
                t.collect_generic_fn_value_refs_in_expr_cursor(inter.edge(0),
                    include_generic_calls, false)
                t.collect_generic_fn_value_refs_in_expr_cursor(inter.edge(1),
                    include_generic_calls, false)
            }
        }
        .expr_unsafe {
            for i in 0 .. expr.edge_count() {
                t.collect_generic_fn_value_refs_in_stmt_cursor(expr.edge(i), include_generic_calls)
            }
        }
        .aux_field_init {
            t.collect_generic_fn_value_refs_in_expr_cursor(expr.edge(0), include_generic_calls,
                false)
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_stmt_edges_cursor(stmt ast.Cursor, start int, include_generic_calls bool) {
    if start >= stmt.edge_count() {
        return
    }
    for i in start .. stmt.edge_count() {
        t.collect_generic_fn_value_refs_in_stmt_cursor(stmt.edge(i), include_generic_calls)
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_field_values_cursor(fields ast.CursorList, value_edge int, include_generic_calls bool) {
    for i in 0 .. fields.len() {
        t.collect_generic_fn_value_refs_in_expr_cursor(fields.at(i).edge(value_edge),
            include_generic_calls, false)
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_stmt_cursor(stmt ast.Cursor, include_generic_calls bool) {
    if !stmt.is_valid() {
        return
    }
    match stmt.kind() {
        .stmt_assert {
            t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(0), include_generic_calls,
                false)
            t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(1), include_generic_calls,
                false)
        }
        .stmt_assign {
            lhs_len := stmt.extra_int()
            if lhs_len < stmt.edge_count() {
                for i in lhs_len .. stmt.edge_count() {
                    t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(i),
                        include_generic_calls, false)
                }
            }
        }
        .stmt_block {
            t.collect_generic_fn_value_refs_in_stmt_edges_cursor(stmt, 0, include_generic_calls)
        }
        .stmt_comptime {
            t.collect_generic_fn_value_refs_in_stmt_cursor(stmt.edge(0), include_generic_calls)
        }
        .stmt_const_decl {
            t.collect_generic_fn_value_refs_in_field_values_cursor(stmt.list_at(0), 0,
                include_generic_calls)
        }
        .stmt_defer {
            t.collect_generic_fn_value_refs_in_stmt_edges_cursor(stmt, 0, include_generic_calls)
        }
        .stmt_enum_decl {
            t.collect_generic_fn_value_refs_in_field_values_cursor(stmt.list_at(2), 1,
                include_generic_calls)
        }
        .stmt_expr {
            t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(0), include_generic_calls,
                false)
        }
        .stmt_fn_decl {
            t.collect_generic_fn_value_refs_in_stmt_list_cursor(stmt.list_at(3),
                include_generic_calls)
        }
        .stmt_for_in {
            t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(2), include_generic_calls,
                false)
        }
        .stmt_for {
            t.collect_generic_fn_value_refs_in_stmt_cursor(stmt.edge(0), include_generic_calls)
            t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(1), include_generic_calls,
                false)
            t.collect_generic_fn_value_refs_in_stmt_cursor(stmt.edge(2), include_generic_calls)
            t.collect_generic_fn_value_refs_in_stmt_edges_cursor(stmt, 3, include_generic_calls)
        }
        .stmt_global_decl {
            t.collect_generic_fn_value_refs_in_field_values_cursor(stmt.list_at(1), 1,
                include_generic_calls)
        }
        .stmt_label {
            t.collect_generic_fn_value_refs_in_stmt_cursor(stmt.edge(0), include_generic_calls)
        }
        .stmt_return {
            for i in 0 .. stmt.edge_count() {
                t.collect_generic_fn_value_refs_in_expr_cursor(stmt.edge(i), include_generic_calls,
                    false)
            }
        }
        .stmt_struct_decl {
            t.collect_generic_fn_value_refs_in_field_values_cursor(stmt.list_at(4), 1,
                include_generic_calls)
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_stmt_list_cursor(stmts ast.CursorList, include_generic_calls bool) {
    for i in 0 .. stmts.len() {
        t.collect_generic_fn_value_refs_in_stmt_cursor(stmts.at(i), include_generic_calls)
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_stmt(stmt ast.Stmt, include_generic_calls bool) {
    if !stmt_has_valid_data(stmt) {
        return
    }
    match stmt {
        ast.AssertStmt {
            t.collect_generic_fn_value_refs_in_expr(stmt.expr, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_expr(stmt.extra, include_generic_calls, false)
        }
        ast.AssignStmt {
            for expr in stmt.rhs {
                t.collect_generic_fn_value_refs_in_expr(expr, include_generic_calls, false)
            }
        }
        ast.BlockStmt {
            t.collect_generic_fn_value_refs_in_stmts(stmt.stmts, include_generic_calls)
        }
        ast.ComptimeStmt {
            t.collect_generic_fn_value_refs_in_stmt(stmt.stmt, include_generic_calls)
        }
        ast.ConstDecl {
            for field in stmt.fields {
                t.collect_generic_fn_value_refs_in_expr(field.value, include_generic_calls, false)
            }
        }
        ast.DeferStmt {
            t.collect_generic_fn_value_refs_in_stmts(stmt.stmts, include_generic_calls)
        }
        ast.EnumDecl {
            for field in stmt.fields {
                t.collect_generic_fn_value_refs_in_expr(field.value, include_generic_calls, false)
            }
        }
        ast.ExprStmt {
            t.collect_generic_fn_value_refs_in_expr(stmt.expr, include_generic_calls, false)
        }
        ast.FnDecl {
            t.collect_generic_fn_value_refs_in_stmts(stmt.stmts, include_generic_calls)
        }
        ast.ForInStmt {
            t.collect_generic_fn_value_refs_in_expr(stmt.expr, include_generic_calls, false)
        }
        ast.ForStmt {
            t.collect_generic_fn_value_refs_in_stmt(stmt.init, include_generic_calls)
            t.collect_generic_fn_value_refs_in_expr(stmt.cond, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_stmt(stmt.post, include_generic_calls)
            t.collect_generic_fn_value_refs_in_stmts(stmt.stmts, include_generic_calls)
        }
        ast.GlobalDecl {
            for field in stmt.fields {
                t.collect_generic_fn_value_refs_in_expr(field.value, include_generic_calls, false)
            }
        }
        ast.LabelStmt {
            t.collect_generic_fn_value_refs_in_stmt(stmt.stmt, include_generic_calls)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                t.collect_generic_fn_value_refs_in_expr(expr, include_generic_calls, false)
            }
        }
        ast.StructDecl {
            for field in stmt.fields {
                t.collect_generic_fn_value_refs_in_expr(field.value, include_generic_calls, false)
            }
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_fn_value_refs_in_expr(expr ast.Expr, include_generic_calls bool, in_call_lhs bool) {
    if !expr_has_valid_data(expr) {
        return
    }
    match expr {
        ast.ArrayInitExpr {
            for item in expr.exprs {
                t.collect_generic_fn_value_refs_in_expr(item, include_generic_calls, false)
            }
            t.collect_generic_fn_value_refs_in_expr(expr.init, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_expr(expr.cap, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_expr(expr.len, include_generic_calls, false)
        }
        ast.AsCastExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.AssocExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
            for field in expr.fields {
                t.collect_generic_fn_value_refs_in_expr(field.value, include_generic_calls, false)
            }
        }
        ast.CallExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, true)
            for arg in expr.args {
                t.collect_generic_fn_value_refs_in_expr(arg, include_generic_calls, false)
            }
        }
        ast.CallOrCastExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.CastExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.ComptimeExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.FieldInit {
            t.collect_generic_fn_value_refs_in_expr(expr.value, include_generic_calls, false)
        }
        ast.FnLiteral {
            for captured in expr.captured_vars {
                t.collect_generic_fn_value_refs_in_expr(captured, include_generic_calls, false)
            }
            t.collect_generic_fn_value_refs_in_stmts(expr.stmts, include_generic_calls)
        }
        ast.GenericArgs {
            // Generic function values like `handler[A, X]` are instantiated later by
            // cgen. Roots are value-position refs; callees are added transitively.
            base_name := generic_ref_short_name(expr.lhs)
            if (include_generic_calls || !in_call_lhs) && base_name in t.generic_fn_decl_names {
                t.generic_fn_value_names[base_name] = true
            }
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, in_call_lhs)
            for arg in expr.args {
                t.collect_generic_fn_value_refs_in_expr(arg, include_generic_calls, false)
            }
        }
        ast.GenericArgOrIndexExpr {
            base_name := generic_ref_short_name(expr.lhs)
            if (include_generic_calls || !in_call_lhs) && base_name in t.generic_fn_decl_names {
                t.generic_fn_value_names[base_name] = true
            }
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, in_call_lhs)
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.IfExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.cond, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_stmts(expr.stmts, include_generic_calls)
            t.collect_generic_fn_value_refs_in_expr(expr.else_expr, include_generic_calls, false)
        }
        ast.IfGuardExpr {
            t.collect_generic_fn_value_refs_in_stmt(expr.stmt, include_generic_calls)
        }
        ast.IndexExpr {
            name := generic_ref_short_name(expr.lhs)
            if (include_generic_calls || !in_call_lhs) && name in t.generic_fn_decl_names {
                t.generic_fn_value_names[name] = true
            }
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, in_call_lhs)
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.InfixExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_expr(expr.rhs, include_generic_calls, false)
        }
        ast.InitExpr {
            for field in expr.fields {
                t.collect_generic_fn_value_refs_in_expr(field.value, include_generic_calls, false)
            }
        }
        ast.KeywordOperator {
            for item in expr.exprs {
                t.collect_generic_fn_value_refs_in_expr(item, include_generic_calls, false)
            }
        }
        ast.LambdaExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.LockExpr {
            for lock_expr in expr.lock_exprs {
                t.collect_generic_fn_value_refs_in_expr(lock_expr, include_generic_calls, false)
            }
            for rlock_expr in expr.rlock_exprs {
                t.collect_generic_fn_value_refs_in_expr(rlock_expr, include_generic_calls, false)
            }
            t.collect_generic_fn_value_refs_in_stmts(expr.stmts, include_generic_calls)
        }
        ast.MapInitExpr {
            for key in expr.keys {
                t.collect_generic_fn_value_refs_in_expr(key, include_generic_calls, false)
            }
            for val in expr.vals {
                t.collect_generic_fn_value_refs_in_expr(val, include_generic_calls, false)
            }
        }
        ast.MatchExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
            for branch in expr.branches {
                for cond in branch.cond {
                    t.collect_generic_fn_value_refs_in_expr(cond, include_generic_calls, false)
                }
                t.collect_generic_fn_value_refs_in_stmts(branch.stmts, include_generic_calls)
            }
        }
        ast.ModifierExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.OrExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_stmts(expr.stmts, include_generic_calls)
        }
        ast.ParenExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, in_call_lhs)
        }
        ast.PostfixExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.PrefixExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.RangeExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.start, include_generic_calls, false)
            t.collect_generic_fn_value_refs_in_expr(expr.end, include_generic_calls, false)
        }
        ast.SelectExpr {
            t.collect_generic_fn_value_refs_in_stmt(expr.stmt, include_generic_calls)
            t.collect_generic_fn_value_refs_in_stmts(expr.stmts, include_generic_calls)
            t.collect_generic_fn_value_refs_in_expr(expr.next, include_generic_calls, false)
        }
        ast.SelectorExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.lhs, include_generic_calls, in_call_lhs)
        }
        ast.SqlExpr {
            t.collect_generic_fn_value_refs_in_expr(expr.expr, include_generic_calls, false)
        }
        ast.StringInterLiteral {
            for inter in expr.inters {
                t.collect_generic_fn_value_refs_in_expr(inter.expr, include_generic_calls, false)
                t.collect_generic_fn_value_refs_in_expr(inter.format_expr, include_generic_calls,
                    false)
            }
        }
        ast.Tuple {
            for item in expr.exprs {
                t.collect_generic_fn_value_refs_in_expr(item, include_generic_calls, false)
            }
        }
        ast.UnsafeExpr {
            t.collect_generic_fn_value_refs_in_stmts(expr.stmts, include_generic_calls)
        }
        else {}
    }
}

// pre_pass runs the sequential pre-pass: builds elided_fns and collects runtime const inits.
pub fn (mut t Transformer) pre_pass(files []ast.File) {
    t.collect_generic_fn_value_refs(files)
    // Pre-pass: scan all function declarations for conditional compilation attributes
    // to build elided_fns set before transforming call sites
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                for attr in stmt.attributes {
                    if attr.comptime_cond !is ast.EmptyExpr {
                        if !t.eval_comptime_cond(attr.comptime_cond) {
                            t.elided_fns[stmt.name] = true
                        }
                    }
                }
            }
        }
    }
    // Pre-pass: collect const declarations that require runtime initialization.
    if !t.is_eval_backend() {
        t.collect_runtime_const_inits(files)
    }
    // Cache scope and method maps for lock-free access during transform.
    t.cache_env_maps()
    t.collect_sum_type_decl_variant_names(files)
}

// pre_pass_from_flat is the FlatAst-driven equivalent of pre_pass. It walks
// file-level stmt cursors so the transformer no longer depends on
// pre-rehydrated []ast.File or per-file []ast.Stmt arrays for its accumulators.
// The generic-function scans still reuse recursive legacy visitors; the
// conditional attribute and runtime-const scans are cursor-native.
pub fn (mut t Transformer) pre_pass_from_flat(flat &ast.FlatAst) {
    t.collect_generic_fn_value_refs_from_flat(flat)
    for i in 0 .. flat.files.len {
        stmts := flat.file_cursor(i).stmts()
        for j in 0 .. stmts.len() {
            stmt := stmts.at(j)
            if stmt.kind() != .stmt_fn_decl {
                continue
            }
            attrs := stmt.list_at(2)
            for ai in 0 .. attrs.len() {
                cond := attrs.at(ai).edge(1)
                if !cond.is_valid() || cond.kind() == .expr_empty {
                    continue
                }
                if !t.eval_comptime_cond_cursor(cond) {
                    t.elided_fns[stmt.name()] = true
                }
            }
        }
    }
    if !t.is_eval_backend() {
        t.collect_runtime_const_inits_from_flat(flat)
    }
    t.cache_env_maps()
    t.collect_sum_type_decl_variant_names_from_flat(flat)
}

// cache_env_maps snapshots the shared Environment maps into plain maps
// for lock-free access during parallel file transformation.
fn (mut t Transformer) cache_env_maps() {
    t.cached_scopes = t.env.snapshot_scopes()
    t.cached_scope_keys = t.cached_scopes.keys()
    t.cached_methods = t.env.snapshot_methods()
    t.cached_method_keys = t.cached_methods.keys()
    t.cached_fn_scopes = t.env.snapshot_fn_scopes()
    t.build_cached_imported_module_scopes()
    t.build_cached_struct_field_type_index()
    t.build_cached_fn_type_index()
    t.build_cached_method_base_index()
    mut by_short := map[string][]string{}
    for key in t.cached_method_keys {
        by_short[method_short_name(key)] << key
    }
    t.cached_method_keys_by_short = by_short.move()
}

// build_cached_imported_module_scopes precomputes, per module, the resolved
// scopes of the modules it imports (skipping self, C and unnamed entries).
// lookup_imported_var_type then iterates only this short list instead of
// rescanning and sorting the whole symbol table on every call. The import set
// is stable for the duration of a transform run (cached_scopes is snapshotted
// once in pre_pass), so a single precompute is safe.
fn (mut t Transformer) build_cached_imported_module_scopes() {
    mut by_module := map[string][]&types.Scope{}
    for module_name in t.cached_scope_keys {
        scope := t.cached_scopes[module_name] or { continue }
        mut imported_scopes := []&types.Scope{}
        for key, obj in scope.objects {
            if obj !is types.Module {
                continue
            }
            module_obj := obj as types.Module
            import_name := if module_obj.name != '' { module_obj.name } else { key }
            if import_name == '' || import_name == module_name || import_name == 'C' {
                continue
            }
            mut module_scope := module_obj.scope
            if module_scope == unsafe { nil } {
                module_scope = t.cached_scopes[import_name] or { continue }
            }
            imported_scopes << module_scope
        }
        by_module[module_name] = imported_scopes
    }
    t.cached_imported_module_scopes = by_module.move()
}

fn (mut t Transformer) build_cached_struct_field_type_index() {
    mut index := map[string]types.Type{}
    for module_name in t.cached_scope_keys {
        scope := t.cached_scopes[module_name] or { continue }
        for obj_name, obj in scope.objects {
            typ := transformer_object_type(obj) or { continue }
            if typ is types.Struct {
                add_struct_field_type_index_entries(mut index, module_name, obj_name, typ)
            }
        }
    }
    t.cached_struct_field_types = index.move()
}

fn add_struct_field_type_index_entries(mut index map[string]types.Type, module_name string, obj_name string, st types.Struct) {
    mut names := []string{cap: 4}
    if obj_name != '' {
        names << obj_name
    }
    if st.name != '' && st.name !in names {
        names << st.name
    }
    if module_name != '' && obj_name != '' && !obj_name.contains('__') {
        qualified := '${module_name}__${obj_name}'
        if qualified !in names {
            names << qualified
        }
    }
    for field in st.fields {
        if field.name == '' || !transformer_string_has_valid_data(field.name) {
            continue
        }
        for name in names {
            key := struct_field_generic_decl_key(name, field.name)
            if key !in index {
                index[key] = field.typ
            }
        }
        if module_name != '' && obj_name != '' {
            module_key := struct_field_lookup_cache_key(module_name, obj_name, field.name)
            if module_key !in index {
                index[module_key] = field.typ
            }
        }
        if module_name != '' && st.name.contains('__') {
            short_name := st.name.all_after_last('__')
            if short_name != '' {
                module_key := struct_field_lookup_cache_key(module_name, short_name, field.name)
                if module_key !in index {
                    index[module_key] = field.typ
                }
            }
        }
    }
}

fn struct_field_lookup_cache_key(module_name string, struct_name string, field_name string) string {
    return '${module_name}#${struct_name}.${field_name}'
}

fn (mut t Transformer) build_cached_fn_type_index() {
    mut fn_index := map[string]types.Type{}
    mut ret_index := map[string]types.Type{}
    for module_name in t.cached_scope_keys {
        scope := t.cached_scopes[module_name] or { continue }
        for fn_name, obj in scope.objects {
            if obj is types.Fn {
                fn_obj := obj as types.Fn
                typ := fn_obj.get_typ()
                if typ is types.FnType {
                    t.add_cached_fn_type_entry(mut fn_index, mut ret_index, module_name, fn_name,
                        typ)
                    short_module := short_module_name(module_name)
                    if short_module != module_name {
                        t.add_cached_fn_type_entry(mut fn_index, mut ret_index, short_module,
                            fn_name, typ)
                    }
                    any_key := '*#${fn_name}'
                    if any_key !in fn_index {
                        fn_index[any_key] = typ
                        if ret_type := typ.get_return_type() {
                            ret_index[any_key] = ret_type
                        }
                    }
                }
            }
        }
    }
    t.cached_fn_type_index = fn_index.move()
    t.cached_fn_return_type_index = ret_index.move()
}

fn (mut t Transformer) add_cached_fn_type_entry(mut fn_index map[string]types.Type, mut ret_index map[string]types.Type, module_name string, fn_name string, fn_type types.FnType) {
    key := '${module_name}#${fn_name}'
    if key in fn_index {
        return
    }
    fn_index[key] = fn_type
    if ret_type := fn_type.get_return_type() {
        ret_index[key] = ret_type
    }
}

fn short_module_name(module_name string) string {
    if module_name.contains('.') {
        return module_name.all_after_last('.')
    }
    if module_name.contains('__') {
        return module_name.all_after_last('__')
    }
    return module_name
}

// build_cached_method_base_index precomputes, for each type, a base-method-name
// -> FnType map so lookup_method_cached is O(1) instead of scanning every method
// and recomputing base names per call site. For each base name it keeps the
// first method (in snapshot order) whose type is an FnType, matching the old
// linear scan's "first base-or-exact match that is a FnType wins" semantics.
fn (mut t Transformer) build_cached_method_base_index() {
    // Iterate via keys()+index, not `for k, v in t.cached_methods`: v2's own
    // codegen mistypes the value of a `for k, v` over map[string][]&types.Fn as
    // []types.Fn (value array), breaking self-host.
    mut index := map[string]types.Type{}
    for type_name in t.cached_methods.keys() {
        methods := t.cached_methods[type_name] or { continue }
        for method in methods {
            typ := method.get_typ()
            if typ is types.FnType {
                base := generic_base_name_without_specialization(method.get_name())
                key := '${type_name}#${base}'
                if key !in index {
                    index[key] = typ
                }
            }
        }
    }
    t.cached_method_base_index = index.move()
}

// GeneratedFnsParts is the pure-computation bundle produced by
// `generated_fns_parts`. Holds the three already-routed buckets of
// auto-generated helper FnDecls: `core_fns` for the builtin module,
// `module_fns` keyed by source module name for module-prefixed helpers
// (e.g. `time__FormatDate__str`), and `user_fns` for everything else
// (typically main / user types).
pub struct GeneratedFnsParts {
pub:
    core_fns   []ast.Stmt
    module_fns map[string][]ast.Stmt
    user_fns   []ast.Stmt
}

// generated_fns_parts is the pure-computation extraction of the
// "collect + route" segment previously inline in `post_pass`. Runs each
// `generate_*_functions` helper that has a non-empty needed-list (str,
// clone, sort-comparator, array-method, go-wrapper), then routes each
// emitted FnDecl by name: `is_core_generated_fn` → `core_fns`; otherwise
// `generated_fn_module(name, files)` non-empty → `module_fns[mod]`;
// otherwise → `user_fns`. Returns `none` when no generator fires.
//
// Does NOT mutate `files` or any caller state (beyond the generators'
// own bookkeeping on `t`, which is part of their existing contract).
// Caller decides whether to splice the buckets into a legacy
// `[]ast.File` (via `post_pass`) or into a `FlatBuilder` (future
// `post_pass_to_flat`).
//
// Fifth Phase 5 (post_pass port) `_parts` extraction (completes the
// s144 punch list: runtime-const-init-fns, runtime-const-init-main-
// calls, live-reload, test-main, generated-fns split). Bit-equal:
// identical generator invocation order, identical per-stmt routing
// (FnDecl name → bucket), identical bucket-append order.
pub fn (mut t Transformer) generated_fns_parts(files []ast.File) ?GeneratedFnsParts {
    mut generated_fns := []ast.Stmt{}
    if t.needed_str_fns.len > 0 {
        generated_fns << t.generate_str_functions(files)
    }
    if t.needed_clone_fns.len > 0 {
        generated_fns << t.generate_clone_functions()
    }
    if t.needed_sort_fns.len > 0 {
        generated_fns << t.generate_sort_comparator_functions()
    }
    if t.needed_array_contains_fns.len > 0 || t.needed_array_index_fns.len > 0
        || t.needed_array_last_index_fns.len > 0 {
        generated_fns << t.generate_array_method_functions()
    }
    if t.needed_go_wrappers.len > 0 {
        generated_fns << t.generate_go_wrapper_functions()
    }
    if generated_fns.len == 0 {
        return none
    }
    mut core_fns := []ast.Stmt{}
    mut user_fns := []ast.Stmt{}
    mut module_fns := map[string][]ast.Stmt{}
    for gf in generated_fns {
        mut is_core := false
        mut fn_module := ''
        if gf is ast.FnDecl {
            is_core = is_core_generated_fn(gf.name)
            if !is_core {
                // Check if function name has a module prefix (e.g., time__FormatDate__str)
                // Extract module name and route to correct module file.
                fn_module = generated_fn_module(gf.name, files)
            }
        }
        if is_core {
            core_fns << gf
        } else if fn_module != '' {
            module_fns[fn_module] << gf
        } else {
            user_fns << gf
        }
    }
    return GeneratedFnsParts{
        core_fns:   core_fns
        module_fns: module_fns
        user_fns:   user_fns
    }
}

// generated_fns_parts_from_flat is the FlatAst-input counterpart to
// `generated_fns_parts`. Same generators, same bucket layout, same
// per-stmt routing — only the two `[]ast.File` consumers change:
//   - `generate_str_functions(files)` is replaced with
//     `generate_str_functions_with_explicit(explicit_str_fns)` where
//     `explicit_str_fns` comes from `explicit_str_method_fn_names_from_flat`
//     (s165).
//   - `generated_fn_module(name, files)` is replaced with
//     `generated_fn_module_from_flat(name, flat)` (s164).
//
// Lets `_via_driver` wedges compute `GeneratedFnsParts` from `&builder.flat`
// instead of `result []ast.File`, so the parts computation no longer pins
// the un-post_pass'd legacy file array.
pub fn (mut t Transformer) generated_fns_parts_from_flat(flat &ast.FlatAst) ?GeneratedFnsParts {
    explicit_str_fns := t.explicit_str_method_fn_names_from_flat(flat)
    mut generated_fns := []ast.Stmt{}
    if t.needed_str_fns.len > 0 {
        generated_fns << t.generate_str_functions_with_explicit(explicit_str_fns)
    }
    if t.needed_clone_fns.len > 0 {
        generated_fns << t.generate_clone_functions()
    }
    if t.needed_sort_fns.len > 0 {
        generated_fns << t.generate_sort_comparator_functions()
    }
    if t.needed_array_contains_fns.len > 0 || t.needed_array_index_fns.len > 0
        || t.needed_array_last_index_fns.len > 0 {
        generated_fns << t.generate_array_method_functions()
    }
    if t.needed_go_wrappers.len > 0 {
        generated_fns << t.generate_go_wrapper_functions()
    }
    if generated_fns.len == 0 {
        return none
    }
    mut core_fns := []ast.Stmt{}
    mut user_fns := []ast.Stmt{}
    mut module_fns := map[string][]ast.Stmt{}
    for gf in generated_fns {
        mut is_core := false
        mut fn_module := ''
        if gf is ast.FnDecl {
            is_core = is_core_generated_fn(gf.name)
            if !is_core {
                fn_module = generated_fn_module_from_flat(gf.name, flat)
            }
        }
        if is_core {
            core_fns << gf
        } else if fn_module != '' {
            module_fns[fn_module] << gf
        } else {
            user_fns << gf
        }
    }
    return GeneratedFnsParts{
        core_fns:   core_fns
        module_fns: module_fns
        user_fns:   user_fns
    }
}

// find_flat_file_idx_by_mod returns the first index into `flat.files` whose
// mod string equals `mod_name`, or -1 if no such file is registered.
// Mirrors the linear `for i, file in files { if file.mod == mod_name {...} }`
// scans inline in legacy `post_pass`.
fn find_flat_file_idx_by_mod(flat &ast.FlatAst, mod_name string) int {
    for i in 0 .. flat.files.len {
        if flat.string_at(flat.files[i].mod_idx) == mod_name {
            return i
        }
    }
    return -1
}

// inject_generated_fns_to_files is the legacy `[]ast.File` splice for
// `GeneratedFnsParts`. Extracted from `post_pass` so the splice can be
// invoked from tests as the reference for the flat-aware port (s153)
// without re-running the full generator pipeline. Behaviour is bit-equal
// to the previous inline routing:
//
//   1. `core_fns` → builtin file (fallback: append to `user_fns` if no
//      builtin file is registered).
//   2. `module_fns[mod]` → mod file (fallback: append to `user_fns` if no
//      mod file is registered).
//   3. `user_fns` → main file → builtin file → last file (3-tier
//      fallback ordering).
//
// Each splice rebuilds the target `ast.File` with the existing attrs +
// imports preserved and the new FnDecls appended after the existing
// stmts. Map iteration over `module_fns` relies on V's insertion-ordered
// DenseArray semantics.
fn inject_generated_fns_to_files(mut result []ast.File, parts GeneratedFnsParts) {
    core_fns := unsafe { parts.core_fns }
    mut user_fns := unsafe { parts.user_fns }
    module_fns := unsafe { parts.module_fns }
    if core_fns.len > 0 {
        mut builtin_idx := -1
        for i, file in result {
            if file.mod == 'builtin' {
                builtin_idx = i
                break
            }
        }
        if builtin_idx >= 0 {
            file := result[builtin_idx]
            mut new_stmts := []ast.Stmt{cap: file.stmts.len + core_fns.len}
            for stmt in file.stmts {
                new_stmts << stmt
            }
            for fn_decl in core_fns {
                new_stmts << fn_decl
            }
            result[builtin_idx] = ast.File{
                attributes: file.attributes
                mod:        file.mod
                name:       file.name
                stmts:      new_stmts
                imports:    file.imports
            }
        } else {
            user_fns << core_fns
        }
    }
    for mod_name, fns in module_fns {
        mut mod_idx := -1
        for i, file in result {
            if file.mod == mod_name {
                mod_idx = i
                break
            }
        }
        if mod_idx >= 0 {
            file := result[mod_idx]
            mut new_stmts := []ast.Stmt{cap: file.stmts.len + fns.len}
            for stmt in file.stmts {
                new_stmts << stmt
            }
            for fn_decl in fns {
                new_stmts << fn_decl
            }
            result[mod_idx] = ast.File{
                attributes: file.attributes
                mod:        file.mod
                name:       file.name
                stmts:      new_stmts
                imports:    file.imports
            }
        } else {
            for fn_decl in fns {
                user_fns << fn_decl
            }
        }
    }
    if user_fns.len > 0 {
        mut target_idx := -1
        for i, file in result {
            if file.mod == 'main' {
                target_idx = i
                break
            }
        }
        if target_idx == -1 {
            for i, file in result {
                if file.mod == 'builtin' {
                    target_idx = i
                    break
                }
            }
        }
        if target_idx == -1 && result.len > 0 {
            target_idx = result.len - 1
        }
        if target_idx >= 0 {
            file := result[target_idx]
            mut new_stmts := []ast.Stmt{cap: file.stmts.len + user_fns.len}
            for stmt in file.stmts {
                new_stmts << stmt
            }
            for fn_decl in user_fns {
                new_stmts << fn_decl
            }
            result[target_idx] = ast.File{
                attributes: file.attributes
                mod:        file.mod
                name:       file.name
                stmts:      new_stmts
                imports:    file.imports
            }
        }
    }
}

// inject_generated_fns_to_flat is the FlatBuilder-side splice counterpart
// to the 3-way `generated_fns_parts` routing previously inline in
// `post_pass`. Takes a pre-computed `GeneratedFnsParts` (caller still
// runs `t.generated_fns_parts(files)` against legacy `[]ast.File` because
// the generators themselves haven't been ported to flat yet) and folds
// each bucket into the appropriate FlatBuilder file root via
// `out.append_file_stmts` (s150's seed primitive):
//
//   1. `core_fns` → builtin file (fallback: append to `user_fns` if no
//      builtin file registered, mirroring legacy `user_fns << core_fns`).
//   2. `module_fns[mod]` → mod file (fallback: append to `user_fns` if no
//      mod file registered).
//   3. `user_fns` → main file → builtin file → last file (legacy 3-tier
//      fallback ordering preserved).
//
// Each splice emits its FnDecls via `out.emit_stmt`, collects the ids,
// then a single `out.append_file_stmts(idx, ids)` call rebuilds the file
// root. Map iteration over `module_fns` relies on V's insertion-ordered
// DenseArray semantics so bit-equality is preserved.
//
// Third flat-aware port (s153, completes the 3 append-only post_pass
// steps from s150's punch list: embed_file_helper, test_main,
// generated_fns). Pinned by 3-case test in
// `inject_generated_fns_to_flat_test.v`.
pub fn (mut t Transformer) inject_generated_fns_to_flat(mut out ast.FlatBuilder, parts GeneratedFnsParts) {
    core_fns := unsafe { parts.core_fns }
    mut user_fns := unsafe { parts.user_fns }
    module_fns := unsafe { parts.module_fns }
    // Bucket 1: core_fns → builtin file (fallback: user_fns).
    if core_fns.len > 0 {
        builtin_idx := find_flat_file_idx_by_mod(&out.flat, 'builtin')
        if builtin_idx >= 0 {
            mut ids := []ast.FlatNodeId{cap: core_fns.len}
            for fn_decl in core_fns {
                ids << out.emit_stmt(fn_decl)
            }
            out.append_file_stmts(builtin_idx, ids)
        } else {
            user_fns << core_fns
        }
    }
    // Bucket 2: module_fns[mod] → mod file (fallback: user_fns).
    for mod_name, fns in module_fns {
        mod_idx := find_flat_file_idx_by_mod(&out.flat, mod_name)
        if mod_idx >= 0 {
            mut ids := []ast.FlatNodeId{cap: fns.len}
            for fn_decl in fns {
                ids << out.emit_stmt(fn_decl)
            }
            out.append_file_stmts(mod_idx, ids)
        } else {
            for fn_decl in fns {
                user_fns << fn_decl
            }
        }
    }
    // Bucket 3: user_fns → main → builtin → last file.
    if user_fns.len > 0 {
        mut target_idx := find_flat_file_idx_by_mod(&out.flat, 'main')
        if target_idx == -1 {
            target_idx = find_flat_file_idx_by_mod(&out.flat, 'builtin')
        }
        if target_idx == -1 && out.flat.files.len > 0 {
            target_idx = out.flat.files.len - 1
        }
        if target_idx >= 0 {
            mut ids := []ast.FlatNodeId{cap: user_fns.len}
            for fn_decl in user_fns {
                ids << out.emit_stmt(fn_decl)
            }
            out.append_file_stmts(target_idx, ids)
        }
    }
}

// post_pass runs the sequential post-pass: injects runtime const init fns, generated functions,
// test main, live reload, and propagates types.
pub fn (mut t Transformer) post_pass(mut result []ast.File) {
    t.post_pass_files_with_generated_parts(mut result, none)
    t.apply_post_pass_tail(result)
}

// post_pass_files_with_generated_parts runs the file-mutating post-pass steps.
pub fn (mut t Transformer) post_pass_files_with_generated_parts(mut result []ast.File, generated_parts ?GeneratedFnsParts) {
    if !t.is_eval_backend() {
        t.inject_runtime_const_init_fns(mut result)
    }
    if t.needed_embed_file_helper {
        t.inject_embed_file_helper(mut result)
    }
    // Generate auto helper functions. Split into two groups:
    // 1. Core functions (for standard types like string, int, etc.) go in the builtin
    //    module file because cached builtin.o/vlib.o reference them. They must always
    //    be available regardless of which program is being compiled.
    // 2. User-type functions (e.g. Array_Test2_str) go in the main module file because
    //    they would pollute the cache and cause undefined symbol errors when a different
    //    program reuses the same cache.
    if parts := generated_parts {
        inject_generated_fns_to_files(mut result, parts)
    } else {
        if parts := t.generated_fns_parts(result) {
            inject_generated_fns_to_files(mut result, parts)
        }
    }
    if t.pref == unsafe { nil } || t.pref.backend != .cleanc {
        t.inject_test_main(mut result)
    }
    if !t.is_eval_backend() {
        t.inject_main_runtime_const_init_calls(mut result)
    }
    if t.is_native_be {
        t.inject_live_reload(mut result)
    }
}

// post_pass_to_flat is the FlatBuilder-side driver counterpart to
// `post_pass`. Runs the six file-mutating steps that legacy `post_pass`
// performs, in identical order, on a `FlatBuilder` instead of a legacy
// `[]ast.File`. Closes the post_pass port arc opened in s150 and
// completed in s151/s152/s153/s155/s159/s160.
//
// Order mirrors legacy `post_pass`:
//   1. `inject_runtime_const_init_fns_to_flat` (skip on eval backend)
//   2. `inject_embed_file_helper_to_flat` (gated by `needed_embed_file_helper`)
//   3. `inject_generated_fns_to_flat` (gated by `generated_parts != none`)
//   4. `inject_test_main_to_flat` (skip on cleanc backend)
//   5. `inject_main_runtime_const_init_to_flat` (skip on eval backend)
//   6. `inject_live_reload_to_flat` (only on native backend)
//
// `generated_parts` is computed by the caller via `t.generated_fns_parts`
// against whatever file source it has (legacy `[]ast.File` today). Once
// `generated_fns_parts_from_flat` lands, callers can drop the legacy file
// list entirely.
//
// The non-file post_pass tail (synth_types accumulator, fn_scopes
// propagation, `propagate_types`) is NOT included here — it operates on
// `t.env` and legacy `[]ast.File` respectively, not on `out`, so callers
// keep running it after this driver returns. `propagate_types` in
// particular still consumes `[]ast.File` and is already gated to skip on
// the arm64 backend in legacy `post_pass`.
pub fn (mut t Transformer) post_pass_to_flat(mut out ast.FlatBuilder, generated_parts ?GeneratedFnsParts) {
    if !t.is_eval_backend() {
        t.inject_runtime_const_init_fns_to_flat(mut out)
    }
    if t.needed_embed_file_helper {
        t.inject_embed_file_helper_to_flat(mut out)
    }
    if parts := generated_parts {
        t.inject_generated_fns_to_flat(mut out, parts)
    }
    if t.pref == unsafe { nil } || t.pref.backend != .cleanc {
        t.inject_test_main_to_flat(mut out)
    }
    if !t.is_eval_backend() {
        t.inject_main_runtime_const_init_to_flat(mut out)
    }
    if t.is_native_be {
        t.inject_live_reload_to_flat(mut out)
    }
}

// apply_post_pass_tail runs the trailing portion of legacy `post_pass`
// that operates on `t.env` and `[]ast.File` rather than on a FlatBuilder:
//
//   1. Apply accumulated `synth_types` to the environment (via
//      `t.env.set_expr_type`).
//   2. Push `cached_fn_scopes` back to `t.env.fn_scopes`.
//   3. Run `propagate_types(files)` for non-arm64 backends.
//
// These three steps are NOT part of `post_pass_to_flat` because they don't
// touch the flat output. They are factored here so any caller routing
// through `post_pass_to_flat` (s162's `transform_files_to_flat_via_driver`
// and s163's parallel counterpart) can share a single tail implementation
// instead of duplicating private-field access at each call site.
pub fn (mut t Transformer) apply_post_pass_tail(files []ast.File) {
    for id, typ in t.synth_types {
        t.env.set_expr_type(id, typ)
    }
    lock t.env.fn_scopes {
        fn_scope_keys := t.cached_fn_scopes.keys()
        for k in fn_scope_keys {
            v := t.cached_fn_scopes[k] or { continue }
            t.env.fn_scopes[k] = v
        }
    }
    if t.pref == unsafe { nil } || t.pref.backend != .arm64 {
        t.propagate_types(files)
    }
}

// apply_post_pass_tail_from_flat is the FlatAst-input counterpart to
// `apply_post_pass_tail`. Same three steps (synth_types accumulator →
// `t.env.set_expr_type`, `cached_fn_scopes` propagation → `t.env.fn_scopes`,
// `propagate_types_from_flat(flat)` for non-arm64 backends), only the third
// step's input changes from `[]ast.File` to `&FlatAst`. Steps 1+2 don't
// touch the file/flat input at all — they only mutate `t.env` from
// pre-accumulated state on `t`. Lets `_via_driver` wedges drop the
// `apply_post_pass_tail(result)` call site (last `[]ast.File` consumer in
// the post_pass tail) in favour of `apply_post_pass_tail_from_flat(&builder.flat)`.
pub fn (mut t Transformer) apply_post_pass_tail_from_flat(flat &ast.FlatAst) {
    for id, typ in t.synth_types {
        t.env.set_expr_type(id, typ)
    }
    lock t.env.fn_scopes {
        fn_scope_keys := t.cached_fn_scopes.keys()
        for k in fn_scope_keys {
            v := t.cached_fn_scopes[k] or { continue }
            t.env.fn_scopes[k] = v
        }
    }
    if t.pref == unsafe { nil } || t.pref.backend != .arm64 {
        t.propagate_types_from_flat(flat)
    }
}

fn embed_file_helper_receiver() ast.Parameter {
    return ast.Parameter{
        name: 'ed'
        typ:  embed_file_helper_type_expr(token.Pos{})
    }
}

fn embed_file_helper_selector(field_name string) ast.Expr {
    return ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'ed'
        })
        rhs: ast.Ident{
            name: field_name
        }
    })
}

fn embed_file_helper_method(name string, return_type ast.Expr, body []ast.Stmt) ast.Stmt {
    return ast.Stmt(ast.FnDecl{
        is_public: true
        is_method: true
        receiver:  embed_file_helper_receiver()
        name:      name
        typ:       ast.FnType{
            return_type: return_type
        }
        stmts:     body
    })
}

fn embed_file_helper_stmts() []ast.Stmt {
    return [
        ast.Stmt(ast.StructDecl{
            is_public: true
            name:      embed_file_helper_type_name
            fields:    [
                ast.FieldDecl{
                    name: '_data'
                    typ:  ast.Expr(ast.Ident{
                        name: 'string'
                    })
                },
                ast.FieldDecl{
                    name: 'len'
                    typ:  ast.Expr(ast.Ident{
                        name: 'int'
                    })
                },
                ast.FieldDecl{
                    name: 'path'
                    typ:  ast.Expr(ast.Ident{
                        name: 'string'
                    })
                },
                ast.FieldDecl{
                    name: 'apath'
                    typ:  ast.Expr(ast.Ident{
                        name: 'string'
                    })
                },
            ]
        }),
        embed_file_helper_method('to_string', ast.Expr(ast.Ident{
            name: 'string'
        }), [
            ast.Stmt(ast.ReturnStmt{
                exprs: [embed_file_helper_selector('_data')]
            }),
        ]),
        embed_file_helper_method('to_bytes', ast.Expr(ast.Type(ast.ArrayType{
            elem_type: ast.Expr(ast.Ident{
                name: 'u8'
            })
        })), [
            ast.Stmt(ast.ReturnStmt{
                exprs: [
                    ast.Expr(ast.CallExpr{
                        lhs: ast.Expr(ast.SelectorExpr{
                            lhs: embed_file_helper_selector('_data')
                            rhs: ast.Ident{
                                name: 'bytes'
                            }
                        })
                    }),
                ]
            }),
        ]),
        embed_file_helper_method('data', ast.Expr(ast.PrefixExpr{
            op:   .amp
            expr: ast.Expr(ast.Ident{
                name: 'u8'
            })
        }), [
            ast.Stmt(ast.ReturnStmt{
                exprs: [
                    ast.Expr(ast.SelectorExpr{
                        lhs: embed_file_helper_selector('_data')
                        rhs: ast.Ident{
                            name: 'str'
                        }
                    }),
                ]
            }),
        ]),
        embed_file_helper_method('free', ast.empty_expr, []ast.Stmt{}),
        embed_file_helper_method('str', ast.Expr(ast.Ident{
            name: 'string'
        }), [
            ast.Stmt(ast.ReturnStmt{
                exprs: [
                    embed_file_helper_selector('path'),
                ]
            }),
        ]),
    ]
}

// EmbedFileHelperParts is the pure-computation bundle produced by
// `inject_embed_file_helper_parts`. `builtin_idx` is the index of the
// `builtin` module file in the caller's `[]ast.File`; `extra_stmts` is
// the helper-decl set (StructDecl + 5 helper FnDecls) that should be
// appended to that file's stmts.
pub struct EmbedFileHelperParts {
pub:
    builtin_idx int
    extra_stmts []ast.Stmt
}

// inject_embed_file_helper_parts is the pure-computation extraction of
// the pre-splice state previously inline in `inject_embed_file_helper`.
// Locates the `builtin` module file (returns `none` if not present),
// scans its existing stmts for a `StructDecl` already named
// `embed_file_helper_type_name` (returns `none` if the helper is
// already injected — re-entry guard), and otherwise pairs the file
// index with a fresh `embed_file_helper_stmts()` payload.
//
// Does NOT mutate `files` or any caller state. Caller decides whether
// to splice `extra_stmts` into a legacy `[]ast.File` (via
// `inject_embed_file_helper`) or into a `FlatBuilder` (future
// `post_pass_to_flat`).
//
// Sixth Phase 5 (post_pass port) `_parts` extraction (closes the
// "every post_pass step has a `_parts` handle" symmetry — sibling to
// s144/s145/s146/s147/s148). Bit-equal: identical builtin-file lookup
// + identical re-entry guard + identical `embed_file_helper_stmts()`
// payload.
pub fn (mut t Transformer) inject_embed_file_helper_parts(files []ast.File) ?EmbedFileHelperParts {
    mut builtin_idx := -1
    for i, file in files {
        if file.mod == 'builtin' {
            builtin_idx = i
            break
        }
    }
    if builtin_idx < 0 {
        return none
    }
    file := files[builtin_idx]
    for stmt in file.stmts {
        if stmt is ast.StructDecl && stmt.name == embed_file_helper_type_name {
            return none
        }
    }
    return EmbedFileHelperParts{
        builtin_idx: builtin_idx
        extra_stmts: embed_file_helper_stmts()
    }
}

fn (mut t Transformer) inject_embed_file_helper(mut result []ast.File) {
    parts := t.inject_embed_file_helper_parts(result) or { return }
    file := result[parts.builtin_idx]
    mut new_stmts := []ast.Stmt{cap: file.stmts.len + parts.extra_stmts.len}
    for stmt in file.stmts {
        new_stmts << stmt
    }
    for stmt in parts.extra_stmts {
        new_stmts << stmt
    }
    result[parts.builtin_idx] = ast.File{
        attributes: file.attributes
        mod:        file.mod
        name:       file.name
        stmts:      new_stmts
        imports:    file.imports
    }
}

// inject_embed_file_helper_parts_from_flat is the flat-cursor sibling of
// `inject_embed_file_helper_parts`. Walks `flat.files` for the `builtin`
// module entry and scans its stmts via cursor for an existing StructDecl
// named `embed_file_helper_type_name` (re-entry guard). Returns the same
// `EmbedFileHelperParts` shape; the `builtin_idx` is into `flat.files`
// (which the legacy callers' `[]ast.File` and the FlatBuilder's
// `flat.files` share by construction).
//
// First flat-aware port of a post_pass `_parts` helper (s151, opens the
// per-step flat-aware sweep). Pinned by `flat_append_file_stmts_test.v`'s
// signature-parity invariant when wired in via `inject_embed_file_helper_to_flat`.
pub fn (mut t Transformer) inject_embed_file_helper_parts_from_flat(flat &ast.FlatAst) ?EmbedFileHelperParts {
    mut builtin_idx := -1
    for i in 0 .. flat.files.len {
        if flat.string_at(flat.files[i].mod_idx) == 'builtin' {
            builtin_idx = i
            break
        }
    }
    if builtin_idx < 0 {
        return none
    }
    stmts := flat.file_cursor(builtin_idx).stmts()
    for i in 0 .. stmts.len() {
        c := stmts.at(i)
        if c.kind() == .stmt_struct_decl && c.name() == embed_file_helper_type_name {
            return none
        }
    }
    return EmbedFileHelperParts{
        builtin_idx: builtin_idx
        extra_stmts: embed_file_helper_stmts()
    }
}

// inject_embed_file_helper_to_flat is the FlatBuilder-side splice
// counterpart to `inject_embed_file_helper` (legacy `[]ast.File` mutator).
// Emits each `parts.extra_stmts` into `out` via `out.emit_stmt`, then
// folds the resulting stmt ids into the file root via
// `out.append_file_stmts(builtin_idx, extra_ids)` (s150's seed primitive).
//
// Bit-equal w.r.t. `signature()` to running legacy
// `inject_embed_file_helper(mut files)` followed by
// `ast.flatten_files(files)`: same builtin-file routing, same helper
// stmt payload, same final file root edges (attrs / imports unchanged,
// stmts list extended by the same stmt ids).
pub fn (mut t Transformer) inject_embed_file_helper_to_flat(mut out ast.FlatBuilder) {
    parts := t.inject_embed_file_helper_parts_from_flat(&out.flat) or { return }
    mut extra_ids := []ast.FlatNodeId{cap: parts.extra_stmts.len}
    for stmt in parts.extra_stmts {
        extra_ids << out.emit_stmt(stmt)
    }
    out.append_file_stmts(parts.builtin_idx, extra_ids)
}

// transform_files transforms all files and returns transformed copies
pub fn (mut t Transformer) transform_files(files []ast.File) []ast.File {
    timing := os.getenv('V2_TTIME') != ''
    mut sw := time.new_stopwatch()
    t_print_mem('enter')
    t.pre_pass(files)
    t_print_mem('after pre_pass')
    if timing {
        eprintln('  [ttime] sequential pre_pass: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    files_to_transform := t.prepare_files_for_transform(files)
    t_print_mem('after prepare/monomorphize')
    if timing {
        eprintln('  [ttime] sequential prepare: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    mut result := []ast.File{cap: files_to_transform.len}
    for file in files_to_transform {
        result << t.transform_file(file)
    }
    t_print_mem('after per-file loop')
    if timing {
        eprintln('  [ttime] sequential per-file: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    t.post_pass(mut result)
    t_print_mem('after post_pass')
    if timing {
        eprintln('  [ttime] sequential post_pass: ${sw.elapsed().milliseconds()}ms')
    }
    return result
}

// transform_files_from_flat drives the same per-file transform pipeline
// but seeds the pre-pass accumulators from FlatAst rather than from the
// legacy ast.File list.
//
// Monomorphization needs the full file set up front (it builds a
// cross-file generic-decl index), so flat input is prepared once and then
// rehydrated one file at a time when `files` is empty.
pub fn (mut t Transformer) transform_files_from_flat(flat &ast.FlatAst, files []ast.File) []ast.File {
    mut result := t.transform_files_from_flat_no_post_pass(flat, files)
    t.post_pass(mut result)
    return result
}

// transform_files_from_flat_no_post_pass is the extraction of
// `transform_files_from_flat`'s per-file transform loop, without the
// trailing `post_pass` call. Both `transform_files_from_flat` (legacy
// wrapper, calls `post_pass` after) and
// `transform_files_to_flat_via_driver` (new flat-output path, calls
// `post_pass_to_flat` on the flattened output instead) call this helper.
fn (mut t Transformer) transform_files_from_flat_no_post_pass(flat &ast.FlatAst, files []ast.File) []ast.File {
    timing := os.getenv('V2_TTIME') != ''
    file_timing := os.getenv('V2_TTIME_FILES') != ''
    mut sw := time.new_stopwatch()
    t_print_mem('flat no-post enter')
    t.pre_pass_from_flat(flat)
    t_print_mem('flat no-post after pre_pass')
    if timing {
        eprintln('  [ttime] flat no-post pre_pass: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    if t.needs_full_files_for_transform() {
        if files.len == 0 {
            extra_stmts := t.prepare_flat_for_transform(flat)
            t_print_mem('flat no-post after prepare/monomorphize')
            if timing {
                eprintln('  [ttime] flat no-post prepare: ${sw.elapsed().milliseconds()}ms')
                sw = time.new_stopwatch()
            }
            mut result := []ast.File{cap: flat.files.len}
            for i in 0 .. flat.files.len {
                mut fsw := time.new_stopwatch()
                src_file := prepared_flat_file_for_transform(flat, extra_stmts, i) or { continue }
                result << t.transform_file(src_file)
                if file_timing {
                    eprintln('  [ttime-file] flat no-post: ${src_file.name} ${fsw.elapsed().milliseconds()}ms')
                }
            }
            t_print_mem('flat no-post after per-file loop')
            if timing {
                eprintln('  [ttime] flat no-post per-file: ${sw.elapsed().milliseconds()}ms')
            }
            return result
        }
        files_to_transform := t.prepare_files_for_transform(files)
        t_print_mem('flat no-post after prepare/monomorphize')
        if timing {
            eprintln('  [ttime] flat no-post prepare: ${sw.elapsed().milliseconds()}ms')
            sw = time.new_stopwatch()
        }
        mut result := []ast.File{cap: files_to_transform.len}
        for file in files_to_transform {
            mut fsw := time.new_stopwatch()
            result << t.transform_file(file)
            if file_timing {
                eprintln('  [ttime-file] flat no-post: ${file.name} ${fsw.elapsed().milliseconds()}ms')
            }
        }
        t_print_mem('flat no-post after per-file loop')
        if timing {
            eprintln('  [ttime] flat no-post per-file: ${sw.elapsed().milliseconds()}ms')
        }
        return result
    }
    if files.len > 0 {
        mut result := []ast.File{cap: files.len}
        for file in files {
            mut fsw := time.new_stopwatch()
            result << t.transform_file(file)
            if file_timing {
                eprintln('  [ttime-file] flat no-post: ${file.name} ${fsw.elapsed().milliseconds()}ms')
            }
        }
        t_print_mem('flat no-post after per-file loop')
        if timing {
            eprintln('  [ttime] flat no-post per-file: ${sw.elapsed().milliseconds()}ms')
        }
        return result
    }
    mut result := []ast.File{cap: flat.files.len}
    for i in 0 .. flat.files.len {
        mut fsw := time.new_stopwatch()
        src_file := flat_file_for_transform(flat, i, []ast.Stmt{}) or { continue }
        result << t.transform_file(src_file)
        if file_timing {
            eprintln('  [ttime-file] flat no-post: ${src_file.name} ${fsw.elapsed().milliseconds()}ms')
        }
    }
    t_print_mem('flat no-post after per-file loop')
    if timing {
        eprintln('  [ttime] flat no-post per-file: ${sw.elapsed().milliseconds()}ms')
    }
    return result
}

// transform_files_to_flat is the legacy-compatible flat-output entry point.
// It wraps transform_files_from_flat + ast.flatten_files and returns both the
// FlatAst and transformed files for callers that still need []ast.File.
//
// NO PRODUCTION CALLERS remain: the builder uses transform_flat_to_flat_direct
// (sequential) / transform_files_parallel_flat_direct (parallel) for every
// backend, and .v/eval rehydrate via flat.to_files() at the codegen boundary.
// Kept only as the legacy parity reference for the flat-diff test suite; delete
// together with the remaining decode-fallback arms once the cursor-native
// transform is complete.
pub fn (mut t Transformer) transform_files_to_flat(flat &ast.FlatAst, files []ast.File) (ast.FlatAst, []ast.File) {
    result := t.transform_files_from_flat(flat, files)
    return ast.flatten_files(result), result
}

// transform_files_to_flat_via_driver is the post_pass_to_flat-based
// counterpart to `transform_files_to_flat`. Same external shape (returns
// `(ast.FlatAst, []ast.File)`) but uses the s161 driver instead of the
// `legacy post_pass + flatten_files` boundary:
//
//   1. Per-file transform via `transform_files_from_flat_no_post_pass`
//      (skips legacy `post_pass`).
//   2. Compute `generated_fns_parts` against the un-post_pass'd result
//      (the parts helper walks `[]ast.File` to determine module routing
//      for generated fns; the file set is the same as legacy at this point).
//   3. Flatten the un-post_pass'd files into a fresh FlatBuilder.
//   4. Run `post_pass_to_flat(mut builder, generated_parts)` — the s161
//      driver appends/prepends/replaces stmts on the flat directly.
//   5. Apply the non-file post_pass tail (synth_types accumulator,
//      fn_scopes propagation, `propagate_types`) which mutates `t.env`
//      and `result` but not the flat output.
//
// Bit-equivalent to legacy in TREE STRUCTURE (each file's stmts list
// holds the same content) but NOT bit-equal in `signature()`: the
// `.file.extra` slot stores `intern(mod)` as a raw intern index, and the
// two paths intern strings in different orders (legacy interns
// post-pass-added strings DURING `flatten_files` walk, leaving later
// files' mod strings at large indices; new path interns all bare files
// first then post-pass-added strings AFTER, leaving later files' mod
// strings at small indices). Compare via per-file `subtree_signature` of
// the stmts list (file root edge 2) to assert structural parity.
//
// Memory: this avoids the legacy post_pass + flatten_files boundary but still
// returns []ast.File for compatibility consumers.
//
// NO PRODUCTION CALLERS remain (every backend transforms flat-direct; .v/eval
// rehydrate at the codegen boundary). Kept only as the legacy parity reference
// for tests; delete once the cursor-native transform is complete.
pub fn (mut t Transformer) transform_files_to_flat_via_driver(flat &ast.FlatAst, files []ast.File) (ast.FlatAst, []ast.File) {
    timing := os.getenv('V2_TTIME') != ''
    mut sw := time.new_stopwatch()
    mut result := t.transform_files_from_flat_no_post_pass(flat, files)
    t_print_mem('flat driver after no-post')
    if timing {
        eprintln('  [ttime] flat driver no-post: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    mut builder := ast.new_flat_builder()
    for file in result {
        builder.append_file(file)
    }
    t_print_mem('flat driver after append')
    if timing {
        eprintln('  [ttime] flat driver append: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    // Compute parts against the freshly-appended flat (s166): no longer
    // needs `result []ast.File` for explicit_str / module routing — both
    // `explicit_str_method_fn_names_from_flat` (s165) and
    // `generated_fn_module_from_flat` (s164) walk `builder.flat` directly.
    generated_parts := t.generated_fns_parts_from_flat(&builder.flat)
    t_print_mem('flat driver after generated parts')
    if timing {
        eprintln('  [ttime] flat driver generated parts: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    t.post_pass_to_flat(mut builder, generated_parts)
    t_print_mem('flat driver after post_pass_to_flat')
    if timing {
        eprintln('  [ttime] flat driver post_pass_to_flat: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    t.post_pass_files_with_generated_parts(mut result, generated_parts)
    t_print_mem('flat driver after files generated parts')
    if timing {
        eprintln('  [ttime] flat driver files generated parts: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    // The compatibility files now receive the same file-mutating post-pass
    // edits as the flat output, so run the non-file tail on those files for
    // downstream legacy consumers.
    t.apply_post_pass_tail(result)
    t_print_mem('flat driver after post_pass tail')
    if timing {
        eprintln('  [ttime] flat driver post_pass tail: ${sw.elapsed().milliseconds()}ms')
    }
    return builder.flat, result
}

// transform_files_to_flat_direct transforms `files` into a FlatAst without
// collecting the transformed legacy []ast.File result. The input still goes
// through the existing whole-program generic preparation, but each prepared file
// is emitted through transform_file_to_flat and is then immediately consumed by
// the FlatBuilder. This is the low-memory path used by native backends that can
// consume post-transform FlatAst directly.
pub fn (mut t Transformer) transform_files_to_flat_direct(files []ast.File) ast.FlatAst {
    timing := os.getenv('V2_TTIME') != ''
    mut sw := time.new_stopwatch()
    t_print_mem('enter')
    t.pre_pass(files)
    t_print_mem('after pre_pass')
    if timing {
        eprintln('  [ttime] flat direct pre_pass: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    files_to_transform := t.prepare_files_for_transform(files)
    t_print_mem('after prepare/monomorphize')
    if timing {
        eprintln('  [ttime] flat direct prepare: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    mut builder := new_transform_output_flat_builder(files_to_transform)
    for file in files_to_transform {
        t.transform_file_to_flat(t.file_without_open_generic_fn_decls(file), mut builder)
    }
    t_print_mem('after per-file flat loop')
    if timing {
        eprintln('  [ttime] flat direct per-file: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    generated_parts := t.generated_fns_parts_from_flat(&builder.flat)
    t.post_pass_to_flat(mut builder, generated_parts)
    t.apply_post_pass_tail_from_flat(&builder.flat)
    t_print_mem('after post_pass')
    if timing {
        eprintln('  [ttime] flat direct post_pass: ${sw.elapsed().milliseconds()}ms')
    }
    return builder.flat
}

// transform_flat_to_flat_direct transforms flat input into flat output without
// collecting a whole legacy []ast.File input or the transformed legacy output.
// Generic monomorphization is append-only, so flat preparation keeps cloned
// declarations in a per-file side table and the per-file loop reads top-level
// statements from cursors, decoding only each statement handed to legacy
// lowering helpers.
pub fn (mut t Transformer) transform_flat_to_flat_direct(flat &ast.FlatAst, files []ast.File) ast.FlatAst {
    if files.len > 0 {
        return t.transform_files_to_flat_direct(files)
    }
    timing := os.getenv('V2_TTIME') != ''
    mut sw := time.new_stopwatch()
    t_print_mem('enter')
    t.pre_pass_from_flat(flat)
    t_print_mem('after pre_pass')
    if timing {
        eprintln('  [ttime] flat input direct pre_pass: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    extra_stmts := t.prepare_flat_for_transform(flat)
    t_print_mem('after prepare/monomorphize')
    if timing {
        eprintln('  [ttime] flat input direct prepare: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    mut builder := new_transform_output_flat_builder_from_flat(flat)
    for i in 0 .. flat.files.len {
        extra := extra_stmts[i] or { []ast.Stmt{} }
        t.transform_flat_file_index_to_flat(flat, i, extra, mut builder)
    }
    t_print_mem('after per-file flat loop')
    if timing {
        eprintln('  [ttime] flat input direct per-file: ${sw.elapsed().milliseconds()}ms')
        sw = time.new_stopwatch()
    }
    generated_parts := t.generated_fns_parts_from_flat(&builder.flat)
    t.post_pass_to_flat(mut builder, generated_parts)
    t.apply_post_pass_tail_from_flat(&builder.flat)
    t_print_mem('after post_pass')
    if timing {
        eprintln('  [ttime] flat input direct post_pass: ${sw.elapsed().milliseconds()}ms')
    }
    t.dump_flat_fallback_stats()
    return builder.flat
}

fn (t &Transformer) file_without_open_generic_fn_decls(file ast.File) ast.File {
    mut has_open_generic_fn := false
    for stmt in file.stmts {
        if stmt is ast.FnDecl && t.omit_backend_generic_decl(stmt) {
            has_open_generic_fn = true
            break
        }
    }
    if !has_open_generic_fn {
        return file
    }
    mut stmts := []ast.Stmt{cap: file.stmts.len}
    for stmt in file.stmts {
        if stmt is ast.FnDecl && t.omit_backend_generic_decl(stmt) {
            continue
        }
        stmts << stmt
    }
    return ast.File{
        attributes:     file.attributes
        mod:            file.mod
        name:           file.name
        stmts:          stmts
        imports:        file.imports
        selector_names: file.selector_names
    }
}

// count_flat_fallback records one legacy-decode fallback hit for a cursor
// transform arm. Used to prioritize the remaining flat-native migration.
@[inline]
fn (mut t Transformer) count_flat_fallback(key string) {
    t.flat_fb_counts[key]++
}

// dump_flat_fallback_stats prints the per-arm legacy-decode fallback counts
// recorded during the transform, gated on V2_FLAT_FB_STATS.
fn (t &Transformer) dump_flat_fallback_stats() {
    if os.getenv('V2_FLAT_FB_STATS') == '' {
        return
    }
    mut keys := t.flat_fb_counts.keys()
    keys.sort_with_compare(fn [t] (a &string, b &string) int {
        return t.flat_fb_counts[*b] - t.flat_fb_counts[*a]
    })
    mut total := 0
    for k in keys {
        total += t.flat_fb_counts[k]
    }
    eprintln('[flat-fb] total legacy-decode fallbacks: ${total}')
    for k in keys {
        eprintln('[flat-fb]   ${t.flat_fb_counts[k]:8} ${k}')
    }
}

fn new_transform_output_flat_builder(files []ast.File) ast.FlatBuilder {
    mut total_bytes := i64(0)
    for file in files {
        if file.name == '' || !os.exists(file.name) {
            continue
        }
        total_bytes += os.file_size(file.name)
    }
    nodes_cap, edges_cap, strings_cap := ast.arena_caps_for_bytes(total_bytes * 2)
    return ast.new_flat_builder_with_capacity(nodes_cap, edges_cap, strings_cap)
}

fn new_transform_output_flat_builder_from_flat(flat &ast.FlatAst) ast.FlatBuilder {
    mut total_bytes := i64(0)
    for ff in flat.files {
        name := flat.file_name(ff)
        if name == '' || !os.exists(name) {
            continue
        }
        total_bytes += os.file_size(name)
    }
    nodes_cap, edges_cap, strings_cap := ast.arena_caps_for_bytes(total_bytes * 2)
    return ast.new_flat_builder_with_capacity(nodes_cap, edges_cap, strings_cap)
}

fn prepared_flat_file_for_transform(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt, fi int) ?ast.File {
    extra := extra_stmts[fi] or { []ast.Stmt{} }
    return flat_file_for_transform(flat, fi, extra)
}

fn flat_file_for_transform(flat &ast.FlatAst, fi int, extra_stmts []ast.Stmt) ?ast.File {
    if fi < 0 || fi >= flat.files.len {
        return none
    }
    fc := flat.file_cursor(fi)
    stmt_list := fc.stmts()
    mut stmts := []ast.Stmt{cap: stmt_list.len() + extra_stmts.len}
    for i in 0 .. stmt_list.len() {
        stmts << stmt_list.at(i).stmt()
    }
    if extra_stmts.len > 0 {
        stmts << extra_stmts
    }
    return ast.File{
        name:           fc.name()
        mod:            fc.mod()
        selector_names: fc.selector_names()
        attributes:     fc.attrs().attributes()
        imports:        fc.imports().import_stmts()
        stmts:          stmts
    }
}

fn runtime_const_init_base_name(mod string) string {
    mut suffix := if mod == '' { 'main' } else { mod }
    suffix = suffix.replace('.', '_').replace('-', '_')
    return '__v_init_consts_${suffix}'
}

fn runtime_const_init_call_name(mod string, fn_name string) string {
    if mod != '' && mod != 'main' && mod != 'builtin' {
        return '${mod}__${fn_name}'
    }
    return fn_name
}

fn module_init_call_name(mod string) string {
    if mod != '' && mod != 'main' && mod != 'builtin' {
        return '${mod}__init'
    }
    return 'init'
}

fn (t &Transformer) uses_minimal_windows_x64_runtime() bool {
    return t.pref != unsafe { nil } && t.pref.backend == .x64 && t.pref.get_effective_arch() == .x64
        && t.pref.target_os_or_host().to_lower() == 'windows'
}

fn (t &Transformer) uses_minimal_linux_x64_runtime() bool {
    return t.pref != unsafe { nil } && t.pref.backend == .x64 && t.pref.get_effective_arch() == .x64
        && t.pref.target_os_or_host().to_lower() == 'linux'
}

fn (t &Transformer) uses_minimal_x64_runtime() bool {
    return t.uses_minimal_windows_x64_runtime() || t.uses_minimal_linux_x64_runtime()
        || t.macos_tiny_candidate_graph
}

fn (t &Transformer) collect_runtime_init_imports_from_if_expr(node ast.IfExpr, mut imports []ast.ImportStmt) {
    if t.eval_comptime_cond(node.cond) {
        t.collect_runtime_init_imports_from_stmts(node.stmts, mut imports)
        return
    }
    match node.else_expr {
        ast.IfExpr {
            if node.else_expr.cond is ast.EmptyExpr {
                t.collect_runtime_init_imports_from_stmts(node.else_expr.stmts, mut imports)
            } else {
                t.collect_runtime_init_imports_from_if_expr(node.else_expr, mut imports)
            }
        }
        else {}
    }
}

fn (t &Transformer) collect_runtime_init_imports_from_stmts(stmts []ast.Stmt, mut imports []ast.ImportStmt) {
    for stmt in stmts {
        match stmt {
            ast.ImportStmt {
                imports << stmt
            }
            ast.ExprStmt {
                if stmt.expr is ast.ComptimeExpr && stmt.expr.expr is ast.IfExpr {
                    t.collect_runtime_init_imports_from_if_expr(stmt.expr.expr, mut imports)
                }
            }
            else {}
        }
    }
}

fn (t &Transformer) active_runtime_init_imports(file ast.File) []ast.ImportStmt {
    mut imports := file.imports.clone()
    t.collect_runtime_init_imports_from_stmts(file.stmts, mut imports)
    return imports
}

fn runtime_init_available_modules(files []ast.File) map[string]bool {
    mut available := map[string]bool{}
    available[''] = true
    available['main'] = true
    for file in files {
        if file.mod != '' {
            available[file.mod] = true
        }
    }
    return available
}

fn add_runtime_init_module_key(mut modules map[string]bool, name string, available map[string]bool) bool {
    if name == '' {
        return false
    }
    mut changed := false
    mut matched_available := false
    mut candidates := [name]
    if name.contains('.') {
        short_name := name.all_after_last('.')
        if short_name != '' {
            candidates << short_name
        }
    }
    for candidate in candidates {
        if candidate !in available {
            continue
        }
        matched_available = true
        if candidate !in modules {
            modules[candidate] = true
            changed = true
        }
    }
    if !matched_available && name !in modules {
        modules[name] = true
        changed = true
    }
    return changed
}

fn (t &Transformer) imported_runtime_init_modules(files []ast.File) map[string]bool {
    mut modules := map[string]bool{}
    modules[''] = true
    available_modules := runtime_init_available_modules(files)
    add_runtime_init_module_key(mut modules, 'main', available_modules)
    mut changed := true
    for changed {
        changed = false
        for file in files {
            if file.mod !in modules {
                continue
            }
            for imp in t.active_runtime_init_imports(file) {
                changed = add_runtime_init_module_key(mut modules, imp.name, available_modules)
                    || changed
            }
        }
    }
    return modules
}

fn runtime_init_available_modules_from_flat(flat &ast.FlatAst) map[string]bool {
    mut available := map[string]bool{}
    available[''] = true
    available['main'] = true
    for ff in flat.files {
        mod_name := flat.file_mod(ff)
        if mod_name != '' {
            available[mod_name] = true
        }
    }
    return available
}

fn (t &Transformer) collect_runtime_init_imports_from_if_expr_cursor(node ast.Cursor, mut imports []ast.ImportStmt) {
    if !node.is_valid() || node.kind() != .expr_if {
        return
    }
    cond := node.edge(0)
    if t.eval_comptime_cond_cursor(cond) {
        t.collect_runtime_init_imports_from_if_cursor_stmts(node, mut imports)
        return
    }
    else_expr := node.edge(1)
    if !else_expr.is_valid() || else_expr.kind() != .expr_if {
        return
    }
    else_cond := else_expr.edge(0)
    if !else_cond.is_valid() || else_cond.kind() == .expr_empty {
        t.collect_runtime_init_imports_from_if_cursor_stmts(else_expr, mut imports)
        return
    }
    t.collect_runtime_init_imports_from_if_expr_cursor(else_expr, mut imports)
}

fn (t &Transformer) collect_runtime_init_imports_from_if_cursor_stmts(node ast.Cursor, mut imports []ast.ImportStmt) {
    for i in 2 .. node.edge_count() {
        t.collect_runtime_init_imports_from_stmt_cursor(node.edge(i), mut imports)
    }
}

fn (t &Transformer) collect_runtime_init_imports_from_stmt_cursor(stmt ast.Cursor, mut imports []ast.ImportStmt) {
    if !stmt.is_valid() {
        return
    }
    match stmt.kind() {
        .stmt_import {
            imports << stmt.import_stmt()
        }
        .stmt_expr {
            expr := stmt.edge(0)
            if !expr.is_valid() || expr.kind() != .expr_comptime {
                return
            }
            inner := expr.edge(0)
            if inner.is_valid() && inner.kind() == .expr_if {
                t.collect_runtime_init_imports_from_if_expr_cursor(inner, mut imports)
            }
        }
        else {}
    }
}

fn (t &Transformer) collect_runtime_init_imports_from_stmt_cursors(stmts ast.CursorList, mut imports []ast.ImportStmt) {
    for i in 0 .. stmts.len() {
        t.collect_runtime_init_imports_from_stmt_cursor(stmts.at(i), mut imports)
    }
}

fn (t &Transformer) active_runtime_init_imports_from_flat_file(fc ast.FileCursor) []ast.ImportStmt {
    file_imports := fc.imports()
    mut imports := []ast.ImportStmt{cap: file_imports.len()}
    for i in 0 .. file_imports.len() {
        imp := file_imports.at(i)
        if imp.kind() == .stmt_import {
            imports << imp.import_stmt()
        }
    }
    t.collect_runtime_init_imports_from_stmt_cursors(fc.stmts(), mut imports)
    return imports
}

fn (t &Transformer) imported_runtime_init_modules_from_flat(flat &ast.FlatAst) map[string]bool {
    mut modules := map[string]bool{}
    modules[''] = true
    available_modules := runtime_init_available_modules_from_flat(flat)
    add_runtime_init_module_key(mut modules, 'main', available_modules)
    mut changed := true
    for changed {
        changed = false
        for i in 0 .. flat.files.len {
            fc := flat.file_cursor(i)
            if fc.mod() !in modules {
                continue
            }
            for imp in t.active_runtime_init_imports_from_flat_file(fc) {
                changed = add_runtime_init_module_key(mut modules, imp.name, available_modules)
                    || changed
            }
        }
    }
    return modules
}

fn is_builtin_main_arg_global(mod string, name string) bool {
    return mod == 'builtin' && (name == 'g_main_argc' || name == 'g_main_argv')
}

fn runtime_const_known_key(mod string, name string) string {
    return '${mod.len}:${mod}:${name}'
}

fn (mut t Transformer) record_runtime_const_init(mod string, name string, expr ast.Expr) {
    if name == '' {
        return
    }
    known_key := runtime_const_known_key(mod, name)
    t.runtime_const_storage_known[known_key] = true
    if known_key in t.runtime_const_known {
        return
    }
    t.runtime_const_known[known_key] = true
    if mod !in t.runtime_const_inits_by_mod {
        t.runtime_const_modules << mod
    }
    mut inits := t.runtime_const_inits_by_mod[mod] or { []RuntimeConstInit{} }
    inits << RuntimeConstInit{
        name: name
        expr: expr
    }
    t.runtime_const_inits_by_mod[mod] = inits
}

fn (mut t Transformer) record_runtime_const_init_cursor(mod string, name string, expr ast.Cursor) {
    if name == '' {
        return
    }
    known_key := runtime_const_known_key(mod, name)
    t.runtime_const_storage_known[known_key] = true
    if known_key in t.runtime_const_known {
        return
    }
    t.runtime_const_known[known_key] = true
    if mod !in t.runtime_const_inits_by_mod {
        t.runtime_const_modules << mod
    }
    mut inits := t.runtime_const_inits_by_mod[mod] or { []RuntimeConstInit{} }
    inits << RuntimeConstInit{
        name:        name
        expr_cursor: expr
    }
    t.runtime_const_inits_by_mod[mod] = inits
}

fn (t &Transformer) expr_depends_on_runtime_const(mod string, expr ast.Expr) bool {
    match expr {
        ast.Ident {
            key := runtime_const_known_key(mod, expr.name)
            return key in t.runtime_const_known || key in t.runtime_const_storage_known
        }
        ast.SelectorExpr {
            if t.expr_depends_on_runtime_const(mod, expr.lhs) {
                return true
            }
            if expr.lhs is ast.Ident {
                key := runtime_const_known_key(expr.lhs.name, expr.rhs.name)
                return key in t.runtime_const_known || key in t.runtime_const_storage_known
            }
            return false
        }
        ast.CallExpr {
            if t.expr_depends_on_runtime_const(mod, expr.lhs) {
                return true
            }
            for arg in expr.args {
                if t.expr_depends_on_runtime_const(mod, arg) {
                    return true
                }
            }
            return false
        }
        ast.CallOrCastExpr {
            return t.expr_depends_on_runtime_const(mod, expr.lhs)
                || t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.CastExpr {
            return t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.ParenExpr {
            return t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.PrefixExpr {
            return t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.PostfixExpr {
            return t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.ModifierExpr {
            return t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.IndexExpr {
            return t.expr_depends_on_runtime_const(mod, expr.lhs)
                || t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.InfixExpr {
            return t.expr_depends_on_runtime_const(mod, expr.lhs)
                || t.expr_depends_on_runtime_const(mod, expr.rhs)
        }
        ast.IfExpr {
            if t.expr_depends_on_runtime_const(mod, expr.cond)
                || t.expr_depends_on_runtime_const(mod, expr.else_expr) {
                return true
            }
            for stmt in expr.stmts {
                if stmt is ast.ExprStmt && t.expr_depends_on_runtime_const(mod, stmt.expr) {
                    return true
                }
            }
            return false
        }
        ast.OrExpr {
            if t.expr_depends_on_runtime_const(mod, expr.expr) {
                return true
            }
            for stmt in expr.stmts {
                if stmt is ast.ExprStmt && t.expr_depends_on_runtime_const(mod, stmt.expr) {
                    return true
                }
            }
            return false
        }
        ast.StringInterLiteral {
            for inter in expr.inters {
                if t.expr_depends_on_runtime_const(mod, inter.expr)
                    || t.expr_depends_on_runtime_const(mod, inter.format_expr) {
                    return true
                }
            }
            return false
        }
        ast.ComptimeExpr {
            return t.expr_depends_on_runtime_const(mod, expr.expr)
        }
        ast.UnsafeExpr {
            for stmt in expr.stmts {
                if stmt is ast.ExprStmt && t.expr_depends_on_runtime_const(mod, stmt.expr) {
                    return true
                }
            }
            return false
        }
        ast.ArrayInitExpr {
            for e in expr.exprs {
                if t.expr_depends_on_runtime_const(mod, e) {
                    return true
                }
            }
            return (expr.init !is ast.EmptyExpr && t.expr_depends_on_runtime_const(mod, expr.init))
                || (expr.len !is ast.EmptyExpr && t.expr_depends_on_runtime_const(mod, expr.len))
                || (expr.cap !is ast.EmptyExpr && t.expr_depends_on_runtime_const(mod, expr.cap))
        }
        ast.InitExpr {
            for field in expr.fields {
                if t.expr_depends_on_runtime_const(mod, field.value) {
                    return true
                }
            }
            return false
        }
        ast.MapInitExpr {
            for key in expr.keys {
                if t.expr_depends_on_runtime_const(mod, key) {
                    return true
                }
            }
            for val in expr.vals {
                if t.expr_depends_on_runtime_const(mod, val) {
                    return true
                }
            }
            return false
        }
        else {
            return false
        }
    }
}

fn expr_cursor_is_empty(c ast.Cursor) bool {
    return !c.is_valid() || c.kind() == .expr_empty
}

fn (t &Transformer) expr_depends_on_runtime_const_cursor(mod string, expr ast.Cursor) bool {
    if !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_ident {
            key := runtime_const_known_key(mod, expr.name())
            return key in t.runtime_const_known || key in t.runtime_const_storage_known
        }
        .expr_selector {
            lhs := expr.edge(0)
            if t.expr_depends_on_runtime_const_cursor(mod, lhs) {
                return true
            }
            rhs := expr.edge(1)
            if lhs.kind() == .expr_ident && rhs.kind() == .expr_ident {
                key := runtime_const_known_key(lhs.name(), rhs.name())
                return key in t.runtime_const_known || key in t.runtime_const_storage_known
            }
            return false
        }
        .expr_call {
            if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        .expr_call_or_cast, .expr_index, .expr_infix {
            return t.expr_depends_on_runtime_const_cursor(mod, expr.edge(0))
                || t.expr_depends_on_runtime_const_cursor(mod, expr.edge(1))
        }
        .expr_cast {
            return t.expr_depends_on_runtime_const_cursor(mod, expr.edge(1))
        }
        .expr_comptime, .expr_modifier, .expr_paren, .expr_postfix, .expr_prefix {
            return t.expr_depends_on_runtime_const_cursor(mod, expr.edge(0))
        }
        .expr_if {
            if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(0))
                || t.expr_depends_on_runtime_const_cursor(mod, expr.edge(1)) {
                return true
            }
            for i in 2 .. expr.edge_count() {
                if t.expr_stmt_depends_on_runtime_const_cursor(mod, expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        .expr_or {
            if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(0)) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if t.expr_stmt_depends_on_runtime_const_cursor(mod, expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        .expr_string_inter {
            inters := expr.list_at(1)
            for i in 0 .. inters.len() {
                inter := inters.at(i)
                if t.expr_depends_on_runtime_const_cursor(mod, inter.edge(0))
                    || t.expr_depends_on_runtime_const_cursor(mod, inter.edge(1)) {
                    return true
                }
            }
            return false
        }
        .expr_unsafe {
            for i in 0 .. expr.edge_count() {
                if t.expr_stmt_depends_on_runtime_const_cursor(mod, expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        .expr_array_init {
            for i in 5 .. expr.edge_count() {
                if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(i)) {
                    return true
                }
            }
            return (!expr_cursor_is_empty(expr.edge(1))
                && t.expr_depends_on_runtime_const_cursor(mod, expr.edge(1)))
                || (!expr_cursor_is_empty(expr.edge(3))
                && t.expr_depends_on_runtime_const_cursor(mod, expr.edge(3)))
                || (!expr_cursor_is_empty(expr.edge(2))
                && t.expr_depends_on_runtime_const_cursor(mod, expr.edge(2)))
        }
        .expr_init {
            for i in 1 .. expr.edge_count() {
                if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(i).edge(0)) {
                    return true
                }
            }
            return false
        }
        .expr_map_init {
            keys_len := expr.extra_int()
            for i in 0 .. keys_len {
                if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(1 + i)) {
                    return true
                }
            }
            for i in (1 + keys_len) .. expr.edge_count() {
                if t.expr_depends_on_runtime_const_cursor(mod, expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        else {
            return false
        }
    }
}

fn (t &Transformer) expr_stmt_depends_on_runtime_const_cursor(mod string, stmt ast.Cursor) bool {
    return stmt.is_valid() && stmt.kind() == .stmt_expr
        && t.expr_depends_on_runtime_const_cursor(mod, stmt.edge(0))
}

fn (mut t Transformer) collect_runtime_const_inits(files []ast.File) {
    is_native := t.pref != unsafe { nil } && (t.is_native_be || t.pref.backend == .c)
    t.runtime_const_inits_by_mod.clear()
    t.runtime_const_modules.clear()
    t.runtime_const_init_fn_name.clear()
    t.runtime_const_known = map[string]bool{}
    t.runtime_const_storage_known = map[string]bool{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.ConstDecl {
                for field in stmt.fields {
                    if t.const_initializer_emits_storage(field.value, is_native) {
                        t.runtime_const_storage_known[runtime_const_known_key(file.mod, field.name)] = true
                    }
                }
            }
        }
    }
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.ConstDecl {
                for field in stmt.fields {
                    if !t.needs_runtime_const_init(field.value, is_native) {
                        continue
                    }
                    t.record_runtime_const_init(file.mod, field.name, field.value)
                }
            }
            if stmt is ast.GlobalDecl {
                for field in stmt.fields {
                    if is_builtin_main_arg_global(file.mod, field.name) {
                        continue
                    }
                    if !t.needs_runtime_global_init(field.value) {
                        continue
                    }
                    t.record_runtime_const_init(file.mod, field.name, field.value)
                }
            }
        }
    }
    mut changed := true
    for changed {
        changed = false
        for file in files {
            for stmt in file.stmts {
                if stmt is ast.ConstDecl {
                    for field in stmt.fields {
                        if runtime_const_known_key(file.mod, field.name) in t.runtime_const_known {
                            continue
                        }
                        if !t.expr_depends_on_runtime_const(file.mod, field.value) {
                            continue
                        }
                        t.record_runtime_const_init(file.mod, field.name, field.value)
                        changed = true
                    }
                }
            }
        }
    }
}

fn (mut t Transformer) collect_runtime_const_inits_from_flat(flat &ast.FlatAst) {
    is_native := t.pref != unsafe { nil } && (t.is_native_be || t.pref.backend == .c)
    t.runtime_const_inits_by_mod.clear()
    t.runtime_const_modules.clear()
    t.runtime_const_init_fn_name.clear()
    t.runtime_const_known = map[string]bool{}
    t.runtime_const_storage_known = map[string]bool{}
    for ff in flat.files {
        mod := flat.file_mod(ff)
        // Walk const field cursors directly. The analysis still materializes
        // the specific initializer expressions it needs, but no full ConstDecl.
        cdecls := ast.Cursor{
            flat: unsafe { flat }
            id:   ff.file_id
        }.list_at(2)
        for ci in 0 .. cdecls.len() {
            cc := cdecls.at(ci)
            if cc.kind() != .stmt_const_decl {
                continue
            }
            fields := cc.list_at(0)
            for fi in 0 .. fields.len() {
                field := fields.at(fi)
                field_name := field.name()
                if field_name == '' {
                    continue
                }
                value_c := field.edge(0)
                if t.const_initializer_emits_storage_cursor(value_c, is_native) {
                    t.runtime_const_storage_known[runtime_const_known_key(mod, field_name)] = true
                }
            }
        }
    }
    for ff in flat.files {
        mod := flat.file_mod(ff)
        // Decode only initializer expressions from const/global field cursors.
        cdecls := ast.Cursor{
            flat: unsafe { flat }
            id:   ff.file_id
        }.list_at(2)
        for ci in 0 .. cdecls.len() {
            cc := cdecls.at(ci)
            ck := cc.kind()
            if ck != .stmt_const_decl && ck != .stmt_global_decl {
                continue
            }
            if ck == .stmt_const_decl {
                fields := cc.list_at(0)
                for fi in 0 .. fields.len() {
                    field := fields.at(fi)
                    field_name := field.name()
                    if field_name == '' {
                        continue
                    }
                    value_c := field.edge(0)
                    if !t.needs_runtime_const_init_cursor(value_c, is_native) {
                        continue
                    }
                    t.record_runtime_const_init_cursor(mod, field_name, value_c)
                }
            }
            if ck == .stmt_global_decl {
                fields := cc.list_at(1)
                for fi in 0 .. fields.len() {
                    field := fields.at(fi)
                    field_name := field.name()
                    if field_name == '' {
                        continue
                    }
                    if is_builtin_main_arg_global(mod, field_name) {
                        continue
                    }
                    value_c := field.edge(1)
                    if !t.needs_runtime_global_init_cursor(value_c) {
                        continue
                    }
                    t.record_runtime_const_init_cursor(mod, field_name, value_c)
                }
            }
        }
    }
    mut changed := true
    for changed {
        changed = false
        for ff in flat.files {
            mod := flat.file_mod(ff)
            // s260: fixpoint loop — decode only const decls each iteration instead
            // of re-decoding the whole file (incl. fn bodies) every pass.
            cdecls := ast.Cursor{
                flat: unsafe { flat }
                id:   ff.file_id
            }.list_at(2)
            for ci in 0 .. cdecls.len() {
                cc := cdecls.at(ci)
                if cc.kind() != .stmt_const_decl {
                    continue
                }
                fields := cc.list_at(0)
                for fi in 0 .. fields.len() {
                    field := fields.at(fi)
                    field_name := field.name()
                    if field_name == '' {
                        continue
                    }
                    if runtime_const_known_key(mod, field_name) in t.runtime_const_known {
                        continue
                    }
                    value_c := field.edge(0)
                    if !t.expr_depends_on_runtime_const_cursor(mod, value_c) {
                        continue
                    }
                    t.record_runtime_const_init_cursor(mod, field_name, value_c)
                    changed = true
                }
            }
        }
    }
}

fn (t &Transformer) const_initializer_emits_storage(expr ast.Expr, is_native bool) bool {
    if t.needs_runtime_const_init(expr, is_native) {
        return true
    }
    if expr is ast.StringLiteral || expr is ast.StringInterLiteral {
        return true
    }
    if typ := t.get_expr_type(expr) {
        c_type := t.type_to_c_name(typ)
        return c_type == 'string' || c_type == 'array' || c_type.starts_with('Array_')
            || c_type.starts_with('Map_')
    }
    return false
}

fn (t &Transformer) const_initializer_emits_storage_cursor(expr ast.Cursor, is_native bool) bool {
    if t.needs_runtime_const_init_cursor(expr, is_native) {
        return true
    }
    if expr.is_valid() && (expr.kind() == .expr_string || expr.kind() == .expr_string_inter) {
        return true
    }
    if typ := t.get_expr_type_cursor(expr) {
        c_type := t.type_to_c_name(typ)
        return c_type == 'string' || c_type == 'array' || c_type.starts_with('Array_')
            || c_type.starts_with('Map_')
    }
    return false
}

fn (t &Transformer) contains_runtime_const_literal(expr ast.Expr, is_native bool) bool {
    match expr {
        ast.MapInitExpr {
            return true
        }
        ast.ArrayInitExpr {
            if is_native {
                return true
            }
            for e in expr.exprs {
                if t.contains_runtime_const_literal(e, is_native) {
                    return true
                }
            }
            return (expr.init !is ast.EmptyExpr
                && t.contains_runtime_const_literal(expr.init, is_native))
                || (expr.len !is ast.EmptyExpr
                && t.contains_runtime_const_literal(expr.len, is_native))
                || (expr.cap !is ast.EmptyExpr
                && t.contains_runtime_const_literal(expr.cap, is_native))
        }
        ast.InitExpr {
            if is_native {
                return true
            }
            for field in expr.fields {
                if t.contains_runtime_const_literal(field.value, is_native) {
                    return true
                }
            }
            return false
        }
        ast.CastExpr {
            return t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.ParenExpr {
            return t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.PrefixExpr {
            return t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.PostfixExpr {
            return t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.ModifierExpr {
            return t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.IndexExpr {
            return t.contains_runtime_const_literal(expr.lhs, is_native)
                || t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.InfixExpr {
            return t.contains_runtime_const_literal(expr.lhs, is_native)
                || t.contains_runtime_const_literal(expr.rhs, is_native)
        }
        ast.IfExpr {
            return true
        }
        ast.OrExpr, ast.StringInterLiteral, ast.UnsafeExpr {
            return true
        }
        ast.ComptimeExpr {
            return t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.CallExpr {
            if t.contains_runtime_const_literal(expr.lhs, is_native) {
                return true
            }
            for arg in expr.args {
                if t.contains_runtime_const_literal(arg, is_native) {
                    return true
                }
            }
            return false
        }
        ast.CallOrCastExpr {
            return t.contains_runtime_const_literal(expr.lhs, is_native)
                || t.contains_runtime_const_literal(expr.expr, is_native)
        }
        ast.SelectorExpr {
            return t.contains_runtime_const_literal(expr.lhs, is_native)
        }
        else {
            return false
        }
    }
}

fn (t &Transformer) contains_runtime_const_literal_cursor(expr ast.Cursor, is_native bool) bool {
    if !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_map_init {
            return true
        }
        .expr_array_init {
            if is_native {
                return true
            }
            for i in 5 .. expr.edge_count() {
                if t.contains_runtime_const_literal_cursor(expr.edge(i), is_native) {
                    return true
                }
            }
            return (!expr_cursor_is_empty(expr.edge(1))
                && t.contains_runtime_const_literal_cursor(expr.edge(1), is_native))
                || (!expr_cursor_is_empty(expr.edge(3))
                && t.contains_runtime_const_literal_cursor(expr.edge(3), is_native))
                || (!expr_cursor_is_empty(expr.edge(2))
                && t.contains_runtime_const_literal_cursor(expr.edge(2), is_native))
        }
        .expr_init {
            if is_native {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if t.contains_runtime_const_literal_cursor(expr.edge(i).edge(0), is_native) {
                    return true
                }
            }
            return false
        }
        .expr_cast {
            return t.contains_runtime_const_literal_cursor(expr.edge(1), is_native)
        }
        .expr_comptime, .expr_modifier, .expr_paren, .expr_postfix, .expr_prefix {
            return t.contains_runtime_const_literal_cursor(expr.edge(0), is_native)
        }
        .expr_index, .expr_infix {
            return t.contains_runtime_const_literal_cursor(expr.edge(0), is_native)
                || t.contains_runtime_const_literal_cursor(expr.edge(1), is_native)
        }
        .expr_if, .expr_or, .expr_string_inter, .expr_unsafe {
            return true
        }
        .expr_call {
            if t.contains_runtime_const_literal_cursor(expr.edge(0), is_native) {
                return true
            }
            for i in 1 .. expr.edge_count() {
                if t.contains_runtime_const_literal_cursor(expr.edge(i), is_native) {
                    return true
                }
            }
            return false
        }
        .expr_call_or_cast {
            return t.contains_runtime_const_literal_cursor(expr.edge(0), is_native)
                || t.contains_runtime_const_literal_cursor(expr.edge(1), is_native)
        }
        .expr_selector {
            return t.contains_runtime_const_literal_cursor(expr.edge(0), is_native)
        }
        else {
            return false
        }
    }
}

// needs_runtime_const_init checks whether a const initializer requires runtime
// initialization. For C/cleanc backends, direct calls and value-position if
// expressions need it because they cannot be emitted as C compile-time
// constants. Map literals are lowered to constructor calls, so they also need
// an injected const init assignment. For SSA-based backends (arm64, x64, c),
// array and struct literals also need runtime init because the SSA builder
// cannot embed them in the data segment.
fn (t &Transformer) needs_runtime_const_init(expr ast.Expr, is_native bool) bool {
    if t.contains_runtime_const_literal(expr, is_native) {
        return true
    }
    if t.contains_call_expr(expr) {
        return true
    }
    if expr is ast.IfExpr {
        return true
    }
    if expr is ast.OrExpr || expr is ast.StringInterLiteral || expr is ast.UnsafeExpr {
        return true
    }
    if expr is ast.ComptimeExpr {
        return t.needs_runtime_const_init(expr.expr, is_native)
    }
    // CallOrCastExpr: distinguish function calls from type casts.
    // Function calls (lowercase lhs, not a primitive type) need runtime init.
    // Type casts (uppercase lhs like IError(...), or primitives like int(...)) are compile-time.
    if expr is ast.CallOrCastExpr {
        if is_native {
            return true
        }
        if expr.lhs is ast.Ident {
            name := expr.lhs.name
            if name.len > 0 && name[0] >= `a` && name[0] <= `z`
                && name !in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'bool', 'rune', 'isize', 'usize', 'byte', 'voidptr', 'charptr', 'byteptr', 'string'] {
                return true
            }
        } else if expr.lhs is ast.SelectorExpr {
            // Module-qualified call like module.func(...)
            return true
        }
    }
    if is_native {
        if expr is ast.CastExpr {
            return true
        }
        if expr is ast.ArrayInitExpr {
            return true
        }
        if expr is ast.InitExpr {
            return true
        }
    }
    return false
}

fn (t &Transformer) needs_runtime_const_init_cursor(expr ast.Cursor, is_native bool) bool {
    if t.contains_runtime_const_literal_cursor(expr, is_native) {
        return true
    }
    if t.contains_call_expr_cursor(expr) {
        return true
    }
    if !expr.is_valid() {
        return false
    }
    if expr.kind() == .expr_if {
        return true
    }
    if expr.kind() in [.expr_or, .expr_string_inter, .expr_unsafe] {
        return true
    }
    if expr.kind() == .expr_comptime {
        return t.needs_runtime_const_init_cursor(expr.edge(0), is_native)
    }
    if expr.kind() == .expr_call_or_cast {
        if is_native {
            return true
        }
        lhs := expr.edge(0)
        if lhs.kind() == .expr_ident {
            name := lhs.name()
            if name.len > 0 && name[0] >= `a` && name[0] <= `z`
                && name !in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'bool', 'rune', 'isize', 'usize', 'byte', 'voidptr', 'charptr', 'byteptr', 'string'] {
                return true
            }
        } else if lhs.kind() == .expr_selector {
            return true
        }
    }
    if is_native && expr.kind() in [.expr_cast, .expr_array_init, .expr_init] {
        return true
    }
    return false
}

fn (t &Transformer) needs_runtime_global_init(expr ast.Expr) bool {
    match expr {
        ast.EmptyExpr {
            return false
        }
        ast.InitExpr, ast.MapInitExpr, ast.IfExpr, ast.CallOrCastExpr {
            return true
        }
        ast.OrExpr, ast.StringInterLiteral, ast.UnsafeExpr, ast.LockExpr, ast.MatchExpr {
            return true
        }
        ast.ComptimeExpr {
            return t.needs_runtime_global_init(expr.expr)
        }
        ast.ArrayInitExpr {
            if expr.typ is ast.Type && expr.typ is ast.ArrayFixedType {
                return t.contains_call_expr(expr)
            }
            return true
        }
        ast.CastExpr {
            return t.needs_runtime_global_init(expr.expr)
        }
        ast.ParenExpr {
            return t.needs_runtime_global_init(expr.expr)
        }
        ast.PrefixExpr {
            return t.needs_runtime_global_init(expr.expr)
        }
        ast.PostfixExpr {
            return t.needs_runtime_global_init(expr.expr)
        }
        ast.ModifierExpr {
            return t.needs_runtime_global_init(expr.expr)
        }
        ast.IndexExpr {
            return t.needs_runtime_global_init(expr.lhs) || t.needs_runtime_global_init(expr.expr)
        }
        ast.InfixExpr {
            return t.needs_runtime_global_init(expr.lhs) || t.needs_runtime_global_init(expr.rhs)
        }
        else {
            return t.contains_call_expr(expr)
        }
    }
}

fn (t &Transformer) needs_runtime_global_init_cursor(expr ast.Cursor) bool {
    if !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_empty {
            return false
        }
        .expr_init, .expr_map_init, .expr_if, .expr_call_or_cast {
            return true
        }
        .expr_or, .expr_string_inter, .expr_unsafe, .expr_lock, .expr_match {
            return true
        }
        .expr_comptime {
            return t.needs_runtime_global_init_cursor(expr.edge(0))
        }
        .expr_array_init {
            if expr.edge(0).kind() == .typ_array_fixed {
                return t.contains_call_expr_cursor(expr)
            }
            return true
        }
        .expr_cast {
            return t.needs_runtime_global_init_cursor(expr.edge(1))
        }
        .expr_modifier, .expr_paren, .expr_postfix, .expr_prefix {
            return t.needs_runtime_global_init_cursor(expr.edge(0))
        }
        .expr_index, .expr_infix {
            return t.needs_runtime_global_init_cursor(expr.edge(0))
                || t.needs_runtime_global_init_cursor(expr.edge(1))
        }
        else {
            return t.contains_call_expr_cursor(expr)
        }
    }
}

fn (t &Transformer) contains_call_expr_cursor(expr ast.Cursor) bool {
    return t.contains_call_expr_cursor_depth(0, expr)
}

fn (t &Transformer) runtime_const_init_contains_call(item RuntimeConstInit) bool {
    if item.expr_cursor.is_valid() {
        return t.contains_call_expr_cursor(item.expr_cursor)
    }
    return t.contains_call_expr(item.expr)
}

fn (t &Transformer) contains_call_expr_cursor_depth(depth int, expr ast.Cursor) bool {
    if depth > max_runtime_const_dep_expr_depth || !expr.is_valid() {
        return false
    }
    match expr.kind() {
        .expr_call {
            return true
        }
        .expr_cast {
            return t.contains_call_expr_cursor_depth(depth + 1, expr.edge(1))
        }
        .expr_call_or_cast {
            return t.contains_call_expr_cursor_depth(depth + 1, expr.edge(1))
        }
        .expr_paren, .expr_postfix, .expr_prefix {
            return t.contains_call_expr_cursor_depth(depth + 1, expr.edge(0))
        }
        .expr_infix, .expr_index {
            return t.contains_call_expr_cursor_depth(depth + 1, expr.edge(0))
                || t.contains_call_expr_cursor_depth(depth + 1, expr.edge(1))
        }
        .expr_array_init {
            for i in 5 .. expr.edge_count() {
                if t.contains_call_expr_cursor_depth(depth + 1, expr.edge(i)) {
                    return true
                }
            }
            return (!expr_cursor_is_empty(expr.edge(1))
                && t.contains_call_expr_cursor_depth(depth + 1, expr.edge(1)))
                || (!expr_cursor_is_empty(expr.edge(3))
                && t.contains_call_expr_cursor_depth(depth + 1, expr.edge(3)))
                || (!expr_cursor_is_empty(expr.edge(2))
                && t.contains_call_expr_cursor_depth(depth + 1, expr.edge(2)))
        }
        .expr_init {
            for i in 1 .. expr.edge_count() {
                if t.contains_call_expr_cursor_depth(depth + 1, expr.edge(i).edge(0)) {
                    return true
                }
            }
            return false
        }
        .expr_map_init {
            keys_len := expr.extra_int()
            for i in 0 .. keys_len {
                if t.contains_call_expr_cursor_depth(depth + 1, expr.edge(1 + i)) {
                    return true
                }
            }
            for i in (1 + keys_len) .. expr.edge_count() {
                if t.contains_call_expr_cursor_depth(depth + 1, expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        .expr_selector {
            return t.contains_call_expr_cursor_depth(depth + 1, expr.edge(0))
        }
        else {
            return false
        }
    }
}

fn (mut t Transformer) transform_expr_in_module(mod string, expr ast.Expr) ast.Expr {
    old_module := t.cur_module
    old_scope := t.scope
    t.cur_module = mod
    if scope := t.get_module_scope(mod) {
        t.scope = scope
    } else {
        t.scope = unsafe { nil }
    }
    transformed := t.transform_expr(expr)
    t.cur_module = old_module
    t.scope = old_scope
    return transformed
}

fn (mut t Transformer) runtime_const_init_fn_stmt(mod string, fn_name string, inits []RuntimeConstInit) ast.Stmt {
    mut stmts := []ast.Stmt{cap: inits.len}
    for item in inits {
        expr := if item.expr_cursor.is_valid() { item.expr_cursor.expr() } else { item.expr }
        saved_pending := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        old_skip_if := t.skip_if_value_lowering
        t.skip_if_value_lowering = true
        transformed_expr := t.transform_expr_in_module(mod, expr)
        t.skip_if_value_lowering = old_skip_if
        generated_pending := t.pending_stmts
        t.pending_stmts = saved_pending
        for pending_stmt in generated_pending {
            stmts << pending_stmt
        }
        stmts << ast.AssignStmt{
            op:  .assign
            lhs: [ast.Expr(ast.Ident{
                name: item.name
            })]
            rhs: [transformed_expr]
        }
    }
    return ast.Stmt(ast.FnDecl{
        name:  fn_name
        typ:   ast.FnType{}
        stmts: stmts
    })
}

fn (mut t Transformer) runtime_const_init_fn_stmt_to_flat(mod string, fn_name string, inits []RuntimeConstInit, mut out ast.FlatBuilder) ast.FlatNodeId {
    mut stmt_ids := []ast.FlatNodeId{cap: inits.len}
    old_module := t.cur_module
    old_scope := t.scope
    t.cur_module = mod
    if scope := t.get_module_scope(mod) {
        t.scope = scope
    } else {
        t.scope = unsafe { nil }
    }
    defer {
        t.cur_module = old_module
        t.scope = old_scope
    }
    for item in inits {
        saved_pending := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        old_skip_if := t.skip_if_value_lowering
        t.skip_if_value_lowering = true
        rhs_id := if item.expr_cursor.is_valid() {
            t.transform_expr_cursor_to_flat(item.expr_cursor, mut out)
        } else {
            transformed_expr := t.transform_expr(item.expr)
            out.emit_expr(transformed_expr)
        }
        t.skip_if_value_lowering = old_skip_if
        generated_pending := t.pending_stmts
        t.pending_stmts = saved_pending
        for pending_stmt in generated_pending {
            stmt_ids << out.emit_stmt(pending_stmt)
        }
        lhs_id := out.emit_ident_by_name(item.name, token.Pos{})
        stmt_ids << out.emit_assign_stmt_by_ids(.assign, [lhs_id], [rhs_id], token.Pos{})
    }
    receiver_id := out.emit_parameter(ast.Parameter{
        typ: ast.empty_expr
    })
    typ_id := out.emit_type(ast.Type(ast.FnType{}))
    attrs_id := out.emit_aux_list_from_ids([])
    stmts_id := out.emit_aux_list_from_ids(stmt_ids)
    return out.emit_fn_decl_by_ids(fn_name, false, false, false, .v, token.Pos{}, receiver_id,
        typ_id, attrs_id, stmts_id)
}

fn (t &Transformer) collect_ident_names_in_expr(mut names map[string]bool, expr ast.Expr) {
    t.collect_ident_names_in_expr_depth(0, mut names, expr)
}

fn (t &Transformer) collect_ident_names_in_runtime_const_init(mut names map[string]bool, item RuntimeConstInit) {
    if item.expr_cursor.is_valid() {
        t.collect_ident_names_in_expr_cursor_depth(0, mut names, item.expr_cursor)
        return
    }
    t.collect_ident_names_in_expr(mut names, item.expr)
}

fn (t &Transformer) collect_ident_names_in_expr_depth(depth int, mut names map[string]bool, expr ast.Expr) {
    if depth > max_runtime_const_dep_expr_depth || !expr_has_valid_data(expr) {
        return
    }
    match expr {
        ast.Ident {
            if expr.name != '' {
                names[expr.name] = true
            }
        }
        ast.SelectorExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.lhs)
        }
        ast.InfixExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.lhs)
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.rhs)
        }
        ast.ParenExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.PrefixExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.PostfixExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.ModifierExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.CastExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.CallExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.lhs)
            for arg in expr.args {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, arg)
            }
        }
        ast.CallOrCastExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.lhs)
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.IfExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.cond)
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.else_expr)
            for stmt in expr.stmts {
                if stmt is ast.ExprStmt {
                    t.collect_ident_names_in_expr_depth(depth + 1, mut names, stmt.expr)
                }
            }
        }
        ast.IndexExpr {
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.lhs)
            t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.expr)
        }
        ast.ArrayInitExpr {
            for e in expr.exprs {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, e)
            }
            if expr.init !is ast.EmptyExpr {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.init)
            }
            if expr.len !is ast.EmptyExpr {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.len)
            }
            if expr.cap !is ast.EmptyExpr {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, expr.cap)
            }
        }
        ast.InitExpr {
            for field in expr.fields {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, field.value)
            }
        }
        ast.MapInitExpr {
            for key in expr.keys {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, key)
            }
            for val in expr.vals {
                t.collect_ident_names_in_expr_depth(depth + 1, mut names, val)
            }
        }
        else {}
    }
}

fn (t &Transformer) collect_ident_names_in_expr_cursor_depth(depth int, mut names map[string]bool, expr ast.Cursor) {
    if depth > max_runtime_const_dep_expr_depth || !expr.is_valid() {
        return
    }
    match expr.kind() {
        .expr_ident {
            if expr.name() != '' {
                names[expr.name()] = true
            }
        }
        .expr_selector {
            t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(0))
        }
        .expr_infix, .expr_index, .expr_call_or_cast {
            t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(0))
            t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(1))
        }
        .expr_paren, .expr_prefix, .expr_postfix, .expr_modifier, .expr_cast, .expr_as_cast {
            t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(0))
        }
        .expr_call {
            for i in 0 .. expr.edge_count() {
                t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(i))
            }
        }
        .expr_if {
            t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(0))
            t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(1))
            for i in 2 .. expr.edge_count() {
                stmt := expr.edge(i)
                if stmt.kind() == .stmt_expr {
                    t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, stmt.edge(0))
                }
            }
        }
        .expr_array_init {
            for i in 5 .. expr.edge_count() {
                t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(i))
            }
            for i in [1, 3, 2] {
                child := expr.edge(i)
                if !expr_cursor_is_empty(child) {
                    t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, child)
                }
            }
        }
        .expr_init {
            for i in 1 .. expr.edge_count() {
                t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names,
                    expr.edge(i).edge(0))
            }
        }
        .expr_map_init {
            keys_len := expr.extra_int()
            for i in 0 .. keys_len {
                t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(1 + i))
            }
            for i in (1 + keys_len) .. expr.edge_count() {
                t.collect_ident_names_in_expr_cursor_depth(depth + 1, mut names, expr.edge(i))
            }
        }
        else {}
    }
}

fn (t &Transformer) order_runtime_const_inits(inits []RuntimeConstInit) []RuntimeConstInit {
    if inits.len < 2 {
        return inits
    }
    // Use maps instead of parallel arrays to avoid ARM64 stack corruption
    // when multiple local arrays interact with array_set operations.
    mut index_by_name := map[string]int{}
    for i, item in inits {
        if item.name !in index_by_name {
            index_by_name[item.name] = i
        }
    }
    mut indegree := map[int]int{}
    mut dependents := map[int][]int{}
    for i, item in inits {
        mut ident_names := map[string]bool{}
        t.collect_ident_names_in_runtime_const_init(mut ident_names, item)
        for dep_name, _ in ident_names {
            if dep_name == item.name {
                continue
            }
            if dep_idx := index_by_name[dep_name] {
                mut dep := []int{}
                if dep_idx in dependents {
                    dep = dependents[dep_idx]
                }
                dep << i
                dependents[dep_idx] = dep
                mut deg := 0
                if i in indegree {
                    deg = indegree[i]
                }
                indegree[i] = deg + 1
            }
        }
    }
    mut ready := []int{}
    for i := 0; i < inits.len; i++ {
        mut deg := 0
        if i in indegree {
            deg = indegree[i]
        }
        if deg == 0 {
            ready << i
        }
    }
    mut ordered_idx := []int{cap: inits.len}
    for ready.len > 0 {
        // Prefer non-call initializers first when dependency order allows it.
        mut best_pos := 0
        for pos := 1; pos < ready.len; pos++ {
            a := ready[pos]
            b := ready[best_pos]
            a_has_call := t.runtime_const_init_contains_call(inits[a])
            b_has_call := t.runtime_const_init_contains_call(inits[b])
            if a_has_call != b_has_call {
                if !a_has_call && b_has_call {
                    best_pos = pos
                }
                continue
            }
            if a < b {
                best_pos = pos
            }
        }
        cur := ready[best_pos]
        ready.delete(best_pos)
        ordered_idx << cur
        mut deps := []int{}
        if cur in dependents {
            deps = dependents[cur]
        }
        for dep in deps {
            mut deg := 0
            if dep in indegree {
                deg = indegree[dep]
            }
            deg--
            indegree[dep] = deg
            if deg == 0 {
                ready << dep
            }
        }
    }
    if ordered_idx.len != inits.len {
        return inits
    }
    mut ordered := []RuntimeConstInit{cap: inits.len}
    for idx in ordered_idx {
        ordered << inits[idx]
    }
    return ordered
}

fn (mut t Transformer) inject_runtime_const_init_fns(mut files []ast.File) {
    for mod, fn_stmt in t.runtime_const_init_fn_stmts_parts() {
        for i, file in files {
            if file.mod != mod {
                continue
            }
            mut new_stmts := []ast.Stmt{cap: file.stmts.len + 1}
            for stmt in file.stmts {
                new_stmts << stmt
            }
            new_stmts << fn_stmt
            files[i] = ast.File{
                attributes: file.attributes
                mod:        file.mod
                name:       file.name
                stmts:      new_stmts
                imports:    file.imports
            }
            break
        }
    }
}

// runtime_const_init_fn_stmts_parts is the pure-computation extraction of
// `inject_runtime_const_init_fns`'s per-module work. Returns a `(module
// name, fn_stmt)` map for each module that has runtime const inits, after
// running the per-module side effects (`runtime_const_init_fn_name[mod] = ...`
// + `order_runtime_const_inits`). Does NOT mutate any `[]ast.File` — the
// caller decides whether to splice each `(mod, fn_stmt)` pair into a legacy
// `[]ast.File` (via `inject_runtime_const_init_fns`) or into a
// `FlatBuilder` (future `post_pass_to_flat`).
//
// First Phase 5 (post_pass port) scaffolding — establishes the "_parts"
// extraction pattern (precedent: `transform_fn_decl_parts` in session 4,
// `transform_assign_stmt_parts` in session 59). Future post_pass-port
// sessions extract `_parts` from `inject_test_main`,
// `inject_embed_file_helper`, `inject_main_runtime_const_init_calls`,
// `inject_live_reload`, and `generate_*_functions` to compose a
// FlatBuilder-aware `post_pass_to_flat`.
pub fn (mut t Transformer) runtime_const_init_fn_stmts_parts() map[string]ast.Stmt {
    mut result := map[string]ast.Stmt{}
    for mod in t.runtime_const_modules {
        inits := t.runtime_const_inits_by_mod[mod] or { []RuntimeConstInit{} }
        if inits.len == 0 {
            continue
        }
        fn_name := runtime_const_init_base_name(mod)
        t.runtime_const_init_fn_name[mod] = fn_name
        ordered_inits := t.order_runtime_const_inits(inits)
        result[mod] = t.runtime_const_init_fn_stmt(mod, fn_name, ordered_inits)
    }
    return result
}

// inject_runtime_const_init_fns_to_flat is the FlatBuilder-side splice
// counterpart to `inject_runtime_const_init_fns` (legacy `[]ast.File`
// mutator). It walks `runtime_const_modules` directly, emits each init
// function from flat cursors when available, then folds the resulting id into
// the first file whose module matches `mod`.
//
// Closes the 6-step post_pass port arc: every file-mutating step in
// legacy `post_pass` now has a flat-aware `_to_flat` variant. Sibling to
// s151's `inject_embed_file_helper_to_flat` (same "find file by mod /
// append fn_stmt" shape; s151 routes through `builtin_idx` instead of
// scanning by mod string).
pub fn (mut t Transformer) inject_runtime_const_init_fns_to_flat(mut out ast.FlatBuilder) {
    for mod in t.runtime_const_modules {
        inits := t.runtime_const_inits_by_mod[mod] or { []RuntimeConstInit{} }
        if inits.len == 0 {
            continue
        }
        fn_name := runtime_const_init_base_name(mod)
        t.runtime_const_init_fn_name[mod] = fn_name
        ordered_inits := t.order_runtime_const_inits(inits)
        mut file_idx := -1
        for i in 0 .. out.flat.files.len {
            if out.flat.string_at(out.flat.files[i].mod_idx) == mod {
                file_idx = i
                break
            }
        }
        if file_idx < 0 {
            continue
        }
        stmt_id := t.runtime_const_init_fn_stmt_to_flat(mod, fn_name, ordered_inits, mut out)
        out.append_file_stmts(file_idx, [stmt_id])
    }
}

// inject_test_main synthesizes a main() function for test files that have
// test_ functions but no explicit main. The generated main calls each test
// function and prints progress messages. This is needed for all backends
// (cleanc has its own synthesis in the C emitter, but native backends rely
// on the transformer to provide main).
// TestMainParts is the pure-computation bundle produced by
// `inject_test_main_parts`. `main_fn` is the synthesised `ast.FnDecl` for
// `main`; `test_file_idx` is the index into `files` of the first file that
// declares a `test_*` function (where the synthesised main is spliced).
pub struct TestMainParts {
pub:
    test_file_idx int
    main_fn       ast.Stmt
}

// inject_test_main_parts is the pure-computation extraction of the
// pre-splice state previously inline in `inject_test_main`. Walks `files`
// to (a) detect an existing user `main` (returns `none` if found), (b)
// collect every top-level `test_*` fn name in declaration order, and (c)
// synthesise the test-runner `main` body — per-test (`println('Running
// test: <name>...')`, `<name>()`, `println('  OK')`) followed by a single
// summary `println('All N tests passed.')`. Returns `none` when no
// `test_*` fns are found.
//
// Does NOT mutate `files` or any caller state. Caller decides whether to
// splice the synthesised `main_fn` into a legacy `[]ast.File` (via
// `inject_test_main`) or into a `FlatBuilder` (future `post_pass_to_flat`).
//
// Fourth Phase 5 (post_pass port) `_parts` extraction (follows s144's
// `runtime_const_init_fn_stmts_parts`, s145's
// `runtime_const_init_main_calls_parts`, s146's `live_reload_parts`).
// Bit-equal: identical traversal order, identical `quote_v_string_literal`
// payloads, identical FnDecl shape (only `name` + `stmts` populated).
pub fn (mut t Transformer) inject_test_main_parts(files []ast.File) ?TestMainParts {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && !stmt.is_method && stmt.name == 'main' {
                return none
            }
        }
    }

    mut test_fn_names := []string{}
    mut test_file_idx := -1
    for i, file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && !stmt.is_method && stmt.name.starts_with('test_') {
                test_fn_names << stmt.name
                if test_file_idx == -1 {
                    test_file_idx = i
                }
            }
        }
    }
    if test_fn_names.len == 0 {
        return none
    }

    return TestMainParts{
        test_file_idx: test_file_idx
        main_fn:       synthesise_test_main_fn(test_fn_names)
    }
}

// synthesise_test_main_fn builds the synthesised `fn main()` stmt used by
// both the legacy `inject_test_main_parts` and the flat-aware
// `inject_test_main_parts_from_flat`. The body is per-test
// (`println('Running test: <name>...')`, `<name>()`, `println('  OK')`)
// followed by a single summary `println('All N tests passed.')`. Pure
// function — no transformer / file state read.
fn synthesise_test_main_fn(test_fn_names []string) ast.Stmt {
    mut main_stmts := []ast.Stmt{}
    for test_fn in test_fn_names {
        main_stmts << ast.ExprStmt{
            expr: ast.CallExpr{
                lhs:  ast.Ident{
                    name: 'println'
                }
                args: [
                    ast.Expr(ast.StringLiteral{
                        kind:  .v
                        value: quote_v_string_literal('Running test: ${test_fn}...')
                    }),
                ]
            }
        }
        main_stmts << ast.ExprStmt{
            expr: ast.CallExpr{
                lhs: ast.Ident{
                    name: test_fn
                }
            }
        }
        main_stmts << ast.ExprStmt{
            expr: ast.CallExpr{
                lhs:  ast.Ident{
                    name: 'println'
                }
                args: [
                    ast.Expr(ast.StringLiteral{
                        kind:  .v
                        value: quote_v_string_literal('  OK')
                    }),
                ]
            }
        }
    }
    main_stmts << ast.ExprStmt{
        expr: ast.CallExpr{
            lhs:  ast.Ident{
                name: 'println'
            }
            args: [
                ast.Expr(ast.StringLiteral{
                    kind:  .v
                    value: quote_v_string_literal('All ${test_fn_names.len} tests passed.')
                }),
            ]
        }
    }
    return ast.Stmt(ast.FnDecl{
        name:  'main'
        stmts: main_stmts
    })
}

// inject_test_main_parts_from_flat is the flat-cursor sibling of
// `inject_test_main_parts`. Walks `flat.files` via FileCursor for (a) an
// existing top-level user `main` FnDecl (returns `none` if found) and
// (b) every top-level `test_*` FnDecl name in declaration order. Both
// scans use `.stmt_fn_decl` kind + `flag_is_method` filter + `name()` /
// `.starts_with('test_')`. Returns the same `TestMainParts` shape as the
// legacy `_parts`; reuses `synthesise_test_main_fn` for the body, so
// bit-equality is by-construction (same payload, same FnDecl shape).
//
// Second flat-aware port (s152, follows s151's
// `inject_embed_file_helper_parts_from_flat`). Pinned by 3-case test in
// `inject_test_main_to_flat_test.v`.
pub fn (mut t Transformer) inject_test_main_parts_from_flat(flat &ast.FlatAst) ?TestMainParts {
    for i in 0 .. flat.files.len {
        stmts := flat.file_cursor(i).stmts()
        for j in 0 .. stmts.len() {
            c := stmts.at(j)
            if c.kind() == .stmt_fn_decl && !c.flag(ast.flag_is_method) && c.name() == 'main' {
                return none
            }
        }
    }

    mut test_fn_names := []string{}
    mut test_file_idx := -1
    for i in 0 .. flat.files.len {
        stmts := flat.file_cursor(i).stmts()
        for j in 0 .. stmts.len() {
            c := stmts.at(j)
            if c.kind() == .stmt_fn_decl && !c.flag(ast.flag_is_method)
                && c.name().starts_with('test_') {
                test_fn_names << c.name()
                if test_file_idx == -1 {
                    test_file_idx = i
                }
            }
        }
    }
    if test_fn_names.len == 0 {
        return none
    }

    return TestMainParts{
        test_file_idx: test_file_idx
        main_fn:       synthesise_test_main_fn(test_fn_names)
    }
}

// inject_test_main_to_flat is the FlatBuilder-side splice counterpart to
// the legacy `inject_test_main(mut []ast.File)` mutator. Emits the
// synthesised `main` FnDecl into `out` via `out.emit_stmt`, then folds
// the resulting stmt id into the test-file root via
// `out.append_file_stmts(test_file_idx, [main_id])` (s150's seed primitive).
//
// Bit-equal w.r.t. `signature()` to running legacy
// `inject_test_main(mut files)` followed by `ast.flatten_files(files)`:
// same test-file routing, same synthesised main payload, same final
// file root edges (attrs / imports unchanged, stmts list extended by
// the same single stmt id).
pub fn (mut t Transformer) inject_test_main_to_flat(mut out ast.FlatBuilder) {
    parts := t.inject_test_main_parts_from_flat(&out.flat) or { return }
    main_id := out.emit_stmt(parts.main_fn)
    out.append_file_stmts(parts.test_file_idx, [main_id])
}

fn (mut t Transformer) inject_test_main(mut files []ast.File) {
    parts := t.inject_test_main_parts(files) or { return }
    file := files[parts.test_file_idx]
    mut new_stmts := []ast.Stmt{cap: file.stmts.len + 1}
    for stmt in file.stmts {
        new_stmts << stmt
    }
    new_stmts << parts.main_fn
    files[parts.test_file_idx] = ast.File{
        attributes: file.attributes
        mod:        file.mod
        name:       file.name
        stmts:      new_stmts
        imports:    file.imports
    }
}

// runtime_const_init_main_calls_parts is the pure-computation extraction of
// the per-main init-call list previously inline in
// `inject_main_runtime_const_init_calls`. Returns the ordered list of
// `__v_init_consts_<mod>()` + `<mod>__init()` call ExprStmts that should be
// prepended to main(): first the runtime-const init calls (one per
// `t.runtime_const_modules` entry that has a registered fn_name; gated by
// `uses_minimal_x64_runtime` + `imported_runtime_init_modules` on minimal x64
// runtimes), then the module-level `init()` calls (one per module seen in
// files that declares a non-method `init` fn; gated by the same minimal
// runtime filter; de-duped per module).
//
// Does NOT mutate `files` or any caller state. Caller decides whether to
// splice the result into a legacy `[]ast.File` (via
// `inject_main_runtime_const_init_calls`) or into a `FlatBuilder` (future
// `post_pass_to_flat`).
//
// Second Phase 5 (post_pass port) `_parts` extraction (follows s144's
// `runtime_const_init_fn_stmts_parts`). Bit-equal: same iteration order
// over `runtime_const_modules` + `files`, same de-dup map semantics.
pub fn (mut t Transformer) runtime_const_init_main_calls_parts(files []ast.File) []ast.Stmt {
    mut init_calls := []ast.Stmt{}
    mut main_const_calls := []ast.Stmt{}
    mut seen_init_mods := map[string]bool{}
    minimal_x64_runtime := t.uses_minimal_x64_runtime()
    init_modules := if minimal_x64_runtime {
        t.imported_runtime_init_modules(files)
    } else {
        map[string]bool{}
    }
    main_mod := main_module_name_from_files(files)
    for mod in t.runtime_const_modules {
        if minimal_x64_runtime && mod !in init_modules {
            continue
        }
        fn_name := t.runtime_const_init_fn_name[mod] or { continue }
        call_name := runtime_const_init_call_name(mod, fn_name)
        call_stmt := ast.ExprStmt{
            expr: ast.CallExpr{
                lhs: ast.Ident{
                    name: call_name
                }
            }
        }
        if normalized_module_name(mod) == main_mod {
            main_const_calls << call_stmt
        } else {
            init_calls << call_stmt
        }
    }
    for file in files {
        if file.mod in seen_init_mods {
            continue
        }
        if minimal_x64_runtime && file.mod !in init_modules {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.FnDecl && !stmt.is_method && stmt.name == 'init' {
                seen_init_mods[file.mod] = true
                init_calls << ast.ExprStmt{
                    expr: ast.CallExpr{
                        lhs: ast.Ident{
                            name: module_init_call_name(file.mod)
                        }
                    }
                }
                break
            }
        }
    }
    init_calls << main_const_calls
    return init_calls
}

fn normalized_module_name(mod string) string {
    return if mod == '' { 'main' } else { mod }
}

fn main_module_name_from_files(files []ast.File) string {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && !stmt.is_method && stmt.name == 'main' {
                return normalized_module_name(file.mod)
            }
        }
    }
    return 'main'
}

fn (mut t Transformer) inject_main_runtime_const_init_calls(mut files []ast.File) {
    init_calls := t.runtime_const_init_main_calls_parts(files)
    if init_calls.len == 0 {
        return
    }
    for i, file in files {
        mut changed := false
        mut new_stmts := []ast.Stmt{cap: file.stmts.len}
        for stmt in file.stmts {
            if stmt is ast.FnDecl && !stmt.is_method && stmt.name == 'main' {
                mut fn_stmts := []ast.Stmt{cap: init_calls.len + stmt.stmts.len}
                for call_stmt in init_calls {
                    fn_stmts << call_stmt
                }
                for fn_stmt in stmt.stmts {
                    fn_stmts << fn_stmt
                }
                new_stmts << ast.FnDecl{
                    attributes: stmt.attributes
                    is_public:  stmt.is_public
                    is_method:  stmt.is_method
                    is_static:  stmt.is_static
                    receiver:   stmt.receiver
                    language:   stmt.language
                    name:       stmt.name
                    typ:        stmt.typ
                    stmts:      fn_stmts
                    pos:        stmt.pos
                }
                changed = true
                continue
            }
            new_stmts << stmt
        }
        if changed {
            files[i] = ast.File{
                attributes: file.attributes
                mod:        file.mod
                name:       file.name
                stmts:      new_stmts
                imports:    file.imports
            }
            break
        }
    }
}

// MainRuntimeConstInitParts carries the locator (file_idx + stmt_idx of the
// top-level `fn main()` FnDecl, plus its current FlatNodeId) and the
// pre-built init-call ExprStmt list that will be prepended to main's body.
// Returned by `inject_main_runtime_const_init_parts_from_flat`; consumed by
// `inject_main_runtime_const_init_to_flat`.
pub struct MainRuntimeConstInitParts {
pub:
    main_file_idx int
    main_stmt_idx int
    main_fn_id    ast.FlatNodeId
    init_calls    []ast.Stmt
}

// runtime_const_init_main_calls_parts_from_flat is the flat-cursor sibling of
// `runtime_const_init_main_calls_parts`. Builds the same ordered list of
// `__v_init_consts_<mod>()` + `<mod>__init()` ExprStmt calls, but reads the
// per-file `init` fn presence from `flat.files` via FileCursor (kind ==
// `.stmt_fn_decl`, `!flag(ast.flag_is_method)`, `name() == 'init'`) instead
// of walking `[]ast.File`. The runtime-const portion is unchanged — it
// iterates `t.runtime_const_modules` + `t.runtime_const_init_fn_name`
// (Transformer state, not file content).
//
// Pure: does not mutate the flat AST or transformer state.
pub fn (mut t Transformer) runtime_const_init_main_calls_parts_from_flat(flat &ast.FlatAst) []ast.Stmt {
    mut init_calls := []ast.Stmt{}
    mut main_const_calls := []ast.Stmt{}
    mut seen_init_mods := map[string]bool{}
    minimal_x64_runtime := t.uses_minimal_x64_runtime()
    init_modules := if minimal_x64_runtime {
        t.imported_runtime_init_modules_from_flat(flat)
    } else {
        map[string]bool{}
    }
    main_mod := main_module_name_from_flat(flat)
    for mod in t.runtime_const_modules {
        if minimal_x64_runtime && mod !in init_modules {
            continue
        }
        fn_name := t.runtime_const_init_fn_name[mod] or { continue }
        call_name := runtime_const_init_call_name(mod, fn_name)
        call_stmt := ast.ExprStmt{
            expr: ast.CallExpr{
                lhs: ast.Ident{
                    name: call_name
                }
            }
        }
        if normalized_module_name(mod) == main_mod {
            main_const_calls << call_stmt
        } else {
            init_calls << call_stmt
        }
    }
    for i in 0 .. flat.files.len {
        fc := flat.file_cursor(i)
        mod := fc.mod()
        if mod in seen_init_mods {
            continue
        }
        if minimal_x64_runtime && mod !in init_modules {
            continue
        }
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            c := stmts.at(j)
            if c.kind() == .stmt_fn_decl && !c.flag(ast.flag_is_method) && c.name() == 'init' {
                seen_init_mods[mod] = true
                init_calls << ast.ExprStmt{
                    expr: ast.CallExpr{
                        lhs: ast.Ident{
                            name: module_init_call_name(mod)
                        }
                    }
                }
                break
            }
        }
    }
    init_calls << main_const_calls
    return init_calls
}

fn main_module_name_from_flat(flat &ast.FlatAst) string {
    for i in 0 .. flat.files.len {
        fc := flat.file_cursor(i)
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            c := stmts.at(j)
            if c.kind() == .stmt_fn_decl && !c.flag(ast.flag_is_method) && c.name() == 'main' {
                return normalized_module_name(fc.mod())
            }
        }
    }
    return 'main'
}

// inject_main_runtime_const_init_parts_from_flat is the flat-cursor sibling of
// the implicit locator in `inject_main_runtime_const_init_calls`. Returns the
// (file_idx, stmt_idx, main_fn_id, init_calls) tuple needed to drive the
// flat-aware splice. Returns `none` when no init calls are needed OR no
// top-level `fn main()` is present in any file.
//
// The "first match wins" semantics of the legacy loop are preserved: we
// scan files in declaration order and stop at the first non-method
// `fn main()` we encounter.
//
// Fourth flat-aware port (s155, follows s151/s152/s153). Pinned by the
// 4-case test in `inject_main_runtime_const_init_to_flat_test.v`.
pub fn (mut t Transformer) inject_main_runtime_const_init_parts_from_flat(flat &ast.FlatAst) ?MainRuntimeConstInitParts {
    init_calls := t.runtime_const_init_main_calls_parts_from_flat(flat)
    if init_calls.len == 0 {
        return none
    }
    for i in 0 .. flat.files.len {
        fc := flat.file_cursor(i)
        stmts := fc.stmts()
        for j in 0 .. stmts.len() {
            c := stmts.at(j)
            if c.kind() == .stmt_fn_decl && !c.flag(ast.flag_is_method) && c.name() == 'main' {
                return MainRuntimeConstInitParts{
                    main_file_idx: i
                    main_stmt_idx: j
                    main_fn_id:    c.id
                    init_calls:    init_calls
                }
            }
        }
    }
    return none
}

// inject_main_runtime_const_init_to_flat is the FlatBuilder-side splice
// counterpart to the legacy `inject_main_runtime_const_init_calls(mut []ast.File)`.
// Locates the `fn main()` via `inject_main_runtime_const_init_parts_from_flat`,
// emits each init-call ExprStmt via `out.emit_stmt`, prepends them to main's
// body via `out.prepend_to_fn_body(main_fn_id, init_call_ids)` (s154's seed
// primitive, returns a NEW fn_decl_id), then rewires the enclosing file's
// stmts list via `out.replace_file_stmt(file_idx, stmt_idx, new_fn_id)`.
//
// Bit-equal w.r.t. `signature()` to running legacy
// `inject_main_runtime_const_init_calls(mut files)` followed by
// `ast.flatten_files(files)`: same first-main routing, same init-call
// payload + ordering (init_calls first, original main body after), same
// final file root edges (attrs / imports unchanged, stmts list one entry
// swapped from old fn_decl_id to new fn_decl_id).
pub fn (mut t Transformer) inject_main_runtime_const_init_to_flat(mut out ast.FlatBuilder) {
    parts := t.inject_main_runtime_const_init_parts_from_flat(&out.flat) or { return }
    mut init_call_ids := []ast.FlatNodeId{cap: parts.init_calls.len}
    for call_stmt in parts.init_calls {
        init_call_ids << out.emit_stmt(call_stmt)
    }
    new_fn_id := out.prepend_to_fn_body(parts.main_fn_id, init_call_ids)
    out.replace_file_stmt(parts.main_file_idx, parts.main_stmt_idx, new_fn_id)
}

fn (mut t Transformer) transform_file(file ast.File) ast.File {
    if t.skip_native_backend_transform_file(file) {
        return file
    }
    t.enter_file_context(file)
    stmts := t.transform_stmts(file.stmts)
    return ast.File{
        attributes: file.attributes
        mod:        file.mod
        name:       file.name
        stmts:      stmts
        imports:    file.imports
    }
}

fn (mut t Transformer) transform_stmt(stmt ast.Stmt) ast.Stmt {
    if !stmt_has_valid_data(stmt) {
        return stmt
    }
    // Check for OrExpr assignment that needs expansion
    if stmt is ast.AssignStmt {
        if expanded := t.try_expand_or_expr_assign(stmt) {
            return expanded
        }
        // Check for map index assignment: m[key] = val -> map__set(&m, &key, &val)
        if transformed := t.try_transform_map_index_assign(stmt) {
            return transformed
        }
    }
    return match stmt {
        ast.AssignStmt {
            t.transform_assign_stmt(stmt)
        }
        ast.BlockStmt {
            ast.BlockStmt{
                stmts: t.transform_stmts(stmt.stmts)
            }
        }
        ast.ComptimeStmt {
            // Keep ComptimeStmt wrapper for $for — cleanc handles it at codegen time
            if stmt.stmt is ast.ForStmt {
                for_stmt := stmt.stmt as ast.ForStmt
                ast.Stmt(ast.ComptimeStmt{
                    stmt: ast.Stmt(ast.ForStmt{
                        init:  for_stmt.init
                        cond:  for_stmt.cond
                        post:  for_stmt.post
                        stmts: t.transform_stmts(for_stmt.stmts)
                    })
                })
            } else {
                t.transform_stmt(stmt.stmt)
            }
        }
        ast.DeferStmt {
            ast.DeferStmt{
                mode:  stmt.mode
                stmts: t.transform_stmts(stmt.stmts)
            }
        }
        ast.ExprStmt {
            // When IfExpr is directly in a statement position (ExprStmt), don't lower
            // to temp variable — it's not used as a value expression.
            is_direct_if := stmt.expr is ast.IfExpr
            saved_skip := t.skip_if_value_lowering
            if is_direct_if {
                t.skip_if_value_lowering = true
            }
            result := ast.Stmt(ast.ExprStmt{
                expr: t.transform_expr(stmt.expr)
            })
            t.skip_if_value_lowering = saved_skip
            result
        }
        ast.FnDecl {
            t.transform_fn_decl(stmt)
        }
        ast.ForStmt {
            t.transform_for_stmt(stmt)
        }
        ast.ForInStmt {
            t.transform_for_in_stmt(stmt)
        }
        ast.LabelStmt {
            ast.LabelStmt{
                name: stmt.name
                stmt: t.transform_stmt(stmt.stmt)
            }
        }
        ast.ReturnStmt {
            t.transform_return_stmt(stmt)
        }
        ast.ConstDecl {
            t.transform_const_decl(stmt)
        }
        ast.GlobalDecl {
            t.transform_global_decl(stmt)
        }
        ast.StructDecl {
            ast.Stmt(t.transform_struct_decl(stmt))
        }
        ast.AssertStmt {
            // Should have been expanded in transform_stmts; fallback pass-through
            ast.AssertStmt{
                expr: t.transform_expr(stmt.expr)
            }
        }
        else {
            stmt
        }
    }
}

fn (mut t Transformer) append_transformed_stmt(mut result []ast.Stmt, stmt ast.Stmt) {
    transformed := t.transform_stmt(stmt)
    if t.pending_stmts.len > 0 {
        for ps in t.pending_stmts {
            result << ps
        }
        t.pending_stmts.clear()
    }
    result << transformed
}

fn (mut t Transformer) transform_stmts(stmts []ast.Stmt) []ast.Stmt {
    mut result := []ast.Stmt{cap: stmts.len}
    is_native_be := t.is_native_be
    block_smartcast_depth := t.smartcast_stack.len
    // Lazy snapshot: most blocks enter with an empty smartcast stack. Cloning an
    // empty stack/map is cheap but still allocates; multiply by tens of thousands
    // of blocks and it adds up. Only snapshot when there is state to restore.
    has_smartcast_state := block_smartcast_depth > 0
    block_smartcast_stack := if has_smartcast_state {
        t.smartcast_stack.clone()
    } else {
        []SmartcastContext{}
    }
    block_smartcast_counts := if has_smartcast_state {
        t.smartcast_expr_counts.clone()
    } else {
        map[string]int{}
    }
    for stmt in stmts {
        if t.smartcast_stack.len < block_smartcast_depth {
            t.smartcast_stack = block_smartcast_stack.clone()
            t.smartcast_expr_counts = block_smartcast_counts.clone()
        } else if t.smartcast_stack.len > block_smartcast_depth {
            t.truncate_smartcasts(block_smartcast_depth)
        }
        if stmt is ast.FnDecl && t.omit_backend_generic_decl(stmt) {
            continue
        }
        // Check for OrExpr assignment that expands to multiple statements
        if stmt is ast.AssignStmt {
            assign_stmt := stmt as ast.AssignStmt
            // Expand comptime $if assignment: `mut res := $if flag ? { expr1 } $else { stmts... ; expr_n }`
            // When the selected branch has multiple statements, inline the statements and use
            // the last expression as the assignment RHS.
            if assign_stmt.rhs.len == 1 && assign_stmt.rhs[0] is ast.ComptimeExpr {
                comptime_expr := assign_stmt.rhs[0] as ast.ComptimeExpr
                if comptime_expr.expr is ast.IfExpr {
                    comptime_if := comptime_expr.expr as ast.IfExpr
                    if !t.can_eval_comptime_cond(comptime_if.cond) {
                        t.append_transformed_stmt(mut result, ast.Stmt(assign_stmt))
                        continue
                    }
                    selected := t.resolve_comptime_if_stmts(comptime_if)
                    if selected.len > 0 {
                        // Inline all but the last statement
                        for i := 0; i < selected.len - 1; i++ {
                            t.append_transformed_stmt(mut result, selected[i])
                        }
                        // Use the last statement's expression as the assignment RHS
                        last_stmt := selected[selected.len - 1]
                        if last_stmt is ast.ExprStmt {
                            last_expr_stmt := last_stmt as ast.ExprStmt
                            t.append_transformed_stmt(mut result, ast.Stmt(ast.AssignStmt{
                                op:  assign_stmt.op
                                lhs: assign_stmt.lhs
                                rhs: [t.transform_expr(last_expr_stmt.expr)]
                                pos: assign_stmt.pos
                            }))
                            continue
                        } else if last_stmt is ast.AssignStmt {
                            last_assign_stmt := last_stmt as ast.AssignStmt
                            t.append_transformed_stmt(mut result, ast.Stmt(ast.AssignStmt{
                                op:  assign_stmt.op
                                lhs: assign_stmt.lhs
                                rhs: last_assign_stmt.rhs
                                pos: assign_stmt.pos
                            }))
                            continue
                        }
                    }
                }
            }
            if is_native_be && assign_stmt.rhs.len == 1 && assign_stmt.lhs.len == 1 {
                lhs_name := t.get_var_name(assign_stmt.lhs[0])
                if lhs_name != '' {
                    if concrete := t.get_interface_assignment_concrete_type(assign_stmt.rhs[0]) {
                        t.interface_concrete_types[lhs_name] = concrete
                    } else if assign_stmt.op in [.assign, .decl_assign] {
                        t.interface_concrete_types.delete(lhs_name)
                    }
                }
            }
            // Native backends (arm64/x64): lower interface casts.
            // `shape1 := Shape(rect)` → `shape1 := rect` and record concrete type mapping.
            if is_native_be && assign_stmt.rhs.len == 1 && assign_stmt.lhs.len == 1
                && assign_stmt.lhs[0] is ast.Ident && t.is_interface_cast(assign_stmt.rhs[0]) {
                inner := t.get_interface_cast_inner_expr(assign_stmt.rhs[0]) or {
                    assign_stmt.rhs[0]
                }
                lhs_name := (assign_stmt.lhs[0] as ast.Ident).name
                // Get the concrete type name from the value being cast
                if concrete := t.get_expr_type_name(inner) {
                    t.interface_concrete_types[lhs_name] = concrete
                }
                // Replace the interface cast with just the inner value
                t.append_transformed_stmt(mut result, ast.Stmt(ast.AssignStmt{
                    op:  assign_stmt.op
                    lhs: assign_stmt.lhs
                    rhs: [inner]
                    pos: assign_stmt.pos
                }))
                continue
            }
            // Native backends: expand sincos(x) → sin(x), cos(x) since sincos uses
            // ChebSeries struct constants that aren't initialized by the native backend.
            // The separate sin/cos functions use C library calls via .c.v overrides.
            if is_native_be && assign_stmt.lhs.len >= 2 && assign_stmt.rhs.len == 1 {
                if sincos_arg := t.try_extract_sincos_arg(assign_stmt.rhs[0]) {
                    lhs0 := assign_stmt.lhs[0]
                    lhs1 := assign_stmt.lhs[1]
                    is_blank0 := lhs0 is ast.Ident && (lhs0 as ast.Ident).name == '_'
                    is_blank1 := lhs1 is ast.Ident && (lhs1 as ast.Ident).name == '_'
                    if !is_blank0 {
                        t.append_transformed_stmt(mut result, ast.Stmt(ast.AssignStmt{
                            op:  assign_stmt.op
                            lhs: [lhs0]
                            rhs: [
                                ast.Expr(ast.CallExpr{
                                    lhs:  ast.Expr(ast.Ident{
                                        name: 'sin'
                                    })
                                    args: [sincos_arg]
                                    pos:  assign_stmt.pos
                                }),
                            ]
                            pos: assign_stmt.pos
                        }))
                    }
                    if !is_blank1 {
                        t.append_transformed_stmt(mut result, ast.Stmt(ast.AssignStmt{
                            op:  assign_stmt.op
                            lhs: [lhs1]
                            rhs: [
                                ast.Expr(ast.CallExpr{
                                    lhs:  ast.Expr(ast.Ident{
                                        name: 'cos'
                                    })
                                    args: [sincos_arg]
                                    pos:  assign_stmt.pos
                                }),
                            ]
                            pos: assign_stmt.pos
                        }))
                    }
                    continue
                }
            }
            if expanded_or_assign := t.try_expand_or_expr_assign_stmts(&assign_stmt) {
                // Note: expand_direct_or_expr_assign already transforms expressions internally,
                // so we don't call transform_stmt again to avoid double transformation
                // (which would cause smartcasts to be applied twice)
                if t.pending_stmts.len > 0 {
                    for ps in t.pending_stmts {
                        result << ps
                    }
                    t.pending_stmts.clear()
                }
                result << expanded_or_assign
                continue
            }
            // Check for tuple if-expression: x, y, w, h := if cond { a, b, c, d } else { e, f, g, h }
            if expanded_tuple_if := t.try_expand_tuple_if_assign_stmts(assign_stmt) {
                for exp_stmt in expanded_tuple_if {
                    t.append_transformed_stmt(mut result, exp_stmt)
                }
                continue
            }
            // Lower multi-value call assignment: a, b = call() → _tuple_t = call(); a = _tuple_t.arg0; b = _tuple_t.arg1
            if expanded_tuple_call := t.try_expand_tuple_call_assign(assign_stmt) {
                for exp_stmt in expanded_tuple_call {
                    t.append_transformed_stmt(mut result, exp_stmt)
                }
                continue
            }
            // Check for if-guard expression: x := if r := map[key] { r } else { default }
            if expanded_if_guard_assign := t.try_expand_if_guard_assign_stmts(assign_stmt) {
                for exp_stmt in expanded_if_guard_assign {
                    t.append_transformed_stmt(mut result, exp_stmt)
                }
                continue
            }
            // Check for if-expression assignment: x = if cond { a } else { b }
            // Transform to a statement-form if that assigns in each branch.
            if expanded_if_expr_assign := t.try_expand_if_expr_assign_stmts(assign_stmt) {
                for exp_stmt in expanded_if_expr_assign {
                    t.append_transformed_stmt(mut result, exp_stmt)
                }
                continue
            }
        }
        // Expand compile-time $if at the statement level
        if stmt is ast.ExprStmt {
            if stmt.expr is ast.ComptimeExpr {
                if stmt.expr.expr is ast.IfExpr {
                    if t.can_eval_comptime_cond(stmt.expr.expr.cond) {
                        selected := t.resolve_comptime_if_stmts(stmt.expr.expr)
                        // Process through transform_stmts to handle nested $if blocks
                        transformed := t.transform_stmts(selected)
                        for s in transformed {
                            result << s
                        }
                        continue
                    }
                    // Can't evaluate — transform body stmts and keep the comptime wrapper
                    transformed_comptime := t.transform_comptime_if_bodies(stmt.expr.expr)
                    result << ast.Stmt(ast.ExprStmt{
                        expr: ast.Expr(ast.ComptimeExpr{
                            expr: ast.Expr(transformed_comptime)
                        })
                    })
                    continue
                }
            }
        }
        // Check for OrExpr in expression statements (e.g., println(may_fail() or { 0 }))
        if stmt is ast.ExprStmt {
            if expanded_or_stmt := t.try_expand_or_expr_stmt(stmt) {
                // Note: expand_single_or_expr already transforms expressions internally,
                // so we don't call transform_stmt again to avoid double transformation
                // (which would cause interface method _object to be added twice)
                if t.pending_stmts.len > 0 {
                    for ps in t.pending_stmts {
                        result << ps
                    }
                    t.pending_stmts.clear()
                }
                result << expanded_or_stmt
                continue
            }
            // Check for if-guard in expression statements (e.g., if attr := table[name] { ... })
            if expanded_if_guard_stmt := t.try_expand_if_guard_stmt(stmt) {
                // Note: try_expand_if_guard_stmt already transforms expressions internally,
                // so we don't call transform_stmt again to avoid double transformation
                for exp_stmt in expanded_if_guard_stmt {
                    result << exp_stmt
                }
                continue
            }
        }
        // Check for flag enum .set() / .clear() calls that need statement-level lowering
        if stmt is ast.ExprStmt {
            if flag_stmt := t.try_transform_flag_enum_set_clear(stmt) {
                result << flag_stmt
                continue
            }
        }
        // Check for OrExpr in return statements
        if stmt is ast.ReturnStmt {
            if expanded_return_match := t.try_expand_return_match_expr(stmt) {
                if t.pending_stmts.len > 0 {
                    for ps in t.pending_stmts {
                        result << ps
                    }
                    t.pending_stmts.clear()
                }
                for exp_stmt in expanded_return_match {
                    result << exp_stmt
                }
                continue
            }
            if expanded_or_return := t.try_expand_or_expr_return(stmt) {
                // Note: expand_single_or_expr already transforms expressions internally,
                // so we don't call transform_stmt again to avoid double transformation.
                // However, transform_expr may have populated pending_stmts (e.g., from
                // lower_if_expr_value), which must be drained before the return stmt.
                if t.pending_stmts.len > 0 {
                    // Insert pending_stmts before the last statement (the return).
                    for i, es in expanded_or_return {
                        if i == expanded_or_return.len - 1 {
                            for ps in t.pending_stmts {
                                result << ps
                            }
                            t.pending_stmts.clear()
                        }
                        result << es
                    }
                } else {
                    result << expanded_or_return
                }
                continue
            }
            // Check for if-expression in return statements
            // Transform: return if cond { a } else { b }
            // Into: if cond { return a } else { return b }
            if expanded_return_if := t.try_expand_return_if_expr(stmt) {
                for exp_stmt in expanded_return_if {
                    t.append_transformed_stmt(mut result, exp_stmt)
                }
                continue
            }
        }
        // Expand lock/rlock expressions into mutex lock/unlock calls around the body
        if stmt is ast.ExprStmt {
            if stmt.expr is ast.LockExpr {
                // Store in a temp variable to avoid double evaluation of expand_lock_expr.
                // V1's C backend compiles `result << fn_call()` as
                // `array__push_many(&result, fn_call().data, fn_call().len)` which calls
                // the function twice, causing temp_counter to advance twice and generating
                // mismatched variable IDs.
                expanded_lock := t.expand_lock_expr(stmt.expr)
                result << expanded_lock
                continue
            }
            // Expand map[key] << value to get_and_set + array_push
            if expanded_map_push := t.try_transform_map_index_push(stmt) {
                result << ast.Stmt(expanded_map_push)
                continue
            }
            // Expand map[key]++ / map[key]-- to compound assignment (handled by try_transform_map_index_assign)
            if expanded_map_postfix := t.try_transform_map_index_postfix(stmt) {
                result << expanded_map_postfix
                continue
            }
            // For native backends, transform obj.field++ / obj.field-- to compound assignment
            // to avoid the build_postfix code path which has issues in self-hosted binaries.
            if t.is_native_be {
                if postfix_assign := t.try_transform_selector_postfix(stmt) {
                    result << postfix_assign
                    continue
                }
            }
        }
        // Check for map iteration expansion
        if stmt is ast.ForStmt {
            if expanded_for_in_map := t.try_expand_for_in_map(stmt) {
                for exp_stmt in expanded_for_in_map {
                    t.append_transformed_stmt(mut result, exp_stmt)
                }
                continue
            }
        }
        // Expand assert statements into if + eprintln + exit
        if stmt is ast.AssertStmt {
            // Store in temp variable to avoid V1 C backend double-evaluation of
            // `for x in fn()` which calls fn() twice per iteration.
            expanded_asserts := t.expand_assert_stmt(stmt)
            for exp_stmt in expanded_asserts {
                t.append_transformed_stmt(mut result, exp_stmt)
                // Drain pending_stmts (e.g. from filter/map expansion in assert condition)
                if t.pending_stmts.len > 0 {
                    last := result.pop()
                    for ps in t.pending_stmts {
                        result << ps
                    }
                    t.pending_stmts.clear()
                    result << last
                }
            }
            continue
        }
        // Transform the statement. Filter/map expression expansions may populate
        // pending_stmts during this call, which must be hoisted before the result.
        t.append_transformed_stmt(mut result, stmt)
        if t.pending_stmts.len > 0 {
            // Move the just-appended transformed statement to after pending_stmts.
            last := result.pop()
            for ps in t.pending_stmts {
                result << ps
            }
            t.pending_stmts.clear()
            result << last
        }
    }
    if t.smartcast_stack.len < block_smartcast_depth {
        t.smartcast_stack = block_smartcast_stack.clone()
        t.smartcast_expr_counts = block_smartcast_counts.clone()
    } else if t.smartcast_stack.len > block_smartcast_depth {
        t.truncate_smartcasts(block_smartcast_depth)
    }
    return result
}

fn (t &Transformer) omit_backend_generic_decl(decl ast.FnDecl) bool {
    return decl_generic_param_names(decl).len > 0
}

fn (mut t Transformer) transform_const_decl(decl ast.ConstDecl) ast.ConstDecl {
    mut fields := []ast.FieldInit{cap: decl.fields.len}
    for field in decl.fields {
        fields << ast.FieldInit{
            name:  field.name
            value: t.transform_expr(field.value)
        }
    }
    return ast.ConstDecl{
        is_public: decl.is_public
        fields:    fields
    }
}

fn (mut t Transformer) transform_global_decl(decl ast.GlobalDecl) ast.GlobalDecl {
    mut fields := []ast.FieldDecl{cap: decl.fields.len}
    for field in decl.fields {
        fields << ast.FieldDecl{
            name:                field.name
            typ:                 t.transform_expr(field.typ)
            value:               t.transform_expr(field.value)
            attributes:          field.attributes
            is_public:           field.is_public
            is_mut:              field.is_mut
            is_module_mut:       field.is_module_mut
            is_interface_method: field.is_interface_method
        }
    }
    return ast.GlobalDecl{
        attributes: decl.attributes
        fields:     fields
        is_public:  decl.is_public
    }
}

fn (mut t Transformer) transform_struct_decl(decl ast.StructDecl) ast.StructDecl {
    mut fields := []ast.FieldDecl{cap: decl.fields.len}
    for field in decl.fields {
        fields << ast.FieldDecl{
            name:                field.name
            typ:                 t.rewrite_concrete_generic_struct_type_expr(field.typ)
            value:               field.value
            attributes:          field.attributes
            is_public:           field.is_public
            is_mut:              field.is_mut
            is_module_mut:       field.is_module_mut
            is_interface_method: field.is_interface_method
        }
    }
    mut embedded := []ast.Expr{cap: decl.embedded.len}
    for item in decl.embedded {
        embedded << t.rewrite_concrete_generic_struct_type_expr(item)
    }
    t.register_concrete_embedded_owner_names(decl, embedded)
    mut implemented_types := []ast.Expr{cap: decl.implements.len}
    for item in decl.implements {
        implemented_types << t.rewrite_concrete_generic_struct_type_expr(item)
    }
    return ast.StructDecl{
        attributes:     decl.attributes
        is_public:      decl.is_public
        is_union:       decl.is_union
        implements:     implemented_types
        embedded:       embedded
        language:       decl.language
        name:           decl.name
        generic_params: decl.generic_params
        fields:         fields
        pos:            decl.pos
    }
}

fn (mut t Transformer) register_concrete_embedded_owner_names(decl ast.StructDecl, embedded []ast.Expr) {
    mut names := map[string]string{}
    for i, original in decl.embedded {
        if i >= embedded.len {
            break
        }
        base_owner := embedded_owner_name_from_type_expr(original)
        concrete_owner := embedded_owner_name_from_type_expr(embedded[i])
        if base_owner == '' || concrete_owner == '' || base_owner == concrete_owner {
            continue
        }
        names[base_owner] = concrete_owner
    }
    if names.len == 0 {
        return
    }
    struct_name := t.struct_decl_c_name_for_current_module(decl)
    if struct_name == '' {
        return
    }
    t.concrete_embedded_owner_names[struct_name] = names.clone()
    if struct_name.contains('__') {
        t.concrete_embedded_owner_names[struct_name.all_after_last('__')] = names.clone()
    }
}

fn (t &Transformer) struct_decl_c_name_for_current_module(decl ast.StructDecl) string {
    if decl.name.contains('__') {
        return decl.name
    }
    if t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin' {
        return '${t.cur_module}__${decl.name}'
    }
    return decl.name
}

fn embedded_owner_name_from_type_expr(expr ast.Expr) string {
    match expr {
        ast.GenericArgs {
            return embedded_owner_name_from_type_expr(expr.lhs)
        }
        ast.GenericArgOrIndexExpr {
            return embedded_owner_name_from_type_expr(expr.lhs)
        }
        ast.Ident {
            return embedded_concrete_owner_name_from_type_name(expr.name)
        }
        ast.IndexExpr {
            return embedded_owner_name_from_type_expr(expr.lhs)
        }
        ast.ModifierExpr {
            return embedded_owner_name_from_type_expr(expr.expr)
        }
        ast.PrefixExpr {
            return embedded_owner_name_from_type_expr(expr.expr)
        }
        ast.SelectorExpr {
            return embedded_concrete_owner_name_from_type_name(expr.rhs.name)
        }
        ast.Type {
            match expr {
                ast.GenericType {
                    return embedded_owner_name_from_type_expr(expr.name)
                }
                ast.PointerType {
                    return embedded_owner_name_from_type_expr(expr.base_type)
                }
                else {}
            }
        }
        else {}
    }

    return ''
}

fn embedded_concrete_owner_name_from_type_name(name string) string {
    if name == '' {
        return ''
    }
    mut field_name := name
    if field_name.contains('.') {
        field_name = field_name.all_after_last('.')
    }
    if suffix_idx := field_name.index('_T_') {
        mut base_name := field_name[..suffix_idx]
        if base_name.contains('__') {
            base_name = base_name.all_after_last('__')
        }
        return base_name + field_name[suffix_idx..]
    }
    if field_name.contains('__') {
        return field_name.all_after_last('__')
    }
    return field_name
}

fn (t &Transformer) concrete_embedded_owner_name(struct_name string, owner string) ?string {
    if owner == '' {
        return none
    }
    for key in [struct_name, struct_name.all_after_last('__')] {
        if names := t.concrete_embedded_owner_names[key] {
            if concrete_owner := names[owner] {
                return concrete_owner
            }
        }
    }
    return none
}

fn (t &Transformer) rewrite_embedded_default_field_name(struct_name string, field_name string) string {
    if !field_name.contains('.') {
        return field_name
    }
    owner := field_name.all_before('.')
    rest := field_name.all_after('.')
    if concrete_owner := t.concrete_embedded_owner_name(struct_name, owner) {
        return '${concrete_owner}.${rest}'
    }
    return field_name
}

fn (mut t Transformer) rewrite_concrete_generic_struct_type_expr(expr ast.Expr) ast.Expr {
    if concrete := t.concrete_generic_struct_type_expr(expr) {
        return concrete
    }
    match expr {
        ast.GenericArgOrIndexExpr {
            rewritten := ast.Expr(ast.GenericArgOrIndexExpr{
                lhs:  t.rewrite_concrete_generic_struct_type_expr(expr.lhs)
                expr: t.rewrite_concrete_generic_struct_type_expr(expr.expr)
                pos:  expr.pos
            })
            if concrete := t.concrete_generic_struct_type_expr(rewritten) {
                return concrete
            }
            return rewritten
        }
        ast.GenericArgs {
            mut args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                args << t.rewrite_concrete_generic_struct_type_expr(arg)
            }
            rewritten := ast.Expr(ast.GenericArgs{
                lhs:  t.rewrite_concrete_generic_struct_type_expr(expr.lhs)
                args: args
                pos:  expr.pos
            })
            if concrete := t.concrete_generic_struct_type_expr(rewritten) {
                return concrete
            }
            return rewritten
        }
        ast.ModifierExpr {
            return ast.Expr(ast.ModifierExpr{
                kind: expr.kind
                expr: t.rewrite_concrete_generic_struct_type_expr(expr.expr)
                pos:  expr.pos
            })
        }
        ast.PrefixExpr {
            return ast.Expr(ast.PrefixExpr{
                op:   expr.op
                expr: t.rewrite_concrete_generic_struct_type_expr(expr.expr)
                pos:  expr.pos
            })
        }
        ast.Type {
            rewritten := ast.Expr(t.rewrite_concrete_generic_struct_type_node(expr))
            if concrete := t.concrete_generic_struct_type_expr(rewritten) {
                return concrete
            }
            return rewritten
        }
        else {
            return expr
        }
    }
}

fn (mut t Transformer) rewrite_concrete_generic_struct_type_node(typ ast.Type) ast.Type {
    match typ {
        ast.ArrayType {
            return ast.Type(ast.ArrayType{
                elem_type: t.rewrite_concrete_generic_struct_type_expr(typ.elem_type)
            })
        }
        ast.ArrayFixedType {
            return ast.Type(ast.ArrayFixedType{
                len:       typ.len
                elem_type: t.rewrite_concrete_generic_struct_type_expr(typ.elem_type)
            })
        }
        ast.ChannelType {
            return ast.Type(ast.ChannelType{
                cap:       typ.cap
                elem_type: t.rewrite_concrete_generic_struct_type_expr(typ.elem_type)
            })
        }
        ast.FnType {
            mut params := []ast.Parameter{cap: typ.params.len}
            for param in typ.params {
                params << ast.Parameter{
                    name:   param.name
                    typ:    t.rewrite_concrete_generic_struct_type_expr(param.typ)
                    is_mut: param.is_mut
                    pos:    param.pos
                }
            }
            return ast.Type(ast.FnType{
                generic_params: typ.generic_params
                params:         params
                return_type:    t.rewrite_concrete_generic_struct_type_expr(typ.return_type)
            })
        }
        ast.GenericType {
            mut params := []ast.Expr{cap: typ.params.len}
            for param in typ.params {
                params << t.rewrite_concrete_generic_struct_type_expr(param)
            }
            return ast.Type(ast.GenericType{
                name:   typ.name
                params: params
            })
        }
        ast.MapType {
            return ast.Type(ast.MapType{
                key_type:   t.rewrite_concrete_generic_struct_type_expr(typ.key_type)
                value_type: t.rewrite_concrete_generic_struct_type_expr(typ.value_type)
            })
        }
        ast.OptionType {
            return ast.Type(ast.OptionType{
                base_type: t.rewrite_concrete_generic_struct_type_expr(typ.base_type)
            })
        }
        ast.PointerType {
            return ast.Type(ast.PointerType{
                base_type: t.rewrite_concrete_generic_struct_type_expr(typ.base_type)
                lifetime:  typ.lifetime
            })
        }
        ast.ResultType {
            return ast.Type(ast.ResultType{
                base_type: t.rewrite_concrete_generic_struct_type_expr(typ.base_type)
            })
        }
        ast.ThreadType {
            return ast.Type(ast.ThreadType{
                elem_type: t.rewrite_concrete_generic_struct_type_expr(typ.elem_type)
            })
        }
        else {
            return typ
        }
    }
}

fn (_ &Transformer) get_tuple_lhs(stmt ast.AssignStmt) ?[]ast.Expr {
    if stmt.lhs.len > 1 {
        return stmt.lhs
    }
    if stmt.lhs.len == 1 && stmt.lhs[0] is ast.Tuple {
        return (stmt.lhs[0] as ast.Tuple).exprs
    }
    return none
}

// try_expand_tuple_call_assign expands `a, b = call()` to:
//   _tuple_tN := call()
//   a = _tuple_tN.arg0
//   b = _tuple_tN.arg1
// This handles tuple-returning calls when cleanc can't resolve the tuple type.
fn (mut t Transformer) try_expand_tuple_call_assign(stmt ast.AssignStmt) ?[]ast.Stmt {
    tuple_lhs := t.get_tuple_lhs(stmt) or { return none }
    n := tuple_lhs.len
    if n < 2 {
        return none
    }
    // Must have single RHS (a call expression or similar)
    if stmt.rhs.len != 1 {
        return none
    }
    // Skip if RHS is an IfExpr (handled by try_expand_tuple_if_assign_stmts)
    if stmt.rhs[0] is ast.IfExpr {
        return none
    }
    rhs_expr := stmt.rhs[0]
    // Only handle when RHS is a call expression or postfix unwrap of a call
    mut is_call := rhs_expr is ast.CallExpr
    if rhs_expr is ast.PostfixExpr {
        if rhs_expr.op in [.not, .question] {
            is_call = rhs_expr.expr is ast.CallExpr
        }
    }
    if !is_call {
        return none
    }
    t.temp_counter++
    tmp_name := '_tuple_t${t.temp_counter}'
    tmp_ident := ast.Ident{
        name: tmp_name
    }
    mut result := []ast.Stmt{cap: n + 1}
    // Assign call result to temp variable
    result << ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(tmp_ident)]
        rhs: [rhs_expr]
        pos: stmt.pos
    })
    // Extract .arg0, .arg1, etc. Use decl_assign for new declarations, assign for re-assignments.
    for i in 0 .. n {
        result << ast.Stmt(ast.AssignStmt{
            op:  stmt.op
            lhs: [tuple_lhs[i]]
            rhs: [
                ast.Expr(ast.SelectorExpr{
                    lhs: tmp_ident
                    rhs: ast.Ident{
                        name: 'arg${i}'
                    }
                }),
            ]
            pos: stmt.pos
        })
    }
    return result
}

fn (mut t Transformer) transform_assign_stmt(stmt ast.AssignStmt) ast.AssignStmt {
    op, lhs, rhs, pos := t.transform_assign_stmt_parts(stmt)
    return ast.AssignStmt{
        op:  op
        lhs: lhs
        rhs: rhs
        pos: pos
    }
}

// transform_assign_stmt_parts returns the four variable parts of a lowered
// AssignStmt — `(op, lhs, rhs, pos)`. The flat-write arm calls this directly
// to skip the `ast.AssignStmt` wrapper allocation; the legacy
// `transform_assign_stmt` above wraps it for non-flat callers. Mirrors the
// `_parts` extraction template established by `transform_fn_decl_parts`
// (session 4) and `transform_return_stmt_parts` (session 59).
fn (mut t Transformer) transform_assign_stmt_parts(stmt ast.AssignStmt) (token.Token, []ast.Expr, []ast.Expr, token.Pos) {
    if !expr_array_has_valid_data(stmt.lhs) || !expr_array_has_valid_data(stmt.rhs) {
        return stmt.op, stmt.lhs, stmt.rhs, stmt.pos
    }
    // Check for string compound assignment: p += x -> p = string__plus(p, x)
    if stmt.op == .plus_assign && stmt.lhs.len == 1 && stmt.rhs.len == 1 {
        lhs_expr := stmt.lhs[0]
        if t.is_string_expr(lhs_expr) {
            // Transform p += x to p = string__plus(p, x)
            return token.Token.assign, stmt.lhs, [
                ast.Expr(ast.CallExpr{
                    lhs:  ast.Ident{
                        name: 'string__plus'
                    }
                    args: [t.transform_expr(lhs_expr), t.transform_expr(stmt.rhs[0])]
                    pos:  stmt.pos
                }),
            ], stmt.pos
        }
    }
    // Lower writes into result/option payload: res.data = v
    if stmt.op == .assign && stmt.lhs.len == 1 && stmt.rhs.len == 1
        && stmt.lhs[0] is ast.SelectorExpr {
        lhs_sel := stmt.lhs[0] as ast.SelectorExpr
        if lhs_sel.rhs.name == 'data' {
            if lhs_type := t.get_expr_type(lhs_sel.lhs) {
                match lhs_type {
                    types.ResultType {
                        base_c := t.type_to_c_name(lhs_type.base_type)
                        if base_c != '' && base_c != 'void' {
                            return token.Token.assign, [
                                t.lower_wrapper_payload_access(t.transform_expr(lhs_sel.lhs),
                                    base_c),
                            ], [t.transform_expr(stmt.rhs[0])], stmt.pos
                        }
                    }
                    types.OptionType {
                        base_c := t.type_to_c_name(lhs_type.base_type)
                        if base_c != '' && base_c != 'void' {
                            return token.Token.assign, [
                                t.lower_wrapper_payload_access(t.transform_expr(lhs_sel.lhs),
                                    base_c),
                            ], [t.transform_expr(stmt.rhs[0])], stmt.pos
                        }
                    }
                    else {}
                }
            }
        }
    }

    mut lhs := []ast.Expr{cap: stmt.lhs.len}
    for _, expr in stmt.lhs {
        if expr is ast.Ident {
            // Assignment writes to the original variable, not a smartcasted view.
            lhs << ast.Expr(expr)
        } else {
            lhs << t.transform_expr(expr)
        }
    }
    is_tuple_lhs := stmt.lhs.len > 1 || (stmt.lhs.len == 1 && stmt.lhs[0] is ast.Tuple)
    // Keep a shallow view of RHS expressions; deep clone can crash on malformed AST payloads.
    mut rhs_src := unsafe { stmt.rhs }
    if is_tuple_lhs && stmt.rhs.len == 1 && stmt.rhs[0] is ast.PostfixExpr {
        postfix := stmt.rhs[0] as ast.PostfixExpr
        if postfix.op in [.not, .question] {
            // For tuple destructuring with `call()!`, keep the raw call expression.
            // Tuple/result unwrapping is handled later by codegen.
            rhs_src = [postfix.expr]
        }
    }
    mut rhs := []ast.Expr{cap: stmt.rhs.len}
    // For decl_assign with IfExpr RHS, skip value-lowering since cleanc
    // already handles this case efficiently (Type name; if (...) { name = a; } else { ... }).
    is_decl_with_if_rhs := stmt.op == .decl_assign && rhs_src.len == 1 && rhs_src[0] is ast.IfExpr
    saved_skip := t.skip_if_value_lowering
    if is_decl_with_if_rhs {
        t.skip_if_value_lowering = true
    }
    mut rhs_smartcast_variants := []string{len: rhs_src.len}
    for i, expr in rhs_src {
        mut rhs_expr := expr
        // Preserve expected type context for untyped literals like `[]` / `{}` on assignment.
        if i < stmt.lhs.len {
            lhs_expr := stmt.lhs[i]
            lhs_is_new_decl_ident := stmt.op == .decl_assign && lhs_expr is ast.Ident
            if !lhs_is_new_decl_ident && !(stmt.op == .decl_assign && rhs_expr is ast.AsCastExpr) {
                mut lhs_type_name_for_wrap := t.assignment_lhs_type_name(lhs_expr)
                if lhs_expr is ast.Ident {
                    if lhs_type_name_for_wrap != '' {
                        if lhs_expected2 := t.lookup_type(lhs_type_name_for_wrap) {
                            rhs_expr = t.resolve_expr_with_expected_type(rhs_expr, lhs_expected2)
                        }
                    }
                } else if lhs_expected := t.get_expr_type(lhs_expr) {
                    rhs_expr = t.resolve_expr_with_expected_type(rhs_expr, lhs_expected)
                }
                if lhs_type_name_for_wrap != '' && t.is_sum_type(lhs_type_name_for_wrap)
                    && expr is ast.Ident {
                    if ctx := t.find_smartcast_for_expr(expr.name) {
                        rhs_smartcast_variants[i] = ctx.variant
                    }
                }
            }
        }
        if t.is_native_be && rhs_expr is ast.ArrayInitExpr {
            arr := rhs_expr as ast.ArrayInitExpr
            if arr.len is ast.EmptyExpr && arr.cap is ast.EmptyExpr && arr.init is ast.EmptyExpr {
                rhs << rhs_expr
                continue
            }
        }
        rhs << t.transform_expr(rhs_expr)
    }
    t.skip_if_value_lowering = saved_skip
    // For simple assignments, check if LHS is a sumtype and wrap the RHS if needed
    if stmt.op in [.assign, .decl_assign] && lhs.len == 1 && rhs.len == 1 {
        lhs_name := t.get_var_name(stmt.lhs[0])
        if lhs_name != '' && !(stmt.op == .decl_assign && rhs_src[0] is ast.AsCastExpr) {
            lhs_type_name := if stmt.op == .decl_assign && stmt.lhs[0] is ast.Ident {
                ''
            } else {
                t.assignment_lhs_type_name(stmt.lhs[0])
            }
            if lhs_type_name != '' && t.is_sum_type(lhs_type_name) {
                if wrapped := t.wrap_sumtype_value_transformed(rhs[0], lhs_type_name) {
                    rhs[0] = wrapped
                } else if rhs_smartcast_variants.len > 0 && rhs_smartcast_variants[0] != '' {
                    variants := t.get_sum_type_variants(lhs_type_name)
                    variant_name := t.match_variant(rhs_smartcast_variants[0], variants) or {
                        rhs_smartcast_variants[0]
                    }
                    if wrapped := t.build_sumtype_init(rhs[0], variant_name, lhs_type_name) {
                        rhs[0] = wrapped
                    }
                }
            }
        }
    }
    // Propagate array element type overrides from RHS temp variables to LHS variables.
    // When .map(fn_name) expansion creates _filter_tN with a type override, propagate
    // it to the declared variable (e.g. r2 := _filter_tN → r2 gets the same override).
    if stmt.op == .decl_assign && rhs.len == 1 {
        rhs0_valid := unsafe { expr_has_valid_data_ref(&rhs[0]) }
        rhs0 := rhs[0]
        if rhs0_valid && rhs0 is ast.Ident {
            rhs_name := (rhs0 as ast.Ident).name
            if override := t.array_elem_type_overrides[rhs_name] {
                lhs_name := t.get_var_name(stmt.lhs[0])
                if lhs_name != '' {
                    t.array_elem_type_overrides[lhs_name] = override
                }
            }
        }
    }
    if stmt.op == .decl_assign && stmt.lhs.len == 1 && rhs_src.len == 1 {
        lhs_name := t.get_var_name(stmt.lhs[0])
        if lhs_name != '' {
            decl_rhs := if rhs.len == 1 && rhs[0] is ast.IfExpr {
                rhs[0]
            } else {
                rhs_src[0]
            }
            if decl_type := t.decl_assign_storage_type(stmt.lhs[0], decl_rhs) {
                t.remember_decl_assign_lhs_type(stmt.lhs, decl_type)
            }
            if rhs_type := t.fn_pointer_call_return_type(rhs_src[0]) {
                t.register_temp_var(lhs_name, rhs_type)
            } else if rhs_type := t.smartcast_type_for_expr(rhs_src[0]) {
                t.register_local_var_type(lhs_name, rhs_type)
            } else if rhs_type := t.rune_arithmetic_expr_type(rhs_src[0]) {
                t.register_local_var_type(lhs_name, rhs_type)
            } else if rhs_src[0] is ast.ArrayInitExpr {
                if rhs_type := t.get_array_init_expr_type(rhs_src[0] as ast.ArrayInitExpr) {
                    t.register_local_var_type(lhs_name, rhs_type)
                }
            } else if rhs_src[0] is ast.MapInitExpr {
                map_init := rhs_src[0] as ast.MapInitExpr
                if map_init.typ !is ast.EmptyExpr {
                    if rhs_type := t.type_from_param_type_expr(map_init.typ, []) {
                        t.register_local_var_type(lhs_name, rhs_type)
                    }
                }
            } else if rhs_src[0] is ast.CallExpr || rhs_src[0] is ast.CallOrCastExpr
                || rhs_src[0] is ast.InitExpr || rhs_src[0] is ast.Ident
                || rhs_src[0] is ast.SelectorExpr {
                if rhs_type := t.get_expr_type(rhs_src[0]) {
                    t.register_local_var_type(lhs_name, rhs_type)
                }
            }
            if bindings := t.generic_bindings_from_generic_call_expr(rhs_src[0]) {
                t.local_receiver_generic_bindings[lhs_name] = bindings.clone()
            } else if bindings := t.generic_bindings_from_generic_init_expr(rhs_src[0]) {
                t.local_receiver_generic_bindings[lhs_name] = bindings.clone()
            }
        }
    }
    return stmt.op, lhs, rhs, stmt.pos
}

fn (t &Transformer) assignment_lhs_type_name(expr ast.Expr) string {
    if expr is ast.Ident {
        type_name := t.get_var_type_name(expr.name)
        if type_name != '' {
            return type_name
        }
    }
    if typ := t.get_expr_type(expr) {
        return t.type_to_c_name(typ)
    }
    return ''
}

fn (t &Transformer) smartcast_type_for_expr(expr ast.Expr) ?types.Type {
    expr_str := t.expr_to_string(expr)
    if expr_str == '' {
        return none
    }
    ctx := t.find_smartcast_for_expr(expr_str) or { return none }
    if ctx.variant_full != '' {
        if typ := t.c_name_to_type(ctx.variant_full) {
            return t.normalize_type(typ)
        }
        if typ := t.lookup_type(ctx.variant_full) {
            return t.normalize_type(typ)
        }
    }
    if ctx.variant != '' {
        if typ := t.c_name_to_type(ctx.variant) {
            return t.normalize_type(typ)
        }
        if typ := t.lookup_type(ctx.variant) {
            return t.normalize_type(typ)
        }
    }
    return none
}

// get_var_name extracts the variable name from an expression, handling ModifierExpr
fn (t &Transformer) get_var_name(expr ast.Expr) string {
    if expr is ast.Ident {
        return expr.name
    }
    if expr is ast.ModifierExpr {
        return t.get_var_name(expr.expr)
    }
    return ''
}

// try_extract_sincos_arg checks if an expression is a call to `sincos(x)` and returns the argument.
fn (t &Transformer) try_extract_sincos_arg(expr ast.Expr) ?ast.Expr {
    if expr is ast.CallExpr {
        if expr.lhs is ast.Ident {
            name := (expr.lhs as ast.Ident).name
            if name == 'sincos' && expr.args.len == 1 {
                return expr.args[0]
            }
        } else if expr.lhs is ast.SelectorExpr {
            sel := expr.lhs as ast.SelectorExpr
            if sel.rhs.name == 'sincos' && expr.args.len == 1 {
                return expr.args[0]
            }
        }
    }
    // sincos(x) with single arg may be parsed as CallOrCastExpr
    if expr is ast.CallOrCastExpr {
        if expr.lhs is ast.Ident {
            name := (expr.lhs as ast.Ident).name
            if name == 'sincos' {
                return expr.expr
            }
        } else if expr.lhs is ast.SelectorExpr {
            sel := expr.lhs as ast.SelectorExpr
            if sel.rhs.name == 'sincos' {
                return expr.expr
            }
        }
    }
    return none
}

// try_expand_or_expr_assign checks if an assignment has an OrExpr RHS (used by transform_stmt)
// Returns none since expansion is handled by try_expand_or_expr_assign_stmts at the list level
fn (mut t Transformer) try_expand_or_expr_assign(_stmt ast.AssignStmt) ?ast.Stmt {
    return none
}

// try_transform_map_index_assign transforms map index assignment to a function call.
// Transforms: m[key] = val -> map__set(&m, &key, &val)
// Also handles compound assignments: m[key] += val -> { tmp = map_get(m,key); tmp += val; map_set(m,key,tmp) }
fn (mut t Transformer) map_value_temp_expr(expr ast.Expr, value_type types.Type) ast.Expr {
    mut resolved := t.resolve_expr_with_expected_type(expr, value_type)
    target_name := t.type_to_c_name(value_type)
    if target_name != '' {
        if t.expr_is_casted_to_type(resolved, target_name) {
            return resolved
        }
        if resolved_type := t.get_expr_type(resolved) {
            if t.type_names_match(t.type_to_c_name(resolved_type), target_name) {
                return resolved
            }
            resolved_base_name := t.type_to_c_name(t.unwrap_alias_and_pointer_type(resolved_type))
            value_base_name := t.type_to_c_name(t.unwrap_alias_and_pointer_type(value_type))
            if t.type_names_match(resolved_base_name, value_base_name) {
                return resolved
            }
        }
    }
    if value_type is types.SumType {
        st := value_type as types.SumType
        return ast.CastExpr{
            typ:  ast.Ident{
                name: st.name
            }
            expr: resolved
            pos:  resolved.pos()
        }
    }
    base := t.unwrap_alias_and_pointer_type(value_type)
    match base {
        types.Primitive, types.ISize, types.USize, types.Char, types.Rune, types.Enum {
            if target_name != '' && t.expr_is_casted_to_type(resolved, target_name) {
                return resolved
            }
            return ast.CastExpr{
                typ:  t.type_to_ast_type_expr(value_type)
                expr: resolved
                pos:  resolved.pos()
            }
        }
        else {}
    }

    return resolved
}

fn (mut t Transformer) try_transform_map_index_assign(stmt ast.AssignStmt) ?ast.Stmt {
    if t.is_eval_backend() {
        return none
    }
    // Handle compound assignment by converting to: m[key] = m[key] op val
    if stmt.op != .assign && stmt.op != .decl_assign {
        infix_op := match stmt.op {
            .plus_assign { token.Token.plus }
            .minus_assign { token.Token.minus }
            .mul_assign { token.Token.mul }
            .div_assign { token.Token.div }
            .mod_assign { token.Token.mod }
            .and_assign { token.Token.amp }
            .or_assign { token.Token.pipe }
            .xor_assign { token.Token.xor }
            .left_shift_assign { token.Token.left_shift }
            .right_shift_assign { token.Token.right_shift }
            else { return none }
        }

        if stmt.lhs.len != 1 || stmt.rhs.len != 1 {
            return none
        }
        // Convert m[key] op= val to m[key] = m[key] op val
        new_rhs := ast.Expr(ast.InfixExpr{
            lhs: stmt.lhs[0]
            op:  infix_op
            rhs: stmt.rhs[0]
            pos: stmt.pos
        })
        return t.try_transform_map_index_assign(ast.AssignStmt{
            op:  .assign
            lhs: stmt.lhs
            rhs: [new_rhs]
            pos: stmt.pos
        })
    }
    // Check for single LHS that is an IndexExpr
    if stmt.lhs.len != 1 || stmt.rhs.len != 1 {
        return none
    }
    lhs_expr := stmt.lhs[0]
    mut index_expr := ast.IndexExpr{}
    if lhs_expr is ast.IndexExpr {
        index_expr = lhs_expr
    } else if lhs_expr is ast.GenericArgOrIndexExpr {
        // The parser may represent `m[key]` as GenericArgOrIndexExpr due to ambiguity with generic args.
        // For assignment LHS, treat it as an index expression unless lhs is callable (generic specialization).
        if lhs_type := t.get_expr_type(lhs_expr.lhs) {
            if t.is_callable_type(lhs_type) {
                return none
            }
        }
        index_expr = ast.IndexExpr{
            lhs:      lhs_expr.lhs
            expr:     lhs_expr.expr
            is_gated: false
            pos:      lhs_expr.pos
        }
    } else if lhs_expr is ast.GenericArgs {
        // Same ambiguity case: `m[key]` may be parsed as GenericArgs (single arg) rather than IndexExpr.
        if lhs_expr.args.len != 1 {
            return none
        }
        if lhs_type := t.get_expr_type(lhs_expr.lhs) {
            if t.is_callable_type(lhs_type) {
                return none
            }
        }
        index_expr = ast.IndexExpr{
            lhs:      lhs_expr.lhs
            expr:     lhs_expr.args[0]
            is_gated: false
            pos:      lhs_expr.pos
        }
    } else if lhs_expr is ast.SelectorExpr {
        // Handle map[key].field = value → ((ValueType*)map__get_and_set(&m, &key, &zero))->field = value
        return t.try_transform_map_selector_assign(stmt, lhs_expr)
    } else {
        return none
    }
    // Check if the indexed expression is a map and extract key/value types.
    map_expr_typ := t.map_index_lhs_type(index_expr.lhs) or { return none }
    map_type := t.unwrap_map_type(map_expr_typ) or { return none }

    // Transform to: { key_tmp := key; val_tmp := val; map__set(&m, &key_tmp, &val_tmp) }
    // Temps are extracted to statement level to avoid scope-escape issues with
    // statement-expression temporaries ({...}) used as function call arguments.
    mut prefix_stmts := []ast.Stmt{}
    // For nested map index assignment (e.g., m['a']['b'] = val), the inner map access
    // must use map__get_and_set to get a pointer to the actual entry, not a copy.
    map_arg := t.map_index_lhs_to_ptr_with_prefix(index_expr.lhs, map_expr_typ, mut prefix_stmts)
    key_arg := t.addr_of_with_prefix_temp(index_expr.expr, map_type.key_type, mut prefix_stmts)
    rhs_val := t.map_value_temp_expr(stmt.rhs[0], map_type.value_type)
    val_arg := t.addr_of_with_prefix_temp(rhs_val, map_type.value_type, mut prefix_stmts)

    call_stmt := ast.Stmt(ast.ExprStmt{
        expr: ast.CallExpr{
            lhs:  ast.Ident{
                name: 'map__set'
            }
            args: [
                map_arg,
                t.voidptr_cast(key_arg),
                t.voidptr_cast(val_arg),
            ]
            pos:  stmt.pos
        }
    })

    if prefix_stmts.len > 0 {
        prefix_stmts << call_stmt
        return ast.BlockStmt{
            stmts: prefix_stmts
        }
    }
    return call_stmt
}

// try_transform_map_selector_assign handles assignment to a field of a map value:
// m[key].field = value → ((ValueType*)map__get_and_set(&m, &key, &zero))->field = value
fn (mut t Transformer) try_transform_map_selector_assign(stmt ast.AssignStmt, sel ast.SelectorExpr) ?ast.Stmt {
    // Extract the map IndexExpr from the SelectorExpr's LHS
    mut index_expr := ast.IndexExpr{}
    if sel.lhs is ast.IndexExpr {
        index_expr = sel.lhs as ast.IndexExpr
    } else if sel.lhs is ast.GenericArgOrIndexExpr {
        gai := sel.lhs as ast.GenericArgOrIndexExpr
        if lhs_type := t.get_expr_type(gai.lhs) {
            if t.is_callable_type(lhs_type) {
                return none
            }
        }
        index_expr = ast.IndexExpr{
            lhs:      gai.lhs
            expr:     gai.expr
            is_gated: false
            pos:      gai.pos
        }
    } else {
        return none
    }
    // Verify this is a map type
    map_expr_typ := t.map_index_lhs_type(index_expr.lhs) or { return none }
    map_type := t.unwrap_map_type(map_expr_typ) or { return none }
    // Get the C type name for the map value type
    val_type_name := t.type_to_c_name(map_type.value_type)
    mut prefix_stmts := []ast.Stmt{}
    // Build: map__get_and_set(&m, &key, &zero)
    map_arg := t.map_index_lhs_to_ptr_with_prefix(index_expr.lhs, map_expr_typ, mut prefix_stmts)
    key_arg := t.addr_of_with_prefix_temp(index_expr.expr, map_type.key_type, mut prefix_stmts)
    zero_expr := t.zero_value_expr_for_type(map_type.value_type)
    zero_arg := t.addr_of_with_prefix_temp(zero_expr, map_type.value_type, mut prefix_stmts)
    get_and_set_call := ast.CallExpr{
        lhs:  ast.Ident{
            name: 'map__get_and_set'
        }
        args: [
            map_arg,
            t.voidptr_cast(key_arg),
            t.voidptr_cast(zero_arg),
        ]
    }
    // Build: (*((ValueType*)map__get_and_set(...))) - parenthesized for correct C precedence
    deref_expr := ast.ParenExpr{
        expr: ast.PrefixExpr{
            op:   .mul
            expr: ast.CastExpr{
                typ:  ast.Ident{
                    name: '${val_type_name}*'
                }
                expr: get_and_set_call
            }
        }
    }
    // Build: (*((ValueType*)map__get_and_set(...))).field
    new_lhs := ast.Expr(ast.SelectorExpr{
        lhs: deref_expr
        rhs: sel.rhs
        pos: sel.pos
    })
    // Create the assignment with the new LHS
    assign_stmt := ast.Stmt(ast.AssignStmt{
        op:  stmt.op
        lhs: [new_lhs]
        rhs: [t.transform_expr(stmt.rhs[0])]
        pos: stmt.pos
    })
    if prefix_stmts.len > 0 {
        prefix_stmts << assign_stmt
        return ast.BlockStmt{
            stmts: prefix_stmts
        }
    }
    return assign_stmt
}

// map_index_lhs_to_ptr generates a pointer expression to a map for use as the first
// argument of map__set. For simple variables (e.g., `m`), it returns `&m`.
// For nested map index expressions (e.g., `outer['key']` where the result is an inner map),
// it uses map__get_and_set to get a pointer to the actual entry in the outer map,
// avoiding the copy-on-read problem that would lose writes to the inner map.
fn (t &Transformer) map_index_lhs_type(lhs ast.Expr) ?types.Type {
    if lhs is ast.SelectorExpr {
        // Selector map fields can lack direct expression metadata in generic/cached
        // module bodies, or carry pointer-shaped metadata from a lowered use.
        // Recover the declared field type from the receiver struct first so
        // `handler.maps[key]` lowers as an addressable map field.
        if field_type := t.get_struct_field_type(lhs) {
            return field_type
        }
    }
    // Unwrap `(expr)` so callers don't need to know about ParenExpr wrappers.
    if lhs is ast.ParenExpr {
        return t.map_index_lhs_type(lhs.expr)
    }
    // `*ptr` where ptr is `&map[K]V`: resolve via the pointer deref so we
    // hand callers the underlying map type, not the pointer.
    if lhs is ast.PrefixExpr && lhs.op == .mul {
        if inner_type := t.get_expr_type(lhs.expr) {
            if inner_type is types.Pointer {
                return inner_type.base_type
            }
        }
    }
    if typ := t.get_expr_type(lhs) {
        return typ
    }
    return none
}

fn (mut t Transformer) map_expr_type_is_trustworthy_pointer(expr ast.Expr, typ types.Type) bool {
    if !t.is_pointer_type(typ) {
        return false
    }
    if expr is ast.SelectorExpr {
        if field_type := t.get_struct_field_type(expr) {
            return t.is_pointer_type(field_type)
        }
        return !t.can_take_address_expr(expr)
    }
    return true
}

fn (mut t Transformer) map_expr_to_runtime_ptr(expr ast.Expr, typ types.Type, map_type types.Map) ast.Expr {
    transformed := t.transform_expr(expr)
    if t.map_expr_type_is_trustworthy_pointer(expr, typ) {
        return transformed
    }
    if t.can_take_address_expr(transformed) {
        return ast.Expr(ast.PrefixExpr{
            op:   .amp
            expr: transformed
        })
    }
    return t.addr_of_expr_with_temp(expr, map_type)
}

fn (t &Transformer) index_expr_from_or_target(expr ast.Expr) ?ast.IndexExpr {
    match expr {
        ast.IndexExpr {
            return expr
        }
        ast.GenericArgOrIndexExpr {
            if lhs_type := t.get_expr_type(expr.lhs) {
                if t.is_callable_type(lhs_type) {
                    return none
                }
            }
            return ast.IndexExpr{
                lhs:      expr.lhs
                expr:     expr.expr
                is_gated: false
                pos:      expr.pos
            }
        }
        ast.GenericArgs {
            if expr.args.len != 1 {
                return none
            }
            if lhs_type := t.get_expr_type(expr.lhs) {
                if t.is_callable_type(lhs_type) {
                    return none
                }
            }
            return ast.IndexExpr{
                lhs:      expr.lhs
                expr:     expr.args[0]
                is_gated: false
                pos:      expr.pos
            }
        }
        else {
            return none
        }
    }

    return none
}

fn (mut t Transformer) map_index_lhs_to_ptr(lhs ast.Expr, lhs_type types.Type) ast.Expr {
    // Check if lhs is a map index expression (nested map case)
    if lhs is ast.IndexExpr {
        outer_type := t.map_index_lhs_type(lhs.lhs) or {
            // Fallback: take address of transformed expression
            return t.addr_of_expr_with_temp(lhs, lhs_type)
        }
        if outer_map := t.unwrap_map_type(outer_type) {
            // Generate: (inner_map_type*) map__get_and_set(&outer, &key, &zero)
            outer_map_arg := t.map_index_lhs_to_ptr(lhs.lhs, outer_type)
            zero_expr := t.zero_value_expr_for_type(outer_map.value_type)
            get_and_set_call := ast.CallExpr{
                lhs:  ast.Ident{
                    name: 'map__get_and_set'
                }
                args: [
                    outer_map_arg,
                    t.voidptr_cast(t.addr_of_expr_with_temp(lhs.expr, outer_map.key_type)),
                    t.voidptr_cast(t.addr_of_expr_with_temp(zero_expr, outer_map.value_type)),
                ]
            }
            // Cast the voidptr result to the correct map pointer type
            return ast.CastExpr{
                typ:  ast.Ident{
                    name: 'map*'
                }
                expr: get_and_set_call
            }
        }
    }
    // Simple case: take address of variable or expression
    if t.is_pointer_type(lhs_type) {
        return t.transform_expr(lhs)
    }
    return t.addr_of_expr_with_temp(lhs, lhs_type)
}

fn (mut t Transformer) map_index_lhs_to_ptr_with_prefix(lhs ast.Expr, lhs_type types.Type, mut prefix_stmts []ast.Stmt) ast.Expr {
    if lhs is ast.IndexExpr {
        outer_type := t.map_index_lhs_type(lhs.lhs) or {
            return t.addr_of_with_prefix_temp(lhs, lhs_type, mut prefix_stmts)
        }
        if outer_map := t.unwrap_map_type(outer_type) {
            outer_map_arg := t.map_index_lhs_to_ptr_with_prefix(lhs.lhs, outer_type, mut
                prefix_stmts)
            key_arg := t.addr_of_with_prefix_temp(lhs.expr, outer_map.key_type, mut prefix_stmts)
            zero_expr := t.zero_value_expr_for_type(outer_map.value_type)
            zero_arg := t.addr_of_with_prefix_temp(zero_expr, outer_map.value_type, mut
                prefix_stmts)
            get_and_set_call := ast.CallExpr{
                lhs:  ast.Ident{
                    name: 'map__get_and_set'
                }
                args: [
                    outer_map_arg,
                    t.voidptr_cast(key_arg),
                    t.voidptr_cast(zero_arg),
                ]
            }
            return ast.CastExpr{
                typ:  ast.Ident{
                    name: 'map*'
                }
                expr: get_and_set_call
            }
        }
    }
    if t.is_pointer_type(lhs_type) {
        return t.transform_expr(lhs)
    }
    return t.addr_of_with_prefix_temp(lhs, lhs_type, mut prefix_stmts)
}

// try_transform_map_index_push transforms map[key] << value to get_and_set + array_push.
// Transforms: m[key] << val -> array__push_noscan((array*)map__get_and_set(&m, &key, &empty), val)
fn (mut t Transformer) try_transform_map_index_push(stmt ast.ExprStmt) ?ast.Stmt {
    if t.is_eval_backend() {
        return none
    }
    if stmt.expr !is ast.InfixExpr {
        return none
    }
    infix := stmt.expr as ast.InfixExpr
    if infix.op != .left_shift {
        return none
    }
    index_expr := t.index_expr_from_or_target(infix.lhs) or { return none }
    // Check if the indexed expression is a map with array value type
    map_expr_typ := t.map_index_lhs_type(index_expr.lhs) or { return none }
    map_type := t.unwrap_map_type(map_expr_typ) or { return none }
    if t.is_pointer_type(map_type.value_type) {
        return none
    }
    // Map values can be aliases of arrays (for example strings.Builder).
    val_type := t.unwrap_alias_and_pointer_type(map_type.value_type)
    if val_type !is types.Array {
        return none
    }
    arr_type := val_type as types.Array
    elem_type_name := t.type_to_c_name(arr_type.elem_type)
    map_arg := if t.is_pointer_type(map_expr_typ) {
        t.transform_expr(index_expr.lhs)
    } else {
        t.addr_of_expr_with_temp(index_expr.lhs, map_expr_typ)
    }
    empty_arr := ast.Expr(ast.ArrayInitExpr{
        typ: ast.Expr(ast.Type(ast.ArrayType{
            elem_type: ast.Ident{
                name: elem_type_name
            }
        }))
    })

    // Common: (array*)map__get_and_set(&m, &key, &empty_array)
    // Appending through a map index must operate on the actual map entry, creating a
    // typed empty array when the key is missing.
    arr_ptr_expr := ast.Expr(ast.CastExpr{
        typ:  ast.Ident{
            name: 'array*'
        }
        expr: ast.CallExpr{
            lhs:  ast.Ident{
                name: 'map__get_and_set'
            }
            args: [
                map_arg,
                // &key
                t.voidptr_cast(t.addr_of_expr_with_temp(index_expr.expr, map_type.key_type)),
                // &empty_array (typed empty array so pushes use the correct element size)
                t.voidptr_cast(t.addr_of_expr_with_temp(empty_arr, map_type.value_type)),
            ]
        }
    })

    // Detect push_many: if RHS is an array whose element type matches our element type
    rhs_is_array := t.append_rhs_is_array_value_compatible(elem_type_name, infix.rhs)

    if rhs_is_array {
        // push_many: array__push_many(arr_ptr, rhs.data, rhs.len)
        rhs_transformed := t.transform_expr(infix.rhs)
        rhs_for_selector := if infix.rhs is ast.PrefixExpr {
            ast.Expr(ast.ParenExpr{
                expr: rhs_transformed
            })
        } else {
            rhs_transformed
        }
        return ast.ExprStmt{
            expr: ast.CallExpr{
                lhs:  ast.Ident{
                    name: 'array__push_many'
                }
                args: [
                    arr_ptr_expr,
                    t.synth_selector(rhs_for_selector, 'data', types.Type(types.voidptr_)),
                    t.synth_selector(rhs_for_selector, 'len', types.Type(types.int_)),
                ]
            }
        }
    }

    // Single element push: array__push_noscan(arr_ptr, (elem_type[1]){value})
    mut push_exprs := []ast.Expr{cap: 1}
    transformed_rhs := t.transform_expr(infix.rhs)
    push_exprs << t.wrap_array_push_elem_value(transformed_rhs, elem_type_name)
    return ast.ExprStmt{
        expr: ast.CallExpr{
            lhs:  ast.Ident{
                name: 'array__push_noscan'
            }
            args: [
                arr_ptr_expr,
                // (elem_type[1]){value}
                ast.Expr(ast.ArrayInitExpr{
                    typ:   ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Ident{
                            name: elem_type_name
                        }
                    }))
                    exprs: push_exprs
                }),
            ]
        }
    }
}

// try_transform_map_index_postfix transforms m[key]++ / m[key]-- to compound assignment.
// Converts: m[key]++ -> m[key] += 1   and   m[key]-- -> m[key] -= 1
// The resulting compound assignment is then handled by try_transform_map_index_assign.
fn (mut t Transformer) try_transform_map_index_postfix(stmt ast.ExprStmt) ?ast.Stmt {
    if stmt.expr !is ast.PostfixExpr {
        return none
    }
    postfix := stmt.expr as ast.PostfixExpr
    if postfix.op != .inc && postfix.op != .dec {
        return none
    }
    // Check if the operand is a map index expression
    mut index_expr := ast.IndexExpr{}
    if postfix.expr is ast.IndexExpr {
        index_expr = postfix.expr
    } else if postfix.expr is ast.GenericArgOrIndexExpr {
        if lhs_type := t.get_expr_type(postfix.expr.lhs) {
            if t.is_callable_type(lhs_type) {
                return none
            }
        }
        index_expr = ast.IndexExpr{
            lhs:      postfix.expr.lhs
            expr:     postfix.expr.expr
            is_gated: false
            pos:      postfix.expr.pos
        }
    } else if postfix.expr is ast.SelectorExpr {
        return t.try_transform_map_selector_postfix(postfix)
    } else {
        return none
    }
    // Verify this is a map type
    map_expr_typ := t.map_index_lhs_type(index_expr.lhs) or { return none }
    _ = t.unwrap_map_type(map_expr_typ) or { return none }
    // Convert to simple assignment: m[key] = m[key] + 1 (or - 1 for --)
    // Build the RHS directly to avoid compound→simple conversion inheriting a source
    // pos that the env may have typed as the map container rather than the value type.
    infix_op := if postfix.op == .inc { token.Token.plus } else { token.Token.minus }
    new_rhs := ast.Expr(ast.InfixExpr{
        lhs: ast.Expr(index_expr)
        op:  infix_op
        rhs: ast.BasicLiteral{
            value: '1'
            kind:  .number
        }
    })
    assign_stmt := ast.AssignStmt{
        op:  .assign
        lhs: [ast.Expr(index_expr)]
        rhs: [new_rhs]
    }
    if t.is_eval_backend() {
        return assign_stmt
    }
    return t.try_transform_map_index_assign(assign_stmt)
}

fn (mut t Transformer) try_transform_map_selector_postfix(postfix ast.PostfixExpr) ?ast.Stmt {
    sel := postfix.expr as ast.SelectorExpr
    assign_op := if postfix.op == .inc { token.Token.plus_assign } else { token.Token.minus_assign }
    assign_stmt := ast.AssignStmt{
        op:  assign_op
        lhs: [ast.Expr(sel)]
        rhs: [ast.Expr(ast.BasicLiteral{
            value: '1'
            kind:  .number
        })]
        pos: postfix.pos
    }
    if t.is_eval_backend() {
        return assign_stmt
    }
    return t.try_transform_map_selector_assign(assign_stmt, sel)
}

// try_transform_selector_postfix transforms obj.field++ / obj.field-- to compound assignment.
// Converts: obj.field++ -> obj.field += 1   and   obj.field-- -> obj.field -= 1
// This avoids the build_postfix SelectorExpr code path which has issues in self-hosted binaries.
fn (mut t Transformer) try_transform_selector_postfix(stmt ast.ExprStmt) ?ast.Stmt {
    if stmt.expr !is ast.PostfixExpr {
        return none
    }
    postfix := stmt.expr as ast.PostfixExpr
    if postfix.op != .inc && postfix.op != .dec {
        return none
    }
    if postfix.expr !is ast.SelectorExpr {
        return none
    }
    assign_op := if postfix.op == .inc { token.Token.plus_assign } else { token.Token.minus_assign }
    return ast.AssignStmt{
        op:  assign_op
        lhs: [t.transform_expr(postfix.expr)]
        rhs: [ast.Expr(ast.BasicLiteral{
            value: '1'
            kind:  .number
        })]
    }
}

// try_expand_or_expr_assign_stmts expands an OrExpr assignment to multiple statements.
// Transforms: a := may_fail(5) or { 0 }
// Into:
//   _t1 := may_fail(5)
//   if _t1.is_error { err := _t1.err; _t1.data = 0 }
//   a := _t1.data
fn (mut t Transformer) try_expand_or_expr_assign_stmts(stmt &ast.AssignStmt) ?[]ast.Stmt {
    // Check for assignment with OrExpr somewhere in RHS (single RHS value)
    if stmt.rhs.len != 1 {
        return none
    }
    rhs_expr := stmt.rhs[0]
    // Check if RHS is directly an OrExpr (simple case)
    if rhs_expr is ast.OrExpr {
        return t.expand_direct_or_expr_assign(stmt, rhs_expr)
    }
    // Check if RHS contains an OrExpr (nested case like cast(OrExpr))
    if t.expr_has_or_expr(rhs_expr) {
        mut prefix_stmts := []ast.Stmt{}
        mut new_rhs := t.extract_or_expr(rhs_expr, mut prefix_stmts)
        if prefix_stmts.len == 0 {
            return none
        }
        if new_rhs is ast.EmptyExpr {
            payload_type := t.or_assign_expected_payload_type(stmt, rhs_expr) or {
                types.Type(types.voidptr_)
            }
            if payload_expr := t.or_payload_expr_from_prefix_stmts(prefix_stmts, payload_type) {
                new_rhs = payload_expr
            }
        }
        // Add the final assignment with the extracted expression.
        // Run through transform_stmt to handle map index assignment lowering (map__set),
        // string compound assignment (string__plus), and other statement-level transforms.
        saved_pending := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        transformed_rhs := t.transform_expr(new_rhs)
        rhs_pending := t.pending_stmts.clone()
        t.pending_stmts = saved_pending
        prefix_stmts << rhs_pending
        // For tuple destructuring (a, b := call()?), expand to:
        //   _tuple_tmp := extracted_value
        //   a := _tuple_tmp.arg0
        //   b := _tuple_tmp.arg1
        if tuple_lhs := t.get_tuple_lhs(stmt) {
            if tuple_lhs.len >= 2 {
                t.temp_counter++
                tuple_tmp_name := '_tuple_tmp_${t.temp_counter}'
                tuple_tmp_ident := ast.Ident{
                    name: tuple_tmp_name
                }
                prefix_stmts << ast.Stmt(ast.AssignStmt{
                    op:  .decl_assign
                    lhs: [ast.Expr(tuple_tmp_ident)]
                    rhs: [transformed_rhs]
                    pos: stmt.pos
                })
                for i in 0 .. tuple_lhs.len {
                    prefix_stmts << ast.Stmt(ast.AssignStmt{
                        op:  stmt.op
                        lhs: [tuple_lhs[i]]
                        rhs: [
                            ast.Expr(ast.SelectorExpr{
                                lhs: tuple_tmp_ident
                                rhs: ast.Ident{
                                    name: 'arg${i}'
                                }
                            }),
                        ]
                        pos: stmt.pos
                    })
                }
                return prefix_stmts
            }
        }
        final_assign := ast.AssignStmt{
            op:  stmt.op
            lhs: stmt.lhs
            rhs: [transformed_rhs]
            pos: stmt.pos
        }
        saved_final_pending := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        transformed_final := t.transform_stmt(final_assign)
        final_pending := t.pending_stmts.clone()
        t.pending_stmts = saved_final_pending
        prefix_stmts << final_pending
        prefix_stmts << transformed_final
        return prefix_stmts
    }
    return none
}

fn transformer_or_payload_type_is_value(typ types.Type) bool {
    if typ.name() == 'void' {
        return false
    }
    return typ !is types.ResultType && typ !is types.OptionType
}

fn (t &Transformer) or_assign_expected_payload_type(stmt &ast.AssignStmt, rhs_expr ast.Expr) ?types.Type {
    if typ := t.get_expr_type(rhs_expr) {
        if transformer_or_payload_type_is_value(typ) {
            return typ
        }
    }
    if stmt.lhs.len == 1 {
        if typ := t.get_expr_type(stmt.lhs[0]) {
            if transformer_or_payload_type_is_value(typ) {
                return typ
            }
        }
    }
    return none
}

fn (mut t Transformer) or_payload_expr_from_prefix_stmts(prefix_stmts []ast.Stmt, payload_type types.Type) ?ast.Expr {
    for offset in 0 .. prefix_stmts.len {
        stmt := prefix_stmts[prefix_stmts.len - 1 - offset]
        if stmt is ast.AssignStmt && stmt.op == .decl_assign && stmt.lhs.len == 1 {
            lhs := stmt.lhs[0]
            if lhs is ast.Ident && lhs.name.starts_with('_or_t') {
                return t.synth_selector(ast.Expr(lhs), 'data', payload_type)
            }
        }
    }
    return none
}

fn (mut t Transformer) transform_or_call_expr(call_expr ast.Expr) (ast.Expr, []ast.Stmt) {
    if t.pref == unsafe { nil } || t.pref.backend != .cleanc {
        return t.transform_expr(call_expr), []ast.Stmt{}
    }
    saved_pending := t.pending_stmts
    t.pending_stmts = []ast.Stmt{}
    transformed_call := t.transform_expr(call_expr)
    call_pending := t.pending_stmts
    t.pending_stmts = saved_pending
    return transformed_call, call_pending
}

fn (mut t Transformer) wrap_or_fallback_for_base_type(value ast.Expr, base_type string) ast.Expr {
    if base_type != '' && t.is_sum_type(base_type) {
        if wrapped := t.wrap_sumtype_value_transformed(value, base_type) {
            return wrapped
        }
    }
    return value
}

// expand_direct_or_expr_assign handles the simple case where RHS is directly an OrExpr
fn (mut t Transformer) expand_direct_or_expr_assign(stmt ast.AssignStmt, or_expr ast.OrExpr) ?[]ast.Stmt {
    // The inner expression should be a call that returns Result or Option, OR a map index
    call_expr := or_expr.expr

    if call_expr is ast.SqlExpr && !call_expr.is_create {
        return [
            ast.Stmt(ast.AssignStmt{
                op:  stmt.op
                lhs: stmt.lhs
                rhs: [t.transform_expr(call_expr)]
                pos: stmt.pos
            }),
        ]
    }

    // Check for map index with or block: map[key] or { fallback }
    // This is handled specially since it doesn't use Result/Option types
    if map_result := t.try_expand_map_index_or_assign(stmt, or_expr) {
        return map_result
    }

    // Check for array index with or block: arr[idx] or { fallback }
    if array_result := t.try_expand_array_index_or_assign(stmt, or_expr) {
        return array_result
    }

    // Check for string range with or block: s[0..20] or { 'fallback' }
    // The checker types this as `string`, but it needs `string__substr_with_check`
    // which returns `!string` (Result).
    mut is_string_range_or := false
    if index_expr := t.index_expr_from_or_target(call_expr) {
        if index_expr.expr is ast.RangeExpr && t.is_string_expr(index_expr.lhs) {
            is_string_range_or = true
        }
    }
    // Check if expression returns Result or Option using expression-based lookup
    // This works for both function calls and method calls
    mut is_result := t.expr_returns_result(call_expr)
    mut is_option := t.expr_returns_option(call_expr)

    fn_name := t.get_call_fn_name(call_expr)
    // Method-call detection: `recv.method(...)` where recv is not a module ident.
    // For method calls, the short `fn_name` can collide with a top-level function
    // (e.g. `header.get` vs `http.get`), so resolve the method return type first
    // and skip the bare-name fallback when it's a method call.
    is_method_call := t.is_method_call_expr(call_expr)
    mut method_ret_base_type := ''
    if !is_result && !is_option && is_method_call {
        if ret_type := t.get_method_return_type(call_expr) {
            if ret_type is types.ResultType {
                is_result = true
                method_ret_base_type = ret_type.base_type.name()
            } else if ret_type is types.OptionType {
                is_option = true
                method_ret_base_type = ret_type.base_type.name()
            }
        }
    }

    // Fallback to function name lookup for non-method calls only.
    if !is_result && !is_option && fn_name != '' && !is_method_call {
        is_result = t.fn_returns_result(fn_name)
        is_option = t.fn_returns_option(fn_name)
    }

    // Method-call fallback for the non-Result/Option case (e.g. checker stored
    // a plain type at the position but the method actually returns ?T/!T).
    if !is_result && !is_option && !is_method_call {
        if ret_type := t.get_method_return_type(call_expr) {
            if ret_type is types.ResultType {
                is_result = true
                method_ret_base_type = ret_type.base_type.name()
            } else if ret_type is types.OptionType {
                is_option = true
                method_ret_base_type = ret_type.base_type.name()
            }
        }
    }
    if !is_result && !is_option {
        if is_string_range_or {
            is_result = true
        } else {
            return none
        }
    }

    if t.is_native_be && is_string_range_or {
        // String ranges still need the native inline bounds-check path because the
        // checker records them as `string` instead of `!string`.
        idx_expr := t.index_expr_from_or_target(call_expr) or { return none }
        mut stmts := []ast.Stmt{}
        result_expr := t.expand_string_range_or_native_expr(idx_expr, or_expr.stmts, mut stmts)
        stmts << ast.AssignStmt{
            op:  stmt.op
            lhs: stmt.lhs
            rhs: [result_expr]
            pos: stmt.pos
        }
        return stmts
    }

    // Get base type using expression-based lookup first, then fallback
    mut base_type := t.get_expr_base_type(call_expr)
    // Method-call: derive base_type from the resolved method return type.
    // Prefer this over the bare-name fn lookup to avoid name collisions
    // (e.g. `header.get` vs top-level `http.get`).
    if (base_type == '' || is_method_call) && method_ret_base_type != '' {
        base_type = method_ret_base_type
    }
    if base_type == '' && fn_name != '' && !is_method_call {
        base_type = t.get_fn_return_base_type(fn_name)
    }
    // String range or-block: the checker typed this as plain string,
    // so base_type lookup fails. Force it to 'string'.
    if is_string_range_or && base_type == '' {
        base_type = 'string'
    }
    is_void_result := base_type == '' || base_type == 'void'
    _ = is_option // suppress unused warning
    // Generate temp variable name
    temp_name := t.gen_temp_name()
    temp_ident := ast.Ident{
        name: temp_name
    }

    // Register temp variable type (the Result/Option wrapper type)
    if wrapper_type := t.expr_wrapper_type_for_or(call_expr) {
        t.register_temp_var(temp_name, wrapper_type)
        t.register_synth_type(call_expr.pos(), wrapper_type)
    } else if ret_type := t.get_method_return_type(call_expr) {
        // Method-call result types are often missing from env expr positions.
        // Register the resolved return wrapper type so cleanc can unwrap `.data`/`.err`.
        if ret_type is types.ResultType || ret_type is types.OptionType {
            t.register_temp_var(temp_name, ret_type)
            t.register_synth_type(call_expr.pos(), ret_type)
        }
    } else if fn_name != '' {
        if fn_ret := t.get_fn_return_type(fn_name) {
            if fn_ret is types.ResultType || fn_ret is types.OptionType {
                t.register_temp_var(temp_name, fn_ret)
                t.register_synth_type(call_expr.pos(), fn_ret)
            }
        }
    }
    // String range or-block: register as _result_string since the checker
    // didn't record a Result type for this expression.
    if is_string_range_or {
        t.register_temp_var(temp_name, types.ResultType{
            base_type: types.string_
        })
    }

    // Build the expanded statements
    mut stmts := []ast.Stmt{}
    // 1. _t1 := call_expr
    transformed_call, call_pending := t.transform_or_call_expr(call_expr)
    // For string range or-blocks, rename string__substr to string__substr_with_check
    // which returns !string (Result) instead of string.
    rhs_expr := if is_string_range_or {
        t.rename_substr_to_checked(transformed_call)
    } else {
        transformed_call
    }
    for pending_stmt in call_pending {
        stmts << pending_stmt
    }
    stmts << ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(temp_ident)]
        rhs: [rhs_expr]
        pos: stmt.pos
    }
    // 2. if _t1.is_error { ... } (for Result) or if _t1.state != 0 { ... } (for Option)
    error_cond := if is_result {
        // _t1.is_error
        t.synth_selector(temp_ident, 'is_error', types.Type(types.bool_))
    } else {
        // _t1.state != 0
        ast.Expr(ast.InfixExpr{
            op:  .ne
            lhs: t.synth_selector(temp_ident, 'state', types.Type(types.int_))
            rhs: ast.BasicLiteral{
                kind:  .number
                value: '0'
            }
        })
    }
    // Build the if-block statements
    mut if_stmts := []ast.Stmt{}
    // Keep `err` available in direct-or expansions; some stdlib or-blocks
    // reference it through transformed interpolation paths.
    if_stmts << ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.Ident{
            name: 'err'
        })]
        rhs: [
            t.synth_selector(temp_ident, 'err', types.Type(types.Struct{
                name: 'IError'
            })),
        ]
    }
    // Check if or-block contains a return statement (control flow)
    if t.or_block_has_return(or_expr.stmts) {
        // Or-block contains return - transform statements here to handle string
        // concatenation and other transformations. This is done here instead of
        // relying on later transform_stmt to avoid double smartcast transformation.
        transformed_or_stmts := t.transform_stmts(or_expr.stmts)
        if_stmts << transformed_or_stmts
    } else if is_void_result {
        if_stmts << t.transform_stmts(or_expr.stmts)
    } else if !is_void_result {
        // Or-block provides a value - assign to data (only for non-void results)
        or_side_effect_stmts, or_value := t.get_or_block_stmts_and_value(or_expr.stmts)
        or_payload_value := t.wrap_or_fallback_for_base_type(or_value, base_type)
        if or_side_effect_stmts.len > 0 {
            if_stmts << or_side_effect_stmts
        }
        if (is_result || is_option) && t.cur_fn_returns_result
            && t.or_fallback_is_ierror(or_payload_value) {
            if_stmts << ast.ReturnStmt{
                exprs: [or_payload_value]
            }
        } else if t.is_void_call_expr(or_payload_value) {
            // Void calls can't be assigned - treat as control flow instead.
            if_stmts << ast.ExprStmt{
                expr: or_payload_value
            }
        } else {
            // _t1.data = or_value (the backend will handle proper casting)
            if_stmts << ast.AssignStmt{
                op:  .assign
                lhs: [
                    t.synth_selector(temp_ident, 'data', types.Type(types.voidptr_)),
                ]
                rhs: [or_payload_value]
            }
        }
    }
    stmts << ast.ExprStmt{
        expr: ast.IfExpr{
            cond:  error_cond
            stmts: if_stmts
        }
    }
    // 3. a := _t1.data (extract value) - only for non-void results
    if !is_void_result {
        data_expr := t.synth_selector(temp_ident, 'data', types.Type(types.voidptr_))
        // For tuple destructuring (a, b := call()?), expand to:
        //   _tuple_tmp := _t1.data
        //   a := _tuple_tmp.arg0
        //   b := _tuple_tmp.arg1
        if tuple_lhs := t.get_tuple_lhs(stmt) {
            if tuple_lhs.len >= 2 {
                t.temp_counter++
                tuple_tmp_name := '_tuple_tmp_${t.temp_counter}'
                tuple_tmp_ident := ast.Ident{
                    name: tuple_tmp_name
                }
                stmts << ast.AssignStmt{
                    op:  .decl_assign
                    lhs: [ast.Expr(tuple_tmp_ident)]
                    rhs: [data_expr]
                    pos: stmt.pos
                }
                for i in 0 .. tuple_lhs.len {
                    stmts << ast.AssignStmt{
                        op:  stmt.op
                        lhs: [tuple_lhs[i]]
                        rhs: [
                            ast.Expr(ast.SelectorExpr{
                                lhs: tuple_tmp_ident
                                rhs: ast.Ident{
                                    name: 'arg${i}'
                                }
                            }),
                        ]
                        pos: stmt.pos
                    }
                }
                return stmts
            }
        }
        // Final assignment. For map index assignments, keep using the normal
        // statement-level lowering so native backends do not see raw map GEPs.
        final_assign := ast.AssignStmt{
            op:  stmt.op
            lhs: stmt.lhs
            rhs: [data_expr]
            pos: stmt.pos
        }
        if map_assign := t.try_transform_map_index_assign(final_assign) {
            stmts << map_assign
        } else {
            stmts << final_assign
        }
    }
    return stmts
}

// gen_temp_name generates a unique temporary variable name
fn (mut t Transformer) gen_temp_name() string {
    t.temp_counter++
    return '_or_t${t.temp_counter}'
}

// register_temp_var registers a temporary variable with its type in fn_root_scope
// This allows cleanc to look up the type from the environment instead of inferring it
fn (mut t Transformer) register_temp_var(name string, typ types.Type) {
    obj := value_object_from_type(typ)
    if t.fn_root_scope != unsafe { nil } {
        t.fn_root_scope.insert_or_update(name, obj)
    }
    if t.scope != unsafe { nil } {
        t.scope.insert_or_update(name, obj)
    }
}

fn (mut t Transformer) typed_temp_ident(name string, typ types.Type) ast.Ident {
    pos := t.next_synth_pos()
    t.register_temp_var(name, typ)
    t.register_synth_type(pos, typ)
    return ast.Ident{
        name: name
        pos:  pos
    }
}

fn (mut t Transformer) gen_typed_temp_ident(typ types.Type) ast.Ident {
    return t.typed_temp_ident(t.gen_temp_name(), typ)
}

fn (mut t Transformer) transform_expr_with_captured_pending(expr ast.Expr) (ast.Expr, []ast.Stmt) {
    saved_pending := t.pending_stmts
    t.pending_stmts = []ast.Stmt{}
    transformed := t.transform_expr(expr)
    captured := t.pending_stmts
    t.pending_stmts = saved_pending
    return transformed, captured
}

fn (mut t Transformer) register_local_var_type(name string, typ types.Type) {
    obj := value_object_from_type(typ)
    if t.fn_root_scope != unsafe { nil } {
        t.fn_root_scope.insert_or_update(name, obj)
        return
    }
    if t.scope != unsafe { nil } {
        t.scope.insert_or_update(name, obj)
    }
}

fn (mut t Transformer) remember_local_decl_type(name string, typ types.Type) {
    if name == '' {
        return
    }
    t.local_decl_types[name] = t.normalize_type(typ)
}

fn (mut t Transformer) remember_decl_assign_lhs_type(lhs []ast.Expr, typ types.Type) {
    for expr in lhs {
        match expr {
            ast.Ident {
                if expr.name != '_' {
                    t.remember_local_decl_type(expr.name, typ)
                    t.register_local_var_type(expr.name, typ)
                    if expr.pos.id != 0 {
                        t.register_synth_type(expr.pos, typ)
                    }
                }
            }
            ast.ModifierExpr {
                if expr.expr is ast.Ident {
                    ident := expr.expr as ast.Ident
                    if ident.name != '_' {
                        t.remember_local_decl_type(ident.name, typ)
                        t.register_local_var_type(ident.name, typ)
                        if ident.pos.id != 0 {
                            t.register_synth_type(ident.pos, typ)
                        }
                    }
                }
            }
            else {}
        }
    }
}

fn (t &Transformer) lookup_local_decl_type(name string) ?types.Type {
    typ := t.local_decl_types[name] or { return none }
    return t.normalize_type(typ)
}

fn (t &Transformer) cast_target_value_type(expr ast.Expr) ?types.Type {
    match expr {
        ast.ParenExpr {
            return t.cast_target_value_type(expr.expr)
        }
        ast.ModifierExpr {
            return t.cast_target_value_type(expr.expr)
        }
        ast.CallOrCastExpr {
            if expr.expr !is ast.EmptyExpr && t.call_or_cast_lhs_is_type(expr.lhs) {
                return t.type_from_param_type_expr(expr.lhs, [])
            }
        }
        ast.CallExpr {
            if expr.args.len == 1 && t.call_or_cast_lhs_is_type(expr.lhs) {
                return t.type_from_param_type_expr(expr.lhs, [])
            }
        }
        ast.CastExpr {
            return t.type_from_param_type_expr(expr.typ, [])
        }
        else {}
    }

    return none
}

fn (t &Transformer) deref_address_of_cast_type(expr ast.PrefixExpr) ?types.Type {
    if expr.op != .mul {
        return none
    }
    match expr.expr {
        ast.ParenExpr {
            return t.deref_address_of_cast_type(ast.PrefixExpr{
                op:   .mul
                expr: expr.expr.expr
                pos:  expr.pos
            })
        }
        ast.CastExpr {
            target_type := t.type_from_param_type_expr(expr.expr.typ, []) or { return none }
            if target_type is types.Pointer {
                return target_type.base_type
            }
        }
        ast.PrefixExpr {
            if expr.expr.op == .amp {
                return t.cast_target_value_type(expr.expr.expr)
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) index_expr_storage_type(expr ast.IndexExpr) ?types.Type {
    if expr.expr is ast.RangeExpr {
        if lhs_type := t.get_expr_type(expr.lhs) {
            return t.normalize_type(lhs_type)
        }
        return none
    }
    if lhs_type := t.map_index_lhs_type(expr.lhs) {
        if map_type := t.unwrap_map_type(lhs_type) {
            return map_type.value_type
        }
        mut base_type := lhs_type
        for {
            if base_type is types.Pointer {
                base_type = base_type.base_type
                continue
            }
            if base_type is types.Alias {
                base_type = t.live_alias_base_type(base_type) or { break }
                continue
            }
            break
        }
        if base_type is types.Array {
            return t.normalize_type(base_type.elem_type)
        }
        if base_type is types.ArrayFixed {
            return t.normalize_type(base_type.elem_type)
        }
        if t.is_string_iterable_type(base_type) {
            return string_iter_value_type()
        }
    }
    return none
}

fn (t &Transformer) decl_assign_storage_type(lhs ast.Expr, rhs ast.Expr) ?types.Type {
    if typ := t.fn_pointer_call_return_type(rhs) {
        return typ
    }
    if typ := t.smartcast_type_for_expr(rhs) {
        return typ
    }
    if rhs is ast.ArrayInitExpr {
        if typ := t.get_array_init_expr_type(rhs) {
            return typ
        }
    }
    if typ := t.rune_arithmetic_expr_type(rhs) {
        return typ
    }
    if rhs is ast.IndexExpr {
        if typ := t.index_expr_storage_type(rhs) {
            return typ
        }
    }
    if rhs is ast.UnsafeExpr {
        if typ := t.get_expr_type(rhs) {
            return typ
        }
    }
    if rhs is ast.IfExpr {
        if typ := t.get_expr_type(rhs) {
            return typ
        }
    }
    if rhs is ast.InitExpr {
        if typ := t.type_from_init_expr(rhs) {
            return typ
        }
    }
    if rhs is ast.CallExpr || rhs is ast.CallOrCastExpr || rhs is ast.CastExpr
        || rhs is ast.AsCastExpr || rhs is ast.InitExpr || rhs is ast.Ident
        || rhs is ast.SelectorExpr {
        if typ := t.get_expr_type(rhs) {
            return typ
        }
    }
    if typ := t.get_expr_type(lhs) {
        return typ
    }
    if lhs is ast.ModifierExpr {
        if typ := t.get_expr_type(lhs.expr) {
            return typ
        }
    }
    return none
}

fn (t &Transformer) rune_arithmetic_expr_type(expr ast.Expr) ?types.Type {
    match expr {
        ast.InfixExpr {
            if expr.op !in [.plus, .minus, .mul, .div, .mod, .amp, .pipe, .xor, .left_shift,
                .right_shift, .right_shift_unsigned] {
                return none
            }
            if t.expr_is_rune_arithmetic_operand(expr.lhs)
                || t.expr_is_rune_arithmetic_operand(expr.rhs) {
                return types.builtin_type('rune')
            }
        }
        ast.ParenExpr {
            return t.rune_arithmetic_expr_type(expr.expr)
        }
        ast.ModifierExpr {
            return t.rune_arithmetic_expr_type(expr.expr)
        }
        else {}
    }

    return none
}

fn (t &Transformer) expr_is_rune_arithmetic_operand(expr ast.Expr) bool {
    if typ := t.get_expr_type(expr) {
        if transformer_type_is_rune(typ) {
            return true
        }
    }
    return t.rune_arithmetic_expr_type(expr) != none
}

fn transformer_type_is_rune(typ types.Type) bool {
    if !types.type_has_valid_payload(typ) {
        return false
    }
    match typ {
        types.Rune {
            return true
        }
        types.Alias {
            return transformer_type_is_rune(typ.base_type)
        }
        else {}
    }

    return false
}

// gen_filter_temp_name generates a unique temporary variable name for filter expansion
fn (mut t Transformer) gen_filter_temp_name() string {
    t.temp_counter++
    return '_filter_t${t.temp_counter}'
}

// try_expand_filter_or_map_expr expands array.filter(cond) or array.map(body) calls
// in any expression context. Generates temp array + for loop statements, appends them
// to t.pending_stmts, and returns the temp variable ident as the replacement expression.
fn (mut t Transformer) try_expand_filter_or_map_expr(expr ast.Expr) ?ast.Expr {
    method_name, receiver_expr, body_expr := t.get_filter_or_map_call_info(expr) or { return none }
    // Handle .any() and .all() — expand to bool result + for loop with break
    // Skip expansion when receiver is a flag enum (handled by flag enum rewrite later).
    if method_name in ['any', 'all'] {
        if t.is_flag_enum_receiver(receiver_expr, t.get_enum_type(receiver_expr)) {
            return none
        }
        return t.expand_any_or_all_expr(method_name, receiver_expr, body_expr)
    }
    if method_name == 'count' {
        t.get_array_type_str(receiver_expr) or { return none }
        return t.expand_count_expr(receiver_expr, body_expr)
    }
    // Get the array type from the receiver
    array_type := t.get_array_type_str(receiver_expr) or { return none }
    elem_type := array_type['Array_'.len..]
    is_filter := method_name == 'filter'
    // For map, determine result element type from the checker's type info
    mut result_elem := elem_type
    mut resolved_via_fn_type := false
    if !is_filter {
        if typ := t.get_expr_type(body_expr) {
            // For function types (fn pointer/literal args), use the return type
            mut resolved_typ := typ
            if typ is types.FnType {
                if rt := typ.get_return_type() {
                    resolved_typ = rt
                    resolved_via_fn_type = true
                }
            }
            c_name := t.type_to_c_name(resolved_typ)
            if c_name != '' && c_name != 'void' && c_name != 'int_literal' {
                result_elem = c_name
            }
        }
        // Fallback: try using the full .map() expression's type (the checker
        // knows the result type of .map() calls including element type).
        // Skip this fallback if we already resolved via FnType return type,
        // because the checker may type .map(fn_name) as []voidptr rather than
        // using the function's actual return type.
        if result_elem == elem_type && !resolved_via_fn_type {
            if map_type := t.get_expr_type(expr) {
                c_name := t.type_to_c_name(map_type)
                if c_name.starts_with('Array_') {
                    map_elem := c_name['Array_'.len..]
                    if map_elem != '' {
                        result_elem = map_elem
                    }
                }
            }
        }
        // Also handle FnLiteral: use its declared return type
        if result_elem == elem_type && body_expr is ast.FnLiteral {
            if ret_type := t.get_expr_type(body_expr.typ.return_type) {
                c_name := t.type_to_c_name(ret_type)
                if c_name != '' && c_name != 'void' {
                    result_elem = c_name
                }
            }
        }
    }
    // Generate temp variable name
    temp_name := t.gen_filter_temp_name()
    temp_id := t.temp_counter
    temp_pos := t.next_synth_pos()
    temp_ident := ast.Ident{
        name: temp_name
        pos:  temp_pos
    }
    if result_type := t.get_expr_type(expr) {
        t.register_temp_var(temp_name, result_type)
        t.register_synth_type(temp_pos, result_type)
    } else if result_elem_type := t.c_name_to_type(result_elem) {
        result_type := types.Type(types.Array{
            elem_type: result_elem_type
        })
        t.register_temp_var(temp_name, result_type)
        t.register_synth_type(temp_pos, result_type)
    }
    // When the fn-by-name return type was resolved, record an override so that
    // println/str resolution uses the correct element type instead of the checker's
    // incorrect []voidptr typing for .map(fn_name) expressions.
    if resolved_via_fn_type {
        t.array_elem_type_overrides[temp_name] = result_elem
    }
    it_ident := ast.Ident{
        name: '_filter_it${temp_id}'
    }
    // 1. mut _filter_t1 := []ResultType{cap: 0}
    init_stmt := ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [
            ast.Expr(ast.ModifierExpr{
                kind: .key_mut
                expr: temp_ident
            }),
        ]
        rhs: [
            ast.Expr(ast.ArrayInitExpr{
                typ: ast.Expr(ast.Type(ast.ArrayType{
                    elem_type: ast.Ident{
                        name: result_elem
                    }
                }))
                cap: ast.BasicLiteral{
                    kind:  .number
                    value: '0'
                }
            }),
        ]
    })

    // Replace 'it' with '_filter_it' in the body expression.
    // If the body is a function reference (named function), call it with the element:
    // e.g., arr.filter(my_fn) → ... if (my_fn(_filter_it)) { ... }
    // If the body is a FnLiteral/LambdaExpr, inline its body with param replaced:
    // e.g., arr.map(fn (i int) string { return i.str() })
    //   → ... string _v = _filter_it.str(); ...
    transformed_body := if body_expr is ast.Ident && !t.expr_contains_ident_named(body_expr, 'it')
        && t.is_fn_ident(body_expr) {
        // Generate CallOrCastExpr (not CallExpr) so it goes through
        // transform_call_or_cast_expr during transform_stmt(for_stmt),
        // which produces the same code path as the (it) syntax case.
        ast.Expr(ast.CallOrCastExpr{
            lhs:  body_expr
            expr: it_ident
            pos:  body_expr.pos
        })
    } else if body_expr is ast.FnLiteral && body_expr.typ.params.len == 1 {
        // Inline FnLiteral: extract its single return expression and replace param with _filter_it
        // e.g., arr.map(fn (i int) string { return i.str() })
        //   → ... _filter_it.str() ...
        param_name := body_expr.typ.params[0].name
        ret_expr := t.extract_fn_literal_return_expr(body_expr)
        t.replace_named_ident(ret_expr, param_name, it_ident.name)
    } else {
        t.replace_it_ident(body_expr, it_ident.name)
    }

    // Build the for loop body
    mut loop_body := []ast.Stmt{}
    if is_filter {
        // For filter: if cond { array__push(&arr, &it) }
        push_call := ast.CallExpr{
            lhs:  ast.Ident{
                name: 'array__push'
            }
            args: [
                ast.Expr(ast.CastExpr{
                    typ:  ast.Ident{
                        name: 'array*'
                    }
                    expr: ast.PrefixExpr{
                        op:   .amp
                        expr: temp_ident
                    }
                }),
                ast.Expr(ast.PrefixExpr{
                    op:   .amp
                    expr: it_ident
                }),
            ]
        }
        loop_body << ast.Stmt(ast.ExprStmt{
            expr: ast.IfExpr{
                cond:  transformed_body
                stmts: [ast.Stmt(ast.ExprStmt{
                    expr: push_call
                })]
            }
        })
    } else {
        // For map: mut _filter_v = body; array__push(&arr, &_filter_v)
        t.temp_counter++
        val_name := '_filter_v${t.temp_counter}'
        val_ident := ast.Ident{
            name: val_name
        }
        // mut _filter_v = body_expr
        loop_body << ast.Stmt(ast.AssignStmt{
            op:  .decl_assign
            lhs: [
                ast.Expr(ast.ModifierExpr{
                    kind: .key_mut
                    expr: val_ident
                }),
            ]
            rhs: [ast.Expr(transformed_body)]
        })
        // array__push((array*)&_filter_t, &_filter_v)
        loop_body << ast.Stmt(ast.ExprStmt{
            expr: ast.CallExpr{
                lhs:  ast.Ident{
                    name: 'array__push'
                }
                args: [
                    ast.Expr(ast.CastExpr{
                        typ:  ast.Ident{
                            name: 'array*'
                        }
                        expr: ast.PrefixExpr{
                            op:   .amp
                            expr: temp_ident
                        }
                    }),
                    ast.Expr(ast.PrefixExpr{
                        op:   .amp
                        expr: val_ident
                    }),
                ]
            }
        })
    }

    // 2. for _filter_it in receiver { ... }
    // Cache complex receiver expressions (e.g., arr[0..3]) in a temp variable
    // to prevent multiple re-evaluations in the for-in expansion. Simple idents
    // and selector expressions are cheap to re-evaluate.
    // NOTE: Do NOT pre-transform receiver_expr here. The for loop goes through
    // transform_stmt which will transform the expression. Pre-transforming
    // causes double smartcast application (e.g., expr.types in a match arm
    // gets expr._data._Variant applied twice).
    mut receiver_for_loop := receiver_expr
    mut has_cache_stmt := false
    mut cache_stmt := ast.empty_stmt
    mut receiver_pending_stmts := []ast.Stmt{}
    if receiver_expr !is ast.Ident && receiver_expr !is ast.SelectorExpr {
        pending_before_receiver := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        transformed_receiver := t.transform_expr(receiver_expr)
        receiver_pending_stmts = t.pending_stmts.clone()
        t.pending_stmts = pending_before_receiver
        cache_name := '_filter_recv${temp_id}'
        cache_pos := t.next_synth_pos()
        cache_ident := ast.Ident{
            name: cache_name
            pos:  cache_pos
        }
        if recv_type := t.get_expr_type(receiver_expr) {
            t.register_temp_var(cache_name, recv_type)
            t.register_synth_type(cache_pos, recv_type)
        }
        cache_stmt = ast.Stmt(ast.AssignStmt{
            op:  .decl_assign
            lhs: [ast.Expr(cache_ident)]
            rhs: [transformed_receiver]
        })
        has_cache_stmt = true
        receiver_for_loop = cache_ident
    }
    for_in_stmt := ast.ForInStmt{
        value: it_ident
        expr:  receiver_for_loop
    }
    raw_for_stmt := ast.ForStmt{
        init:  for_in_stmt
        stmts: loop_body
    }

    // Transform generated statements while lowering the synthetic loop with the
    // array type already resolved above. Nested expression expansions inside the
    // loop body stay scoped to that loop.
    saved_pending := t.pending_stmts
    t.pending_stmts = []ast.Stmt{}
    mut generated_stmts := []ast.Stmt{cap: 2}
    if has_cache_stmt {
        generated_stmts << cache_stmt
    }
    generated_stmts << init_stmt
    transformed_generated := t.transform_stmts(generated_stmts)
    generated_pending := t.pending_stmts.clone()
    t.pending_stmts = []ast.Stmt{}
    iter_type := t.c_name_to_type(array_type) or { return none }
    t.open_scope()
    transformed_for := ast.Stmt(t.transform_array_for_in(raw_for_stmt, for_in_stmt, iter_type))
    t.close_scope()
    loop_pending := t.pending_stmts
    t.pending_stmts = saved_pending
    t.pending_stmts << receiver_pending_stmts
    t.pending_stmts << generated_pending
    t.pending_stmts << transformed_generated
    t.pending_stmts << transformed_for
    t.pending_stmts << loop_pending

    // Return the temp variable as the replacement expression
    return temp_ident
}

// expand_any_or_all_expr expands array.any(cond) / array.all(cond) calls.
// .any(cond) → bool _filter_tN = false; for _filter_itN in arr { if cond { _filter_tN = true; break; } }
// .all(cond) → bool _filter_tN = true; for _filter_itN in arr { if !cond { _filter_tN = false; break; } }
fn (mut t Transformer) expand_any_or_all_expr(method_name string, receiver_expr ast.Expr, body_expr ast.Expr) ?ast.Expr {
    is_any := method_name == 'any'
    temp_name := t.gen_filter_temp_name()
    temp_id := t.temp_counter
    temp_ident := ast.Ident{
        name: temp_name
    }
    it_ident := ast.Ident{
        name: '_filter_it${temp_id}'
    }
    // bool _filter_tN = false (any) / true (all)
    init_val := if is_any {
        ast.Expr(ast.BasicLiteral{
            kind:  .key_false
            value: 'false'
        })
    } else {
        ast.Expr(ast.BasicLiteral{
            kind:  .key_true
            value: 'true'
        })
    }
    init_stmt := ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.ModifierExpr{
            kind: .key_mut
            expr: temp_ident
        })]
        rhs: [init_val]
    })
    // Replace 'it' with '_filter_itN' in the body expression
    transformed_body := t.replace_it_ident(body_expr, it_ident.name)
    // Build condition: for any, use cond directly; for all, negate it
    cond := if is_any {
        transformed_body
    } else {
        ast.Expr(ast.PrefixExpr{
            op:   .not
            expr: transformed_body
        })
    }
    // The value to assign on match: true for any, false for all
    assign_val := if is_any {
        ast.Expr(ast.BasicLiteral{
            kind:  .key_true
            value: 'true'
        })
    } else {
        ast.Expr(ast.BasicLiteral{
            kind:  .key_false
            value: 'false'
        })
    }
    // Build loop body: if cond { _filter_tN = true/false; break; }
    loop_body := [
        ast.Stmt(ast.ExprStmt{
            expr: ast.IfExpr{
                cond:  cond
                stmts: [
                    ast.Stmt(ast.AssignStmt{
                        op:  .assign
                        lhs: [ast.Expr(temp_ident)]
                        rhs: [assign_val]
                    }),
                    ast.Stmt(ast.FlowControlStmt{
                        op: .key_break
                    }),
                ]
            }
        }),
    ]
    // Cache complex receiver expressions
    mut receiver_for_loop := receiver_expr
    mut has_cache_stmt := false
    mut cache_stmt := ast.empty_stmt
    mut receiver_pending_stmts := []ast.Stmt{}
    if receiver_expr !is ast.Ident && receiver_expr !is ast.SelectorExpr {
        pending_before_receiver := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        transformed_receiver := t.transform_expr(receiver_expr)
        receiver_pending_stmts = t.pending_stmts.clone()
        t.pending_stmts = pending_before_receiver
        cache_name := '_filter_recv${temp_id}'
        cache_ident := ast.Ident{
            name: cache_name
        }
        if recv_type := t.get_expr_type(receiver_expr) {
            t.register_temp_var(cache_name, recv_type)
        }
        cache_stmt = ast.Stmt(ast.AssignStmt{
            op:  .decl_assign
            lhs: [ast.Expr(cache_ident)]
            rhs: [transformed_receiver]
        })
        has_cache_stmt = true
        receiver_for_loop = cache_ident
    }
    for_stmt := ast.Stmt(ast.ForStmt{
        init:  ast.ForInStmt{
            value: it_ident
            expr:  receiver_for_loop
        }
        stmts: loop_body
    })
    saved_pending := t.pending_stmts
    t.pending_stmts = []ast.Stmt{}
    transformed_init := t.transform_stmt(init_stmt)
    transformed_for := t.transform_stmt(for_stmt)
    t.pending_stmts = saved_pending
    t.pending_stmts << receiver_pending_stmts
    if has_cache_stmt {
        t.pending_stmts << cache_stmt
    }
    t.pending_stmts << transformed_init
    t.pending_stmts << transformed_for
    return temp_ident
}

// expand_count_expr expands array.count(cond) calls.
// .count(cond) -> int _filter_tN = 0; for _filter_itN in arr { if cond { _filter_tN += 1 } }
fn (mut t Transformer) expand_count_expr(receiver_expr ast.Expr, body_expr ast.Expr) ?ast.Expr {
    temp_name := t.gen_filter_temp_name()
    temp_id := t.temp_counter
    temp_ident := ast.Ident{
        name: temp_name
    }
    it_ident := ast.Ident{
        name: '_filter_it${temp_id}'
    }
    init_stmt := ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.ModifierExpr{
            kind: .key_mut
            expr: temp_ident
        })]
        rhs: [ast.Expr(ast.BasicLiteral{
            kind:  .number
            value: '0'
        })]
    })
    transformed_body := t.replace_it_ident(body_expr, it_ident.name)
    loop_body := [
        ast.Stmt(ast.ExprStmt{
            expr: ast.IfExpr{
                cond:  transformed_body
                stmts: [
                    ast.Stmt(ast.AssignStmt{
                        op:  .plus_assign
                        lhs: [ast.Expr(temp_ident)]
                        rhs: [
                            ast.Expr(ast.BasicLiteral{
                                kind:  .number
                                value: '1'
                            }),
                        ]
                    }),
                ]
            }
        }),
    ]
    mut receiver_for_loop := receiver_expr
    mut has_cache_stmt := false
    mut cache_stmt := ast.empty_stmt
    mut receiver_pending_stmts := []ast.Stmt{}
    if receiver_expr !is ast.Ident && receiver_expr !is ast.SelectorExpr {
        pending_before_receiver := t.pending_stmts
        t.pending_stmts = []ast.Stmt{}
        transformed_receiver := t.transform_expr(receiver_expr)
        receiver_pending_stmts = t.pending_stmts.clone()
        t.pending_stmts = pending_before_receiver
        cache_name := '_filter_recv${temp_id}'
        cache_ident := ast.Ident{
            name: cache_name
        }
        if recv_type := t.get_expr_type(receiver_expr) {
            t.register_temp_var(cache_name, recv_type)
        }
        cache_stmt = ast.Stmt(ast.AssignStmt{
            op:  .decl_assign
            lhs: [ast.Expr(cache_ident)]
            rhs: [transformed_receiver]
        })
        has_cache_stmt = true
        receiver_for_loop = cache_ident
    }
    for_stmt := ast.Stmt(ast.ForStmt{
        init:  ast.ForInStmt{
            value: it_ident
            expr:  receiver_for_loop
        }
        stmts: loop_body
    })
    saved_pending := t.pending_stmts
    t.pending_stmts = []ast.Stmt{}
    transformed_init := t.transform_stmt(init_stmt)
    transformed_for := t.transform_stmt(for_stmt)
    t.pending_stmts = saved_pending
    t.pending_stmts << receiver_pending_stmts
    if has_cache_stmt {
        t.pending_stmts << cache_stmt
    }
    t.pending_stmts << transformed_init
    t.pending_stmts << transformed_for
    return temp_ident
}

// get_filter_or_map_call_info extracts info from a filter/map method call.
// Returns (method_name, receiver_expr, body_expr) or none if not a filter/map call.
fn (t &Transformer) get_filter_or_map_call_info(expr ast.Expr) ?(string, ast.Expr, ast.Expr) {
    // Check for CallOrCastExpr: arr.filter(cond) / arr.map(body)
    if expr is ast.CallOrCastExpr {
        if expr.lhs is ast.SelectorExpr {
            sel := expr.lhs as ast.SelectorExpr
            method_name := sel.rhs.name
            if method_name in ['filter', 'map', 'any', 'all', 'count'] {
                return method_name, sel.lhs, expr.expr
            }
        }
    }
    // Check for CallExpr: arr.filter(cond) / arr.map(body)
    if expr is ast.CallExpr {
        if expr.lhs is ast.SelectorExpr {
            sel := expr.lhs as ast.SelectorExpr
            method_name := sel.rhs.name
            if method_name in ['filter', 'map', 'any', 'all', 'count'] && expr.args.len == 1 {
                return method_name, sel.lhs, expr.args[0]
            }
        }
    }
    return none
}

fn is_implicit_it_array_method_name(name string) bool {
    return name in ['filter', 'map', 'any', 'all', 'count']
}

// replace_it_ident replaces all occurrences of 'it' identifier with the given name
fn (t &Transformer) replace_it_ident(expr ast.Expr, new_name string) ast.Expr {
    match expr {
        ast.Ident {
            if expr.name == 'it' {
                return ast.Ident{
                    name: new_name
                    pos:  expr.pos
                }
            }
            return expr
        }
        ast.InfixExpr {
            return ast.InfixExpr{
                op:  expr.op
                lhs: t.replace_it_ident(expr.lhs, new_name)
                rhs: t.replace_it_ident(expr.rhs, new_name)
                pos: expr.pos
            }
        }
        ast.PrefixExpr {
            return ast.PrefixExpr{
                op:   expr.op
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.ParenExpr {
            return ast.ParenExpr{
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.CallExpr {
            // For nested implicit-it array method calls, don't replace 'it'
            // in the body argument — it belongs to the inner scope.
            if expr.lhs is ast.SelectorExpr {
                sel := expr.lhs as ast.SelectorExpr
                sel_name := sel.rhs.name
                if is_implicit_it_array_method_name(sel_name) && expr.args.len == 1 {
                    return ast.CallExpr{
                        lhs:  t.replace_it_ident(expr.lhs, new_name)
                        args: expr.args // keep body untouched
                        pos:  expr.pos
                    }
                }
            }
            mut new_args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                new_args << t.replace_it_ident(arg, new_name)
            }
            return ast.CallExpr{
                lhs:  t.replace_it_ident(expr.lhs, new_name)
                args: new_args
                pos:  expr.pos
            }
        }
        ast.CallOrCastExpr {
            // For nested implicit-it array method calls, don't replace 'it' in the body
            // argument — it belongs to the inner scope.
            if expr.lhs is ast.SelectorExpr {
                sel := expr.lhs as ast.SelectorExpr
                sel_name := sel.rhs.name
                if is_implicit_it_array_method_name(sel_name) {
                    return ast.CallOrCastExpr{
                        lhs:  t.replace_it_ident(expr.lhs, new_name)
                        expr: expr.expr // keep body untouched
                        pos:  expr.pos
                    }
                }
            }
            return ast.CallOrCastExpr{
                lhs:  t.replace_it_ident(expr.lhs, new_name)
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.SelectorExpr {
            return ast.SelectorExpr{
                lhs: t.replace_it_ident(expr.lhs, new_name)
                rhs: expr.rhs
                pos: expr.pos
            }
        }
        ast.IndexExpr {
            return ast.IndexExpr{
                lhs:  t.replace_it_ident(expr.lhs, new_name)
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.OrExpr {
            return ast.OrExpr{
                expr:  t.replace_it_ident(expr.expr, new_name)
                stmts: t.replace_it_in_stmts(expr.stmts, new_name)
                pos:   expr.pos
            }
        }
        ast.IfExpr {
            return ast.IfExpr{
                cond:      t.replace_it_ident(expr.cond, new_name)
                stmts:     t.replace_it_in_stmts(expr.stmts, new_name)
                else_expr: t.replace_it_ident(expr.else_expr, new_name)
                pos:       expr.pos
            }
        }
        ast.MatchExpr {
            mut branches := []ast.MatchBranch{cap: expr.branches.len}
            for branch in expr.branches {
                mut conds := []ast.Expr{cap: branch.cond.len}
                for cond in branch.cond {
                    conds << t.replace_it_ident(cond, new_name)
                }
                branches << ast.MatchBranch{
                    cond:  conds
                    stmts: t.replace_it_in_stmts(branch.stmts, new_name)
                    pos:   branch.pos
                }
            }
            return ast.MatchExpr{
                expr:     t.replace_it_ident(expr.expr, new_name)
                branches: branches
                pos:      expr.pos
            }
        }
        ast.ArrayInitExpr {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.replace_it_ident(item, new_name)
            }
            return ast.ArrayInitExpr{
                typ:   t.replace_it_ident(expr.typ, new_name)
                exprs: exprs
                init:  t.replace_it_ident(expr.init, new_name)
                len:   t.replace_it_ident(expr.len, new_name)
                cap:   t.replace_it_ident(expr.cap, new_name)
                pos:   expr.pos
            }
        }
        ast.InitExpr {
            mut fields := []ast.FieldInit{cap: expr.fields.len}
            for field in expr.fields {
                fields << ast.FieldInit{
                    name:  field.name
                    value: t.replace_it_ident(field.value, new_name)
                }
            }
            return ast.InitExpr{
                typ:    t.replace_it_ident(expr.typ, new_name)
                fields: fields
                pos:    expr.pos
            }
        }
        ast.ModifierExpr {
            return ast.ModifierExpr{
                kind: expr.kind
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.Tuple {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.replace_it_ident(item, new_name)
            }
            return ast.Tuple{
                exprs: exprs
                pos:   expr.pos
            }
        }
        ast.UnsafeExpr {
            return ast.UnsafeExpr{
                stmts: t.replace_it_in_stmts(expr.stmts, new_name)
            }
        }
        ast.ComptimeExpr {
            return ast.ComptimeExpr{
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.AsCastExpr {
            return ast.AsCastExpr{
                expr: t.replace_it_ident(expr.expr, new_name)
                typ:  expr.typ
                pos:  expr.pos
            }
        }
        ast.CastExpr {
            return ast.CastExpr{
                typ:  expr.typ
                expr: t.replace_it_ident(expr.expr, new_name)
                pos:  expr.pos
            }
        }
        ast.StringInterLiteral {
            mut new_inters := []ast.StringInter{cap: expr.inters.len}
            for inter in expr.inters {
                new_inters << ast.StringInter{
                    ...inter
                    expr: t.replace_it_ident(inter.expr, new_name)
                }
            }
            return ast.StringInterLiteral{
                kind:   expr.kind
                values: expr.values
                inters: new_inters
                pos:    expr.pos
            }
        }
        else {
            return expr
        }
    }
}

fn (t &Transformer) replace_it_in_stmts(stmts []ast.Stmt, new_name string) []ast.Stmt {
    mut out := []ast.Stmt{cap: stmts.len}
    for stmt in stmts {
        out << t.replace_it_in_stmt(stmt, new_name)
    }
    return out
}

fn (t &Transformer) replace_it_in_stmt(stmt ast.Stmt, new_name string) ast.Stmt {
    match stmt {
        ast.AssignStmt {
            mut lhs := []ast.Expr{cap: stmt.lhs.len}
            for item in stmt.lhs {
                lhs << t.replace_it_ident(item, new_name)
            }
            mut rhs := []ast.Expr{cap: stmt.rhs.len}
            for item in stmt.rhs {
                rhs << t.replace_it_ident(item, new_name)
            }
            return ast.AssignStmt{
                op:  stmt.op
                lhs: lhs
                rhs: rhs
                pos: stmt.pos
            }
        }
        ast.AssertStmt {
            return ast.AssertStmt{
                expr:  t.replace_it_ident(stmt.expr, new_name)
                extra: t.replace_it_ident(stmt.extra, new_name)
            }
        }
        ast.BlockStmt {
            return ast.BlockStmt{
                stmts: t.replace_it_in_stmts(stmt.stmts, new_name)
            }
        }
        ast.ComptimeStmt {
            return ast.ComptimeStmt{
                stmt: t.replace_it_in_stmt(stmt.stmt, new_name)
            }
        }
        ast.DeferStmt {
            return ast.DeferStmt{
                mode:  stmt.mode
                stmts: t.replace_it_in_stmts(stmt.stmts, new_name)
            }
        }
        ast.ExprStmt {
            return ast.ExprStmt{
                expr: t.replace_it_ident(stmt.expr, new_name)
            }
        }
        ast.ForStmt {
            return ast.ForStmt{
                init:  t.replace_it_in_stmt(stmt.init, new_name)
                cond:  t.replace_it_ident(stmt.cond, new_name)
                post:  t.replace_it_in_stmt(stmt.post, new_name)
                stmts: t.replace_it_in_stmts(stmt.stmts, new_name)
            }
        }
        ast.ForInStmt {
            return ast.ForInStmt{
                key:   t.replace_it_ident(stmt.key, new_name)
                value: t.replace_it_ident(stmt.value, new_name)
                expr:  t.replace_it_ident(stmt.expr, new_name)
            }
        }
        ast.LabelStmt {
            return ast.LabelStmt{
                name: stmt.name
                stmt: t.replace_it_in_stmt(stmt.stmt, new_name)
            }
        }
        ast.ReturnStmt {
            mut exprs := []ast.Expr{cap: stmt.exprs.len}
            for expr in stmt.exprs {
                exprs << t.replace_it_ident(expr, new_name)
            }
            return ast.ReturnStmt{
                exprs: exprs
            }
        }
        else {
            return stmt
        }
    }
}

// replace_named_ident replaces all occurrences of an identifier with the given old_name
// to a new name. This is a generalized version of replace_it_ident.
fn (t &Transformer) replace_named_ident(expr ast.Expr, old_name string, new_name string) ast.Expr {
    match expr {
        ast.Ident {
            if expr.name == old_name {
                return ast.Ident{
                    name: new_name
                    pos:  expr.pos
                }
            }
            return expr
        }
        ast.InfixExpr {
            return ast.InfixExpr{
                op:  expr.op
                lhs: t.replace_named_ident(expr.lhs, old_name, new_name)
                rhs: t.replace_named_ident(expr.rhs, old_name, new_name)
                pos: expr.pos
            }
        }
        ast.PrefixExpr {
            return ast.PrefixExpr{
                op:   expr.op
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.ParenExpr {
            return ast.ParenExpr{
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.CallExpr {
            mut new_args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                new_args << t.replace_named_ident(arg, old_name, new_name)
            }
            return ast.CallExpr{
                lhs:  t.replace_named_ident(expr.lhs, old_name, new_name)
                args: new_args
                pos:  expr.pos
            }
        }
        ast.CallOrCastExpr {
            return ast.CallOrCastExpr{
                lhs:  t.replace_named_ident(expr.lhs, old_name, new_name)
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.SelectorExpr {
            return ast.SelectorExpr{
                lhs: t.replace_named_ident(expr.lhs, old_name, new_name)
                rhs: expr.rhs
                pos: expr.pos
            }
        }
        ast.IndexExpr {
            return ast.IndexExpr{
                lhs:  t.replace_named_ident(expr.lhs, old_name, new_name)
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.OrExpr {
            return ast.OrExpr{
                expr:  t.replace_named_ident(expr.expr, old_name, new_name)
                stmts: t.replace_named_ident_in_stmts(expr.stmts, old_name, new_name)
                pos:   expr.pos
            }
        }
        ast.IfExpr {
            return ast.IfExpr{
                cond:      t.replace_named_ident(expr.cond, old_name, new_name)
                stmts:     t.replace_named_ident_in_stmts(expr.stmts, old_name, new_name)
                else_expr: t.replace_named_ident(expr.else_expr, old_name, new_name)
                pos:       expr.pos
            }
        }
        ast.MatchExpr {
            mut branches := []ast.MatchBranch{cap: expr.branches.len}
            for branch in expr.branches {
                mut conds := []ast.Expr{cap: branch.cond.len}
                for cond in branch.cond {
                    conds << t.replace_named_ident(cond, old_name, new_name)
                }
                branches << ast.MatchBranch{
                    cond:  conds
                    stmts: t.replace_named_ident_in_stmts(branch.stmts, old_name, new_name)
                    pos:   branch.pos
                }
            }
            return ast.MatchExpr{
                expr:     t.replace_named_ident(expr.expr, old_name, new_name)
                branches: branches
                pos:      expr.pos
            }
        }
        ast.ArrayInitExpr {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.replace_named_ident(item, old_name, new_name)
            }
            return ast.ArrayInitExpr{
                typ:   t.replace_named_ident(expr.typ, old_name, new_name)
                exprs: exprs
                init:  t.replace_named_ident(expr.init, old_name, new_name)
                len:   t.replace_named_ident(expr.len, old_name, new_name)
                cap:   t.replace_named_ident(expr.cap, old_name, new_name)
                pos:   expr.pos
            }
        }
        ast.InitExpr {
            mut fields := []ast.FieldInit{cap: expr.fields.len}
            for field in expr.fields {
                fields << ast.FieldInit{
                    name:  field.name
                    value: t.replace_named_ident(field.value, old_name, new_name)
                }
            }
            return ast.InitExpr{
                typ:    t.replace_named_ident(expr.typ, old_name, new_name)
                fields: fields
                pos:    expr.pos
            }
        }
        ast.ModifierExpr {
            return ast.ModifierExpr{
                kind: expr.kind
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.Tuple {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.replace_named_ident(item, old_name, new_name)
            }
            return ast.Tuple{
                exprs: exprs
                pos:   expr.pos
            }
        }
        ast.UnsafeExpr {
            return ast.UnsafeExpr{
                stmts: t.replace_named_ident_in_stmts(expr.stmts, old_name, new_name)
            }
        }
        ast.ComptimeExpr {
            return ast.ComptimeExpr{
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.AsCastExpr {
            return ast.AsCastExpr{
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                typ:  expr.typ
                pos:  expr.pos
            }
        }
        ast.CastExpr {
            return ast.CastExpr{
                typ:  expr.typ
                expr: t.replace_named_ident(expr.expr, old_name, new_name)
                pos:  expr.pos
            }
        }
        ast.StringInterLiteral {
            mut new_inters := []ast.StringInter{cap: expr.inters.len}
            for inter in expr.inters {
                new_inters << ast.StringInter{
                    ...inter
                    expr: t.replace_named_ident(inter.expr, old_name, new_name)
                }
            }
            return ast.StringInterLiteral{
                kind:   expr.kind
                values: expr.values
                inters: new_inters
                pos:    expr.pos
            }
        }
        else {
            return expr
        }
    }
}

fn (t &Transformer) replace_named_ident_in_stmts(stmts []ast.Stmt, old_name string, new_name string) []ast.Stmt {
    mut out := []ast.Stmt{cap: stmts.len}
    for stmt in stmts {
        out << t.replace_named_ident_in_stmt(stmt, old_name, new_name)
    }
    return out
}

fn (t &Transformer) replace_named_ident_in_stmt(stmt ast.Stmt, old_name string, new_name string) ast.Stmt {
    match stmt {
        ast.AssignStmt {
            mut lhs := []ast.Expr{cap: stmt.lhs.len}
            for item in stmt.lhs {
                lhs << t.replace_named_ident(item, old_name, new_name)
            }
            mut rhs := []ast.Expr{cap: stmt.rhs.len}
            for item in stmt.rhs {
                rhs << t.replace_named_ident(item, old_name, new_name)
            }
            return ast.AssignStmt{
                op:  stmt.op
                lhs: lhs
                rhs: rhs
                pos: stmt.pos
            }
        }
        ast.AssertStmt {
            return ast.AssertStmt{
                expr:  t.replace_named_ident(stmt.expr, old_name, new_name)
                extra: t.replace_named_ident(stmt.extra, old_name, new_name)
            }
        }
        ast.BlockStmt {
            return ast.BlockStmt{
                stmts: t.replace_named_ident_in_stmts(stmt.stmts, old_name, new_name)
            }
        }
        ast.ComptimeStmt {
            return ast.ComptimeStmt{
                stmt: t.replace_named_ident_in_stmt(stmt.stmt, old_name, new_name)
            }
        }
        ast.DeferStmt {
            return ast.DeferStmt{
                mode:  stmt.mode
                stmts: t.replace_named_ident_in_stmts(stmt.stmts, old_name, new_name)
            }
        }
        ast.ExprStmt {
            return ast.ExprStmt{
                expr: t.replace_named_ident(stmt.expr, old_name, new_name)
            }
        }
        ast.ForStmt {
            return ast.ForStmt{
                init:  t.replace_named_ident_in_stmt(stmt.init, old_name, new_name)
                cond:  t.replace_named_ident(stmt.cond, old_name, new_name)
                post:  t.replace_named_ident_in_stmt(stmt.post, old_name, new_name)
                stmts: t.replace_named_ident_in_stmts(stmt.stmts, old_name, new_name)
            }
        }
        ast.ForInStmt {
            return ast.ForInStmt{
                key:   t.replace_named_ident(stmt.key, old_name, new_name)
                value: t.replace_named_ident(stmt.value, old_name, new_name)
                expr:  t.replace_named_ident(stmt.expr, old_name, new_name)
            }
        }
        ast.LabelStmt {
            return ast.LabelStmt{
                name: stmt.name
                stmt: t.replace_named_ident_in_stmt(stmt.stmt, old_name, new_name)
            }
        }
        ast.ReturnStmt {
            mut exprs := []ast.Expr{cap: stmt.exprs.len}
            for expr in stmt.exprs {
                exprs << t.replace_named_ident(expr, old_name, new_name)
            }
            return ast.ReturnStmt{
                exprs: exprs
            }
        }
        else {
            return stmt
        }
    }
}

// extract_fn_literal_return_expr extracts the single return expression from a FnLiteral.
// For simple FnLiterals like `fn (i int) string { return i.str() }`, extracts `i.str()`.
// Falls back to the body expression of an ExprStmt if no ReturnStmt found.
fn (t &Transformer) extract_fn_literal_return_expr(lit ast.FnLiteral) ast.Expr {
    for stmt in lit.stmts {
        if stmt is ast.ReturnStmt {
            if stmt.exprs.len > 0 {
                return stmt.exprs[0]
            }
        }
        // Also handle expression statements (implicit return)
        if stmt is ast.ExprStmt {
            return stmt.expr
        }
    }
    // Fallback: return a zero literal (should not be reached for valid FnLiterals)
    return ast.BasicLiteral{
        kind:  .number
        value: '0'
    }
}

// or_block_has_return checks if the or-block contains a control flow statement
// (return, continue, break, panic, exit)
fn (t &Transformer) or_block_has_return(stmts []ast.Stmt) bool {
    for stmt in stmts {
        if stmt is ast.ReturnStmt {
            return true
        }
        if stmt is ast.FlowControlStmt {
            // break, continue, goto
            return true
        }
        if stmt is ast.ExprStmt {
            // Check for panic() or exit() calls
            if stmt.expr is ast.CallExpr {
                if stmt.expr.lhs is ast.Ident {
                    name := stmt.expr.lhs.name
                    if name in ['panic', 'exit'] {
                        return true
                    }
                }
            } else if stmt.expr is ast.CallOrCastExpr {
                if stmt.expr.lhs is ast.Ident {
                    name := stmt.expr.lhs.name
                    if name in ['panic', 'exit'] {
                        return true
                    }
                }
            }
            // Check for nested OrExpr that contains control flow
            // e.g., scopes[k1] or { scopes[k2] or { return -999 } }
            if stmt.expr is ast.OrExpr {
                or_expr := stmt.expr as ast.OrExpr
                if t.or_block_has_return(or_expr.stmts) {
                    return true
                }
            }
            // Check for if-expression where all branches diverge
            // e.g., if cond { continue } else { return err }
            if stmt.expr is ast.IfExpr {
                if t.if_expr_all_branches_diverge(stmt.expr as ast.IfExpr) {
                    return true
                }
            }
        }
    }
    return false
}

// if_expr_all_branches_diverge checks if every branch of an if-expression
// contains a return, continue, break, or other diverging control flow.
// Used to detect or-blocks like: if cond { continue } else { return err }
fn (t &Transformer) if_expr_all_branches_diverge(expr ast.IfExpr) bool {
    // Plain else block: cond is EmptyExpr, just check its stmts
    if expr.cond is ast.EmptyExpr {
        return t.or_block_has_return(expr.stmts)
    }
    // Check the then-branch
    if !t.or_block_has_return(expr.stmts) {
        return false
    }
    // Must have an else branch, otherwise the if might fall through
    if expr.else_expr is ast.EmptyExpr {
        return false
    }
    // else-if chain or plain else: recurse into the nested IfExpr
    if expr.else_expr is ast.IfExpr {
        return t.if_expr_all_branches_diverge(expr.else_expr as ast.IfExpr)
    }
    return false
}

fn (t &Transformer) stmt_uses_ident(stmt ast.Stmt, name string) bool {
    match stmt {
        ast.AssignStmt {
            for lhs in stmt.lhs {
                if t.expr_contains_ident_named(lhs, name) {
                    return true
                }
            }
            for rhs in stmt.rhs {
                if t.expr_contains_ident_named(rhs, name) {
                    return true
                }
            }
        }
        ast.ExprStmt {
            return t.expr_contains_ident_named(stmt.expr, name)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                if t.expr_contains_ident_named(expr, name) {
                    return true
                }
            }
        }
        ast.ForStmt {
            if t.stmt_uses_ident(stmt.init, name) || t.expr_contains_ident_named(stmt.cond, name)
                || t.stmt_uses_ident(stmt.post, name) {
                return true
            }
            for body_stmt in stmt.stmts {
                if t.stmt_uses_ident(body_stmt, name) {
                    return true
                }
            }
        }
        ast.BlockStmt {
            for body_stmt in stmt.stmts {
                if t.stmt_uses_ident(body_stmt, name) {
                    return true
                }
            }
        }
        ast.DeferStmt {
            for body_stmt in stmt.stmts {
                if t.stmt_uses_ident(body_stmt, name) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (t &Transformer) stmts_use_ident(stmts []ast.Stmt, name string) bool {
    for stmt in stmts {
        if t.stmt_uses_ident(stmt, name) {
            return true
        }
    }
    return false
}

// get_or_block_value extracts the value expression from an or-block
// The value is typically the last expression statement, or 0/default for empty blocks
fn (mut t Transformer) get_or_block_value(stmts []ast.Stmt) ast.Expr {
    _, value := t.get_or_block_stmts_and_value(stmts)
    return value
}

// get_or_block_stmts_and_value extracts side-effect statements and fallback value
// from an or-block. Side effects are all statements before the trailing value expr.
fn (mut t Transformer) get_or_block_stmts_and_value(stmts []ast.Stmt) ([]ast.Stmt, ast.Expr) {
    mut end := stmts.len
    for end > 0 && stmts[end - 1] is ast.EmptyStmt {
        end--
    }
    if end == 0 {
        return []ast.Stmt{}, ast.Expr(ast.BasicLiteral{
            kind:  .number
            value: '0'
        })
    }
    effective_stmts := stmts[..end]
    last := effective_stmts[effective_stmts.len - 1]
    if last is ast.ExprStmt {
        side_effects := if effective_stmts.len > 1 {
            t.transform_stmts(effective_stmts[..effective_stmts.len - 1])
        } else {
            []ast.Stmt{}
        }
        return side_effects, t.transform_expr(last.expr)
    }
    transformed := t.transform_stmts(effective_stmts)
    if transformed.len > 0 {
        transformed_last := transformed[transformed.len - 1]
        if transformed_last is ast.ExprStmt {
            side_effects := if transformed.len > 1 {
                transformed[..transformed.len - 1]
            } else {
                []ast.Stmt{}
            }
            return side_effects, transformed_last.expr
        }
    }
    return transformed, ast.Expr(ast.BasicLiteral{
        kind:  .number
        value: '0'
    })
}

fn transformer_type_is_ierror_like(typ types.Type) bool {
    name := typ.name()
    return name == 'IError' || name.ends_with('__IError')
}

fn (t &Transformer) or_fallback_is_ierror(expr ast.Expr) bool {
    error_fn_names := ['error', 'error_posix', 'error_with_code', 'error_win32']
    fn_name := t.get_call_fn_name(expr)
    if fn_name != '' && fn_name.all_after_last('__') in error_fn_names {
        return true
    }
    if expr is ast.Ident && expr.name == 'err' {
        return true
    }
    if typ := t.get_expr_type(expr) {
        if transformer_type_is_ierror_like(typ) {
            return true
        }
    }
    if ret_type := t.resolve_call_return_type(expr) {
        if transformer_type_is_ierror_like(ret_type) {
            return true
        }
    }
    return false
}

// try_expand_or_expr_stmt handles OrExpr in expression statements like println(may_fail() or { 0 })
// Transforms: println(may_fail(5) or { 0 })
// Into:
//   _t1 := may_fail(5)
//   if _t1.is_error { err := _t1.err; _t1.data = 0 }
//   println(_t1.data)
fn (mut t Transformer) try_expand_or_expr_stmt(stmt ast.ExprStmt) ?[]ast.Stmt {
    // Check if expression contains any OrExpr or error propagation (PostfixExpr{.not/.question})
    if !t.expr_has_or_expr(stmt.expr) {
        return none
    }
    if stmt.expr is ast.OrExpr {
        if direct_stmts := t.try_expand_direct_or_expr_stmt(stmt.expr) {
            return direct_stmts
        }
    }
    // Extract OrExpr and get prefix statements + transformed expression
    mut prefix_stmts := []ast.Stmt{}
    new_expr := t.extract_or_expr(stmt.expr, mut prefix_stmts)
    if prefix_stmts.len == 0 {
        return none
    }
    // Save/restore pending_stmts: transform_expr(new_expr) may generate
    // pending_stmts (e.g., lower_if_expr_value creates _if_tN). These must
    // be placed AFTER the or-expr prefix_stmts (which define _or_tN used
    // by the if condition), not before.
    saved_pending := t.pending_stmts
    t.pending_stmts = []ast.Stmt{}
    // The expression is used at statement level (ExprStmt), so skip
    // IfExpr value lowering which would create temp variables for void results.
    saved_skip_if := t.skip_if_value_lowering
    t.skip_if_value_lowering = true
    transformed_new := t.transform_expr(new_expr)
    t.skip_if_value_lowering = saved_skip_if
    inner_pending := t.pending_stmts
    t.pending_stmts = saved_pending
    // Merge: prefix_stmts first (or-expr decls), then any inner pending
    for ip in inner_pending {
        prefix_stmts << ip
    }
    // Add the final expression statement
    prefix_stmts << ast.ExprStmt{
        expr: transformed_new
    }
    return prefix_stmts
}

fn (mut t Transformer) try_expand_direct_or_expr_stmt(or_expr ast.OrExpr) ?[]ast.Stmt {
    call_expr := or_expr.expr
    if call_expr is ast.IndexExpr {
        return none
    }
    if call_expr is ast.SqlExpr && !call_expr.is_create {
        return [
            ast.Stmt(ast.ExprStmt{
                expr: t.transform_expr(call_expr)
            }),
        ]
    }

    mut is_result := t.expr_returns_result(call_expr)
    mut is_option := t.expr_returns_option(call_expr)
    fn_name := t.get_call_fn_name(call_expr)
    if !is_result && !is_option && fn_name != '' {
        is_result = t.fn_returns_result(fn_name)
        is_option = t.fn_returns_option(fn_name)
    }

    temp_name := t.gen_temp_name()
    temp_ident := ast.Ident{
        name: temp_name
    }
    if wrapper_type := t.expr_wrapper_type_for_or(call_expr) {
        t.register_temp_var(temp_name, wrapper_type)
        t.register_synth_type(call_expr.pos(), wrapper_type)
        if wrapper_type is types.OptionType {
            is_result = false
            is_option = true
        } else if wrapper_type is types.ResultType {
            is_result = true
            is_option = false
        }
    } else if call_type := t.get_expr_type(call_expr) {
        if call_type is types.OptionType || call_type is types.ResultType {
            t.register_temp_var(temp_name, call_type)
            if call_type is types.OptionType {
                is_result = false
                is_option = true
            } else if call_type is types.ResultType {
                is_result = true
                is_option = false
            }
        }
    } else if ret_type := t.get_method_return_type(call_expr) {
        if ret_type is types.OptionType || ret_type is types.ResultType {
            t.register_temp_var(temp_name, ret_type)
            if ret_type is types.OptionType {
                is_result = false
                is_option = true
            } else if ret_type is types.ResultType {
                is_result = true
                is_option = false
            }
        }
    } else if fn_name != '' {
        if fn_ret := t.get_fn_return_type(fn_name) {
            if fn_ret is types.OptionType || fn_ret is types.ResultType {
                t.register_temp_var(temp_name, fn_ret)
                if fn_ret is types.OptionType {
                    is_result = false
                    is_option = true
                } else if fn_ret is types.ResultType {
                    is_result = true
                    is_option = false
                }
            }
        }
    }

    if !is_result && !is_option {
        return none
    }

    transformed_call, call_pending := t.transform_or_call_expr(call_expr)
    mut stmts := []ast.Stmt{}
    for pending_stmt in call_pending {
        stmts << pending_stmt
    }
    stmts << ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(temp_ident)]
        rhs: [transformed_call]
    }
    error_cond := if is_result {
        t.synth_selector(temp_ident, 'is_error', types.Type(types.bool_))
    } else {
        ast.Expr(ast.InfixExpr{
            op:  .ne
            lhs: t.synth_selector(temp_ident, 'state', types.Type(types.int_))
            rhs: ast.BasicLiteral{
                kind:  .number
                value: '0'
            }
        })
    }
    mut if_stmts := []ast.Stmt{}
    if_stmts << ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.Ident{
            name: 'err'
        })]
        rhs: [
            t.synth_selector(temp_ident, 'err', types.Type(types.Struct{
                name: 'IError'
            })),
        ]
    }
    if_stmts << t.transform_stmts(or_expr.stmts)
    stmts << ast.ExprStmt{
        expr: ast.IfExpr{
            cond:  error_cond
            stmts: if_stmts
        }
    }
    return stmts
}

// try_expand_or_expr_return handles OrExpr in return statements
// Transforms: return may_fail(5) or { 0 }
// Into:
//   _t1 := may_fail(5)
//   if _t1.is_error { err := _t1.err; _t1.data = 0 }
//   return _t1.data
fn (mut t Transformer) try_expand_or_expr_return(stmt ast.ReturnStmt) ?[]ast.Stmt {
    // Check if any return expression contains OrExpr
    mut has_or_expr := false
    for expr in stmt.exprs {
        if t.expr_has_or_expr(expr) {
            has_or_expr = true
            break
        }
    }
    if !has_or_expr {
        return none
    }
    // Extract OrExpr from all return expressions
    mut prefix_stmts := []ast.Stmt{}
    mut new_exprs := []ast.Expr{cap: stmt.exprs.len}
    for expr in stmt.exprs {
        return_expr := if t.cur_fn_returns_option && expr is ast.OrExpr
            && or_stmts_are_none(expr.stmts) {
            ast.Expr(ast.OrExpr{
                expr:  expr.expr
                stmts: [
                    ast.Stmt(ast.ReturnStmt{
                        exprs: [ast.Expr(ast.Ident{
                            name: 'none'
                        })]
                    }),
                ]
                pos:   expr.pos
            })
        } else {
            expr
        }
        new_expr := t.extract_or_expr(return_expr, mut prefix_stmts)
        new_exprs << new_expr
    }
    if prefix_stmts.len == 0 {
        return none
    }
    // Add the final return statement
    prefix_stmts << t.transform_return_stmt(ast.ReturnStmt{
        exprs: new_exprs
    })
    return prefix_stmts
}

fn expr_is_none(expr ast.Expr) bool {
    match expr {
        ast.Keyword {
            return expr.tok == .key_none
        }
        ast.Ident {
            return expr.name == 'none'
        }
        ast.Type {
            return expr is ast.NoneType
        }
        else {
            return false
        }
    }
}

fn expr_is_nil(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            return expr.name == 'nil'
        }
        ast.Type {
            return expr is ast.NilType
        }
        else {
            return false
        }
    }
}

fn or_stmts_are_none(stmts []ast.Stmt) bool {
    if stmts.len != 1 {
        return false
    }
    stmt := stmts[0]
    return stmt is ast.ExprStmt && expr_is_none((stmt as ast.ExprStmt).expr)
}

fn or_stmts_are_nil(stmts []ast.Stmt) bool {
    if stmts.len != 1 {
        return false
    }
    stmt := stmts[0]
    return stmt is ast.ExprStmt && expr_is_nil((stmt as ast.ExprStmt).expr)
}

// expr_has_or_expr checks if an expression contains any OrExpr
fn (t &Transformer) expr_has_or_expr(expr ast.Expr) bool {
    if !expr_has_valid_data(expr) {
        return false
    }
    if expr is ast.OrExpr {
        return true
    }
    // `expr!` and `expr?` are syntactic sugar for `expr or { return err }`
    // and `expr or { none }` respectively — treat them like OrExpr.
    if expr is ast.PostfixExpr {
        if expr.op in [.not, .question] {
            return true
        }
    }
    match expr {
        ast.CallExpr {
            if !expr_array_has_valid_data(expr.args) {
                return false
            }
            if t.call_has_scoped_it_body(expr.lhs, expr.args.len) {
                if expr.lhs is ast.SelectorExpr {
                    return t.expr_has_or_expr(expr.lhs.lhs)
                }
                return false
            }
            if t.expr_has_or_expr(expr.lhs) {
                return true
            }
            for arg in expr.args {
                if t.expr_has_or_expr(arg) {
                    return true
                }
            }
        }
        ast.CallOrCastExpr {
            if t.call_has_scoped_it_body(expr.lhs, 1) {
                if expr.lhs is ast.SelectorExpr {
                    return t.expr_has_or_expr(expr.lhs.lhs)
                }
                return false
            }
            if t.expr_has_or_expr(expr.lhs) {
                return true
            }
            if t.expr_has_or_expr(expr.expr) {
                return true
            }
        }
        ast.InfixExpr {
            if t.expr_has_or_expr(expr.lhs) || t.expr_has_or_expr(expr.rhs) {
                return true
            }
        }
        ast.PrefixExpr {
            if t.expr_has_or_expr(expr.expr) {
                return true
            }
        }
        ast.ParenExpr {
            if t.expr_has_or_expr(expr.expr) {
                return true
            }
        }
        ast.IndexExpr {
            if t.expr_has_or_expr(expr.lhs) || t.expr_has_or_expr(expr.expr) {
                return true
            }
        }
        ast.SelectorExpr {
            if t.expr_has_or_expr(expr.lhs) {
                return true
            }
        }
        ast.CastExpr {
            if t.expr_has_or_expr(expr.expr) {
                return true
            }
        }
        ast.IfExpr {
            if t.expr_has_or_expr(expr.cond) {
                return true
            }
            if t.expr_has_or_expr(expr.else_expr) {
                return true
            }
            // Note: stmts inside IfExpr are handled separately by transform_stmts
        }
        ast.MatchExpr {
            if t.expr_has_or_expr(expr.expr) {
                return true
            }
        }
        ast.ArrayInitExpr {
            for e in expr.exprs {
                if t.expr_has_or_expr(e) {
                    return true
                }
            }
        }
        ast.InitExpr {
            for field in expr.fields {
                if t.expr_has_or_expr(field.value) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

fn (t &Transformer) call_has_scoped_it_body(lhs ast.Expr, arg_count int) bool {
    if arg_count != 1 {
        return false
    }
    if lhs is ast.SelectorExpr {
        return lhs.rhs.name in ['filter', 'map', 'any', 'all', 'count']
    }
    return false
}

fn (mut t Transformer) extract_or_expr_from_method_lhs(lhs ast.Expr, mut prefix_stmts []ast.Stmt) ast.Expr {
    if lhs is ast.SelectorExpr {
        return ast.SelectorExpr{
            lhs: t.extract_or_expr(lhs.lhs, mut prefix_stmts)
            rhs: lhs.rhs
            pos: lhs.pos
        }
    }
    return lhs
}

// extract_or_expr extracts OrExpr from an expression tree.
// It generates prefix statements for the OrExpr expansion and returns the expression
// with OrExpr replaced by the temp variable's data access.
fn (mut t Transformer) extract_or_expr(expr ast.Expr, mut prefix_stmts []ast.Stmt) ast.Expr {
    // If this is an OrExpr, expand it directly
    if expr is ast.OrExpr {
        return t.expand_single_or_expr(expr, mut prefix_stmts)
    }
    // `expr!` (error propagation) is equivalent to `expr or { return err }`
    // `expr?` (option propagation) is equivalent to `expr or { return none }`
    if expr is ast.PostfixExpr {
        if expr.op in [.not, .question] {
            mut or_stmts := []ast.Stmt{}
            if expr.op == .not {
                if t.cur_fn_returns_result {
                    // `!` → `or { return err }`
                    or_stmts << ast.ReturnStmt{
                        exprs: [ast.Expr(ast.Ident{
                            name: 'err'
                        })]
                    }
                } else {
                    // In non-Result functions, `return err` is not a valid C return value.
                    err_expr := ast.Expr(ast.Ident{
                        name: 'err'
                    })
                    or_stmts << ast.ExprStmt{
                        expr: ast.CallExpr{
                            lhs:  ast.Ident{
                                name: 'panic'
                            }
                            args: [err_expr]
                        }
                    }
                }
            } else {
                // `?` → `or { return none }`
                or_stmts << ast.ReturnStmt{
                    exprs: [ast.Expr(ast.Ident{
                        name: 'none'
                    })]
                }
            }
            or_expr := ast.OrExpr{
                expr:  expr.expr
                stmts: or_stmts
                pos:   expr.pos
            }
            return t.expand_single_or_expr(or_expr, mut prefix_stmts)
        }
    }
    // Recursively check sub-expressions
    match expr {
        ast.CallExpr {
            if t.call_has_scoped_it_body(expr.lhs, expr.args.len) {
                return ast.CallExpr{
                    lhs:  t.extract_or_expr_from_method_lhs(expr.lhs, mut prefix_stmts)
                    args: expr.args
                    pos:  expr.pos
                }
            }
            mut new_lhs := expr.lhs
            if expr.lhs is ast.SelectorExpr {
                new_lhs = t.extract_or_expr_from_method_lhs(expr.lhs, mut prefix_stmts)
            } else if t.expr_has_or_expr(expr.lhs) {
                new_lhs = t.extract_or_expr(expr.lhs, mut prefix_stmts)
            }
            mut new_args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                new_args << t.extract_or_expr(arg, mut prefix_stmts)
            }
            return ast.CallExpr{
                lhs:  new_lhs
                args: new_args
                pos:  expr.pos
            }
        }
        ast.CallOrCastExpr {
            if t.call_has_scoped_it_body(expr.lhs, 1) {
                return ast.CallOrCastExpr{
                    lhs:  t.extract_or_expr_from_method_lhs(expr.lhs, mut prefix_stmts)
                    expr: expr.expr
                    pos:  expr.pos
                }
            }
            mut new_lhs := expr.lhs
            if expr.lhs is ast.SelectorExpr {
                new_lhs = t.extract_or_expr_from_method_lhs(expr.lhs, mut prefix_stmts)
            } else if t.expr_has_or_expr(expr.lhs) {
                new_lhs = t.extract_or_expr(expr.lhs, mut prefix_stmts)
            }
            // When the single argument is directly an OrExpr and the lhs is a function
            // call (not a type cast), the `or {}` MAY belong to the call result.
            // Lift it only when the call itself returns option/result:
            //   `f(x or {z})` → `f(x) or {z}`    (when f returns ?T / !T)
            // When f returns a plain type, the `or {}` belongs to the argument:
            //   `f(map[key] or {z})` → `tmp := map[key] or {z}; f(tmp)`
            // For type casts like `i8(call() or { 0 })`, keep the OrExpr inside so
            // the cast applies to the unwrapped data, not the Result.
            if expr.expr is ast.OrExpr && !t.call_or_cast_lhs_is_type(expr.lhs) {
                or_inner := expr.expr as ast.OrExpr
                // Build the hypothetical lifted call to check if it returns option/result
                lifted_call := ast.Expr(ast.CallOrCastExpr{
                    lhs:  expr.lhs
                    expr: or_inner.expr
                    pos:  expr.pos
                })
                if t.expr_returns_option(lifted_call) || t.expr_returns_result(lifted_call) {
                    lifted := ast.OrExpr{
                        expr:  lifted_call
                        stmts: or_inner.stmts
                        pos:   or_inner.pos
                    }
                    return t.expand_single_or_expr(lifted, mut prefix_stmts)
                }
                // The call does NOT return option/result — the `or {}` belongs to the
                // argument.  Recurse into the inner expression to expand it there.
            }
            new_inner := t.extract_or_expr(expr.expr, mut prefix_stmts)
            return ast.CallOrCastExpr{
                lhs:  new_lhs
                expr: new_inner
                pos:  expr.pos
            }
        }
        ast.InfixExpr {
            new_lhs := t.extract_or_expr(expr.lhs, mut prefix_stmts)
            new_rhs := t.extract_or_expr(expr.rhs, mut prefix_stmts)
            return ast.InfixExpr{
                op:  expr.op
                lhs: new_lhs
                rhs: new_rhs
                pos: expr.pos
            }
        }
        ast.PrefixExpr {
            if expr.op == .arrow && expr.expr is ast.OrExpr {
                or_expr := expr.expr as ast.OrExpr
                rewritten_or := ast.OrExpr{
                    expr:  ast.Expr(ast.PrefixExpr{
                        op:   .arrow
                        expr: or_expr.expr
                        pos:  expr.pos
                    })
                    stmts: or_expr.stmts
                    pos:   or_expr.pos
                }
                return t.expand_single_or_expr(rewritten_or, mut prefix_stmts)
            }
            if expr.op == .amp {
                if expr.expr is ast.OrExpr {
                    if result := t.try_expand_map_index_addr_or_nil(expr.expr as ast.OrExpr, mut
                        prefix_stmts)
                    {
                        return result
                    }
                }
                if expr.expr is ast.PostfixExpr && expr.expr.op in [.not, .question] {
                    return ast.PrefixExpr{
                        op:   expr.op
                        expr: expr.expr
                        pos:  expr.pos
                    }
                }
                if expr.expr is ast.CastExpr {
                    cast_expr := expr.expr as ast.CastExpr
                    if t.expr_returns_option(cast_expr.expr)
                        || t.expr_returns_result(cast_expr.expr) {
                        return ast.PrefixExpr{
                            op:   expr.op
                            expr: expr.expr
                            pos:  expr.pos
                        }
                    }
                }
            }
            new_inner := t.extract_or_expr(expr.expr, mut prefix_stmts)
            return ast.PrefixExpr{
                op:   expr.op
                expr: new_inner
                pos:  expr.pos
            }
        }
        ast.ParenExpr {
            new_inner := t.extract_or_expr(expr.expr, mut prefix_stmts)
            return ast.ParenExpr{
                expr: new_inner
                pos:  expr.pos
            }
        }
        ast.IndexExpr {
            new_lhs := t.extract_or_expr(expr.lhs, mut prefix_stmts)
            new_idx := t.extract_or_expr(expr.expr, mut prefix_stmts)
            return ast.IndexExpr{
                lhs:      new_lhs
                expr:     new_idx
                is_gated: expr.is_gated
            }
        }
        ast.SelectorExpr {
            new_lhs := t.extract_or_expr(expr.lhs, mut prefix_stmts)