// 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 ssa

import v2.ast
import v2.markused
import v2.types

struct DynConstArray {
    arr_global_name  string // V array struct global name
    data_global_name string // raw data global name
    elem_count       int
    elem_size        int
}

pub struct Builder {
pub mut:
    mod        &Module
    cur_module string = 'main'
    // When set, build_fn_bodies only builds this function (hot code reload optimization)
    hot_fn string
    // When set, build_all skips Phase 4 (function bodies) — caller handles it.
    skip_fn_bodies bool
    // When set, only build functions whose decl key is in this map (dead code elimination).
    used_fn_keys map[string]bool
    // When set, skip all functions from these modules (dead code elimination for unused backends).
    skip_modules map[string]bool
mut:
    env       &types.Environment = unsafe { nil }
    cur_func  int                = -1
    cur_block BlockID            = -1
    // Variable name -> SSA ValueID (alloca pointer)
    vars map[string]ValueID
    // Loop break/continue targets
    loop_stack []LoopInfo
    // Struct name -> SSA TypeID
    struct_types map[string]TypeID
    // Enum name -> field values
    enum_values map[string]int
    // Function name -> SSA function index
    fn_index map[string]int
    // Function name -> SSA func_ref value
    fn_refs map[string]ValueID
    // Global variable name -> SSA global value
    global_refs map[string]ValueID
    // Constant name -> evaluated integer value (for inlining)
    const_values      map[string]i64
    const_value_types map[string]TypeID // SSA type for the constant (e.g., u64 vs i64)
    // String constant name -> string literal value (for inlining)
    string_const_values map[string]string
    // Float constant name -> float literal string (for inlining as f64)
    float_const_values map[string]string
    // Label name -> SSA BlockID (for goto/label support)
    label_blocks map[string]BlockID
    // Track mut pointer params (e.g., mut buf &u8) that need extra dereference
    // when used in expressions (buf is ptr(ptr(i8)), but user sees buf as &u8)
    mut_ptr_params map[string]bool
    // Set during sum type init _data field building to trigger heap allocation
    // for &struct_local (prevents dangling stack pointers in returned sum types)
    in_sumtype_data bool
    // Constant array globals: names of globals that store raw element data
    // (not V array structs). build_ident returns the pointer directly.
    const_array_globals    map[string]bool
    const_array_elem_count map[string]int
    // Dynamic const arrays: array struct globals that need _vinit initialization.
    // Key: array struct global name, Value: data global name + metadata.
    dyn_const_arrays []DynConstArray
    // Synthetic native wrapper types for ?T / !T.
    option_wrapper_types map[string]TypeID
    result_wrapper_types map[string]TypeID
    // Counter for generating unique anonymous function names
    anon_fn_counter int
    // Array element types by variable name (for transformer-generated functions
    // where checker position info is unavailable). Maps param/var name to element SSA type.
    array_elem_types map[string]TypeID
}

struct LoopInfo {
    cond_block BlockID
    exit_block BlockID
}

pub fn Builder.new(mod &Module) &Builder {
    return Builder.new_with_env(mod, unsafe { nil })
}

pub fn Builder.new_with_env(mod &Module, env &types.Environment) &Builder {
    mut b := &Builder{
        mod:                  mod
        vars:                 map[string]ValueID{}
        loop_stack:           []LoopInfo{}
        struct_types:         map[string]TypeID{}
        enum_values:          map[string]int{}
        fn_index:             map[string]int{}
        fn_refs:              map[string]ValueID{}
        global_refs:          map[string]ValueID{}
        option_wrapper_types: map[string]TypeID{}
        result_wrapper_types: map[string]TypeID{}
    }
    unsafe {
        b.env = env
        mod.env = env
    }
    return b
}

// new_worker_clone creates a Builder for parallel SSA building.
// Shares read-only maps from the main builder, uses a separate worker Module.
// worker_idx offsets anon_fn_counter so workers don't generate conflicting names.
pub fn (mut b Builder) new_worker_clone(worker_mod &Module, worker_idx int) &Builder {
    // Clone all maps to avoid COW races between threads.
    // Maps that are read-only in Phase 4 (struct_types, enum_values, const_values, etc.)
    // still need cloning because V's map read operations can trigger internal COW writes.
    // Maps that are written in Phase 4 (fn_index, option_wrapper_types, etc.)
    // obviously need per-worker copies.
    return &Builder{
        mod:                    worker_mod
        env:                    b.env
        struct_types:           b.struct_types.clone()
        enum_values:            b.enum_values.clone()
        fn_index:               b.fn_index.clone()
        global_refs:            b.global_refs.clone()
        const_values:           b.const_values.clone()
        const_value_types:      b.const_value_types.clone()
        string_const_values:    b.string_const_values.clone()
        float_const_values:     b.float_const_values.clone()
        const_array_globals:    b.const_array_globals.clone()
        const_array_elem_count: b.const_array_elem_count.clone()
        option_wrapper_types:   b.option_wrapper_types.clone()
        result_wrapper_types:   b.result_wrapper_types.clone()
        // Offset anon_fn_counter so each worker generates unique names.
        // Stride of 100_000 per worker avoids collisions.
        anon_fn_counter: (worker_idx + 1) * 100_000
        // Per-function state is reset at start of each build_fn, so empty init is fine
        fn_refs:        map[string]ValueID{}
        vars:           map[string]ValueID{}
        loop_stack:     []LoopInfo{}
        label_blocks:   map[string]BlockID{}
        mut_ptr_params: map[string]bool{}
    }
}

pub fn (mut b Builder) build_all(files []ast.File) {
    // Register builtin globals needed by all backends
    i32_t := b.mod.type_store.get_int(32)
    i8_t := b.mod.type_store.get_int(8)
    ptr_t := b.mod.type_store.get_ptr(i8_t)
    ptr_ptr_t := b.mod.type_store.get_ptr(ptr_t)
    b.mod.add_global('g_main_argc', i32_t, false)
    b.mod.add_global('g_main_argv', ptr_ptr_t, false)

    // Phase 1a: Register core builtin types first (string, array) since other structs depend on them.
    // First, register builtin enums (e.g., ArrayFlags) so their types resolve correctly
    // when registering struct fields for array/string.
    for file in files {
        b.cur_module = file_module_name(file)
        if b.cur_module == 'builtin' {
            for stmt in file.stmts {
                if stmt is ast.EnumDecl {
                    b.register_enum(stmt)
                }
            }
        }
    }
    for file in files {
        b.cur_module = file_module_name(file)
        if b.cur_module == 'builtin' {
            for stmt in file.stmts {
                if stmt is ast.StructDecl {
                    if stmt.name in ['string', 'array'] {
                        b.register_struct(stmt)
                    }
                }
            }
        }
    }
    // Phase 1b: Register all struct type names (forward declarations) and enums
    for file in files {
        b.cur_module = file_module_name(file)
        b.register_types_pass1(file)
    }
    // Phase 1c: Fill in struct field types (now all struct names are known)
    for file in files {
        b.cur_module = file_module_name(file)
        b.register_types_pass2(file)
    }
    // Phase 2: Register consts and globals
    for file in files {
        b.cur_module = file_module_name(file)
        b.register_consts_and_globals(file)
    }
    // Phase 2b: Re-evaluate constants with forward references
    // Constants that referenced other constants from later files got value 0.
    // Now that all constants are collected, re-evaluate them.
    b.resolve_forward_const_refs(files)
    // Build global lookup cache once before expression lowering.
    b.index_global_values()
    // Phase 3: Register function signatures
    for file in files {
        b.cur_module = file_module_name(file)
        b.register_fn_signatures(file)
    }
    // Phase 3.1: Remove globals that collide with function names.
    // e.g. sgl has both `const default_context = ...` and `fn default_context() ...`.
    // The function takes precedence; the global would cause the init_consts function
    // to write to the function's TEXT address (read-only), causing a bus error.
    for mut gvar in b.mod.globals {
        if gvar.name in b.fn_index {
            gvar.linkage = .external // Mark as external so codegen skips data symbol
            b.global_refs.delete(gvar.name) // Remove from lookup so stores are not generated
        }
    }

    // Phase 3.5: Generate synthetic stubs for transformer-generated functions
    if b.hot_fn.len == 0 {
        b.generate_array_eq_stub()
        b.generate_wymix_stub()
        b.generate_wyhash64_stub()
        b.generate_wyhash_stub()
        b.generate_ierror_stubs()
        b.generate_fd_macro_stubs()
    }

    // Phase 4: Build function bodies
    if !b.skip_fn_bodies {
        b.build_all_fn_bodies(files)
    }

    // Phase 5: Generate _vinit for dynamic array constant initialization
    // Always generate _vinit (even if empty) so the symbol is always resolvable
    if b.hot_fn.len == 0 && !b.skip_fn_bodies {
        b.generate_vinit()
    }
}

// build_all_fn_bodies builds SSA for all function bodies (Phase 4).
// Separated from build_all to allow the parallel builder to replace this step.
pub fn (mut b Builder) build_all_fn_bodies(files []ast.File) {
    for file in files {
        b.cur_module = file_module_name(file)
        b.build_fn_bodies(file)
    }
}

pub fn file_module_name(file ast.File) string {
    for stmt in file.stmts {
        if stmt is ast.ModuleStmt {
            return stmt.name.replace('.', '_')
        }
    }
    return 'main'
}

// --- Type resolution using types.Environment ---

fn (mut b Builder) type_to_ssa(t types.Type) TypeID {
    match t {
        types.Primitive {
            if t.props.has(.boolean) {
                return b.mod.type_store.get_int(1)
            }
            if t.props.has(.float) {
                width := if t.size == 32 { 32 } else { 64 }
                return b.mod.type_store.get_float(width)
            }
            if t.props.has(.integer) {
                size := if t.size == 0 { 32 } else { int(t.size) }
                if t.props.has(.unsigned) {
                    return b.mod.type_store.get_uint(size)
                }
                return b.mod.type_store.get_int(size)
            }
            return b.mod.type_store.get_int(32)
        }
        types.Pointer {
            base := b.type_to_ssa(t.base_type)
            return b.mod.type_store.get_ptr(base)
        }
        types.String {
            return b.get_string_type()
        }
        types.Struct {
            if t.name in b.struct_types {
                return b.struct_types[t.name]
            }
            // Try module-qualified name: C structs are registered as "os__dirent"
            // but the type checker stores them as just "dirent"
            qualified := '${b.cur_module}__${t.name}'
            if qualified in b.struct_types {
                return b.struct_types[qualified]
            }
            // Try all known module prefixes for cross-module struct access
            for sname, sid in b.struct_types {
                if sname.ends_with('__${t.name}') {
                    return sid
                }
            }
            return b.mod.type_store.get_int(64) // fallback
        }
        types.Enum {
            return b.mod.type_store.get_int(32)
        }
        types.Void {
            return 0 // void
        }
        types.Char {
            return b.mod.type_store.get_int(8)
        }
        types.Rune {
            return b.mod.type_store.get_int(32)
        }
        types.ISize {
            return b.mod.type_store.get_int(64)
        }
        types.USize {
            return b.mod.type_store.get_uint(64)
        }
        types.Alias {
            return b.type_to_ssa(t.base_type)
        }
        types.Array {
            // Dynamic arrays are struct-like: {data*, len, cap, element_size}
            return b.get_array_type()
        }
        types.ArrayFixed {
            // Fixed-size arrays: [N]T → SSA array type
            elem_type := b.type_to_ssa(t.elem_type)
            if t.len > 0 && elem_type != 0 {
                return b.mod.type_store.get_array(elem_type, t.len)
            }
            return b.mod.type_store.get_int(64) // fallback
        }
        types.Nil {
            i8_t := b.mod.type_store.get_int(8)
            return b.mod.type_store.get_ptr(i8_t)
        }
        types.None {
            return 0
        }
        types.Tuple {
            tt := t.get_types()
            mut elem_types := []TypeID{cap: tt.len}
            for et in tt {
                elem_types << b.type_to_ssa(et)
            }
            return b.mod.type_store.get_tuple(elem_types)
        }
        types.SumType {
            if t.name in b.struct_types {
                return b.struct_types[t.name]
            }
            // Try module-qualified name
            qualified_st := '${b.cur_module}__${t.name}'
            if qualified_st in b.struct_types {
                return b.struct_types[qualified_st]
            }
            // Search all known module prefixes
            for sname, sid in b.struct_types {
                if sname.ends_with('__${t.name}') {
                    return sid
                }
            }
            return b.mod.type_store.get_int(64) // fallback
        }
        types.Map {
            return b.struct_types['map'] or { b.mod.type_store.get_int(64) }
        }
        types.OptionType {
            return b.get_option_wrapper_type(b.type_to_ssa(t.base_type))
        }
        types.ResultType {
            return b.get_result_wrapper_type(b.type_to_ssa(t.base_type))
        }
        types.FnType {
            i8_t := b.mod.type_store.get_int(8)
            return b.mod.type_store.get_ptr(i8_t) // fn pointers
        }
        types.Interface {
            return b.mod.type_store.get_int(64) // interfaces lowered to i64
        }
        else {
            return b.mod.type_store.get_int(64) // fallback for unhandled
        }
    }
}

fn (mut b Builder) get_string_type() TypeID {
    return b.struct_types['string'] or { 0 }
}

fn (mut b Builder) get_array_type() TypeID {
    return b.struct_types['array'] or { 0 }
}

fn (b &Builder) is_string_like_ssa_type(typ_id TypeID) bool {
    if typ_id == 0 || int(typ_id) >= b.mod.type_store.types.len {
        return false
    }
    str_type := b.struct_types['string'] or { TypeID(0) }
    if str_type != 0 && typ_id == str_type {
        return true
    }
    typ := b.mod.type_store.types[typ_id]
    return typ.kind == .ptr_t && typ.elem_type == str_type
}

fn (mut b Builder) load_string_like_value(val_id ValueID) ValueID {
    if val_id <= 0 || int(val_id) >= b.mod.values.len {
        return val_id
    }
    str_type := b.get_string_type()
    if str_type == 0 {
        return val_id
    }
    typ_id := b.mod.values[val_id].typ
    if typ_id == str_type {
        return val_id
    }
    if typ_id > 0 && int(typ_id) < b.mod.type_store.types.len {
        typ := b.mod.type_store.types[typ_id]
        if typ.kind == .ptr_t && typ.elem_type == str_type {
            return b.mod.add_instr(.load, b.cur_block, str_type, [val_id])
        }
    }
    return val_id
}

fn (mut b Builder) get_ierror_storage_type() TypeID {
    if 'IError' in b.struct_types {
        return b.struct_types['IError']
    }
    return b.mod.type_store.get_int(64)
}

fn (mut b Builder) get_option_wrapper_type(base_type TypeID) TypeID {
    key := base_type.str()
    if type_id := b.option_wrapper_types[key] {
        return type_id
    }
    state_type := b.mod.type_store.get_int(8)
    err_type := b.get_ierror_storage_type()
    mut field_types := []TypeID{cap: 3}
    mut field_names := []string{cap: 3}
    field_types << state_type
    field_names << 'state'
    field_types << err_type
    field_names << 'err'
    if base_type != 0 {
        field_types << base_type
        field_names << 'data'
    }
    type_id := b.mod.type_store.register(Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
    })
    b.option_wrapper_types[key] = type_id
    return type_id
}

fn (mut b Builder) get_result_wrapper_type(base_type TypeID) TypeID {
    key := base_type.str()
    if type_id := b.result_wrapper_types[key] {
        return type_id
    }
    bool_type := b.mod.type_store.get_int(1)
    err_type := b.get_ierror_storage_type()
    mut field_types := []TypeID{cap: 3}
    mut field_names := []string{cap: 3}
    field_types << bool_type
    field_names << 'is_error'
    field_types << err_type
    field_names << 'err'
    if base_type != 0 {
        field_types << base_type
        field_names << 'data'
    }
    type_id := b.mod.type_store.register(Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
    })
    b.result_wrapper_types[key] = type_id
    return type_id
}

fn (b &Builder) is_option_wrapper_type(type_id TypeID) bool {
    if type_id <= 0 || type_id >= b.mod.type_store.types.len {
        return false
    }
    typ := b.mod.type_store.types[type_id]
    return typ.kind == .struct_t && typ.field_names.len >= 2 && typ.field_names[0] == 'state'
        && typ.field_names[1] == 'err'
}

fn (b &Builder) is_result_wrapper_type(type_id TypeID) bool {
    if type_id <= 0 || type_id >= b.mod.type_store.types.len {
        return false
    }
    typ := b.mod.type_store.types[type_id]
    return typ.kind == .struct_t && typ.field_names.len >= 2 && typ.field_names[0] == 'is_error'
        && typ.field_names[1] == 'err'
}

fn (b &Builder) is_wrapper_type(type_id TypeID) bool {
    return b.is_option_wrapper_type(type_id) || b.is_result_wrapper_type(type_id)
}

fn (b &Builder) wrapper_has_data(type_id TypeID) bool {
    if type_id <= 0 || type_id >= b.mod.type_store.types.len {
        return false
    }
    typ := b.mod.type_store.types[type_id]
    return typ.kind == .struct_t && typ.field_names.len >= 3 && typ.field_names[2] == 'data'
}

fn (b &Builder) wrapper_data_type(type_id TypeID) TypeID {
    if !b.wrapper_has_data(type_id) {
        return 0
    }
    return b.mod.type_store.types[type_id].fields[2]
}

fn (b &Builder) current_fn_return_type() TypeID {
    if b.cur_func >= 0 && b.cur_func < b.mod.funcs.len {
        return b.mod.funcs[b.cur_func].typ
    }
    return 0
}

fn (mut b Builder) build_unwrapped_postfix(expr ast.PostfixExpr, wrapped_val ValueID) ValueID {
    if wrapped_val <= 0 || wrapped_val >= b.mod.values.len {
        return wrapped_val
    }
    wrapped_type := b.mod.values[wrapped_val].typ
    if !b.is_wrapper_type(wrapped_type) {
        return wrapped_val
    }
    wrapper_info := b.mod.type_store.types[wrapped_type]
    i32_t := b.mod.type_store.get_int(32)
    bool_t := b.mod.type_store.get_int(1)
    flag_idx := b.mod.get_or_add_const(i32_t, '0')
    err_idx := b.mod.get_or_add_const(i32_t, '1')
    flag_type := wrapper_info.fields[0]
    flag_val := b.mod.add_instr(.extractvalue, b.cur_block, flag_type, [wrapped_val, flag_idx])
    mut fail_cond := flag_val
    if b.is_option_wrapper_type(wrapped_type) {
        zero_flag := b.mod.get_or_add_const(flag_type, '0')
        fail_cond = b.mod.add_instr(.ne, b.cur_block, bool_t, [flag_val, zero_flag])
    }
    fail_block := b.mod.add_block(b.cur_func, 'postfix_fail')
    ok_block := b.mod.add_block(b.cur_func, 'postfix_ok')
    b.mod.add_instr(.br, b.cur_block, 0,
        [fail_cond, b.mod.blocks[fail_block].val_id, b.mod.blocks[ok_block].val_id])
    b.add_edge(b.cur_block, fail_block)
    b.add_edge(b.cur_block, ok_block)

    b.cur_block = fail_block
    fn_ret_type := b.current_fn_return_type()
    if fn_ret_type != 0 && b.is_wrapper_type(fn_ret_type) {
        if fn_ret_type == wrapped_type {
            b.mod.add_instr(.ret, b.cur_block, 0, [wrapped_val])
        } else {
            err_type := if wrapper_info.fields.len > 1 {
                wrapper_info.fields[1]
            } else {
                b.get_ierror_storage_type()
            }
            err_val := b.mod.add_instr(.extractvalue, b.cur_block, err_type, [
                wrapped_val,
                err_idx,
            ])
            propagated := b.build_wrapper_value(fn_ret_type, false, err_val, false)
            b.mod.add_instr(.ret, b.cur_block, 0, [propagated])
        }
    } else {
        panic_name := if 'builtin__panic' in b.fn_index { 'builtin__panic' } else { 'panic' }
        if panic_name in b.fn_index {
            panic_ref := b.get_or_create_fn_ref(panic_name, 0)
            panic_msg := b.build_string_literal(ast.StringLiteral{
                kind:  .v
                value: if expr.op == .not {
                    "'postfix ! unwrap failed'"
                } else {
                    "'postfix ? unwrap failed'"
                }
            })
            b.mod.add_instr(.call, b.cur_block, 0, [panic_ref, panic_msg])
        }
        b.mod.add_instr(.unreachable, b.cur_block, 0, []ValueID{})
    }

    b.cur_block = ok_block
    if !b.wrapper_has_data(wrapped_type) {
        return b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
    }
    data_type := b.wrapper_data_type(wrapped_type)
    data_idx := b.mod.get_or_add_const(i32_t, '2')
    return b.mod.add_instr(.extractvalue, b.cur_block, data_type, [wrapped_val, data_idx])
}

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

fn (b &Builder) is_error_expr(expr ast.Expr) bool {
    error_fn_names := ['error', 'error_posix', 'error_with_code', 'error_win32']
    match expr {
        ast.Ident {
            return expr.name == 'err'
        }
        ast.CallExpr {
            return expr.lhs is ast.Ident && expr.lhs.name in error_fn_names
        }
        ast.CallOrCastExpr {
            return expr.lhs is ast.Ident && expr.lhs.name in error_fn_names
        }
        else {
            return false
        }
    }
}

fn (mut b Builder) build_wrapper_value(wrapper_type TypeID, success bool, payload ValueID, has_payload bool) ValueID {
    if wrapper_type <= 0 || wrapper_type >= b.mod.type_store.types.len {
        return payload
    }
    wrapper_info := b.mod.type_store.types[wrapper_type]
    if wrapper_info.kind != .struct_t || wrapper_info.field_names.len < 2 {
        return payload
    }
    mut wrapper := b.mod.get_or_add_const(wrapper_type, '0')
    i32_t := b.mod.type_store.get_int(32)
    flag_idx := b.mod.get_or_add_const(i32_t, '0')
    err_idx := b.mod.get_or_add_const(i32_t, '1')
    flag_type := wrapper_info.fields[0]
    flag_val := if b.is_option_wrapper_type(wrapper_type) {
        // V options use state==0 for success and state==2 for none/error.
        b.mod.get_or_add_const(flag_type, if success { '0' } else { '2' })
    } else {
        b.mod.get_or_add_const(flag_type, if success { '0' } else { '1' })
    }
    wrapper = b.mod.add_instr(.insertvalue, b.cur_block, wrapper_type,
        [wrapper, flag_val, flag_idx])
    if !success {
        err_type := wrapper_info.fields[1]
        mut err_val := payload
        if err_val == 0 {
            err_val = b.mod.get_or_add_const(err_type, '0')
        } else if b.mod.values[err_val].typ != err_type {
            err_val = b.cast_value_to_type(err_val, err_type)
        }
        wrapper = b.mod.add_instr(.insertvalue, b.cur_block, wrapper_type,
            [wrapper, err_val, err_idx])
    }
    if has_payload && b.wrapper_has_data(wrapper_type) {
        data_idx := b.mod.get_or_add_const(i32_t, '2')
        data_type := wrapper_info.fields[2]
        mut data_val := payload
        if data_val == 0 {
            data_val = b.mod.get_or_add_const(data_type, '0')
        } else if b.mod.values[data_val].typ != data_type {
            data_val = b.cast_value_to_type(data_val, data_type)
        }
        wrapper = b.mod.add_instr(.insertvalue, b.cur_block, wrapper_type, [wrapper, data_val,
            data_idx])
    }
    return wrapper
}

fn (mut b Builder) coerce_wrapper_value(expr ast.Expr, val ValueID, wrapper_type TypeID) ValueID {
    if !b.is_wrapper_type(wrapper_type) {
        return val
    }
    if b.is_none_expr(expr) {
        return b.build_wrapper_value(wrapper_type, false, 0, false)
    }
    if b.is_error_expr(expr) {
        return b.build_wrapper_value(wrapper_type, false, val, false)
    }
    if val > 0 && val < b.mod.values.len && b.mod.values[val].typ == wrapper_type {
        match b.mod.values[val].kind {
            .argument, .global, .instruction {
                return val
            }
            else {}
        }
    }
    return b.build_wrapper_value(wrapper_type, true, val, true)
}

fn (mut b Builder) expr_type(e ast.Expr) TypeID {
    if b.env != unsafe { nil } {
        pos := e.pos()
        if pos.id != 0 {
            if typ := b.env.get_expr_type(pos.id) {
                return b.type_to_ssa(typ)
            }
        }
    }
    // Fallback for literals
    match e {
        ast.BasicLiteral {
            if e.kind == .key_true || e.kind == .key_false {
                return b.mod.type_store.get_int(1)
            }
            if e.kind == .number && (e.value.contains('.')
                || (!e.value.starts_with('0x') && !e.value.starts_with('0X')
                && (e.value.contains('e') || e.value.contains('E')))) {
                return b.mod.type_store.get_float(64)
            }
            return b.mod.type_store.get_int(64)
        }
        ast.StringLiteral {
            return b.get_string_type()
        }
        else {
            return b.mod.type_store.get_int(64)
        }
    }
}

fn (mut b Builder) const_field_type(field_name string, value ast.Expr) TypeID {
    if b.env != unsafe { nil } {
        if scope := b.env.get_scope(b.cur_module) {
            if obj := scope.lookup_parent(field_name, 0) {
                obj_type := b.type_to_ssa(obj.typ())
                if obj_type != 0 {
                    return obj_type
                }
            }
        }
    }
    return b.expr_type(value)
}

fn (mut b Builder) types_type_c_name(t types.Type) string {
    match t {
        types.Primitive {
            if t.props.has(.boolean) {
                return 'bool'
            }
            if t.props.has(.float) {
                return if t.size == 32 { 'f32' } else { 'f64' }
            }
            if t.props.has(.integer) {
                if t.props.has(.untyped) {
                    return 'int'
                }
                size := if t.size == 0 { 32 } else { int(t.size) }
                is_signed := !t.props.has(.unsigned)
                return if is_signed {
                    match size {
                        8 { 'i8' }
                        16 { 'i16' }
                        64 { 'i64' }
                        else { 'int' }
                    }
                } else {
                    match size {
                        8 { 'u8' }
                        16 { 'u16' }
                        32 { 'u32' }
                        else { 'u64' }
                    }
                }
            }
            return 'int'
        }
        types.Pointer {
            return b.types_type_c_name(t.base_type) + '*'
        }
        types.String {
            return 'string'
        }
        types.Struct {
            return t.name
        }
        types.Enum {
            return t.name
        }
        types.Void {
            return 'void'
        }
        types.Char {
            return 'char'
        }
        types.Alias {
            return b.types_type_c_name(t.base_type)
        }
        types.Array {
            // []rune → Array_rune, []int → Array_int, etc.
            return 'Array_${b.types_type_c_name(t.elem_type)}'
        }
        types.Rune {
            return 'rune'
        }
        types.SumType {
            return t.name
        }
        types.Interface {
            return t.name
        }
        types.FnType {
            return 'FnType'
        }
        types.Map {
            return 'map'
        }
        types.OptionType {
            // Unwrap Option to base type for method resolution
            // (e.g., r.str() where r was unwrapped from ?int should resolve to int__str)
            return b.types_type_c_name(t.base_type)
        }
        types.ResultType {
            // Unwrap Result to base type for method resolution
            return b.types_type_c_name(t.base_type)
        }
        types.ArrayFixed {
            return 'ArrayFixed'
        }
        else {
            return 'int'
        }
    }
}

// --- Phase 1: Register types ---

// Pass 1: Register struct names as forward declarations (empty structs),
// enums, and sumtypes. This ensures all struct names are in struct_types
// before any field types are resolved.
fn (mut b Builder) register_types_pass1(file ast.File) {
    for stmt in file.stmts {
        match stmt {
            ast.StructDecl {
                b.register_struct_name(stmt)
            }
            ast.EnumDecl {
                b.register_enum(stmt)
            }
            ast.TypeDecl {
                b.register_sumtype(stmt)
            }
            else {}
        }
    }
}

// Pass 2: Fill in struct field types. All struct names are now registered,
// so cross-module struct references (e.g., &scanner.Scanner in Parser)
// resolve correctly to the struct type instead of falling back to i64.
fn (mut b Builder) register_types_pass2(file ast.File) {
    nstmts := file.stmts.len
    for si in 0 .. nstmts {
        stmt := file.stmts[si]
        if stmt is ast.StructDecl {
            b.register_struct_fields(stmt)
        }
    }
}

fn (mut b Builder) struct_mangled_name(decl ast.StructDecl) string {
    return if b.cur_module == 'builtin'
        && decl.name in ['array', 'string', 'map', 'DenseArray', 'IError', 'Error', 'MessageError', 'None__', '_option', '_result', 'Option'] {
        decl.name
    } else if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${decl.name}'
    } else {
        decl.name
    }
}

// register_struct_name registers a struct name with an empty struct type.
// The fields will be filled in by register_struct_fields in pass 2.
fn (mut b Builder) register_struct_name(decl ast.StructDecl) {
    name := b.struct_mangled_name(decl)

    if name in b.struct_types {
        return
    }

    type_id := b.mod.type_store.register(Type{
        kind:     .struct_t
        is_union: decl.is_union
    })
    b.struct_types[name] = type_id
    b.mod.c_struct_names[type_id] = name
}

// register_struct_fields fills in the field types for a previously forward-declared struct.
fn (mut b Builder) register_struct_fields(decl ast.StructDecl) {
    name := b.struct_mangled_name(decl)

    type_id := b.struct_types[name] or { return }

    // Skip if fields are already populated (e.g., builtin types registered in Phase 1a)
    if b.mod.type_store.types[type_id].fields.len > 0 {
        return
    }

    mut field_types := []TypeID{}
    mut field_names := []string{}
    n_embedded := decl.embedded.len
    n_fields := decl.fields.len

    // Flatten embedded struct fields first (e.g., ObjectCommon in Const)
    if n_embedded > 0 {
        b.collect_embedded_fields(decl.embedded, mut field_names, mut field_types)
    }

    for fi in 0 .. n_fields {
        field := decl.fields[fi]
        ft := b.ast_type_to_ssa(field.typ)
        field_types << ft
        field_names << field.name
    }

    b.mod.type_store.types[type_id] = Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
        is_union:    decl.is_union
    }
}

// register_struct is the legacy combined registration (used for Phase 1a core types).
fn (mut b Builder) register_struct(decl ast.StructDecl) {
    name := b.struct_mangled_name(decl)

    if name in b.struct_types {
        return
    }

    mut field_types := []TypeID{}
    mut field_names := []string{}

    // Flatten embedded struct fields first
    b.collect_embedded_fields(decl.embedded, mut field_names, mut field_types)

    for field in decl.fields {
        ft := b.ast_type_to_ssa(field.typ)
        field_types << ft
        field_names << field.name
    }

    type_id := b.mod.type_store.register(Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
        is_union:    decl.is_union
    })
    b.struct_types[name] = type_id
    b.mod.c_struct_names[type_id] = name
}

// collect_embedded_fields resolves embedded type expressions and adds their
// flattened fields to the field_names and field_types lists.
// Embedded structs (e.g., `ObjectCommon` in `struct Const { ObjectCommon; int_val int }`)
// have their fields in a separate `embedded` list in the AST StructDecl.
// This function looks up each embedded type in struct_types and prepends its fields.
fn (mut b Builder) collect_embedded_fields(embedded []ast.Expr, mut field_names []string, mut field_types []TypeID) {
    for emb in embedded {
        // Get the type name from the embedded expression
        emb_name := if emb is ast.Ident {
            emb.name
        } else if emb is ast.SelectorExpr && emb.lhs is ast.Ident {
            mod_name := (emb.lhs as ast.Ident).name.replace('.', '_')
            '${mod_name}__${emb.rhs.name}'
        } else {
            ''
        }
        if emb_name == '' {
            continue
        }
        // Look up the embedded struct type, trying module-qualified name first
        mut emb_type_id := TypeID(0)
        if b.cur_module != '' && b.cur_module != 'main' {
            qualified := '${b.cur_module}__${emb_name}'
            if qualified in b.struct_types {
                emb_type_id = b.struct_types[qualified]
            }
        }
        if emb_type_id == 0 {
            if emb_name in b.struct_types {
                emb_type_id = b.struct_types[emb_name]
            }
        }
        if emb_type_id == 0 {
            continue
        }
        if emb_type_id < b.mod.type_store.types.len {
            emb_typ := b.mod.type_store.types[emb_type_id]
            if emb_typ.kind == .struct_t && emb_typ.field_names.len > 0 {
                for i, fname in emb_typ.field_names {
                    field_names << fname
                    if i < emb_typ.fields.len {
                        field_types << emb_typ.fields[i]
                    } else {
                        field_types << b.mod.type_store.get_int(64)
                    }
                }
            }
        }
    }
}

fn (mut b Builder) register_enum(decl ast.EnumDecl) {
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${decl.name}'
    } else {
        decl.name
    }

    is_flag := decl.attributes.has('flag')
    for i, field in decl.fields {
        key := '${name}__${field.name}'
        if is_flag {
            // @[flag] enums use power-of-2 values: 1, 2, 4, 8, ...
            b.enum_values[key] = 1 << i
        } else {
            b.enum_values[key] = i
        }
    }
}

// is_enum_type checks if a type name corresponds to a registered enum
// by looking for any enum_values key that starts with the name followed by '__'.
fn (b &Builder) is_enum_type(name string) bool {
    prefix := '${name}__'
    for key, _ in b.enum_values {
        if key.starts_with(prefix) {
            return true
        }
    }
    return false
}

fn (mut b Builder) register_sumtype(decl ast.TypeDecl) {
    if decl.variants.len == 0 {
        return
    }
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${decl.name}'
    } else {
        decl.name
    }

    if name in b.struct_types {
        return
    }

    i64_t := b.mod.type_store.get_int(64)
    type_id := b.mod.type_store.register(Type{
        kind:        .struct_t
        fields:      [i64_t, i64_t]
        field_names: ['_tag', '_data']
    })
    b.struct_types[name] = type_id
    b.mod.c_struct_names[type_id] = name
}

fn (mut b Builder) register_consts_and_globals(file ast.File) {
    for stmt in file.stmts {
        match stmt {
            ast.ConstDecl {
                for field in stmt.fields {
                    const_name := if b.cur_module != '' && b.cur_module != 'main' {
                        '${b.cur_module}__${field.name}'
                    } else {
                        field.name
                    }
                    mut const_type := b.const_field_type(field.name, field.value)
                    // Check if this is a string constant - store for inline resolution
                    str_val := b.try_eval_const_string(field.value)
                    if str_val.len > 0 {
                        b.string_const_values[const_name] = str_val
                        b.string_const_values[field.name] = str_val
                    }
                    // Check if this is a float constant - store for inline resolution
                    if field.value is ast.BasicLiteral && field.value.kind == .number
                        && (field.value.value.contains('.')
                        || (!field.value.value.starts_with('0x')
                        && !field.value.value.starts_with('0X')
                        && (field.value.value.contains('e') || field.value.value.contains('E')))) {
                        b.float_const_values[const_name] = field.value.value
                        b.float_const_values[field.name] = field.value.value
                    } else if b.is_float_cast_expr(field.value) {
                        if fval := b.try_eval_computed_float(field.value) {
                            fval_str := fval.str()
                            b.float_const_values[const_name] = fval_str
                            b.float_const_values[field.name] = fval_str
                        }
                    }
                    initial_value := b.try_eval_const_int(field.value)
                    // Detect sum type constants: these are multi-word values that
                    // cannot be inlined as a single i64.
                    // Case 1: Transformer succeeded → InitExpr{_tag: N, _data: ...}
                    // Case 2: Transformer failed → CastExpr{typ: SumType, expr: ...}
                    mut is_sumtype_const := false
                    if field.value is ast.InitExpr {
                        for init_field in field.value.fields {
                            if init_field.name == '_tag' {
                                is_sumtype_const = true
                                break
                            }
                        }
                    }
                    if !is_sumtype_const {
                        mut cast_type_name := ''
                        if field.value is ast.CastExpr {
                            if field.value.typ is ast.Ident {
                                cast_type_name = field.value.typ.name
                            }
                        } else if field.value is ast.CallOrCastExpr {
                            if field.value.lhs is ast.Ident {
                                cast_type_name = field.value.lhs.name
                            }
                        }
                        if cast_type_name != '' {
                            qualified_cast := if b.cur_module != '' && b.cur_module != 'main' {
                                '${b.cur_module}__${cast_type_name}'
                            } else {
                                cast_type_name
                            }
                            for _, check_name in [cast_type_name, qualified_cast] {
                                if st_type := b.struct_types[check_name] {
                                    if int(st_type) < b.mod.type_store.types.len {
                                        st := b.mod.type_store.types[st_type]
                                        if st.kind == .struct_t && st.field_names.len >= 2
                                            && st.field_names[0] == '_tag' {
                                            is_sumtype_const = true
                                            // Fix the global type: use the sum type struct
                                            // instead of the i64 fallback from expr_type()
                                            const_type = st_type
                                            break
                                        }
                                    }
                                }
                            }
                        }
                    }
                    // For sum type constants detected via InitExpr, also fix const_type
                    if is_sumtype_const && field.value is ast.InitExpr {
                        if field.value.typ is ast.Ident {
                            type_name := field.value.typ.name
                            if st_type := b.struct_types[type_name] {
                                const_type = st_type
                            } else {
                                // Try with module prefix
                                qualified_st := '${b.cur_module}__${type_name}'
                                if st_type2 := b.struct_types[qualified_st] {
                                    const_type = st_type2
                                }
                            }
                        }
                    }
                    // Detect constant FIXED arrays with all-literal elements.
                    if field.value is ast.ArrayInitExpr && field.value.exprs.len > 0 {
                        mut is_fixed_array := true
                        // Check type environment to see if this is a dynamic array
                        if b.env != unsafe { nil } {
                            fpos := field.value.pos
                            if fpos.id != 0 {
                                if ct := b.env.get_expr_type(fpos.id) {
                                    if ct is types.Array {
                                        is_fixed_array = false
                                    }
                                }
                            }
                        }
                        arr_data := b.try_serialize_const_array(field.value)
                        if arr_data.len > 0 {
                            elem_size := arr_data.len / field.value.exprs.len
                            is_float_arr := b.is_float_array(field.value)
                            elem_type := if is_float_arr {
                                b.mod.type_store.get_float(elem_size * 8)
                            } else if elem_size == 8 {
                                b.mod.type_store.get_int(64)
                            } else if elem_size == 4 {
                                b.mod.type_store.get_int(32)
                            } else if elem_size == 2 {
                                b.mod.type_store.get_int(16)
                            } else {
                                b.mod.type_store.get_int(8)
                            }
                            if is_fixed_array {
                                b.mod.add_global_with_data(const_name, elem_type, true, arr_data)
                                b.const_array_globals[const_name] = true
                                b.const_array_globals[field.name] = true
                                b.const_array_elem_count[const_name] = field.value.exprs.len
                                b.const_array_elem_count[field.name] = field.value.exprs.len
                                continue
                            } else {
                                // Dynamic array constant: serialize data, create array struct global
                                data_name := '${const_name}__data'
                                b.mod.add_global_with_data(data_name, elem_type, true, arr_data)
                                b.const_array_globals[data_name] = true
                                // Add array struct global (initialized in _vinit)
                                arr_struct_type := b.get_array_type()
                                b.mod.add_global(const_name, arr_struct_type, false)
                                b.dyn_const_arrays << DynConstArray{
                                    arr_global_name:  const_name
                                    data_global_name: data_name
                                    elem_count:       field.value.exprs.len
                                    elem_size:        elem_size
                                }
                                continue
                            }
                        }
                    }
                    // For float constants, store bit pattern as initial_value
                    mut actual_init := initial_value
                    if const_name in b.float_const_values {
                        f_val := b.float_const_values[const_name].f64()
                        actual_init = i64(unsafe { *(&i64(&f_val)) })
                        const_type = b.mod.type_store.get_float(64)
                    }
                    b.mod.add_global_with_value(const_name, const_type, true, actual_init)
                    if !is_sumtype_const && (initial_value != 0 || b.is_zero_literal(field.value)) {
                        b.const_values[const_name] = initial_value
                        b.const_value_types[const_name] = const_type
                        // Also store without module prefix for transformer-generated references
                        b.const_values[field.name] = initial_value
                        b.const_value_types[field.name] = const_type
                    }
                }
            }
            ast.GlobalDecl {
                for field in stmt.fields {
                    glob_name := if b.cur_module != '' && b.cur_module != 'main' {
                        '${b.cur_module}__${field.name}'
                    } else {
                        field.name
                    }
                    glob_type := if field.typ != ast.empty_expr {
                        b.ast_type_to_ssa(field.typ)
                    } else if field.value is ast.ArrayInitExpr && field.value.typ != ast.empty_expr {
                        b.ast_type_to_ssa(field.value.typ)
                    } else {
                        b.mod.type_store.get_int(64)
                    }
                    initial_value := if field.value != ast.empty_expr {
                        b.try_eval_const_int(field.value)
                    } else {
                        i64(0)
                    }
                    b.mod.add_global_with_value(glob_name, glob_type, false, initial_value)
                }
            }
            else {}
        }
    }
}

// resolve_forward_const_refs re-evaluates constants that had value 0 due to forward references.
// After all constants are registered, references that previously failed can now be resolved.
fn (mut b Builder) resolve_forward_const_refs(files []ast.File) {
    for file in files {
        b.cur_module = file_module_name(file)
        for stmt in file.stmts {
            if stmt is ast.ConstDecl {
                for field in stmt.fields {
                    const_name := if b.cur_module != '' && b.cur_module != 'main' {
                        '${b.cur_module}__${field.name}'
                    } else {
                        field.name
                    }
                    // Skip constants that already have non-zero values
                    if const_name in b.const_values {
                        continue
                    }
                    // Skip zero literals (they're intentionally 0)
                    if b.is_zero_literal(field.value) {
                        continue
                    }
                    // Skip sum type constants (multi-word values stored as globals, not inline)
                    if field.value is ast.InitExpr {
                        mut has_tag := false
                        for init_field in field.value.fields {
                            if init_field.name == '_tag' {
                                has_tag = true
                                break
                            }
                        }
                        if has_tag {
                            continue
                        }
                    }
                    // Re-evaluate the constant expression
                    new_value := b.try_eval_const_int(field.value)
                    if new_value != 0 {
                        b.const_values[const_name] = new_value
                        b.const_values[field.name] = new_value
                        ct := b.const_field_type(field.name, field.value)
                        b.const_value_types[const_name] = ct
                        b.const_value_types[field.name] = ct
                        // Update the global variable's initial value
                        for i, g in b.mod.globals {
                            if g.name == const_name {
                                b.mod.globals[i] = GlobalVar{
                                    ...g
                                    initial_value: new_value
                                }
                                break
                            }
                        }
                    }
                }
            }
        }
    }
}

// resolve_const_int looks up a constant name in const_values, trying bare, module-qualified,
// and builtin-qualified names. Returns 0 if not found.
fn (b &Builder) resolve_const_int(name string) int {
    if name in b.const_values {
        return int(b.const_values[name])
    }
    qualified := '${b.cur_module}__${name}'
    if qualified in b.const_values {
        return int(b.const_values[qualified])
    }
    builtin_q := 'builtin__${name}'
    if builtin_q in b.const_values {
        return int(b.const_values[builtin_q])
    }
    return 0
}

// try_eval_const_int attempts to evaluate a constant expression to an integer value.
// Returns 0 for expressions that cannot be evaluated at compile time.
fn (b &Builder) is_float_array(arr ast.ArrayInitExpr) bool {
    if arr.exprs.len > 0 {
        first := arr.exprs[0]
        if first is ast.CallOrCastExpr {
            if first.lhs is ast.Ident {
                return first.lhs.name in ['f32', 'f64']
            }
        } else if first is ast.CastExpr {
            if first.typ is ast.Ident {
                return first.typ.name in ['f32', 'f64']
            }
        }
    }
    return false
}

// try_serialize_const_array attempts to serialize a constant array's elements to raw bytes.
// Returns the serialized data or empty if any element can't be evaluated at compile time.
fn (mut b Builder) try_serialize_const_array(arr ast.ArrayInitExpr) []u8 {
    if arr.exprs.len == 0 {
        return []u8{}
    }
    // Determine element size and whether it's a float array from the first element's type hint
    mut elem_size := 8 // default to 8 bytes (u64/i64)
    mut is_float := false
    // Check first element for type cast (e.g., u64(0x123), f64(0.5))
    first := arr.exprs[0]
    if first is ast.CallOrCastExpr {
        if first.lhs is ast.Ident {
            match first.lhs.name {
                'u8', 'i8', 'byte' {
                    elem_size = 1
                }
                'u16', 'i16' {
                    elem_size = 2
                }
                'u32', 'i32', 'int' {
                    elem_size = 4
                }
                'f32' {
                    elem_size = 4
                    is_float = true
                }
                'u64', 'i64' {
                    elem_size = 8
                }
                'f64' {
                    elem_size = 8
                    is_float = true
                }
                else {}
            }
        }
    } else if first is ast.CastExpr {
        if first.typ is ast.Ident {
            match first.typ.name {
                'u8', 'i8', 'byte' {
                    elem_size = 1
                }
                'u16', 'i16' {
                    elem_size = 2
                }
                'u32', 'i32', 'int' {
                    elem_size = 4
                }
                'f32' {
                    elem_size = 4
                    is_float = true
                }
                'u64', 'i64' {
                    elem_size = 8
                }
                'f64' {
                    elem_size = 8
                    is_float = true
                }
                else {}
            }
        }
    }
    mut data := []u8{cap: arr.exprs.len * elem_size}
    for ei, expr in arr.exprs {
        _ = ei
        if is_float {
            // For float arrays, parse as f64 and store IEEE 754 bits
            fval := b.try_eval_const_float(expr)
            if elem_size == 4 {
                fval32 := f32(fval)
                bits := unsafe { *(&u32(&fval32)) }
                data << u8(bits & 0xFF)
                data << u8((bits >> 8) & 0xFF)
                data << u8((bits >> 16) & 0xFF)
                data << u8((bits >> 24) & 0xFF)
            } else {
                bits := unsafe { *(&u64(&fval)) }
                data << u8(bits & 0xFF)
                data << u8((bits >> 8) & 0xFF)
                data << u8((bits >> 16) & 0xFF)
                data << u8((bits >> 24) & 0xFF)
                data << u8((bits >> 32) & 0xFF)
                data << u8((bits >> 40) & 0xFF)
                data << u8((bits >> 48) & 0xFF)
                data << u8((bits >> 56) & 0xFF)
            }
        } else {
            val := b.try_eval_const_int(expr)
            match elem_size {
                1 {
                    data << u8(val)
                }
                2 {
                    data << u8(val & 0xFF)
                    data << u8((val >> 8) & 0xFF)
                }
                4 {
                    data << u8(val & 0xFF)
                    data << u8((val >> 8) & 0xFF)
                    data << u8((val >> 16) & 0xFF)
                    data << u8((val >> 24) & 0xFF)
                }
                else {
                    v := u64(val)
                    data << u8(v & 0xFF)
                    data << u8((v >> 8) & 0xFF)
                    data << u8((v >> 16) & 0xFF)
                    data << u8((v >> 24) & 0xFF)
                    data << u8((v >> 32) & 0xFF)
                    data << u8((v >> 40) & 0xFF)
                    data << u8((v >> 48) & 0xFF)
                    data << u8((v >> 56) & 0xFF)
                }
            }
        }
    }
    return data
}

// try_eval_const_float evaluates a compile-time float constant expression.
fn (b &Builder) try_eval_const_float(expr ast.Expr) f64 {
    match expr {
        ast.BasicLiteral {
            if expr.kind == .number {
                return expr.value.f64()
            }
        }
        ast.CallOrCastExpr {
            // f64(0.5), f32(1.0), etc.
            return b.try_eval_const_float(expr.expr)
        }
        ast.PrefixExpr {
            if expr.op == .minus {
                return -b.try_eval_const_float(expr.expr)
            }
        }
        else {}
    }

    return 0.0
}

// is_float_cast_expr returns true if the expression is a cast to a float type
// (e.g., f64(literal), f32(expr)), which should be evaluated as a float constant.
// This prevents pure integer expressions like `64 - 11 - 1` from being stored
// as float constants.
fn (b &Builder) is_float_cast_expr(expr ast.Expr) bool {
    if expr is ast.CastExpr {
        if expr.typ is ast.Ident {
            return expr.typ.name == 'f64' || expr.typ.name == 'f32'
        }
    }
    if expr is ast.CallOrCastExpr {
        if expr.lhs is ast.Ident {
            return expr.lhs.name == 'f64' || expr.lhs.name == 'f32'
        }
    }
    if expr is ast.BasicLiteral {
        if expr.kind == .number {
            return expr.value.contains('.')
                || (!expr.value.starts_with('0x') && !expr.value.starts_with('0X')
                && (expr.value.contains('e') || expr.value.contains('E')))
        }
    }
    // Check for InfixExpr/PrefixExpr involving float operations
    // (e.g., `1.0 / ln2` or `-0.5`)
    if expr is ast.PrefixExpr {
        return b.is_float_cast_expr(expr.expr)
    }
    if expr is ast.InfixExpr {
        return b.is_float_cast_expr(expr.lhs) || b.is_float_cast_expr(expr.rhs)
    }
    return false
}

// try_eval_computed_float evaluates a constant expression to a float value.
// Handles computed float constants like `pi / 2.0`, `1.0 / ln2`, etc.
// Returns none if the expression can't be evaluated as a compile-time float.
fn (mut b Builder) try_eval_computed_float(expr ast.Expr) ?f64 {
    match expr {
        ast.BasicLiteral {
            if expr.kind == .number && expr.value.contains('.') {
                return expr.value.f64()
            }
            if expr.kind == .number {
                return f64(expr.value.i64())
            }
            return none
        }
        ast.Ident {
            // Look up the identifier in float_const_values
            if fval := b.float_const_values[expr.name] {
                return fval.f64()
            }
            qualified := '${b.cur_module}__${expr.name}'
            if fval := b.float_const_values[qualified] {
                return fval.f64()
            }
            return none
        }
        ast.InfixExpr {
            lhs := b.try_eval_computed_float(expr.lhs) or { return none }
            rhs := b.try_eval_computed_float(expr.rhs) or { return none }
            return match expr.op {
                .plus {
                    lhs + rhs
                }
                .minus {
                    lhs - rhs
                }
                .mul {
                    lhs * rhs
                }
                .div {
                    if rhs != 0.0 {
                        lhs / rhs
                    } else {
                        f64(0.0)
                    }
                }
                else {
                    return none
                }
            }
        }
        ast.PrefixExpr {
            if expr.op == .minus {
                val := b.try_eval_computed_float(expr.expr) or { return none }
                return -val
            }
            return none
        }
        ast.CastExpr {
            // Only evaluate as float if casting to a float type (f64, f32)
            if expr.typ is ast.Ident && (expr.typ.name == 'f64' || expr.typ.name == 'f32') {
                return b.try_eval_computed_float(expr.expr)
            }
            return none
        }
        ast.CallOrCastExpr {
            // Only evaluate as float if casting to a float type (f64, f32)
            if expr.lhs is ast.Ident && (expr.lhs.name == 'f64' || expr.lhs.name == 'f32') {
                return b.try_eval_computed_float(expr.expr)
            }
            return none
        }
        else {
            return none
        }
    }
}

fn parse_const_uint_literal(lit string) u64 {
    if lit.len == 0 {
        return 0
    }
    mut idx := 0
    if lit[idx] == `+` || lit[idx] == `-` {
        idx++
    }
    mut base := u64(10)
    if idx + 1 < lit.len && lit[idx] == `0` {
        match lit[idx + 1] {
            `x`, `X` {
                base = 16
                idx += 2
            }
            `o`, `O` {
                base = 8
                idx += 2
            }
            `b`, `B` {
                base = 2
                idx += 2
            }
            else {}
        }
    }
    mut val := u64(0)
    for idx < lit.len {
        ch := lit[idx]
        if ch == `_` {
            idx++
            continue
        }
        digit := match true {
            ch >= `0` && ch <= `9` { u64(ch - `0`) }
            base == 16 && ch >= `a` && ch <= `f` { u64(ch - `a` + 10) }
            base == 16 && ch >= `A` && ch <= `F` { u64(ch - `A` + 10) }
            else { break }
        }

        if digit >= base {
            break
        }
        val = val * base + digit
        idx++
    }
    return val
}

fn parse_const_int_literal(lit string) i64 {
    if lit.len == 0 {
        return 0
    }
    neg := lit[0] == `-`
    val := parse_const_uint_literal(lit)
    if neg {
        // Keep the conversion in unsigned space so `-9223372036854775808` stays intact
        // even in self-hosted ARM64 builds where string.i64()/u64() are unreliable.
        return i64(u64(0) - val)
    }
    return i64(val)
}

fn (mut b Builder) try_eval_const_int(expr ast.Expr) i64 {
    match expr {
        ast.BasicLiteral {
            if expr.kind == .number {
                // Handle float notation (e.g., 1e10, 1.5e3) cast to integer
                // But skip hex values like 0x01e8480000000000 where 'e' is a hex digit
                if !expr.value.starts_with('0x') && !expr.value.starts_with('0X')
                    && (expr.value.contains('e') || expr.value.contains('E')
                    || expr.value.contains('.')) {
                    return i64(expr.value.f64())
                }
                return parse_const_int_literal(expr.value)
            }
            if expr.kind == .key_true {
                return 1
            }
            if expr.kind == .key_false {
                return 0
            }
            if expr.kind == .char {
                return b.resolve_char_const_value(expr.value)
            }
        }
        ast.InfixExpr {
            lhs := b.try_eval_const_int(expr.lhs)
            rhs := b.try_eval_const_int(expr.rhs)
            result2 := match expr.op {
                .plus {
                    lhs + rhs
                }
                .minus {
                    lhs - rhs
                }
                .mul {
                    lhs * rhs
                }
                .div {
                    if rhs != 0 { lhs / rhs } else { i64(0) }
                }
                .mod {
                    if rhs != 0 { lhs % rhs } else { i64(0) }
                }
                .left_shift {
                    i64(u64(lhs) << u64(rhs))
                }
                .right_shift {
                    i64(u64(lhs) >> u64(rhs))
                }
                .amp {
                    lhs & rhs
                }
                .pipe {
                    lhs | rhs
                }
                .xor {
                    lhs ^ rhs
                }
                else {
                    i64(0)
                }
            }

            return result2
        }
        ast.PrefixExpr {
            val := b.try_eval_const_int(expr.expr)
            return match expr.op {
                .minus { -val }
                .bit_not { ~val }
                else { 0 }
            }
        }
        ast.Ident {
            // Try to resolve reference to another constant
            if expr.name in b.const_values {
                return b.const_values[expr.name]
            }
            qualified := '${b.cur_module}__${expr.name}'
            if qualified in b.const_values {
                return b.const_values[qualified]
            }
            builtin_qual := 'builtin__${expr.name}'
            if builtin_qual in b.const_values {
                return b.const_values[builtin_qual]
            }
        }
        ast.CastExpr {
            return b.try_eval_const_int(expr.expr)
        }
        ast.CallOrCastExpr {
            // V2 parser produces CallOrCastExpr for type casts like u32(52), u64(0xF)
            return b.try_eval_const_int(expr.expr)
        }
        ast.ParenExpr {
            return b.try_eval_const_int(expr.expr)
        }
        ast.InitExpr {
            // Handle sum type init: InitExpr{_tag: N, _data: ...}
            // Extract the _tag value so struct constants get correct tag in data section
            for field in expr.fields {
                if field.name == '_tag' {
                    return b.try_eval_const_int(field.value)
                }
            }
        }
        else {}
    }

    return 0
}

fn (b &Builder) is_zero_literal(expr ast.Expr) bool {
    if expr is ast.BasicLiteral {
        return expr.kind == .number && expr.value == '0'
    }
    return false
}

// resolve_char_const_value is like resolve_char_value but returns i64 for use in try_eval_const_int.
fn (b &Builder) resolve_char_const_value(val string) i64 {
    return i64(b.resolve_char_value(val))
}

// resolve_char_value converts a V character literal value to its numeric byte value.
// Handles escape sequences like \n, \t, \r, \\, \', \0, and raw characters.
fn (b &Builder) resolve_char_value(val string) int {
    mut s := val
    // Strip surrounding quotes if present
    if s.len >= 2 && s[0] == `\`` && s[s.len - 1] == `\`` {
        s = s[1..s.len - 1]
    }
    if s.len >= 2 && ((s[0] == `'` && s[s.len - 1] == `'`) || (s[0] == `"` && s[s.len - 1] == `"`)) {
        s = s[1..s.len - 1]
    }
    if s.len == 0 {
        return 0
    }
    // Handle escape sequences
    if s.len >= 2 && s[0] == `\\` {
        return match s[1] {
            `n` { 10 }
            `t` { 9 }
            `r` { 13 }
            `\\` { 92 }
            `'` { 39 }
            `"` { 34 }
            `0` { 0 }
            `a` { 7 }
            `b` { 8 }
            `f` { 12 }
            `v` { 11 }
            `e` { 27 }
            else { int(s[1]) }
        }
    }
    // Multi-byte UTF-8 character → decode to Unicode code point
    if s.len >= 2 && s[0] >= 0xC0 {
        return utf8_to_codepoint(s)
    }
    // Single ASCII character
    return int(s[0])
}

// utf8_to_codepoint decodes the first UTF-8 character in s to its Unicode code point.
fn utf8_to_codepoint(s string) int {
    if s.len == 0 {
        return 0
    }
    b0 := s[0]
    if b0 < 0x80 {
        return int(b0)
    }
    if b0 < 0xE0 && s.len >= 2 {
        return int(u32(b0 & 0x1F) << 6 | u32(s[1] & 0x3F))
    }
    if b0 < 0xF0 && s.len >= 3 {
        return int(u32(b0 & 0x0F) << 12 | u32(s[1] & 0x3F) << 6 | u32(s[2] & 0x3F))
    }
    if s.len >= 4 {
        return int(u32(b0 & 0x07) << 18 | u32(s[1] & 0x3F) << 12 | u32(s[2] & 0x3F) << 6 | u32(s[3] & 0x3F))
    }
    return int(b0)
}

// try_eval_const_string attempts to extract a string value from a constant expression.
// Returns empty string if the expression is not a string literal.
fn (b &Builder) try_eval_const_string(expr ast.Expr) string {
    match expr {
        ast.StringLiteral {
            mut val := expr.value
            // Strip surrounding quotes if present
            if val.len >= 2 && ((val[0] == `'` && val[val.len - 1] == `'`)
                || (val[0] == `"` && val[val.len - 1] == `"`)) {
                val = val[1..val.len - 1]
            }
            return val
        }
        ast.BasicLiteral {
            if expr.kind == .string {
                mut val := expr.value
                if val.len >= 2 && ((val[0] == `'` && val[val.len - 1] == `'`)
                    || (val[0] == `"` && val[val.len - 1] == `"`)) {
                    val = val[1..val.len - 1]
                }
                return val
            }
        }
        else {}
    }

    return ''
}

fn (mut b Builder) ast_type_to_ssa(typ ast.Expr) TypeID {
    match typ {
        ast.Ident {
            return b.ident_type_to_ssa(typ.name)
        }
        ast.Type {
            return b.ast_type_node_to_ssa(typ)
        }
        ast.PrefixExpr {
            if typ.op == .amp {
                base := b.ast_type_to_ssa(typ.expr)
                return b.mod.type_store.get_ptr(base)
            }
            if typ.op == .ellipsis {
                // Variadic params (...T) are lowered to []T (dynamic array)
                return b.get_array_type()
            }
            return b.mod.type_store.get_int(64)
        }
        ast.ModifierExpr {
            // mut/shared receivers: unwrap the modifier, the pointer is added by the caller
            return b.ast_type_to_ssa(typ.expr)
        }
        ast.SelectorExpr {
            // module.Type — e.g., C.dirent, os.Stat
            if typ.lhs is ast.Ident {
                mod_name := typ.lhs.name
                full_name := '${mod_name}.${typ.rhs.name}'
                // Try C.StructName → look up as module__C.StructName
                qualified := '${b.cur_module}__${full_name}'
                if qualified in b.struct_types {
                    return b.struct_types[qualified]
                }
                // Also try just the full name (e.g., C.dirent)
                if full_name in b.struct_types {
                    return b.struct_types[full_name]
                }
                // Try module__StructName (for module.Type references like os.Stat)
                mod_qualified := '${mod_name}__${typ.rhs.name}'
                if mod_qualified in b.struct_types {
                    return b.struct_types[mod_qualified]
                }
                // For C.X types: C structs are registered under their declaring module
                // (e.g., C.dirent in os module → "os__dirent")
                // Try cur_module__StructName
                if mod_name == 'C' {
                    cur_qualified := '${b.cur_module}__${typ.rhs.name}'
                    if cur_qualified in b.struct_types {
                        return b.struct_types[cur_qualified]
                    }
                    // Search all modules for this C struct
                    for sname, sid in b.struct_types {
                        if sname.ends_with('__${typ.rhs.name}') {
                            return sid
                        }
                    }
                }
                // Try looking up in the referenced module's scope via type environment
                // (e.g., token.Token where Token is an enum, not a struct)
                if b.env != unsafe { nil } {
                    mod_name_v := mod_name.replace('.', '_')
                    if scope := b.env.get_scope(mod_name_v) {
                        if obj := scope.lookup_parent(typ.rhs.name, 0) {
                            return b.type_to_ssa(obj.typ())
                        }
                    }
                }
            }
            return b.ident_type_to_ssa(typ.rhs.name)
        }
        ast.EmptyExpr {
            return 0 // void
        }
        ast.Tuple {
            mut elem_types := []TypeID{cap: typ.exprs.len}
            for e in typ.exprs {
                elem_types << b.ast_type_to_ssa(e)
            }
            return b.mod.type_store.get_tuple(elem_types)
        }
        else {
            return b.mod.type_store.get_int(64)
        }
    }
}

fn (mut b Builder) ast_type_node_to_ssa(typ ast.Type) TypeID {
    match typ {
        ast.ArrayType {
            return b.get_array_type()
        }
        ast.ArrayFixedType {
            // [N]T → SSA array type with N elements of T
            elem_type := b.ast_type_to_ssa(typ.elem_type)
            arr_len := if typ.len is ast.BasicLiteral {
                int(parse_const_int_literal(typ.len.value))
            } else if typ.len is ast.Ident {
                b.resolve_const_int(typ.len.name)
            } else {
                0
            }
            if arr_len > 0 {
                return b.mod.type_store.get_array(elem_type, arr_len)
            }
            return b.mod.type_store.get_int(64) // fallback
        }
        ast.MapType {
            return b.struct_types['map'] or { b.mod.type_store.get_int(64) }
        }
        ast.FnType {
            i8_t := b.mod.type_store.get_int(8)
            return b.mod.type_store.get_ptr(i8_t) // fn pointers
        }
        ast.OptionType {
            return b.get_option_wrapper_type(b.ast_type_to_ssa(typ.base_type))
        }
        ast.ResultType {
            return b.get_result_wrapper_type(b.ast_type_to_ssa(typ.base_type))
        }
        ast.PointerType {
            base := b.ast_type_to_ssa(typ.base_type)
            return b.mod.type_store.get_ptr(base)
        }
        ast.TupleType {
            mut elem_types := []TypeID{cap: typ.types.len}
            for t in typ.types {
                elem_types << b.ast_type_to_ssa(t)
            }
            return b.mod.type_store.get_tuple(elem_types)
        }
        else {
            return b.mod.type_store.get_int(64)
        }
    }
}

fn (mut b Builder) ident_type_to_ssa(name string) TypeID {
    return match name {
        'int' {
            b.mod.type_store.get_int(32)
        }
        'i8' {
            b.mod.type_store.get_int(8)
        }
        'i16' {
            b.mod.type_store.get_int(16)
        }
        'i32' {
            b.mod.type_store.get_int(32)
        }
        'i64' {
            b.mod.type_store.get_int(64)
        }
        'u8', 'byte' {
            b.mod.type_store.get_uint(8)
        }
        'u16' {
            b.mod.type_store.get_uint(16)
        }
        'u32' {
            b.mod.type_store.get_uint(32)
        }
        'u64' {
            b.mod.type_store.get_uint(64)
        }
        'f32' {
            b.mod.type_store.get_float(32)
        }
        'f64' {
            b.mod.type_store.get_float(64)
        }
        'bool' {
            b.mod.type_store.get_int(1)
        }
        'string' {
            b.get_string_type()
        }
        'voidptr' {
            i8_t := b.mod.type_store.get_int(8)
            b.mod.type_store.get_ptr(i8_t)
        }
        'rune' {
            b.mod.type_store.get_int(32)
        }
        'char' {
            b.mod.type_store.get_int(8)
        }
        else {
            // Pointer types must be checked FIRST: `Array_int*` in a CastExpr means
            // "pointer to array struct" (used by sumtype smartcast data access),
            // NOT "array of &int". The non-pointer `Array_int` (without `*`) is the
            // array struct itself.
            if name.ends_with('*') {
                // Check for pointer types (e.g., 'StructType*', 'int*', 'Array_int*')
                base_name := name[..name.len - 1]
                base_type := b.ident_type_to_ssa(base_name)
                return b.mod.type_store.get_ptr(base_type)
            } else if name.starts_with('Array_fixed_') {
                b.fixed_array_type_from_name(name)
            } else if name.starts_with('Array_') {
                // Array_* are transformer-generated mangled names for []T.
                // They always represent the builtin array struct.
                b.get_array_type()
            } else if name.starts_with('Map_') {
                b.struct_types['map'] or { b.mod.type_store.get_int(64) }
            } else if name in b.struct_types {
                // Check struct types
                b.struct_types[name]
            } else if name == 'strings__Builder' {
                // strings.Builder = []u8 = array (type alias)
                b.get_array_type()
            } else if name == 'Builder' {
                // Builder could be strings.Builder alias or an actual struct
                // Try module-qualified first, fall back to array alias
                qualified_b := '${b.cur_module}__Builder'
                if qualified_b in b.struct_types {
                    b.struct_types[qualified_b]
                } else {
                    b.get_array_type()
                }
            } else {
                // Try module-qualified
                qualified := '${b.cur_module}__${name}'
                if qualified in b.struct_types {
                    b.struct_types[qualified]
                } else if b.is_enum_type(name) || b.is_enum_type(qualified) {
                    // Enum types are always int (i32) in V
                    b.mod.type_store.get_int(32)
                } else if b.env != unsafe { nil } {
                    // Use the type checker environment to resolve aliases and other types.
                    // First try the current module scope, then try the module prefix in the name
                    // (e.g., 'ssa__BlockID' → look up 'BlockID' in 'ssa' module).
                    mut resolved := false
                    mut resolved_type := TypeID(0)
                    if scope := b.env.get_scope(b.cur_module) {
                        if obj := scope.lookup_parent(name, 0) {
                            resolved_type = b.type_to_ssa(obj.typ())
                            resolved = true
                        }
                    }
                    if !resolved && name.contains('__') {
                        // Try module-prefixed name: 'ssa__BlockID' → module='ssa', type='BlockID'
                        parts := name.split('__')
                        if parts.len >= 2 {
                            mod_name := parts[0]
                            type_name := parts[1..].join('__')
                            if mod_scope := b.env.get_scope(mod_name) {
                                if obj := mod_scope.lookup_parent(type_name, 0) {
                                    resolved_type = b.type_to_ssa(obj.typ())
                                    resolved = true
                                }
                            }
                        }
                    }
                    if resolved && resolved_type != 0 {
                        resolved_type
                    } else {
                        b.mod.type_store.get_int(64)
                    }
                } else {
                    b.mod.type_store.get_int(64)
                }
            }
        }
    }
}

fn (mut b Builder) fixed_array_type_from_name(name string) TypeID {
    if !name.starts_with('Array_fixed_') {
        return b.mod.type_store.get_int(64)
    }
    payload := name['Array_fixed_'.len..]
    len_str := payload.all_after_last('_')
    arr_len := len_str.int()
    if arr_len <= 0 {
        return b.mod.type_store.get_int(64)
    }
    elem_name := payload.all_before_last('_')
    elem_type := b.ident_type_to_ssa(elem_name)
    if elem_type == 0 {
        return b.mod.type_store.get_int(64)
    }
    return b.mod.type_store.get_array(elem_type, arr_len)
}

// --- Phase 2: Register function signatures ---

fn (mut b Builder) register_fn_signatures(file ast.File) {
    for stmt in file.stmts {
        if stmt is ast.FnDecl {
            if stmt.typ.generic_params.len > 0 {
                continue
            }
            b.register_fn_sig(stmt)
        }
    }
}

fn (mut b Builder) register_fn_sig(decl ast.FnDecl) {
    fn_name := b.mangle_fn_name(decl)
    if fn_name in b.fn_index {
        return
    }

    ret_type := b.ast_type_to_ssa(decl.typ.return_type)
    idx := b.mod.new_function(fn_name, ret_type, []TypeID{})
    b.fn_index[fn_name] = idx
    if decl.language == .c {
        b.mod.func_set_c_extern(idx, true)
    }

    // Register parameter types for correct forward declarations.
    // For methods, add receiver as the first parameter.
    // Skip for static methods (is_static=true) — they have no receiver in the call.
    if decl.is_method && !decl.is_static {
        recv_type := b.ast_type_to_ssa(decl.receiver.typ)
        // For &Type (PrefixExpr), ast_type_to_ssa already returns ptr(Type).
        // For mut receivers, the parser sets is_mut on the Parameter (not ModifierExpr),
        // so we need to add the pointer level.
        actual_type := if decl.receiver.is_mut {
            b.mod.type_store.get_ptr(recv_type)
        } else {
            recv_type
        }
        receiver_name := if decl.receiver.name != '' {
            decl.receiver.name
        } else {
            'self'
        }
        param_val := b.mod.add_value_node(.argument, actual_type, receiver_name, 0)
        b.mod.func_add_param(idx, param_val)
    }
    for param in decl.typ.params {
        param_type := b.ast_type_to_ssa(param.typ)
        // For `mut` params, add a pointer level for pass-by-reference semantics,
        // but NOT if the type is already a pointer (e.g., `mut buf &u8` → param is already ptr(i8)).
        // In C, `mut buf &u8` is just `u8* buf`, not `u8** buf`.
        actual_type := if param.is_mut && !(param_type < b.mod.type_store.types.len
            && b.mod.type_store.types[param_type].kind == .ptr_t) {
            b.mod.type_store.get_ptr(param_type)
        } else {
            param_type
        }
        param_val := b.mod.add_value_node(.argument, actual_type, param.name, 0)
        b.mod.func_add_param(idx, param_val)
    }
}

fn (mut b Builder) mangle_fn_name(decl ast.FnDecl) string {
    if decl.is_method {
        receiver_name := b.receiver_type_name(decl.receiver.typ)
        return '${receiver_name}__${decl.name}'
    }
    // C functions use their bare name (no module prefix)
    if decl.language == .c {
        return decl.name
    }
    if decl.name == 'main' {
        return 'main'
    }
    if b.cur_module != '' && b.cur_module != 'main' {
        // Don't add module prefix if name already starts with it (e.g., generated
        // enum str functions placed back in their source module).
        if decl.name.starts_with('${b.cur_module}__') {
            return decl.name
        }
        return '${b.cur_module}__${decl.name}'
    }
    return decl.name
}

fn (mut b Builder) receiver_type_name(typ ast.Expr) string {
    match typ {
        ast.Ident {
            if b.cur_module != '' && b.cur_module != 'main' {
                return '${b.cur_module}__${typ.name}'
            }
            return typ.name
        }
        ast.PrefixExpr {
            return b.receiver_type_name(typ.expr)
        }
        ast.ModifierExpr {
            return b.receiver_type_name(typ.expr)
        }
        ast.SelectorExpr {
            return '${typ.lhs.name()}__${typ.rhs.name}'
        }
        ast.Type {
            // Handle type expressions used as receivers (e.g., []rune for (ra []rune) string())
            inner := ast.Type(typ)
            if inner is ast.PointerType {
                return b.receiver_type_name(inner.base_type)
            }
            if inner is ast.ArrayType {
                // []rune → Array_rune, []int → Array_int, etc.
                elem_name := if inner.elem_type is ast.Ident {
                    inner.elem_type.name
                } else {
                    b.receiver_type_name(inner.elem_type)
                }
                prefix := if b.cur_module != '' && b.cur_module != 'main' {
                    '${b.cur_module}__'
                } else {
                    ''
                }
                return '${prefix}Array_${elem_name}'
            }
            return 'unknown'
        }
        else {
            return 'unknown'
        }
    }
}

// --- Phase 3: Build function bodies ---

pub fn (mut b Builder) build_fn_bodies(file ast.File) {
    nstmts := file.stmts.len
    for si in 0 .. nstmts {
        if file.stmts[si] is ast.FnDecl {
            decl := file.stmts[si] as ast.FnDecl
            if decl.language == .c && decl.stmts.len == 0 {
                continue
            }
            if decl.typ.generic_params.len > 0 {
                continue
            }
            // In hot_fn mode, only build the target function
            if b.hot_fn.len > 0 {
                mangled := b.mangle_fn_name(decl)
                if mangled != b.hot_fn {
                    continue
                }
            }
            // Dead code elimination: skip functions not reachable from main
            if !b.should_build_fn(file.name, decl) {
                continue
            }
            b.build_fn(decl)
        }
    }
}

// should_build_fn returns true if the function should be compiled.
// When used_fn_keys is populated (markused ran), only reachable functions are built.
pub fn (mut b Builder) should_build_fn(file_name string, decl ast.FnDecl) bool {
    // Skip entire modules for unused backends (e.g., cleanc/eval/x64 when building arm64-only)
    if b.skip_modules.len > 0 && b.cur_module in b.skip_modules {
        return false
    }
    if b.used_fn_keys.len == 0 {
        return true // No markused data — build everything
    }
    // Always build init_consts, init, deinit, main
    if decl.name.starts_with('__v_init_consts_') {
        return true
    }
    if decl.name == 'init' || decl.name == 'deinit' {
        return true
    }
    if decl.name == 'main' {
        return true
    }
    // Always build functions from core modules that the runtime needs
    if b.cur_module in ['builtin', 'strings', 'strconv', 'bits', 'sha256', 'binary'] {
        return true
    }
    // Always build .vh header declarations
    if file_name.ends_with('.vh') {
        return true
    }
    // Keep transformer-generated array/map method specializations
    if decl.is_method {
        mangled := b.mangle_fn_name(decl)
        if mangled.contains('__Array_') || mangled.contains('__Map_') {
            return true
        }
    }
    // Check markused reachability
    key := markused.decl_key(b.cur_module, decl, b.env)
    return key in b.used_fn_keys
}

pub fn (mut b Builder) build_fn(decl ast.FnDecl) {
    fn_name := b.mangle_fn_name(decl)
    // Skip C-language extern functions without bodies
    if decl.language == .c {
        return
    }
    func_idx := b.fn_index[fn_name] or { return }
    // Skip if already built (can happen with .c.v and .v files).
    // Exception: user-defined methods always override auto-generated non-method functions
    // (e.g., custom Token.str() overrides auto-generated token__Token__str enum str).
    if b.mod.funcs[func_idx].blocks.len > 0 {
        if decl.is_method && decl.stmts.len > 0 {
            // Method with a body overrides previously-built auto-generated function.
            // Clear blocks so we can rebuild with the real method body.
            b.mod.func_clear_blocks(func_idx)
        } else {
            return
        }
    }

    // Skip functions without a body (e.g., extern declarations).
    // Build function bodies for ALL modules so cross-module calls work at runtime.
    if decl.stmts.len == 0 {
        // Emit a minimal function body (entry + ret) so backends have a valid function
        b.cur_func = func_idx
        entry := b.mod.add_block(func_idx, 'entry')
        b.cur_block = entry
        ret_type := b.mod.funcs[func_idx].typ
        if ret_type != 0 {
            ret_type_info := b.mod.type_store.types[ret_type]
            if ret_type_info.kind == .struct_t {
                // For struct return types, alloca + zero init + load
                ptr_type := b.mod.type_store.get_ptr(ret_type)
                alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
                ret_val := b.mod.add_instr(.load, b.cur_block, ret_type, [alloca])
                b.mod.add_instr(.ret, b.cur_block, 0, [ret_val])
            } else {
                zero := b.mod.get_or_add_const(ret_type, '0')
                b.mod.add_instr(.ret, b.cur_block, 0, [zero])
            }
        } else {
            b.mod.add_instr(.ret, b.cur_block, 0, []ValueID{})
        }
        return
    }

    b.cur_func = func_idx

    // Reset local variables
    b.vars = map[string]ValueID{}
    b.mut_ptr_params = map[string]bool{}
    b.label_blocks = map[string]BlockID{}
    b.array_elem_types = map[string]TypeID{}

    // Clear params (they were registered in register_fn_sig for forward decls,
    // but we need to re-create them here with proper alloca bindings)
    b.mod.func_set_params(func_idx, []ValueID{})

    // Create entry block
    entry := b.mod.add_block(func_idx, 'entry')
    b.cur_block = entry

    // Add parameters
    // Skip receiver for static methods (is_static=true) — no receiver in call
    if decl.is_method && !decl.is_static {
        // Receiver is the first parameter
        receiver_name := if decl.receiver.name != '' {
            decl.receiver.name
        } else {
            'self'
        }
        recv_type := b.ast_type_to_ssa(decl.receiver.typ)
        // For &Type (PrefixExpr), ast_type_to_ssa already returns ptr(Type).
        // For mut receivers, the parser sets is_mut on the Parameter (not ModifierExpr),
        // so we need to add the pointer level.
        actual_type := if decl.receiver.is_mut {
            b.mod.type_store.get_ptr(recv_type)
        } else {
            recv_type
        }
        param_val := b.mod.add_value_node(.argument, actual_type, receiver_name, 0)
        b.mod.func_add_param(func_idx, param_val)
        // Alloca + store for receiver
        alloca := b.mod.add_instr(.alloca, entry, b.mod.type_store.get_ptr(actual_type),
            []ValueID{})
        b.mod.add_instr(.store, entry, 0, [param_val, alloca])
        b.vars[receiver_name] = alloca
    }

    for param in decl.typ.params {
        param_type := b.ast_type_to_ssa(param.typ)
        // For `mut` params, add pointer level only if the type isn't already a pointer.
        // `mut buf &u8` → param_type is ptr(i8), no extra level needed (like C: u8* buf).
        // `mut val int` → param_type is i32, needs ptr(i32) for pass-by-reference.
        is_already_ptr := param_type < b.mod.type_store.types.len
            && b.mod.type_store.types[param_type].kind == .ptr_t
        actual_type := if param.is_mut && !is_already_ptr {
            b.mod.type_store.get_ptr(param_type)
        } else {
            param_type
        }
        param_val := b.mod.add_value_node(.argument, actual_type, param.name, 0)
        b.mod.func_add_param(func_idx, param_val)
        // Alloca + store
        alloca := b.mod.add_instr(.alloca, entry, b.mod.type_store.get_ptr(actual_type),
            []ValueID{})
        b.mod.add_instr(.store, entry, 0, [param_val, alloca])
        b.vars[param.name] = alloca

        // Track array element types for transformer-generated functions (no checker info).
        // E.g., param 'a' with type 'Array_int' → element type is 'int' → i32.
        if param.typ is ast.Ident {
            param_type_name := param.typ.name
            if param_type_name.starts_with('Array_') {
                elem_name := param_type_name['Array_'.len..]
                elem_ssa := b.ident_type_to_ssa(elem_name)
                if elem_ssa != 0 {
                    b.array_elem_types[param.name] = elem_ssa
                }
            }
        }
    }

    // Build body
    b.build_stmts(decl.stmts)

    // If no terminator, add implicit return
    if !b.block_has_terminator(b.cur_block) {
        if fn_name == 'main' {
            zero := b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
            b.mod.add_instr(.ret, b.cur_block, 0, [zero])
        } else {
            b.mod.add_instr(.ret, b.cur_block, 0, []ValueID{})
        }
    }
}

fn (mut b Builder) is_mut_receiver(typ ast.Expr) bool {
    if typ is ast.ModifierExpr {
        return typ.kind == .key_mut || typ.kind == .key_shared
    }
    if typ is ast.PrefixExpr {
        return typ.op == .amp
    }
    return false
}

fn (mut b Builder) block_has_terminator(block BlockID) bool {
    instrs := b.mod.blocks[block].instrs
    if instrs.len == 0 {
        return false
    }
    last := instrs[instrs.len - 1]
    last_instr := b.mod.instrs[b.mod.values[last].index]
    return last_instr.op in [.ret, .br, .jmp, .unreachable]
}

// --- Statement building ---

fn (mut b Builder) build_stmts(stmts []ast.Stmt) {
    for stmt in stmts {
        b.build_stmt(stmt)
    }
}

fn (mut b Builder) build_stmt(stmt ast.Stmt) {
    match stmt {
        ast.AssignStmt {
            b.build_assign(stmt)
        }
        ast.ExprStmt {
            b.build_expr_stmt(stmt)
        }
        ast.ReturnStmt {
            b.build_return(stmt)
        }
        ast.ForStmt {
            b.build_for(stmt)
        }
        ast.FlowControlStmt {
            b.build_flow_control(stmt)
        }
        ast.BlockStmt {
            b.build_stmts(stmt.stmts)
        }
        ast.LabelStmt {
            b.build_label(stmt)
        }
        ast.ModuleStmt {
            b.cur_module = stmt.name.replace('.', '_')
        }
        ast.ImportStmt {}
        ast.ConstDecl {}
        ast.StructDecl {}
        ast.EnumDecl {}
        ast.TypeDecl {}
        ast.InterfaceDecl {}
        ast.GlobalDecl {}
        ast.FnDecl {} // nested fn decls handled separately
        ast.Directive {}
        ast.ComptimeStmt {}
        ast.DeferStmt {}
        ast.AssertStmt {
            b.build_assert(stmt)
        }
        []ast.Attribute {}
        ast.EmptyStmt {}
        ast.AsmStmt {}
        ast.ForInStmt {
            panic('SSA builder: ForInStmt should have been lowered by transformer')
        }
    }
}

fn (mut b Builder) build_expr_stmt(stmt ast.ExprStmt) {
    if stmt.expr is ast.UnsafeExpr {
        for s in stmt.expr.stmts {
            b.build_stmt(s)
        }
        return
    }
    if stmt.expr is ast.IfExpr {
        b.build_if_stmt(stmt.expr)
        return
    }
    b.build_expr(stmt.expr)
}

fn (mut b Builder) unwrap_ident(expr ast.Expr) ?ast.Ident {
    if expr is ast.Ident {
        return expr
    }
    if expr is ast.ModifierExpr {
        return b.unwrap_ident(expr.expr)
    }
    return none
}

fn (mut b Builder) build_assign(stmt ast.AssignStmt) {
    // Multi-return decomposition: when LHS has more vars than RHS,
    // the single RHS is a function call returning a tuple.
    if stmt.lhs.len > 1 && stmt.rhs.len == 1 {
        mut rhs_val := b.build_expr(stmt.rhs[0])
        mut rhs_typ_id := b.mod.values[rhs_val].typ
        mut rhs_typ := b.mod.type_store.types[rhs_typ_id]
        // If RHS is an Option/Result wrapper, unwrap the data field first.
        // The transformer strips the ? postfix in tuple destructuring, leaving
        // the raw wrapper struct. Extract .data (field 2) to get the inner tuple.
        if b.is_option_wrapper_type(rhs_typ_id) || b.is_result_wrapper_type(rhs_typ_id) {
            if b.wrapper_has_data(rhs_typ_id) && rhs_typ.kind == .struct_t
                && rhs_typ.fields.len >= 3 {
                data_type := rhs_typ.fields[2]
                data_idx := b.mod.get_or_add_const(b.mod.type_store.get_int(32), '2')
                rhs_val = b.mod.add_instr(.extractvalue, b.cur_block, data_type, [
                    rhs_val,
                    data_idx,
                ])
                rhs_typ_id = data_type
                rhs_typ = b.mod.type_store.types[rhs_typ_id]
            }
        }
        for i, lhs in stmt.lhs {
            // Extract each element from the tuple
            mut elem_val := rhs_val
            if rhs_typ.kind == .struct_t && i < rhs_typ.fields.len {
                elem_type := rhs_typ.fields[i]
                idx_val := b.mod.get_or_add_const(b.mod.type_store.get_int(32), i.str())
                elem_val = b.mod.add_instr(.extractvalue, b.cur_block, elem_type, [
                    rhs_val,
                    idx_val,
                ])
            }
            if ident := b.unwrap_ident(lhs) {
                if stmt.op == .decl_assign {
                    elem_type := b.mod.values[elem_val].typ
                    alloca := b.mod.add_instr(.alloca, b.cur_block,
                        b.mod.type_store.get_ptr(elem_type), []ValueID{})
                    b.mod.add_instr(.store, b.cur_block, 0, [elem_val, alloca])
                    b.vars[ident.name] = alloca
                } else if ident.name == '_' {
                    continue
                } else {
                    mut ptr := ValueID(0)
                    if p := b.vars[ident.name] {
                        ptr = p
                    } else if glob_id := b.find_global(ident.name) {
                        ptr = glob_id
                    } else if glob_id := b.find_global('${b.cur_module}__${ident.name}') {
                        ptr = glob_id
                    } else if glob_id := b.find_global('builtin__${ident.name}') {
                        ptr = glob_id
                    }
                    if ptr != 0 {
                        b.mod.add_instr(.store, b.cur_block, 0, [elem_val, ptr])
                    }
                }
            }
        }
        return
    }
    // For multi-assign with plain assignment (a, b = b, a), evaluate all RHS
    // values before any stores to avoid aliasing issues.
    if stmt.lhs.len > 1 && stmt.rhs.len > 1 && stmt.op == .assign {
        mut rhs_vals := []ValueID{cap: stmt.rhs.len}
        for rhs_expr in stmt.rhs {
            rhs_vals << b.build_expr(rhs_expr)
        }
        for i, lhs in stmt.lhs {
            if i >= rhs_vals.len {
                break
            }
            rhs_val := rhs_vals[i]
            if ident := b.unwrap_ident(lhs) {
                if ident.name == '_' {
                    continue
                }
                mut ptr := ValueID(0)
                if p := b.vars[ident.name] {
                    ptr = p
                } else if glob_id := b.find_global(ident.name) {
                    ptr = glob_id
                } else if glob_id := b.find_global('${b.cur_module}__${ident.name}') {
                    ptr = glob_id
                } else if glob_id := b.find_global('builtin__${ident.name}') {
                    ptr = glob_id
                }
                if ptr != 0 {
                    b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, ptr])
                }
            } else if lhs is ast.SelectorExpr {
                base := b.build_addr(lhs)
                if base != 0 {
                    b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, base])
                }
            } else if lhs is ast.IndexExpr {
                base := b.build_addr(lhs)
                if base != 0 {
                    b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, base])
                }
            }
        }
        return
    }
    for i, lhs in stmt.lhs {
        if i >= stmt.rhs.len {
            break
        }
        rhs := stmt.rhs[i]
        rhs_val := b.build_expr(rhs)

        if ident := b.unwrap_ident(lhs) {
            if stmt.op == .decl_assign {
                // New variable declaration - use the actual type of the built RHS value
                rhs_type := b.mod.values[rhs_val].typ
                alloca := b.mod.add_instr(.alloca, b.cur_block, b.mod.type_store.get_ptr(rhs_type),
                    []ValueID{})
                b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, alloca])
                b.vars[ident.name] = alloca
            } else if ident.name == '_' && stmt.op == .assign {
                // Discard for plain assignment only; compound assignments (+=, etc.)
                // must still execute (e.g. for loop counter `_ += 1`).
                continue
            } else {
                // Assignment to existing variable (local or global)
                // Skip stores to const_array_globals — they are already initialized
                // in the data segment. The runtime const init function would overwrite
                // the first element with a stack pointer.
                // Only skip if RHS is an ArrayInitExpr (fixed array runtime init).
                // Do NOT skip if RHS is a function call (e.g. new_array_from_c_array
                // for dynamic arrays — those need their _vinit assignment).
                if rhs is ast.ArrayInitExpr {
                    if ident.name in b.const_array_globals
                        || '${b.cur_module}__${ident.name}' in b.const_array_globals
                        || 'builtin__${ident.name}' in b.const_array_globals {
                        continue
                    }
                }
                mut ptr := ValueID(0)
                if p := b.vars[ident.name] {
                    ptr = p
                } else if glob_id := b.find_global(ident.name) {
                    ptr = glob_id
                } else if glob_id := b.find_global('${b.cur_module}__${ident.name}') {
                    ptr = glob_id
                } else if glob_id := b.find_global('builtin__${ident.name}') {
                    ptr = glob_id
                }
                if ptr != 0 {
                    if stmt.op == .assign {
                        b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, ptr])
                    } else {
                        // Compound assignment (+=, -=, etc.)
                        ptr_typ := b.mod.values[ptr].typ
                        elem_typ := b.mod.type_store.types[ptr_typ].elem_type
                        loaded := b.mod.add_instr(.load, b.cur_block, elem_typ, [ptr])
                        ca_is_float := elem_typ > 0 && int(elem_typ) < b.mod.type_store.types.len
                            && b.mod.type_store.types[elem_typ].kind == .float_t
                        op := if ca_is_float {
                            match stmt.op {
                                .plus_assign { OpCode.fadd }
                                .minus_assign { OpCode.fsub }
                                .mul_assign { OpCode.fmul }
                                .div_assign { OpCode.fdiv }
                                .mod_assign { OpCode.frem }
                                else { OpCode.fadd }
                            }
                        } else {
                            match stmt.op {
                                .plus_assign { OpCode.add }
                                .minus_assign { OpCode.sub }
                                .mul_assign { OpCode.mul }
                                .div_assign { OpCode.sdiv }
                                .mod_assign { OpCode.srem }
                                .left_shift_assign { OpCode.shl }
                                .right_shift_assign { OpCode.ashr }
                                .and_assign { OpCode.and_ }
                                .or_assign { OpCode.or_ }
                                .xor_assign { OpCode.xor }
                                else { OpCode.add }
                            }
                        }
                        // If LHS is float but RHS is int, convert RHS to float
                        mut actual_rhs := rhs_val
                        if ca_is_float {
                            rhs_typ := b.mod.values[rhs_val].typ
                            rhs_is_float := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                                && b.mod.type_store.types[rhs_typ].kind == .float_t
                            if !rhs_is_float {
                                rhs_unsigned := rhs_typ > 0
                                    && int(rhs_typ) < b.mod.type_store.types.len
                                    && b.mod.type_store.types[rhs_typ].is_unsigned
                                conv_op := if rhs_unsigned {
                                    OpCode.uitofp
                                } else {
                                    OpCode.sitofp
                                }
                                actual_rhs = b.mod.add_instr(conv_op, b.cur_block, elem_typ, [
                                    rhs_val,
                                ])
                            }
                        }
                        result := b.mod.add_instr(op, b.cur_block, b.mod.values[loaded].typ, [
                            loaded,
                            actual_rhs,
                        ])
                        b.mod.add_instr(.store, b.cur_block, 0, [result, ptr])
                    }
                }
            }
        } else if lhs is ast.SelectorExpr {
            // Field assignment: obj.field = val or obj.field += val
            base := b.build_addr(lhs)
            if base != 0 {
                if stmt.op == .assign {
                    b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, base])
                } else {
                    // Compound assignment (+=, -=, etc.)
                    ptr_typ := b.mod.values[base].typ
                    elem_typ := if ptr_typ < b.mod.type_store.types.len {
                        b.mod.type_store.types[ptr_typ].elem_type
                    } else {
                        b.mod.values[rhs_val].typ
                    }
                    loaded := b.mod.add_instr(.load, b.cur_block, elem_typ, [base])
                    sf_is_float := elem_typ > 0 && int(elem_typ) < b.mod.type_store.types.len
                        && b.mod.type_store.types[elem_typ].kind == .float_t
                    op := if sf_is_float {
                        match stmt.op {
                            .plus_assign { OpCode.fadd }
                            .minus_assign { OpCode.fsub }
                            .mul_assign { OpCode.fmul }
                            .div_assign { OpCode.fdiv }
                            .mod_assign { OpCode.frem }
                            else { OpCode.fadd }
                        }
                    } else {
                        match stmt.op {
                            .plus_assign { OpCode.add }
                            .minus_assign { OpCode.sub }
                            .mul_assign { OpCode.mul }
                            .div_assign { OpCode.sdiv }
                            .mod_assign { OpCode.srem }
                            .left_shift_assign { OpCode.shl }
                            .right_shift_assign { OpCode.ashr }
                            .and_assign { OpCode.and_ }
                            .or_assign { OpCode.or_ }
                            .xor_assign { OpCode.xor }
                            else { OpCode.add }
                        }
                    }
                    // If LHS is float but RHS is int, convert RHS to float
                    mut actual_rhs := rhs_val
                    if sf_is_float {
                        rhs_typ := b.mod.values[rhs_val].typ
                        rhs_is_float := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                            && b.mod.type_store.types[rhs_typ].kind == .float_t
                        if !rhs_is_float {
                            rhs_unsigned := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                                && b.mod.type_store.types[rhs_typ].is_unsigned
                            conv_op := if rhs_unsigned {
                                OpCode.uitofp
                            } else {
                                OpCode.sitofp
                            }
                            actual_rhs = b.mod.add_instr(conv_op, b.cur_block, elem_typ, [
                                rhs_val,
                            ])
                        }
                    }
                    result := b.mod.add_instr(op, b.cur_block, b.mod.values[loaded].typ, [
                        loaded,
                        actual_rhs,
                    ])
                    b.mod.add_instr(.store, b.cur_block, 0, [result, base])
                }
            }
        } else if lhs is ast.PrefixExpr && lhs.op == .mul {
            // Pointer dereference assignment: *ptr = val
            // Build the inner expression to get the pointer, then store to it
            ptr := b.build_expr(lhs.expr)
            if stmt.op == .assign {
                b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, ptr])
            } else {
                // Compound assignment (*ptr += val)
                ptr_typ := b.mod.values[ptr].typ
                elem_typ := if int(ptr_typ) < b.mod.type_store.types.len {
                    b.mod.type_store.types[ptr_typ].elem_type
                } else {
                    b.mod.values[rhs_val].typ
                }
                loaded := b.mod.add_instr(.load, b.cur_block, elem_typ, [ptr])
                pd_is_float := elem_typ > 0 && int(elem_typ) < b.mod.type_store.types.len
                    && b.mod.type_store.types[elem_typ].kind == .float_t
                op := if pd_is_float {
                    match stmt.op {
                        .plus_assign { OpCode.fadd }
                        .minus_assign { OpCode.fsub }
                        .mul_assign { OpCode.fmul }
                        .div_assign { OpCode.fdiv }
                        else { OpCode.fadd }
                    }
                } else {
                    match stmt.op {
                        .plus_assign { OpCode.add }
                        .minus_assign { OpCode.sub }
                        .mul_assign { OpCode.mul }
                        .div_assign { OpCode.sdiv }
                        else { OpCode.add }
                    }
                }
                // If LHS is float but RHS is int, convert RHS to float
                mut actual_rhs := rhs_val
                if pd_is_float {
                    rhs_typ := b.mod.values[rhs_val].typ
                    rhs_is_float := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                        && b.mod.type_store.types[rhs_typ].kind == .float_t
                    if !rhs_is_float {
                        rhs_unsigned := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                            && b.mod.type_store.types[rhs_typ].is_unsigned
                        conv_op := if rhs_unsigned {
                            OpCode.uitofp
                        } else {
                            OpCode.sitofp
                        }
                        actual_rhs = b.mod.add_instr(conv_op, b.cur_block, elem_typ, [
                            rhs_val,
                        ])
                    }
                }
                result := b.mod.add_instr(op, b.cur_block, b.mod.values[loaded].typ, [
                    loaded,
                    actual_rhs,
                ])
                b.mod.add_instr(.store, b.cur_block, 0, [result, ptr])
            }
        } else if lhs is ast.IndexExpr {
            // Index assignment: arr[i] = val or arr[i] += val
            base := b.build_addr(lhs)
            if base != 0 {
                if stmt.op == .assign {
                    b.mod.add_instr(.store, b.cur_block, 0, [rhs_val, base])
                } else {
                    // Compound assignment (+=, -=, etc.)
                    ptr_typ := b.mod.values[base].typ
                    elem_typ := if ptr_typ < b.mod.type_store.types.len {
                        b.mod.type_store.types[ptr_typ].elem_type
                    } else {
                        b.mod.values[rhs_val].typ
                    }
                    loaded := b.mod.add_instr(.load, b.cur_block, elem_typ, [base])
                    ix_is_float := elem_typ > 0 && int(elem_typ) < b.mod.type_store.types.len
                        && b.mod.type_store.types[elem_typ].kind == .float_t
                    op := if ix_is_float {
                        match stmt.op {
                            .plus_assign { OpCode.fadd }
                            .minus_assign { OpCode.fsub }
                            .mul_assign { OpCode.fmul }
                            .div_assign { OpCode.fdiv }
                            .mod_assign { OpCode.frem }
                            else { OpCode.fadd }
                        }
                    } else {
                        match stmt.op {
                            .plus_assign { OpCode.add }
                            .minus_assign { OpCode.sub }
                            .mul_assign { OpCode.mul }
                            .div_assign { OpCode.sdiv }
                            .mod_assign { OpCode.srem }
                            .left_shift_assign { OpCode.shl }
                            .right_shift_assign { OpCode.ashr }
                            .and_assign { OpCode.and_ }
                            .or_assign { OpCode.or_ }
                            .xor_assign { OpCode.xor }
                            else { OpCode.add }
                        }
                    }
                    // If LHS is float but RHS is int, convert RHS to float
                    mut actual_rhs := rhs_val
                    if ix_is_float {
                        rhs_typ := b.mod.values[rhs_val].typ
                        rhs_is_float := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                            && b.mod.type_store.types[rhs_typ].kind == .float_t
                        if !rhs_is_float {
                            rhs_unsigned := rhs_typ > 0 && int(rhs_typ) < b.mod.type_store.types.len
                                && b.mod.type_store.types[rhs_typ].is_unsigned
                            conv_op := if rhs_unsigned {
                                OpCode.uitofp
                            } else {
                                OpCode.sitofp
                            }
                            actual_rhs = b.mod.add_instr(conv_op, b.cur_block, elem_typ, [
                                rhs_val,
                            ])
                        }
                    }
                    result := b.mod.add_instr(op, b.cur_block, b.mod.values[loaded].typ, [
                        loaded,
                        actual_rhs,
                    ])
                    b.mod.add_instr(.store, b.cur_block, 0, [result, base])
                }
            }
        }
    }
}

fn (mut b Builder) build_return(stmt ast.ReturnStmt) {
    fn_ret_type := if b.cur_func >= 0 && b.cur_func < b.mod.funcs.len {
        b.mod.funcs[b.cur_func].typ
    } else {
        TypeID(0)
    }
    is_option_ret := b.is_option_wrapper_type(fn_ret_type)
    is_result_ret := b.is_result_wrapper_type(fn_ret_type)
    if stmt.exprs.len == 0 {
        if is_option_ret || is_result_ret {
            b.mod.add_instr(.ret, b.cur_block, 0, [
                b.build_wrapper_value(fn_ret_type, true, 0, false),
            ])
        } else {
            b.mod.add_instr(.ret, b.cur_block, 0, []ValueID{})
        }
    } else if stmt.exprs.len == 1 {
        ret_expr := stmt.exprs[0]
        mut val := b.build_expr(ret_expr)
        if (is_option_ret || is_result_ret) && b.mod.values[val].typ != fn_ret_type {
            val = b.coerce_wrapper_value(ret_expr, val, fn_ret_type)
        } else if fn_ret_type > 0 && int(fn_ret_type) < b.mod.type_store.types.len
            && b.mod.type_store.types[fn_ret_type].kind == .float_t {
            // If function returns float but value is int, convert (e.g., `return 1` in fn() f64)
            val_type := b.mod.values[val].typ
            if val_type > 0 && int(val_type) < b.mod.type_store.types.len
                && b.mod.type_store.types[val_type].kind != .float_t {
                val = b.mod.add_instr(.sitofp, b.cur_block, fn_ret_type, [val])
            }
        }
        b.mod.add_instr(.ret, b.cur_block, 0, [val])
    } else {
        // Multiple return values -> build a tuple via insertvalue
        mut elem_types := []TypeID{cap: stmt.exprs.len}
        mut vals := []ValueID{cap: stmt.exprs.len}
        for expr in stmt.exprs {
            v := b.build_expr(expr)
            vals << v
            elem_types << b.mod.values[v].typ
        }
        tuple_type := b.mod.type_store.get_tuple(elem_types)
        // Build tuple by chaining insertvalue instructions
        mut tuple_val := b.mod.get_or_add_const(tuple_type, 'undef')
        for i, v in vals {
            idx := b.mod.get_or_add_const(b.mod.type_store.get_int(32), i.str())
            tuple_val = b.mod.add_instr(.insertvalue, b.cur_block, tuple_type, [
                tuple_val,
                v,
                idx,
            ])
        }
        // If function returns Option/Result, wrap the tuple in the wrapper
        if (is_option_ret || is_result_ret) && tuple_type != fn_ret_type {
            tuple_val = b.build_wrapper_value(fn_ret_type, true, tuple_val, true)
        }
        b.mod.add_instr(.ret, b.cur_block, 0, [tuple_val])
    }
}

fn (mut b Builder) build_for(stmt ast.ForStmt) {
    has_init := stmt.init !is ast.EmptyStmt
    has_cond := stmt.cond !is ast.EmptyExpr
    has_post := stmt.post !is ast.EmptyStmt

    // Build init in current block
    if has_init {
        b.build_stmt(stmt.init)
    }

    // Create blocks
    cond_block := b.mod.add_block(b.cur_func, 'for_cond')
    body_block := b.mod.add_block(b.cur_func, 'for_body')
    post_block := if has_post {
        b.mod.add_block(b.cur_func, 'for_post')
    } else {
        cond_block
    }
    exit_block := b.mod.add_block(b.cur_func, 'for_exit')

    // Jump to condition
    b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[cond_block].val_id])
    b.add_edge(b.cur_block, cond_block)

    // Condition block
    b.cur_block = cond_block
    if has_cond {
        cond_val := b.build_expr(stmt.cond)
        b.mod.add_instr(.br, b.cur_block, 0,
            [cond_val, b.mod.blocks[body_block].val_id, b.mod.blocks[exit_block].val_id])
        b.add_edge(cond_block, body_block)
        b.add_edge(cond_block, exit_block)
    } else {
        // Infinite loop
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[body_block].val_id])
        b.add_edge(cond_block, body_block)
    }

    // Body block
    b.cur_block = body_block
    b.loop_stack << LoopInfo{
        cond_block: post_block
        exit_block: exit_block
    }
    b.build_stmts(stmt.stmts)
    b.loop_stack.delete_last()

    if !b.block_has_terminator(b.cur_block) {
        // Jump to post (or back to cond)
        target := if has_post { post_block } else { cond_block }
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[target].val_id])
        b.add_edge(b.cur_block, target)
    }

    // Post block
    if has_post {
        b.cur_block = post_block
        b.build_stmt(stmt.post)
        if !b.block_has_terminator(b.cur_block) {
            b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[cond_block].val_id])
            b.add_edge(post_block, cond_block)
        }
    }

    b.cur_block = exit_block
}

fn (mut b Builder) build_if_stmt(node ast.IfExpr) {
    if node.cond is ast.EmptyExpr {
        // Pure else block
        b.build_stmts(node.stmts)
        return
    }

    then_block := b.mod.add_block(b.cur_func, 'if_then')
    merge_block := b.mod.add_block(b.cur_func, 'if_merge')

    has_else := node.else_expr !is ast.EmptyExpr
    else_block := if has_else {
        b.mod.add_block(b.cur_func, 'if_else')
    } else {
        merge_block
    }

    // Condition
    cond_val := b.build_expr(node.cond)
    b.mod.add_instr(.br, b.cur_block, 0,
        [cond_val, b.mod.blocks[then_block].val_id, b.mod.blocks[else_block].val_id])
    b.add_edge(b.cur_block, then_block)
    b.add_edge(b.cur_block, else_block)

    // Then
    b.cur_block = then_block
    b.build_stmts(node.stmts)
    if !b.block_has_terminator(b.cur_block) {
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[merge_block].val_id])
        b.add_edge(b.cur_block, merge_block)
    }

    // Else
    if has_else {
        b.cur_block = else_block
        if node.else_expr is ast.IfExpr {
            else_if := node.else_expr as ast.IfExpr
            if else_if.cond is ast.EmptyExpr {
                // Pure else
                b.build_stmts(else_if.stmts)
            } else {
                b.build_if_stmt(else_if)
            }
        } else if node.else_expr is ast.UnsafeExpr {
            for s in node.else_expr.stmts {
                b.build_stmt(s)
            }
        }
        if !b.block_has_terminator(b.cur_block) {
            b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[merge_block].val_id])
            b.add_edge(b.cur_block, merge_block)
        }
    }

    b.cur_block = merge_block
    // If the merge block has no predecessors (both branches returned/jumped elsewhere),
    // mark it as unreachable so no implicit return is added
    if b.mod.blocks[merge_block].preds.len == 0 {
        b.mod.add_instr(.unreachable, b.cur_block, 0, []ValueID{})
    }
}

fn (mut b Builder) build_flow_control(stmt ast.FlowControlStmt) {
    if stmt.op == .key_goto {
        // goto label — jump to the label's block (create if not yet seen)
        target := b.get_or_create_label_block(stmt.label)
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[target].val_id])
        b.add_edge(b.cur_block, target)
        // Create a new unreachable block for any code after the goto
        dead_block := b.mod.add_block(b.cur_func, 'after_goto')
        b.cur_block = dead_block
        return
    }
    if b.loop_stack.len == 0 {
        return
    }
    loop_info := b.loop_stack[b.loop_stack.len - 1]
    if stmt.op == .key_break {
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[loop_info.exit_block].val_id])
        b.add_edge(b.cur_block, loop_info.exit_block)
    } else if stmt.op == .key_continue {
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[loop_info.cond_block].val_id])
        b.add_edge(b.cur_block, loop_info.cond_block)
    }
}

fn (mut b Builder) get_or_create_label_block(name string) BlockID {
    if name in b.label_blocks {
        return b.label_blocks[name]
    }
    block := b.mod.add_block(b.cur_func, 'label_${name}')
    b.label_blocks[name] = block
    return block
}

fn (mut b Builder) build_label(stmt ast.LabelStmt) {
    label_block := b.get_or_create_label_block(stmt.name)
    // Fall through from current block to label block
    b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[label_block].val_id])
    b.add_edge(b.cur_block, label_block)
    b.cur_block = label_block
}

fn (mut b Builder) build_assert(stmt ast.AssertStmt) {
    // assert expr -> if (!expr) { exit(1) }
    cond := b.build_expr(stmt.expr)
    pass_block := b.mod.add_block(b.cur_func, 'assert_pass')
    fail_block := b.mod.add_block(b.cur_func, 'assert_fail')

    b.mod.add_instr(.br, b.cur_block, 0,
        [cond, b.mod.blocks[pass_block].val_id, b.mod.blocks[fail_block].val_id])
    b.add_edge(b.cur_block, pass_block)
    b.add_edge(b.cur_block, fail_block)

    // Fail block: call exit(1)
    b.cur_block = fail_block
    one := b.mod.get_or_add_const(b.mod.type_store.get_int(32), '1')
    exit_ref := b.get_or_create_fn_ref('exit', b.mod.type_store.get_int(32))
    b.mod.add_instr(.call, b.cur_block, 0, [exit_ref, one])
    b.mod.add_instr(.unreachable, b.cur_block, 0, []ValueID{})

    b.cur_block = pass_block
}

// --- Expression building ---

fn (mut b Builder) build_expr(expr ast.Expr) ValueID {
    match expr {
        ast.BasicLiteral {
            return b.build_basic_literal(expr)
        }
        ast.StringLiteral {
            return b.build_string_literal(expr)
        }
        ast.Ident {
            return b.build_ident(expr)
        }
        ast.InfixExpr {
            return b.build_infix(expr)
        }
        ast.PrefixExpr {
            return b.build_prefix(expr)
        }
        ast.CallExpr {
            return b.build_call(expr)
        }
        ast.SelectorExpr {
            return b.build_selector(expr)
        }
        ast.IndexExpr {
            return b.build_index(expr)
        }
        ast.IfExpr {
            return b.build_if_expr(expr)
        }
        ast.InitExpr {
            return b.build_init_expr(expr)
        }
        ast.CastExpr {
            return b.build_cast(expr)
        }
        ast.ParenExpr {
            return b.build_expr(expr.expr)
        }
        ast.ModifierExpr {
            return b.build_expr(expr.expr)
        }
        ast.UnsafeExpr {
            if expr.stmts.len > 0 {
                for i := 0; i < expr.stmts.len - 1; i++ {
                    b.build_stmt(expr.stmts[i])
                }
                last := expr.stmts[expr.stmts.len - 1]
                if last is ast.ExprStmt {
                    return b.build_expr(last.expr)
                }
                b.build_stmt(last)
            }
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
        }
        ast.Keyword {
            return b.build_keyword(expr)
        }
        ast.KeywordOperator {
            return b.build_keyword_operator(expr)
        }
        ast.PostfixExpr {
            return b.build_postfix(expr)
        }
        ast.ArrayInitExpr {
            return b.build_array_init_expr(expr)
        }
        ast.MapInitExpr {
            // TODO: map init
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), '0')
        }
        ast.StringInterLiteral {
            return b.build_string_inter_literal(expr)
        }
        ast.MatchExpr {
            // Should be lowered by transformer
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
        }
        ast.OrExpr {
            return b.build_expr(expr.expr)
        }
        ast.FnLiteral {
            return b.build_fn_literal(expr)
        }
        ast.RangeExpr {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), '0')
        }
        ast.CallOrCastExpr {
            return b.build_call_or_cast(expr)
        }
        ast.AsCastExpr {
            return b.build_as_cast(expr)
        }
        ast.AssocExpr {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), '0')
        }
        ast.Tuple {
            if expr.exprs.len > 0 {
                return b.build_expr(expr.exprs[0])
            }
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
        }
        else {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
        }
    }
}

fn (mut b Builder) build_basic_literal(lit ast.BasicLiteral) ValueID {
    match lit.kind {
        .key_true {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(1), '1')
        }
        .key_false {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(1), '0')
        }
        .char {
            // Resolve character literal to its numeric value (Unicode code point)
            char_val := b.resolve_char_value(lit.value)
            // Always use 32-bit (rune) type — V rune literals are i32
            typ := b.mod.type_store.get_int(32)
            return b.mod.get_or_add_const(typ, char_val.str())
        }
        .number {
            if lit.value.contains('.')
                || (!lit.value.starts_with('0x') && !lit.value.starts_with('0X')
                && (lit.value.contains('e') || lit.value.contains('E'))) {
                typ := b.mod.type_store.get_float(64)
                return b.mod.get_or_add_const(typ, lit.value)
            }
            mut typ := b.expr_type(ast.Expr(lit))
            // Number literals should never have bool (i1) type. This can happen when
            // expr_type resolves a literal like "1" in "-1" to bool in && contexts.
            // Override to i32 to prevent 1-bit arithmetic overflow in negation.
            if typ != 0 && int(typ) < b.mod.type_store.types.len {
                t0 := b.mod.type_store.types[typ]
                if t0.kind == .int_t && t0.width == 1 {
                    typ = b.mod.type_store.get_int(32)
                }
            }
            // Widen to i64 if the literal value overflows the assigned type.
            // The type checker may assign `int` (i32) to a literal like 9223372036854775807
            // which doesn't fit in 32 bits.
            if typ != 0 && int(typ) < b.mod.type_store.types.len {
                t := b.mod.type_store.types[typ]
                if t.kind == .int_t && t.width <= 32 {
                    val := lit.value
                    // Check if the value exceeds i32 range
                    if val.len >= 10 {
                        parsed := val.i64()
                        if parsed > 2147483647 || parsed < -2147483648 {
                            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), val)
                        }
                    }
                }
            }
            return b.mod.get_or_add_const(typ, lit.value)
        }
        else {
            // Integer or other
            typ := b.expr_type(ast.Expr(lit))
            return b.mod.get_or_add_const(typ, lit.value)
        }
    }
}

fn (mut b Builder) build_string_literal(lit ast.StringLiteral) ValueID {
    // Strip surrounding quotes from V string literal values
    mut val := lit.value
    if val.len >= 2 && ((val[0] == `'` && val[val.len - 1] == `'`)
        || (val[0] == `"` && val[val.len - 1] == `"`)) {
        val = val[1..val.len - 1]
    }
    if lit.kind == .c {
        // C string literal -> raw i8* pointer
        i8_t := b.mod.type_store.get_int(8)
        ptr_t := b.mod.type_store.get_ptr(i8_t)
        return b.mod.add_value_node(.c_string_literal, ptr_t, val, 0)
    }
    // Process V escape sequences for non-raw strings
    if lit.kind != .raw {
        val = process_v_escapes(val)
    }
    typ := b.get_string_type()
    result := b.mod.add_value_node(.string_literal, typ, val, val.len)
    return result
}

// process_v_escapes converts V escape sequences (\n, \t, etc.) in a string
// to their actual byte values. The V2 scanner stores raw escape sequences
// (e.g., \t as two chars '\' + 't'), not processed bytes.
fn process_v_escapes(s string) string {
    // Fast path: no backslashes means no escapes
    if !s.contains('\\') {
        return s
    }
    mut result := []u8{cap: s.len}
    mut i := 0
    for i < s.len {
        if s[i] == `\\` && i + 1 < s.len {
            match s[i + 1] {
                `n` {
                    result << 0x0A
                }
                `t` {
                    result << 0x09
                }
                `r` {
                    result << 0x0D
                }
                `\\` {
                    result << 0x5C
                }
                `'` {
                    result << 0x27
                }
                `"` {
                    result << 0x22
                }
                `0` {
                    result << 0x00
                }
                `a` {
                    result << 0x07
                }
                `b` {
                    result << 0x08
                }
                `f` {
                    result << 0x0C
                }
                `v` {
                    result << 0x0B
                }
                `e` {
                    result << 0x1B
                }
                0x0A {
                    // Backslash followed by newline: line continuation
                    // Skip the backslash, newline, and leading whitespace on next line
                    i += 2
                    for i < s.len && (s[i] == ` ` || s[i] == `\t`) {
                        i++
                    }
                    continue
                }
                `x` {
                    // \xNN hex escape
                    if i + 3 < s.len {
                        hi := hex_digit(s[i + 2])
                        lo := hex_digit(s[i + 3])
                        if hi >= 0 && lo >= 0 {
                            result << u8(hi * 16 + lo)
                            i += 4
                            continue
                        }
                    }
                    result << s[i]
                    i++
                    continue
                }
                `u` {
                    code, ok := parse_hex_escape(s, i + 2, 4)
                    if ok && append_utf8_codepoint(mut result, code) {
                        i += 6
                        continue
                    }
                    result << s[i]
                    i++
                    continue
                }
                `U` {
                    code, ok := parse_hex_escape(s, i + 2, 8)
                    if ok && append_utf8_codepoint(mut result, code) {
                        i += 10
                        continue
                    }
                    result << s[i]
                    i++
                    continue
                }
                else {
                    result << s[i]
                    i++
                    continue
                }
            }

            i += 2
        } else {
            result << s[i]
            i++
        }
    }
    return result.bytestr()
}

fn parse_hex_escape(s string, start int, count int) (int, bool) {
    if start + count > s.len {
        return 0, false
    }
    mut code := 0
    for j := 0; j < count; j++ {
        digit := hex_digit(s[start + j])
        if digit < 0 {
            return 0, false
        }
        code = code * 16 + digit
    }
    return code, true
}

fn append_utf8_codepoint(mut result []u8, code int) bool {
    if code < 0 || code > 0x10FFFF {
        return false
    }
    if code <= 0x7F {
        result << u8(code)
    } else if code <= 0x7FF {
        result << u8(0xC0 | (code >> 6))
        result << u8(0x80 | (code & 0x3F))
    } else if code <= 0xFFFF {
        result << u8(0xE0 | (code >> 12))
        result << u8(0x80 | ((code >> 6) & 0x3F))
        result << u8(0x80 | (code & 0x3F))
    } else {
        result << u8(0xF0 | (code >> 18))
        result << u8(0x80 | ((code >> 12) & 0x3F))
        result << u8(0x80 | ((code >> 6) & 0x3F))
        result << u8(0x80 | (code & 0x3F))
    }
    return true
}

fn hex_digit(c u8) int {
    if c >= `0` && c <= `9` {
        return int(c - `0`)
    }
    if c >= `a` && c <= `f` {
        return int(c - `a` + 10)
    }
    if c >= `A` && c <= `F` {
        return int(c - `A` + 10)
    }
    return -1
}

fn (mut b Builder) build_string_inter_literal(expr ast.StringInterLiteral) ValueID {
    // String interpolation: concatenate literal parts and expression-to-string conversions.
    // Pattern: values[0] + str(inters[0]) + values[1] + str(inters[1]) + ...
    str_type := b.get_string_type()
    plus_fn := b.get_or_create_fn_ref('builtin__string__+', str_type)

    mut parts := []ValueID{}
    for i, raw_val in expr.values {
        // Strip surrounding quotes from first and last values (parser artifact)
        mut val := raw_val
        if i == 0 && val.len > 0 && (val[0] == `'` || val[0] == `"`) {
            val = val[1..]
        }
        if i == expr.values.len - 1 && val.len > 0
            && (val[val.len - 1] == `'` || val[val.len - 1] == `"`) {
            val = val[..val.len - 1]
        }
        // Process V escape sequences in interpolation literal parts
        val = process_v_escapes(val)
        if val.len > 0 {
            parts << b.mod.add_value_node(.string_literal, str_type, val, val.len)
        }
        if i < expr.inters.len {
            inter := expr.inters[i]
            // Check if this interpolation needs C.snprintf formatting.
            // Use snprintf for explicit format specifiers (:.3f, :03d, :c, :x, :o, etc.)
            // but not for :s (string) or unformatted — those use V string concatenation.
            needs_snprintf := inter.format != .unformatted && inter.format != .string
                && inter.resolved_fmt.len > 0
            if needs_snprintf {
                // Use C.snprintf to format the value with the resolved format string.
                // 1. Allocate a stack buffer (64 bytes)
                i8_t := b.mod.type_store.get_int(8)
                ptr_type := b.mod.type_store.get_ptr(i8_t)
                count_64 := b.mod.get_or_add_const(i8_t, '64')
                buf_ptr := b.mod.add_instr(.alloca, b.cur_block, ptr_type, [count_64])
                // 2. Build the value expression (use raw value, not str()-converted)
                inter_val := b.build_expr(inter.expr)
                formatted_val := b.prepare_snprintf_arg(inter_val, inter.resolved_fmt)
                // 3. Call snprintf(buf, 64, fmt, val)
                i32_t := b.mod.type_store.get_int(32)
                snprintf_ref := b.get_or_create_fn_ref('snprintf', i32_t)
                size_val := b.mod.get_or_add_const(i32_t, '64')
                fmt_val := b.mod.add_value_node(.c_string_literal, ptr_type, inter.resolved_fmt, 0)
                sn_len := b.mod.add_instr(.call, b.cur_block, i32_t, [snprintf_ref, buf_ptr, size_val,
                    fmt_val, formatted_val])
                // 4. Call builtin__tos(buf_ptr, len) to make a V string
                tos_ref := b.get_or_create_fn_ref('builtin__tos', str_type)
                str_val := b.mod.add_instr(.call, b.cur_block, str_type, [tos_ref, buf_ptr, sn_len])
                parts << str_val
            } else {
                // Unformatted or simple format: use string concatenation.
                // If the inter.expr is a SelectorExpr accessing '.str' on a string,
                // use the base expression (the V string) directly.
                mut use_expr := inter.expr
                if inter.expr is ast.SelectorExpr {
                    sel := inter.expr as ast.SelectorExpr
                    if sel.rhs.name == 'str' {
                        use_expr = sel.lhs
                    }
                }
                inter_val := b.build_expr(use_expr)
                inter_type := b.mod.values[inter_val].typ
                // Convert the interpolation value to string
                str_val := b.convert_to_string(inter_val, inter_type)
                parts << str_val
            }
        }
    }

    if parts.len == 0 {
        return b.mod.add_value_node(.string_literal, str_type, '', 0)
    }
    if parts.len == 1 {
        return parts[0]
    }

    // Concatenate all parts with string__+
    mut result := parts[0]
    for i := 1; i < parts.len; i++ {
        result = b.mod.add_instr(.call, b.cur_block, str_type, [plus_fn, result, parts[i]])
    }
    return result
}

fn (mut b Builder) prepare_snprintf_arg(val ValueID, fmt string) ValueID {
    if fmt.len == 0 || val <= 0 || val >= b.mod.values.len {
        return val
    }
    typ_id := b.mod.values[val].typ
    if typ_id <= 0 || typ_id >= b.mod.type_store.types.len {
        return val
    }
    typ := b.mod.type_store.types[typ_id]
    fmt_char := fmt[fmt.len - 1]
    match fmt_char {
        `d`, `i`, `u`, `o`, `x`, `X`, `c` {
            if typ.kind != .int_t {
                return val
            }
            needs_u32 := fmt_char in [`u`, `o`, `x`, `X`]
            if fmt.contains('ll') {
                target := if needs_u32 {
                    b.mod.type_store.get_uint(64)
                } else {
                    b.mod.type_store.get_int(64)
                }
                return b.cast_value_to_type(val, target)
            }
            target := if needs_u32 {
                b.mod.type_store.get_uint(32)
            } else {
                b.mod.type_store.get_int(32)
            }
            return b.cast_value_to_type(val, target)
        }
        `f`, `e`, `g` {
            if typ.kind == .float_t && typ.width == 32 {
                return b.cast_value_to_type(val, b.mod.type_store.get_float(64))
            }
        }
        else {}
    }

    return val
}

fn (mut b Builder) convert_to_string(val ValueID, typ TypeID) ValueID {
    str_type := b.get_string_type()
    // If already a string, return as-is
    if str_type != 0 && typ == str_type {
        return val
    }
    // Also check if the type is a struct named 'string' (may have different ID)
    if typ < b.mod.type_store.types.len {
        tinfo := b.mod.type_store.types[typ]
        if tinfo.kind == .struct_t {
            // Check if this is the string struct by field count (str, len, is_lit)
            if tinfo.fields.len == 3 || typ == str_type {
                return val
            }
        }
    }
    // Determine the conversion function based on the type
    type_info := b.mod.type_store.types[typ]
    mut fn_name := ''
    if type_info.kind == .int_t {
        if type_info.width == 1 {
            // bool
            fn_name = 'builtin__bool__str'
        } else if type_info.width == 64 {
            fn_name = 'builtin__i64__str'
        } else {
            fn_name = 'builtin__int__str'
        }
    } else if type_info.kind == .float_t {
        if type_info.width == 32 {
            fn_name = 'builtin__f32__str'
        } else {
            fn_name = 'builtin__f64__str'
        }
    }
    if fn_name != '' {
        fn_ref := b.get_or_create_fn_ref(fn_name, str_type)
        return b.mod.add_instr(.call, b.cur_block, str_type, [fn_ref, val])
    }
    // Fallback: return empty string
    return b.mod.add_value_node(.string_literal, str_type, '', 0)
}

fn (mut b Builder) build_ident(ident ast.Ident) ValueID {
    // Handle 'nil' identifier (generated by transformer from `unsafe { nil }`)
    if ident.name == 'nil' {
        i8_t := b.mod.type_store.get_int(8)
        ptr_t := b.mod.type_store.get_ptr(i8_t)
        return b.mod.get_or_add_const(ptr_t, '0')
    }
    if ident.name in b.vars {
        ptr := b.vars[ident.name]
        ptr_typ := b.mod.values[ptr].typ
        elem_typ := b.mod.type_store.types[ptr_typ].elem_type
        val := b.mod.add_instr(.load, b.cur_block, elem_typ, [ptr])
        // For mut pointer params (e.g., mut buf &u8), the alloca stores ptr(ptr(T)).
        // One load gives ptr(ptr(T)), but user sees buf as ptr(T).
        // Add extra dereference to get the actual pointer value.
        if ident.name in b.mut_ptr_params {
            inner_typ := b.mod.type_store.types[elem_typ].elem_type
            if inner_typ != 0 {
                return b.mod.add_instr(.load, b.cur_block, inner_typ, [val])
            }
        }
        return val
    }
    // Could be a constant, enum value, or function reference
    if ident.name in b.enum_values {
        val := b.enum_values[ident.name]
        return b.mod.get_or_add_const(b.mod.type_store.get_int(32), val.str())
    }
    // Try enum value with module prefix (e.g., Token__key_fn → token__Token__key_fn)
    {
        enum_qualified := '${b.cur_module}__${ident.name}'
        if enum_qualified in b.enum_values {
            val := b.enum_values[enum_qualified]
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), val.str())
        }
    }
    // Try as function reference
    if ident.name in b.fn_index {
        return b.get_or_create_fn_ref(ident.name, 0)
    }
    // Try with module prefix (transformer strips module prefix for builtin functions)
    builtin_name := 'builtin__${ident.name}'
    if builtin_name in b.fn_index {
        return b.get_or_create_fn_ref(builtin_name, 0)
    }
    qualified_name := '${b.cur_module}__${ident.name}'
    if qualified_name in b.fn_index {
        return b.get_or_create_fn_ref(qualified_name, 0)
    }
    // Try as float constant (inline as f64)
    if fval := b.float_const_values[ident.name] {
        return b.mod.get_or_add_const(b.mod.type_store.get_float(64), fval)
    }
    if fval := b.float_const_values[qualified_name] {
        return b.mod.get_or_add_const(b.mod.type_store.get_float(64), fval)
    }
    builtin_const := 'builtin__${ident.name}'
    if fval := b.float_const_values[builtin_const] {
        return b.mod.get_or_add_const(b.mod.type_store.get_float(64), fval)
    }
    // Try as compile-time constant (inline the value directly)
    if ident.name in b.const_values {
        ct := if ident.name in b.const_value_types {
            b.const_value_types[ident.name]
        } else {
            b.mod.type_store.get_int(64)
        }
        return b.mod.get_or_add_const(ct, b.const_values[ident.name].str())
    }
    if qualified_name in b.const_values {
        ct := if qualified_name in b.const_value_types {
            b.const_value_types[qualified_name]
        } else {
            b.mod.type_store.get_int(64)
        }
        return b.mod.get_or_add_const(ct, b.const_values[qualified_name].str())
    }
    if builtin_const in b.const_values {
        ct := if builtin_const in b.const_value_types {
            b.const_value_types[builtin_const]
        } else {
            b.mod.type_store.get_int(64)
        }
        return b.mod.get_or_add_const(ct, b.const_values[builtin_const].str())
    }
    // Try as string constant (inline the string literal directly)
    if ident.name in b.string_const_values {
        return b.build_string_literal(ast.StringLiteral{
            kind:  .v
            value: b.string_const_values[ident.name]
        })
    }
    if qualified_name in b.string_const_values {
        return b.build_string_literal(ast.StringLiteral{
            kind:  .v
            value: b.string_const_values[qualified_name]
        })
    }
    if builtin_const in b.string_const_values {
        return b.build_string_literal(ast.StringLiteral{
            kind:  .v
            value: b.string_const_values[builtin_const]
        })
    }
    // Try as constant array global (return pointer directly for indexing)
    if ident.name in b.const_array_globals {
        if glob_id := b.find_global(ident.name) {
            return glob_id
        }
        // Cross-module const array: transformer strips the module prefix
        // (e.g., "strconv__pow5_split_64_x" → "pow5_split_64_x").
        // Scan globals for a match with any module prefix.
        suffix := '__${ident.name}'
        for v in b.mod.values {
            if v.kind == .global && v.name.ends_with(suffix) {
                return v.id
            }
        }
    }
    if qualified_name in b.const_array_globals {
        if glob_id := b.find_global(qualified_name) {
            return glob_id
        }
    }
    if builtin_const in b.const_array_globals {
        if glob_id := b.find_global(builtin_const) {
            return glob_id
        }
    }
    // Try as global variable
    if glob_id := b.find_global(ident.name) {
        glob_typ := b.mod.values[glob_id].typ
        elem_typ := b.mod.type_store.types[glob_typ].elem_type
        return b.mod.add_instr(.load, b.cur_block, elem_typ, [glob_id])
    }
    // Try with prefixes for globals too
    if glob_id := b.find_global(builtin_const) {
        glob_typ := b.mod.values[glob_id].typ
        elem_typ := b.mod.type_store.types[glob_typ].elem_type
        return b.mod.add_instr(.load, b.cur_block, elem_typ, [glob_id])
    }
    if glob_id := b.find_global(qualified_name) {
        glob_typ := b.mod.values[glob_id].typ
        elem_typ := b.mod.type_store.types[glob_typ].elem_type
        return b.mod.add_instr(.load, b.cur_block, elem_typ, [glob_id])
    }
    return b.mod.get_or_add_const(b.mod.type_store.get_int(64), '0')
}

fn (mut b Builder) find_global(name string) ?ValueID {
    if name in b.global_refs {
        return b.global_refs[name]
    }
    return none
}

fn (mut b Builder) index_global_values() {
    for v in b.mod.values {
        if v.kind == .global {
            b.global_refs[v.name] = v.id
        }
    }
}

fn (mut b Builder) build_infix(expr ast.InfixExpr) ValueID {
    // Short-circuit evaluation for logical || and &&
    if expr.op == .logical_or {
        bool_type := b.mod.type_store.get_int(1)
        // Evaluate LHS
        lhs := b.build_expr(expr.lhs)
        lhs_block := b.cur_block
        // Create blocks: rhs_block (evaluate RHS), merge_block
        rhs_block := b.mod.add_block(b.cur_func, 'or_rhs')
        merge_block := b.mod.add_block(b.cur_func, 'or_merge')
        // If LHS is true, short-circuit to merge; else evaluate RHS
        b.mod.add_instr(.br, b.cur_block, 0,
            [lhs, b.mod.blocks[merge_block].val_id, b.mod.blocks[rhs_block].val_id])
        b.add_edge(b.cur_block, merge_block)
        b.add_edge(b.cur_block, rhs_block)
        // RHS block
        b.cur_block = rhs_block
        rhs := b.build_expr(expr.rhs)
        rhs_end_block := b.cur_block
        if !b.block_has_terminator(b.cur_block) {
            b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[merge_block].val_id])
            b.add_edge(b.cur_block, merge_block)
        }
        // Merge block: use phi to select result (no alloca/store/load)
        b.cur_block = merge_block
        one := b.mod.get_or_add_const(bool_type, '1')
        phi_val := b.mod.add_instr(.phi, merge_block, bool_type, [one, b.mod.blocks[lhs_block].val_id,
            rhs, b.mod.blocks[rhs_end_block].val_id])
        return phi_val
    }
    if expr.op == .and {
        bool_type := b.mod.type_store.get_int(1)
        // Evaluate LHS
        lhs := b.build_expr(expr.lhs)
        lhs_block := b.cur_block
        // Create blocks: rhs_block (evaluate RHS), merge_block
        rhs_block := b.mod.add_block(b.cur_func, 'and_rhs')
        merge_block := b.mod.add_block(b.cur_func, 'and_merge')
        // If LHS is false, short-circuit to merge with false; else evaluate RHS
        b.mod.add_instr(.br, b.cur_block, 0,
            [lhs, b.mod.blocks[rhs_block].val_id, b.mod.blocks[merge_block].val_id])
        b.add_edge(b.cur_block, rhs_block)
        b.add_edge(b.cur_block, merge_block)
        // RHS block
        b.cur_block = rhs_block
        rhs := b.build_expr(expr.rhs)
        rhs_end_block := b.cur_block
        if !b.block_has_terminator(b.cur_block) {
            b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[merge_block].val_id])
            b.add_edge(b.cur_block, merge_block)
        }
        // Merge block: use phi to select result (no alloca/store/load)
        b.cur_block = merge_block
        zero := b.mod.get_or_add_const(bool_type, '0')
        phi_val := b.mod.add_instr(.phi, merge_block, bool_type, [zero, b.mod.blocks[lhs_block].val_id,
            rhs, b.mod.blocks[rhs_end_block].val_id])
        return phi_val
    }

    lhs := b.build_expr(expr.lhs)
    rhs := b.build_expr(expr.rhs)
    result_type := b.expr_type(ast.Expr(expr))
    // Handle Option/Result comparison with none: x == none / x != none
    // Compare the state field (field 0) with 0 (success state) instead of
    // doing a whole-struct comparison with an integer.
    if (expr.op == .eq || expr.op == .ne) && (b.is_none_expr(expr.rhs) || b.is_none_expr(expr.lhs)) {
        option_val := if b.is_none_expr(expr.rhs) { lhs } else { rhs }
        option_type := b.mod.values[option_val].typ
        if b.is_option_wrapper_type(option_type) {
            // Extract state field and check: state != 0 means none/error
            i32_t := b.mod.type_store.get_int(32)
            bool_t := b.mod.type_store.get_int(1)
            flag_idx := b.mod.get_or_add_const(i32_t, '0')
            flag_type := b.mod.type_store.types[option_type].fields[0]
            flag_val := b.mod.add_instr(.extractvalue, b.cur_block, flag_type, [
                option_val,
                flag_idx,
            ])
            zero_flag := b.mod.get_or_add_const(flag_type, '0')
            if expr.op == .eq {
                // x == none → state != 0 (non-zero state means none)
                return b.mod.add_instr(.ne, b.cur_block, bool_t, [flag_val, zero_flag])
            } else {
                // x != none → state == 0 (zero state means success/has value)
                return b.mod.add_instr(.eq, b.cur_block, bool_t, [flag_val, zero_flag])
            }
        }
        if b.is_result_wrapper_type(option_type) {
            i32_t := b.mod.type_store.get_int(32)
            bool_t := b.mod.type_store.get_int(1)
            flag_idx := b.mod.get_or_add_const(i32_t, '0')
            flag_type := b.mod.type_store.types[option_type].fields[0]
            flag_val := b.mod.add_instr(.extractvalue, b.cur_block, flag_type, [
                option_val,
                flag_idx,
            ])
            zero_flag := b.mod.get_or_add_const(flag_type, '0')
            if expr.op == .eq {
                return b.mod.add_instr(.ne, b.cur_block, bool_t, [flag_val, zero_flag])
            } else {
                return b.mod.add_instr(.eq, b.cur_block, bool_t, [flag_val, zero_flag])
            }
        }
    }
    // Check for string comparison: if either operand is a string-like type
    // (string or &string), emit string calls instead of integer comparisons.
    // This handles match-on-string expressions where the transformer creates
    // InfixExpr{.eq, ...} that bypasses the normal string comparison lowering.
    str_type := b.get_string_type()
    if str_type != 0 {
        lhs_type := b.mod.values[lhs].typ
        rhs_type := b.mod.values[rhs].typ
        if b.is_string_like_ssa_type(lhs_type) || b.is_string_like_ssa_type(rhs_type) {
            string_lhs := b.load_string_like_value(lhs)
            string_rhs := b.load_string_like_value(rhs)
            if expr.op in [.eq, .ne] {
                bool_type := b.mod.type_store.get_int(1)
                fn_ref := b.get_or_create_fn_ref('builtin__string__==', bool_type)
                eq_result := b.mod.add_instr(.call, b.cur_block, bool_type, [fn_ref, string_lhs,
                    string_rhs])
                if expr.op == .ne {
                    return b.mod.add_instr(.xor, b.cur_block, bool_type, [eq_result,
                        b.mod.get_or_add_const(bool_type, '1')])
                }
                return eq_result
            }
            if expr.op in [.lt, .gt, .le, .ge] {
                bool_type := b.mod.type_store.get_int(1)
                fn_ref := b.get_or_create_fn_ref('builtin__string__<', bool_type)
                lt_lhs := if expr.op in [.gt, .le] { string_rhs } else { string_lhs }
                lt_rhs := if expr.op in [.gt, .le] { string_lhs } else { string_rhs }
                lt_result := b.mod.add_instr(.call, b.cur_block, bool_type,
                    [fn_ref, lt_lhs, lt_rhs])
                if expr.op in [.le, .ge] {
                    return b.mod.add_instr(.xor, b.cur_block, bool_type, [lt_result,
                        b.mod.get_or_add_const(bool_type, '1')])
                }
                return lt_result
            }
            if expr.op == .plus {
                fn_ref := b.get_or_create_fn_ref('builtin__string__+', str_type)
                return b.mod.add_instr(.call, b.cur_block, str_type,
                    [fn_ref, string_lhs, string_rhs])
            }
        }
    }

    // Check for array comparison: if either operand is an array type,
    // call array__eq instead of bitwise comparison.
    // This handles cases where the transformer didn't lower the comparison
    // (e.g., type aliases like `type Strings = []string`).
    array_type := b.get_array_type()
    if array_type != 0 && (expr.op == .eq || expr.op == .ne) {
        lhs_type := b.mod.values[lhs].typ
        rhs_type := b.mod.values[rhs].typ
        if lhs_type == array_type || rhs_type == array_type {
            bool_type := b.mod.type_store.get_int(1)
            fn_ref := b.get_or_create_fn_ref('array__eq', bool_type)
            eq_result := b.mod.add_instr(.call, b.cur_block, bool_type, [fn_ref, lhs, rhs])
            if expr.op == .ne {
                return b.mod.add_instr(.xor, b.cur_block, bool_type, [eq_result,
                    b.mod.get_or_add_const(bool_type, '1')])
            }
            return eq_result
        }
    }

    // Pointer arithmetic: ptr + int or int + ptr → GEP for proper element scaling.
    // Without this, `*i32 + 1` adds 1 byte instead of 4 bytes.
    if expr.op == .plus || expr.op == .minus {
        lhs_t := b.mod.values[lhs].typ
        rhs_t := b.mod.values[rhs].typ
        mut ptr_val := ValueID(0)
        mut int_val := ValueID(0)
        mut is_ptr_arith := false
        if lhs_t > 0 && int(lhs_t) < b.mod.type_store.types.len
            && b.mod.type_store.types[lhs_t].kind == .ptr_t {
            ptr_val = lhs
            int_val = rhs
            is_ptr_arith = true
        } else if rhs_t > 0 && int(rhs_t) < b.mod.type_store.types.len
            && b.mod.type_store.types[rhs_t].kind == .ptr_t {
            ptr_val = rhs
            int_val = lhs
            is_ptr_arith = true
        }
        if is_ptr_arith {
            ptr_type := b.mod.values[ptr_val].typ
            if expr.op == .minus {
                // ptr - int: negate the integer, then GEP
                int_val = b.mod.add_instr(.sub, b.cur_block, b.mod.values[int_val].typ, [
                    b.mod.get_or_add_const(b.mod.values[int_val].typ, '0'),
                    int_val,
                ])
            }
            return b.mod.add_instr(.get_element_ptr, b.cur_block, ptr_type, [
                ptr_val,
                int_val,
            ])
        }
    }

    // Check if operands are float type to use float opcodes.
    // When one operand is float and the other is int, promote the int to float.
    mut lhs_v := lhs
    mut rhs_v := rhs
    lhs_type := b.mod.values[lhs_v].typ
    rhs_type_id := b.mod.values[rhs_v].typ
    lhs_is_float := lhs_type > 0 && int(lhs_type) < b.mod.type_store.types.len
        && b.mod.type_store.types[lhs_type].kind == .float_t
    rhs_is_float := rhs_type_id > 0 && int(rhs_type_id) < b.mod.type_store.types.len
        && b.mod.type_store.types[rhs_type_id].kind == .float_t
    is_float := lhs_is_float || rhs_is_float
    if is_float {
        if lhs_is_float && !rhs_is_float {
            // Promote RHS int to float: use uitofp for unsigned types, sitofp for signed
            rhs_unsigned := rhs_type_id > 0 && int(rhs_type_id) < b.mod.type_store.types.len
                && b.mod.type_store.types[rhs_type_id].is_unsigned
            conv_op := if rhs_unsigned { OpCode.uitofp } else { OpCode.sitofp }
            rhs_v = b.mod.add_instr(conv_op, b.cur_block, lhs_type, [rhs_v])
        } else if rhs_is_float && !lhs_is_float {
            // Promote LHS int to float: use uitofp for unsigned types, sitofp for signed
            lhs_unsigned := lhs_type > 0 && int(lhs_type) < b.mod.type_store.types.len
                && b.mod.type_store.types[lhs_type].is_unsigned
            conv_op := if lhs_unsigned { OpCode.uitofp } else { OpCode.sitofp }
            lhs_v = b.mod.add_instr(conv_op, b.cur_block, rhs_type_id, [lhs_v])
        }
    }

    mut forced_result_type := TypeID(0)
    if !is_float && expr.op == .minus {
        lhs_t := b.mod.values[lhs_v].typ
        rhs_t := b.mod.values[rhs_v].typ
        if lhs_t > 0 && rhs_t > 0 && int(lhs_t) < b.mod.type_store.types.len
            && int(rhs_t) < b.mod.type_store.types.len {
            lhs_info := b.mod.type_store.types[lhs_t]
            rhs_info := b.mod.type_store.types[rhs_t]
            if lhs_info.kind == .int_t && rhs_info.kind == .int_t && lhs_info.width < 32
                && rhs_info.width < 32 {
                int_t := b.mod.type_store.get_int(32)
                if lhs_t != int_t {
                    lhs_v = b.mod.add_instr(if lhs_info.is_unsigned { .zext } else { .sext },
                        b.cur_block, int_t, [lhs_v])
                }
                if rhs_t != int_t {
                    rhs_v = b.mod.add_instr(if rhs_info.is_unsigned { .zext } else { .sext },
                        b.cur_block, int_t, [rhs_v])
                }
                forced_result_type = int_t
            }
        }
    }

    op := if is_float {
        match expr.op {
            .plus { OpCode.fadd }
            .minus { OpCode.fsub }
            .mul { OpCode.fmul }
            .div { OpCode.fdiv }
            .mod { OpCode.frem }
            // Comparisons use the same opcodes - the arm64 codegen
            // already checks float type for eq/ne/lt/gt/le/ge
            .eq { OpCode.eq }
            .ne { OpCode.ne }
            .lt { OpCode.lt }
            .gt { OpCode.gt }
            .le { OpCode.le }
            .ge { OpCode.ge }
            else { OpCode.fadd }
        }
    } else {
        is_unsigned := lhs_type > 0 && int(lhs_type) < b.mod.type_store.types.len
            && b.mod.type_store.types[lhs_type].is_unsigned
        match expr.op {
            .plus {
                OpCode.add
            }
            .minus {
                OpCode.sub
            }
            .mul {
                OpCode.mul
            }
            .div {
                if is_unsigned {
                    OpCode.udiv
                } else {
                    OpCode.sdiv
                }
            }
            .mod {
                if is_unsigned {
                    OpCode.urem
                } else {
                    OpCode.srem
                }
            }
            .eq {
                OpCode.eq
            }
            .ne {
                OpCode.ne
            }
            .lt {
                if is_unsigned {
                    OpCode.ult
                } else {
                    OpCode.lt
                }
            }
            .gt {
                if is_unsigned {
                    OpCode.ugt
                } else {
                    OpCode.gt
                }
            }
            .le {
                if is_unsigned {
                    OpCode.ule
                } else {
                    OpCode.le
                }
            }
            .ge {
                if is_unsigned {
                    OpCode.uge
                } else {
                    OpCode.ge
                }
            }
            .amp {
                OpCode.and_
            }
            .pipe {
                OpCode.or_
            }
            .xor {
                OpCode.xor
            }
            .left_shift {
                OpCode.shl
            }
            .right_shift {
                if is_unsigned {
                    OpCode.lshr
                } else {
                    OpCode.ashr
                }
            }
            else {
                OpCode.add
            }
        }
    }

    // If expr_type() returned a struct/aggregate type for an arithmetic/bitwise operation,
    // it's a stale checker position (e.g., transformer-reconstructed expressions from .map()).
    // Fall back to the LHS operand type which is always correct for arithmetic.
    mut final_type := result_type
    if forced_result_type != 0 {
        final_type = forced_result_type
    }
    if final_type > 0 && int(final_type) < b.mod.type_store.types.len {
        kind := b.mod.type_store.types[final_type].kind
        if kind == .struct_t || kind == .array_t {
            final_type = b.mod.values[lhs_v].typ
        }
    }
    // Widen result type to match operands: if either operand is wider than the
    // result type (e.g., lhs is i64 but type checker assigned i32 to the expression),
    // use the wider operand type to avoid truncation.
    if final_type > 0 && int(final_type) < b.mod.type_store.types.len {
        ft := b.mod.type_store.types[final_type]
        if ft.kind == .int_t {
            lhs_t := b.mod.values[lhs_v].typ
            rhs_t := b.mod.values[rhs_v].typ
            if lhs_t > 0 && int(lhs_t) < b.mod.type_store.types.len {
                lt := b.mod.type_store.types[lhs_t]
                if lt.kind == .int_t && lt.width > ft.width {
                    final_type = lhs_t
                }
            }
            if rhs_t > 0 && int(rhs_t) < b.mod.type_store.types.len {
                rt := b.mod.type_store.types[rhs_t]
                if rt.kind == .int_t && rt.width > ft.width {
                    final_type = rhs_t
                }
            }
        }
    }
    return b.mod.add_instr(op, b.cur_block, final_type, [lhs_v, rhs_v])
}

fn (mut b Builder) build_prefix(expr ast.PrefixExpr) ValueID {
    // Special case: &InitExpr (heap/pointer to struct init)
    // Build the struct via alloca+GEP+store but return the pointer instead of loading
    if expr.op == .amp && expr.expr is ast.InitExpr {
        return b.build_init_expr_ptr(expr.expr)
    }

    // Special case: &T(expr) → bitcast to *T (pointer type cast)
    // In V, &u8(val) means "cast val to type &u8", NOT "address-of (u8 cast of val)".
    // The parser interprets &u8(val) as PrefixExpr(.amp, CastExpr/CallOrCastExpr)
    // but the V semantic is always a pointer type cast.
    // Handle both pointer and integer sources (int→ptr is needed for &u8(u64_val)).
    if expr.op == .amp && expr.expr is ast.CastExpr {
        cast_expr := expr.expr as ast.CastExpr
        inner_val := b.build_expr(cast_expr.expr)
        inner_type := b.mod.values[inner_val].typ
        if inner_type != 0 && int(inner_type) < b.mod.type_store.types.len {
            inner_t := b.mod.type_store.types[inner_type]
            if inner_t.kind == .ptr_t || inner_t.kind == .int_t {
                target_elem := b.ast_type_to_ssa(cast_expr.typ)
                ptr_type := b.mod.type_store.get_ptr(target_elem)
                return b.mod.add_instr(.bitcast, b.cur_block, ptr_type, [inner_val])
            }
        }
    }
    // Same for &CallOrCastExpr (parser uses CallOrCastExpr when it cannot distinguish
    // between a function call and a type cast, e.g. u8(expr))
    if expr.op == .amp && expr.expr is ast.CallOrCastExpr {
        coce := expr.expr as ast.CallOrCastExpr
        inner_val := b.build_expr(coce.expr)
        inner_type := b.mod.values[inner_val].typ
        if inner_type != 0 && int(inner_type) < b.mod.type_store.types.len {
            inner_t := b.mod.type_store.types[inner_type]
            if inner_t.kind == .ptr_t || inner_t.kind == .int_t {
                target_elem := b.ast_type_to_ssa(coce.lhs)
                ptr_type := b.mod.type_store.get_ptr(target_elem)
                return b.mod.add_instr(.bitcast, b.cur_block, ptr_type, [inner_val])
            }
        }
    }
    // Handle &&T(expr) — nested ampersand pointer-type cast pattern.
    // Parser creates PrefixExpr(.amp, PrefixExpr(.amp, CallOrCastExpr/CastExpr(T, expr)))
    // for &&T(expr), meaning "cast expr to type **T", not "address-of address-of cast".
    if expr.op == .amp && expr.expr is ast.PrefixExpr {
        inner_prefix := expr.expr as ast.PrefixExpr
        if inner_prefix.op == .amp {
            if inner_prefix.expr is ast.CallOrCastExpr {
                coce := inner_prefix.expr as ast.CallOrCastExpr
                inner_val := b.build_expr(coce.expr)
                inner_type := b.mod.values[inner_val].typ
                if inner_type != 0 && int(inner_type) < b.mod.type_store.types.len {
                    inner_t := b.mod.type_store.types[inner_type]
                    if inner_t.kind == .ptr_t || inner_t.kind == .int_t {
                        // &&T(expr): cast to **T = ptr(ptr(T))
                        target_elem := b.ast_type_to_ssa(coce.lhs)
                        ptr_type := b.mod.type_store.get_ptr(target_elem)
                        ptr_ptr_type := b.mod.type_store.get_ptr(ptr_type)
                        return b.mod.add_instr(.bitcast, b.cur_block, ptr_ptr_type, [
                            inner_val,
                        ])
                    }
                }
            } else if inner_prefix.expr is ast.CastExpr {
                cast_expr := inner_prefix.expr as ast.CastExpr
                inner_val := b.build_expr(cast_expr.expr)
                inner_type := b.mod.values[inner_val].typ
                if inner_type != 0 && int(inner_type) < b.mod.type_store.types.len {
                    inner_t := b.mod.type_store.types[inner_type]
                    if inner_t.kind == .ptr_t || inner_t.kind == .int_t {
                        target_elem := b.ast_type_to_ssa(cast_expr.typ)
                        ptr_type := b.mod.type_store.get_ptr(target_elem)
                        ptr_ptr_type := b.mod.type_store.get_ptr(ptr_type)
                        return b.mod.add_instr(.bitcast, b.cur_block, ptr_ptr_type, [
                            inner_val,
                        ])
                    }
                }
            }
        }
    }

    // Special case: negation of float literal → create negated constant directly.
    // This handles -0.0 correctly (fsub(0,0) = +0.0 per IEEE 754, but -0.0 has sign bit set).
    if expr.op == .minus && expr.expr is ast.BasicLiteral {
        lit := expr.expr as ast.BasicLiteral
        is_float_lit := lit.value.contains('.')
            || (!lit.value.starts_with('0x') && !lit.value.starts_with('0X')
            && (lit.value.contains('e') || lit.value.contains('E')))
        if is_float_lit {
            neg_str := '-' + lit.value
            float_type := b.mod.type_store.get_float(64)
            return b.mod.get_or_add_const(float_type, neg_str)
        }
    }

    val := b.build_expr(expr.expr)

    match expr.op {
        .minus {
            val_type := b.mod.values[val].typ
            is_float := val_type > 0 && int(val_type) < b.mod.type_store.types.len
                && b.mod.type_store.types[val_type].kind == .float_t
            if is_float {
                // Float negation at runtime: XOR with sign bit mask.
                // Use integer type for XOR since it's a bit operation.
                i64_type := b.mod.type_store.get_int(64)
                sign_mask := b.mod.get_or_add_const(i64_type, '0x8000000000000000')
                int_val := b.mod.add_instr(.bitcast, b.cur_block, i64_type, [val])
                xored := b.mod.add_instr(.xor, b.cur_block, i64_type, [int_val, sign_mask])
                return b.mod.add_instr(.bitcast, b.cur_block, val_type, [xored])
            }
            zero := b.mod.get_or_add_const(val_type, '0')
            return b.mod.add_instr(.sub, b.cur_block, val_type, [zero, val])
        }
        .not {
            // Logical NOT: !x → (x == 0)
            // Returns 1 if x is 0, 0 if x is non-zero
            zero := b.mod.get_or_add_const(b.mod.values[val].typ, '0')
            return b.mod.add_instr(.eq, b.cur_block, b.mod.type_store.get_int(1), [
                val,
                zero,
            ])
        }
        .amp {
            // Address-of: return the alloca pointer for the variable
            addr := b.build_addr(expr.expr)
            if addr != 0 {
                // Sumtype `_data` stores escape the current scope. Materialize a heap copy
                // instead of passing through the address of stack-backed data.
                if b.in_sumtype_data {
                    if heap_ptr := b.heap_copy_from_address(addr) {
                        return heap_ptr
                    }
                }
                return addr
            }
            // No addressable location (e.g. function call return value) –
            // For function references, &fn_name is just the function pointer
            // itself — no extra indirection needed.
            if b.mod.values[val].kind == .func_ref {
                return val
            }
            // For sumtype boxing, the pointee must outlive the wrapping scope.
            if b.in_sumtype_data {
                if heap_ptr := b.heap_copy_value(val) {
                    return heap_ptr
                }
            }
            // For struct types, use heap allocation so the pointer survives
            // the current scope (needed for sum type boxing where _data
            // must outlive the wrapping function).
            // For scalars, use stack alloca (they're typically short-lived).
            val_type := b.mod.values[val].typ
            if val_type != 0 {
                ptr_type := b.mod.type_store.get_ptr(val_type)
                typ_info := b.mod.type_store.types[val_type]
                if typ_info.kind == .struct_t {
                    // Heap-allocate struct values to ensure pointer validity
                    heap_ptr := b.mod.add_instr(.heap_alloc, b.cur_block, ptr_type, []ValueID{})
                    b.mod.add_instr(.store, b.cur_block, 0, [val, heap_ptr])
                    return heap_ptr
                }
                alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
                b.mod.add_instr(.store, b.cur_block, 0, [val, alloca])
                return alloca
            }
            return val
        }
        .bit_not {
            neg_one := b.mod.get_or_add_const(b.mod.values[val].typ, '-1')
            return b.mod.add_instr(.xor, b.cur_block, b.mod.values[val].typ, [val, neg_one])
        }
        .mul {
            // Dereference: load from pointer
            val_type := b.mod.values[val].typ
            if val_type != 0 && int(val_type) < b.mod.type_store.types.len {
                typ := b.mod.type_store.types[val_type]
                if typ.kind == .ptr_t && typ.elem_type != 0 {
                    return b.mod.add_instr(.load, b.cur_block, typ.elem_type, [val])
                }
            }
            return val
        }
        else {
            return val
        }
    }
}

fn (mut b Builder) build_call(expr ast.CallExpr) ValueID {
    // Resolve function name
    fn_name := b.resolve_call_name(expr)
    mut module_call_name := ''
    if expr.lhs is ast.SelectorExpr {
        module_call_name = b.selector_module_name(expr.lhs as ast.SelectorExpr) or { '' }
    }

    // Check if this is a type cast disguised as a call (e.g., IError(ptr)).
    // If the name is a struct type and not a registered function, treat as cast.
    if fn_name !in b.fn_index && expr.args.len == 1 {
        // Try to find a struct type matching this name
        if target_type := b.struct_types[fn_name] {
            val := b.build_expr(expr.args[0])
            src_type := b.mod.values[val].typ
            if src_type == target_type {
                return val
            }
            return b.mod.add_instr(.bitcast, b.cur_block, target_type, [val])
        }
        // Also try with module prefix
        qualified := '${b.cur_module}__${fn_name}'
        if target_type := b.struct_types[qualified] {
            val := b.build_expr(expr.args[0])
            src_type := b.mod.values[val].typ
            if src_type == target_type {
                return val
            }
            return b.mod.add_instr(.bitcast, b.cur_block, target_type, [val])
        }
    }

    mut ret_type := b.expr_type(ast.Expr(expr))
    // If the function is registered, always use its declared return type.
    // This is critical for void functions like push_noscan: the checker may
    // annotate the transformed call expression with the type of the original
    // expression (e.g., array struct for `arr << val`), but the actual
    // function returns void. Using the wrong return type causes the ARM64
    // backend to emit incorrect struct-return ABI handling.
    if fn_name in b.fn_index {
        fn_idx := b.fn_index[fn_name]
        ret_type = b.mod.funcs[fn_idx].typ
    }
    // Check if this is a function pointer field call (e.g., m.hash_fn(pkey))
    // rather than a method call. If the selector field matches a struct field name
    // and the resolved function name is not in fn_index, it's a function pointer call.
    if expr.lhs is ast.SelectorExpr {
        sel := expr.lhs as ast.SelectorExpr
        if module_call_name == '' && fn_name !in b.fn_index {
            field_name := sel.rhs.name
            mut is_fnptr_field_call := b.is_struct_field(sel.lhs, field_name)
            // Interface method calls are transformed to selector-based function-pointer
            // calls (e.g. `i.msg(i._object)`), but the receiver type is `Interface`,
            // so `is_struct_field` alone returns false.
            if !is_fnptr_field_call && b.env != unsafe { nil } {
                sel_pos := sel.pos
                if sel_pos.is_valid() {
                    if sel_type := b.env.get_expr_type(sel_pos.id) {
                        if sel_type is types.FnType {
                            is_fnptr_field_call = true
                        }
                    }
                }
            }
            if is_fnptr_field_call {
                // Build the selector expression to get the function pointer value
                fn_ptr := b.build_selector(sel)
                // Recover return type for function-pointer field calls from checker
                // metadata. The transformed AST can lose direct call expression typing,
                // which would otherwise fall back to i64 and break ABI lowering.
                mut call_ret := ret_type
                if b.env != unsafe { nil } {
                    lhs_pos := sel.pos
                    if lhs_pos.is_valid() {
                        if field_type := b.env.get_expr_type(lhs_pos.id) {
                            unwrapped := b.unwrap_alias_type(field_type)
                            if unwrapped is types.FnType {
                                if fn_ret := unwrapped.get_return_type() {
                                    call_ret = b.type_to_ssa(fn_ret)
                                }
                            }
                        }
                    }
                }
                // Build arguments (no receiver - this is a field access, not a method call)
                mut fnptr_args := []ValueID{}
                for arg in expr.args {
                    if arg is ast.ModifierExpr && arg.kind == .key_mut {
                        addr := b.build_addr(arg.expr)
                        if addr != 0 {
                            fnptr_args << addr
                        } else {
                            fnptr_args << b.build_expr(arg)
                        }
                    } else {
                        fnptr_args << b.build_expr(arg)
                    }
                }
                mut operands := []ValueID{cap: fnptr_args.len + 1}
                operands << fn_ptr
                operands << fnptr_args
                return b.mod.add_instr(.call_indirect, b.cur_block, call_ret, operands)
            }
        }
    }

    // Build arguments
    mut args := []ValueID{}
    // For method calls, add receiver as first arg
    if expr.lhs is ast.SelectorExpr {
        sel := expr.lhs as ast.SelectorExpr
        // Check if this is a method call (not a module function call)
        if module_call_name == '' {
            // Check if method expects pointer receiver (mut receiver)
            mut expects_ptr := false
            if fn_name in b.fn_index {
                fn_idx := b.fn_index[fn_name]
                if b.mod.funcs[fn_idx].params.len > 0 {
                    param_type := b.mod.values[b.mod.funcs[fn_idx].params[0]].typ
                    if param_type < b.mod.type_store.types.len
                        && b.mod.type_store.types[param_type].kind == .ptr_t {
                        expects_ptr = true
                    }
                }
            }
            mut receiver := if expects_ptr {
                // Mut receiver: pass address (pointer to struct)
                addr := b.build_addr(sel.lhs)
                if addr != 0 {
                    // build_addr for an Ident returns the alloca.
                    // For a mut receiver variable, the alloca is ptr(ptr(Struct)),
                    // storing the struct pointer. We need to load from the alloca
                    // to get the actual struct pointer ptr(Struct).
                    addr_typ := b.mod.values[addr].typ
                    if addr_typ < b.mod.type_store.types.len
                        && b.mod.type_store.types[addr_typ].kind == .ptr_t {
                        inner := b.mod.type_store.types[addr_typ].elem_type
                        if inner < b.mod.type_store.types.len
                            && b.mod.type_store.types[inner].kind == .ptr_t {
                            pointee := b.mod.type_store.types[inner].elem_type
                            if pointee < b.mod.type_store.types.len
                                && b.mod.type_store.types[pointee].kind == .struct_t {
                                // addr is ptr(ptr(Struct)) — load to get ptr(Struct)
                                b.mod.add_instr(.load, b.cur_block, inner, [addr])
                            } else {
                                addr
                            }
                        } else {
                            addr
                        }
                    } else {
                        addr
                    }
                } else {
                    b.build_expr(sel.lhs)
                }
            } else {
                b.build_expr(sel.lhs)
            }
            // Auto-deref pointer receivers: if receiver is a pointer to a struct
            // but the method expects a value receiver, load through the pointer
            if !expects_ptr {
                recv_typ := b.mod.values[receiver].typ
                if recv_typ < b.mod.type_store.types.len
                    && b.mod.type_store.types[recv_typ].kind == .ptr_t {
                    pointee := b.mod.type_store.types[recv_typ].elem_type
                    if pointee < b.mod.type_store.types.len
                        && b.mod.type_store.types[pointee].kind == .struct_t {
                        receiver = b.mod.add_instr(.load, b.cur_block, pointee, [
                            receiver,
                        ])
                    }
                }
            }
            args << receiver
        }
    }
    // Determine parameter types to decide if we should pass addresses for mut receivers
    mut fn_params := []ValueID{}
    if fn_name in b.fn_index {
        fn_params = b.mod.funcs[b.fn_index[fn_name]].params.clone()
    }
    for arg in expr.args {
        // For mut arguments, pass the address (pointer) instead of the value.
        // But if the value is already a pointer (e.g., &FileSet field or parameter),
        // pass it directly instead of creating an extra level of indirection.
        if arg is ast.ModifierExpr && arg.kind == .key_mut {
            // Check if the parameter expects ptr(struct)
            param_idx := args.len
            mut param_wants_ptr_to_struct := false
            if param_idx < fn_params.len {
                param_type := b.mod.values[fn_params[param_idx]].typ
                if param_type < b.mod.type_store.types.len
                    && b.mod.type_store.types[param_type].kind == .ptr_t {
                    pointee := b.mod.type_store.types[param_type].elem_type
                    if pointee < b.mod.type_store.types.len
                        && b.mod.type_store.types[pointee].kind == .struct_t {
                        param_wants_ptr_to_struct = true
                    }
                }
            }
            if param_wants_ptr_to_struct {
                // Check if the value is already a pointer — if so, pass it directly
                val := b.build_expr(arg.expr)
                val_type := b.mod.values[val].typ
                val_is_ptr := val_type < b.mod.type_store.types.len
                    && b.mod.type_store.types[val_type].kind == .ptr_t
                if val_is_ptr {
                    args << val
                } else {
                    // Value type: take its address
                    addr := b.build_addr(arg.expr)
                    if addr != 0 {
                        args << addr
                    } else {
                        alloca_type := b.mod.type_store.get_ptr(val_type)
                        tmp_alloca := b.mod.add_instr(.alloca, b.cur_block, alloca_type,
                            []ValueID{})
                        b.mod.add_instr(.store, b.cur_block, 0, [val, tmp_alloca])
                        args << tmp_alloca
                    }
                }
            } else {
                // Check if the parameter type is already a pointer (e.g., `mut buf &u8`).
                // If so, the function takes a plain pointer, not pointer-to-pointer,
                // so evaluate the expression directly instead of taking its address.
                param_idx2 := args.len
                mut param_is_already_ptr := false
                if param_idx2 < fn_params.len {
                    pt := b.mod.values[fn_params[param_idx2]].typ
                    if pt < b.mod.type_store.types.len && b.mod.type_store.types[pt].kind == .ptr_t {
                        pointee2 := b.mod.type_store.types[pt].elem_type
                        // Only skip addr-of if pointee is NOT a struct (struct mut params need addr-of)
                        if pointee2 < b.mod.type_store.types.len
                            && b.mod.type_store.types[pointee2].kind != .struct_t {
                            param_is_already_ptr = true
                        }
                    }
                }
                if param_is_already_ptr
                    || (arg.expr is ast.PrefixExpr && (arg.expr as ast.PrefixExpr).op == .amp) {
                    // Parameter already expects a pointer value (not pointer-to-value),
                    // or argument explicitly provides a pointer with &.
                    args << b.build_expr(arg.expr)
                } else {
                    addr := b.build_addr(arg.expr)
                    if addr != 0 {
                        args << addr
                    } else {
                        val := b.build_expr(arg.expr)
                        val_type := b.mod.values[val].typ
                        alloca_type := b.mod.type_store.get_ptr(val_type)
                        tmp_alloca := b.mod.add_instr(.alloca, b.cur_block, alloca_type,
                            []ValueID{})
                        b.mod.add_instr(.store, b.cur_block, 0, [val, tmp_alloca])
                        args << tmp_alloca
                    }
                }
            }
        } else {
            // Use args.len as param index (accounts for receiver already in args)
            param_idx := args.len
            mut param_wants_struct_ptr := false
            if param_idx < fn_params.len {
                param_type := b.mod.values[fn_params[param_idx]].typ
                // Only use build_addr for ptr(struct_t) params (mut receivers/params),
                // NOT for ptr(int_t), ptr(ptr_t) etc. (normal pointer params like C.puts)
                if param_type < b.mod.type_store.types.len
                    && b.mod.type_store.types[param_type].kind == .ptr_t {
                    pointee := b.mod.type_store.types[param_type].elem_type
                    if pointee < b.mod.type_store.types.len
                        && b.mod.type_store.types[pointee].kind == .struct_t {
                        param_wants_struct_ptr = true
                    }
                }
            }
            // For args where the function expects ptr(struct) (mut receiver/param),
            // try to pass the original variable address instead of a copy
            if param_wants_struct_ptr && (arg is ast.Ident || arg is ast.SelectorExpr
                || arg is ast.IndexExpr || arg is ast.ParenExpr) {
                // First try build_expr: if it already returns ptr(struct), use it directly
                val := b.build_expr(arg)
                val_typ := b.mod.values[val].typ
                val_is_ptr := val_typ < b.mod.type_store.types.len
                    && b.mod.type_store.types[val_typ].kind == .ptr_t
                if val_is_ptr {
                    // Already a pointer (e.g., mut receiver re-passing its own pointer)
                    args << val
                } else {
                    // Value type (local mut variable): use build_addr to get the alloca
                    addr := b.build_addr(arg)
                    if addr != 0 {
                        args << addr
                    } else {
                        args << val
                    }
                }
            } else {
                args << b.build_expr(arg)
            }
        }
    }

    // Auto-deref/ref arguments to match function parameter types
    if fn_params.len > 0 {
        for ai := 0; ai < args.len && ai < fn_params.len; ai++ {
            arg_type := b.mod.values[args[ai]].typ
            param_type := b.mod.values[fn_params[ai]].typ
            if arg_type < b.mod.type_store.types.len && param_type < b.mod.type_store.types.len {
                arg_kind := b.mod.type_store.types[arg_type].kind
                param_kind := b.mod.type_store.types[param_type].kind
                // Pointer arg but value param: auto-deref
                // Only auto-deref when the pointee is a struct and the
                // parameter expects that struct value. Do NOT deref raw
                // pointers (ptr(i8)/voidptr) when the param is a plain
                // int type (e.g., i64 from variadic params).
                if arg_kind == .ptr_t && param_kind == .struct_t {
                    pointee := b.mod.type_store.types[arg_type].elem_type
                    if pointee == param_type {
                        args[ai] = b.mod.add_instr(.load, b.cur_block, pointee, [
                            args[ai],
                        ])
                    }
                }
                // Value arg but pointer param: auto-ref (alloca + store + pass pointer)
                if arg_kind == .struct_t && param_kind == .ptr_t {
                    ptr_type := b.mod.type_store.get_ptr(arg_type)
                    alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
                    b.mod.add_instr(.store, b.cur_block, 0, [args[ai], alloca])
                    args[ai] = alloca
                }
                if arg_kind == .array_t && param_kind == .ptr_t {
                    pointee := b.mod.type_store.types[param_type].elem_type
                    if pointee == arg_type {
                        ptr_type := b.mod.type_store.get_ptr(arg_type)
                        alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
                        b.mod.add_instr(.store, b.cur_block, 0, [args[ai], alloca])
                        args[ai] = alloca
                    }
                }
                // Int arg but float param: auto-convert (sitofp)
                if arg_kind == .int_t && param_kind == .float_t {
                    args[ai] = b.mod.add_instr(.sitofp, b.cur_block, param_type, [
                        args[ai],
                    ])
                }
                // Scalar arg but voidptr param: auto-ref for builtin methods
                // (array insert/prepend, map delete/set/get, new_array_with_default, etc. take voidptr = "pointer to element")
                i8_t := b.mod.type_store.get_int(8)
                voidptr_t := b.mod.type_store.get_ptr(i8_t)
                if param_type == voidptr_t && arg_kind in [.int_t, .float_t]
                    && (fn_name.contains('array__') || fn_name.contains('map__')
                    || fn_name.contains('new_array')) {
                    ptr_type := b.mod.type_store.get_ptr(arg_type)
                    alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
                    b.mod.add_instr(.store, b.cur_block, 0, [args[ai], alloca])
                    args[ai] = alloca
                }
            }
        }
    }

    // Check if fn_name is a local variable holding a function pointer
    // (e.g., `cfn(s)` where cfn is a parameter of type `fn(string) string`)
    if fn_name in b.vars {
        // The ret_type from expr_type may be wrong — it uses the expression position,
        // which for fn-by-name .map() expansion points to the function identifier
        // (typed as FnType → ptr(i8)) instead of the call return type.
        // Extract the actual return type from the FnType.
        mut call_ret := ret_type
        if expr.lhs is ast.Ident {
            lhs_pos := expr.lhs.pos
            if lhs_pos.is_valid() && b.env != unsafe { nil } {
                if var_type := b.env.get_expr_type(lhs_pos.id) {
                    unwrapped := b.unwrap_alias_type(var_type)
                    if unwrapped is types.FnType {
                        if fn_ret := unwrapped.get_return_type() {
                            call_ret = b.type_to_ssa(fn_ret)
                        }
                    }
                }
            }
        }
        fn_ptr := b.build_ident(ast.Ident{ name: fn_name })
        mut indirect_operands := []ValueID{cap: args.len + 1}
        indirect_operands << fn_ptr
        indirect_operands << args
        return b.mod.add_instr(.call_indirect, b.cur_block, call_ret, indirect_operands)
    }

    // Check if fn_name is a global variable holding a function pointer
    // (e.g., `__live_hot_fn(args)` where __live_hot_fn is a global voidptr)
    if glob_id := b.find_global(fn_name) {
        glob_typ := b.mod.values[glob_id].typ
        elem_typ := b.mod.type_store.types[glob_typ].elem_type
        fn_ptr := b.mod.add_instr(.load, b.cur_block, elem_typ, [glob_id])
        mut indirect_operands := []ValueID{cap: args.len + 1}
        indirect_operands << fn_ptr
        indirect_operands << args
        return b.mod.add_instr(.call_indirect, b.cur_block, ret_type, indirect_operands)
    }

    fn_ref := b.get_or_create_fn_ref(fn_name, ret_type)
    mut operands := []ValueID{cap: args.len + 1}
    operands << fn_ref
    operands << args

    call_val := b.mod.add_instr(.call, b.cur_block, ret_type, operands)

    // array__first/last/pop/pop_left return voidptr (pointer to element).
    // Dereference the result to get the actual element value.
    if fn_name in ['array__first', 'array__last', 'array__pop', 'array__pop_left',
        'builtin__array__first', 'builtin__array__last', 'builtin__array__pop',
        'builtin__array__pop_left'] {
        elem_type := b.infer_array_elem_type_from_receiver(expr)
        if elem_type != 0 {
            elem_ptr := b.mod.type_store.get_ptr(elem_type)
            typed_ptr := b.mod.add_instr(.bitcast, b.cur_block, elem_ptr, [call_val])
            return b.mod.add_instr(.load, b.cur_block, elem_type, [typed_ptr])
        }
    }

    return call_val
}

// infer_array_elem_type_from_receiver infers the element type of an array
// from the first argument (receiver) of array methods like first/last/pop.
fn (mut b Builder) infer_array_elem_type_from_receiver(expr ast.CallExpr) TypeID {
    if b.env == unsafe { nil } || expr.args.len == 0 {
        return 0
    }
    receiver := expr.args[0]
    pos := receiver.pos()
    if pos.id != 0 {
        if arr_typ := b.env.get_expr_type(pos.id) {
            if arr_typ is types.Array {
                return b.type_to_ssa(arr_typ.elem_type)
            }
        }
    }
    return 0
}

fn (mut b Builder) selector_module_name(sel ast.SelectorExpr) ?string {
    if sel.lhs !is ast.Ident {
        return none
    }
    mod_ident := sel.lhs as ast.Ident
    if mod_ident.name == 'C' {
        return 'C'
    }
    if b.env != unsafe { nil } {
        if scope := b.env.get_scope(b.cur_module) {
            if obj := scope.lookup_parent(mod_ident.name, 0) {
                if obj is types.Module {
                    return obj.name.replace('.', '_')
                }
                return none
            }
        }
    }
    qualified := '${mod_ident.name}__${sel.rhs.name}'
    if qualified in b.fn_index {
        return mod_ident.name
    }
    return none
}

fn (mut b Builder) is_module_name(expr ast.Expr) bool {
    if expr is ast.Ident {
        if b.env != unsafe { nil } {
            if scope := b.env.get_scope(b.cur_module) {
                if obj := scope.lookup_parent(expr.name, 0) {
                    return obj is types.Module
                }
            }
        }
    }
    return false
}

fn (mut b Builder) resolve_call_name(expr ast.CallExpr) string {
    match expr.lhs {
        ast.Ident {
            name := expr.lhs.name
            // Try module-qualified FIRST to avoid shadowing by C functions.
            // E.g., os.getenv() should resolve to os__getenv, not C.getenv.
            qualified := '${b.cur_module}__${name}'
            if qualified in b.fn_index {
                return qualified
            }
            // Check if it's a known function
            if name in b.fn_index {
                return name
            }
            // Try builtin-qualified (transformer remaps builtin__X to X)
            builtin_qualified := 'builtin__${name}'
            if builtin_qualified in b.fn_index {
                return builtin_qualified
            }
            // For names with module prefix (e.g., v__error), try replacing
            // the module prefix with builtin__
            if idx := name.index('__') {
                suffix := name[idx + 2..]
                alt := 'builtin__${suffix}'
                if alt in b.fn_index {
                    return alt
                }
            }
            // Resolve operator method names: the transformer generates e.g.
            // 'string__plus' but the SSA builder registers 'builtin__string__+'
            // Map transformer names to operator symbols.
            op_map := {
                'plus':  '+'
                'minus': '-'
                'mult':  '*'
                'div':   '/'
                'mod':   '%'
                'eq':    '=='
                'ne':    '!='
                'lt':    '<'
                'gt':    '>'
                'le':    '<='
                'ge':    '>='
            }
            if idx2 := name.last_index('__') {
                method_part := name[idx2 + 2..]
                if op_sym := op_map[method_part] {
                    type_part := name[..idx2]
                    op_name := '${type_part}__${op_sym}'
                    if op_name in b.fn_index {
                        return op_name
                    }
                    op_builtin := 'builtin__${op_name}'
                    if op_builtin in b.fn_index {
                        return op_builtin
                    }
                }
            }
            // Self-hosted ARM64 builds can lower byte helper calls through the
            // signed 8-bit prefix even though the builtin methods live on `u8`.
            if name.starts_with('i8__') {
                byte_name := 'u8__${name['i8__'.len..]}'
                if byte_name in b.fn_index {
                    return byte_name
                }
                builtin_byte_name := 'builtin__${byte_name}'
                if builtin_byte_name in b.fn_index {
                    return builtin_byte_name
                }
            }
            if name.starts_with('builtin__i8__') {
                byte_name := 'builtin__u8__${name['builtin__i8__'.len..]}'
                if byte_name in b.fn_index {
                    return byte_name
                }
            }
            // C functions: strip C__ prefix for direct C interop
            if name.starts_with('C__') {
                return name[3..]
            }
            // Transformer generates Array_module__Type__method (V1 naming) but SSA
            // registers as module__Array_Type__method. Remap:
            // Array_ast__Attribute__has → ast__Array_Attribute__has
            if name.starts_with('Array_') {
                rest := name[6..] // after "Array_"
                if mod_end := rest.index('__') {
                    mod_name := rest[..mod_end]
                    after_mod := rest[mod_end + 2..]
                    remap := '${mod_name}__Array_${after_mod}'
                    if remap in b.fn_index {
                        return remap
                    }
                }
            }
            // V1 C backend naming uses single underscore for type_method (e.g., array_push_noscan),
            // but SSA builder uses double underscore (array__push_noscan).
            // Try converting known type prefixes from single to double underscore.
            v1_type_prefixes := ['array_', 'string_', 'int_', 'i8_', 'i16_', 'i64_', 'u8_', 'u16_',
                'u32_', 'u64_', 'f32_', 'f64_', 'bool_', 'map_', 'rune_', 'char_']
            // Check bare name (e.g., "array_push_noscan") and builtin-prefixed
            for prefix in v1_type_prefixes {
                // Check bare name
                if name.starts_with(prefix) {
                    type_name := prefix[..prefix.len - 1]
                    method_part := name[prefix.len..]
                    double_name := '${type_name}__${method_part}'
                    if double_name in b.fn_index {
                        return double_name
                    }
                    double_builtin := 'builtin__${double_name}'
                    if double_builtin in b.fn_index {
                        return double_builtin
                    }
                }
                // Check builtin__type_method
                bp := 'builtin__${prefix}'
                if name.starts_with(bp) {
                    type_name := prefix[..prefix.len - 1]
                    method_part := name[bp.len..]
                    double_name := 'builtin__${type_name}__${method_part}'
                    if double_name in b.fn_index {
                        return double_name
                    }
                }
            }
            return name
        }
        ast.SelectorExpr {
            sel := expr.lhs as ast.SelectorExpr
            if mod_name := b.selector_module_name(sel) {
                // Module function call: module.fn()
                // C functions: C.puts() → just 'puts' for direct C interop
                if mod_name == 'C' {
                    return sel.rhs.name
                }
                qualified := '${mod_name}__${sel.rhs.name}'
                if qualified in b.fn_index {
                    return qualified
                }
                return qualified
            }
            // Method call: expr.method()
            mut receiver_type := b.get_receiver_type_name(sel.lhs)
            // Strip pointer prefix for method resolution (e.g., Point* → Point)
            for receiver_type.ends_with('*') {
                receiver_type = receiver_type[..receiver_type.len - 1]
            }
            method_name := '${receiver_type}__${sel.rhs.name}'
            if method_name in b.fn_index {
                return method_name
            }
            // Try with builtin__ prefix (e.g., Array_rune__string → builtin__Array_rune__string)
            builtin_method := 'builtin__${method_name}'
            if builtin_method in b.fn_index {
                return builtin_method
            }
            // Try with current module prefix
            if b.cur_module != '' && b.cur_module != 'main' {
                mod_method := '${b.cur_module}__${method_name}'
                if mod_method in b.fn_index {
                    return mod_method
                }
            }
            // Try alias names: strings.Builder = []u8 = array. The receiver_type
            // from SSA may be 'array', but the method is registered under
            // 'strings__Builder'. Find all struct_types names with the same TypeID.
            if type_id := b.struct_types[receiver_type] {
                for alt_name, alt_id in b.struct_types {
                    if alt_id == type_id && alt_name != receiver_type {
                        alt_method := '${alt_name}__${sel.rhs.name}'
                        if alt_method in b.fn_index {
                            return alt_method
                        }
                        alt_builtin := 'builtin__${alt_method}'
                        if alt_builtin in b.fn_index {
                            return alt_builtin
                        }
                    }
                }
            }
            // Handle Array_T patterns: Array_u8, Array_int, Array_string, etc.
            // These are SSA names for V generic arrays ([]u8, []int, etc.).
            // Methods may be registered under 'array__method' (base) or
            // 'strings__Builder__method' (for Array_u8 = []u8 = strings.Builder).
            if receiver_type.starts_with('Array_') {
                // Try array__method (base array type)
                array_method := 'array__${sel.rhs.name}'
                if array_method in b.fn_index {
                    return array_method
                }
                builtin_array := 'builtin__array__${sel.rhs.name}'
                if builtin_array in b.fn_index {
                    return builtin_array
                }
                // For Array_u8, also try strings__Builder__method
                if receiver_type == 'Array_u8' {
                    builder_method := 'strings__Builder__${sel.rhs.name}'
                    if builder_method in b.fn_index {
                        return builder_method
                    }
                    builtin_builder := 'builtin__strings__Builder__${sel.rhs.name}'
                    if builtin_builder in b.fn_index {
                        return builtin_builder
                    }
                }
                // Try specialized Array_T__method (e.g., Array_string__join)
                spec_method := 'builtin__${method_name}'
                if spec_method in b.fn_index {
                    return spec_method
                }
                // For Array_ast__T, try ast__Array_T__method (strip module prefix from type)
                if receiver_type.starts_with('Array_ast__') {
                    inner := receiver_type.replace('Array_ast__', 'Array_')
                    ast_method := 'ast__${inner}__${sel.rhs.name}'
                    if ast_method in b.fn_index {
                        return ast_method
                    }
                }
            }
            // Self-hosted ARM64 builds can infer byte-oriented receivers as `i8`
            // instead of `u8`; fall back to the existing byte helper methods only
            // after the direct `i8`/`Array_i8` lookup path failed.
            if receiver_type == 'i8' {
                byte_method := 'u8__${sel.rhs.name}'
                if byte_method in b.fn_index {
                    return byte_method
                }
                builtin_byte_method := 'builtin__${byte_method}'
                if builtin_byte_method in b.fn_index {
                    return builtin_byte_method
                }
            }
            if receiver_type == 'Array_i8' {
                byte_array_method := 'Array_u8__${sel.rhs.name}'
                if byte_array_method in b.fn_index {
                    return byte_array_method
                }
                builtin_byte_array_method := 'builtin__${byte_array_method}'
                if builtin_byte_array_method in b.fn_index {
                    return builtin_byte_array_method
                }
            }
            // i64 aliases: time.Duration = i64
            if receiver_type == 'i64' {
                dur_method := 'time__Duration__${sel.rhs.name}'
                if dur_method in b.fn_index {
                    return dur_method
                }
            }
            // void/voidptr methods
            if receiver_type == 'void' || receiver_type == 'voidptr' {
                voidptr_method := 'builtin__voidptr__${sel.rhs.name}'
                if voidptr_method in b.fn_index {
                    return voidptr_method
                }
            }
            // array base type: try specialized Array_string__ for array-specific methods
            if receiver_type == 'array' {
                arr_string_method := 'builtin__Array_string__${sel.rhs.name}'
                if arr_string_method in b.fn_index {
                    return arr_string_method
                }
            }
            // OptionType/ResultType aliased to base Type
            if receiver_type.contains('Option') || receiver_type.contains('Result') {
                base_method := 'types__Type__${sel.rhs.name}'
                if base_method in b.fn_index {
                    return base_method
                }
            }
            // When method resolution failed completely, scan fn_index for matching suffix.
            // Only for 'unknown' receiver (env type lookup failed completely).
            if receiver_type == 'unknown' {
                method_suffix := '__${sel.rhs.name}'
                mut best_match := ''
                for fn_name, _ in b.fn_index {
                    if fn_name.ends_with(method_suffix) {
                        if b.cur_module != '' && fn_name.starts_with('${b.cur_module}__') {
                            return fn_name
                        }
                        if best_match == '' {
                            best_match = fn_name
                        }
                    }
                }
                if best_match != '' {
                    return best_match
                }
            }
            return method_name
        }
        else {
            return 'unknown_fn'
        }
    }
}

fn (mut b Builder) get_receiver_type_name(expr ast.Expr) string {
    // For literals used as method receivers (e.g., `A`.length_in_bytes(), 65.str()),
    // the env type at the literal's position may be the method's function type
    // rather than the literal's value type. Handle these cases before env lookup.
    if expr is ast.BasicLiteral {
        if expr.kind == .char {
            return 'rune'
        }
        if expr.kind == .number {
            if expr.value.contains('.') {
                return 'f64'
            }
            return 'int'
        }
        if expr.kind == .key_true || expr.kind == .key_false {
            return 'bool'
        }
    }
    if expr is ast.StringLiteral || expr is ast.StringInterLiteral {
        return 'string'
    }
    if b.env != unsafe { nil } {
        pos := expr.pos()
        if pos.id != 0 {
            if typ := b.env.get_expr_type(pos.id) {
                return b.types_type_c_name(typ)
            }
        }
    }
    if expr is ast.Ident {
        // Try to get the type from the SSA variable's alloca type.
        // This is more reliable than env.get_expr_type in ARM64-compiled binaries
        // where the type checker's expr_type_values may have corrupt entries.
        if var_id := b.vars[expr.name] {
            mut var_type := b.mod.values[var_id].typ
            // Alloca types are ptr(T), unwrap the pointer to get base type
            if var_type != 0 {
                ts_type := b.mod.type_store.types[int(var_type)]
                if ts_type.kind == .ptr_t && ts_type.elem_type != 0 {
                    var_type = ts_type.elem_type
                }
                name := b.type_id_to_receiver_name(var_type)
                if name != 'unknown' {
                    return name
                }
            }
        }
        return expr.name
    }
    // For CallExpr/CallOrCastExpr, try to infer receiver type from the called
    // function's return type. This is needed when env.get_expr_type fails (e.g.,
    // in ARM64-compiled binaries where the checker's type store may be unreliable).
    if expr is ast.CallExpr {
        call_fn_name := b.resolve_call_name(expr)
        if call_fn_name in b.fn_index {
            fn_idx := b.fn_index[call_fn_name]
            ret_typ := b.mod.funcs[fn_idx].typ
            if ret_typ != 0 {
                return b.type_id_to_receiver_name(ret_typ)
            }
        }
    }
    if expr is ast.CallOrCastExpr {
        // Try resolving as CallExpr for receiver type inference
        call_expr := ast.CallExpr{
            lhs:  expr.lhs
            args: if expr.expr is ast.EmptyExpr { []ast.Expr{} } else { [expr.expr] }
        }
        call_fn_name := b.resolve_call_name(call_expr)
        if call_fn_name in b.fn_index {
            fn_idx := b.fn_index[call_fn_name]
            ret_typ := b.mod.funcs[fn_idx].typ
            if ret_typ != 0 {
                return b.type_id_to_receiver_name(ret_typ)
            }
        }
    }
    // For SelectorExpr (e.g., obj.field), try to resolve the field's type
    // by looking up the LHS type and then the field type in struct definitions.
    if expr is ast.SelectorExpr {
        if b.env != unsafe { nil } {
            lhs_pos := expr.lhs.pos()
            if lhs_pos.id != 0 {
                if lhs_typ := b.env.get_expr_type(lhs_pos.id) {
                    // If the LHS is a struct, look up the field type
                    if lhs_typ is types.Struct {
                        for field in lhs_typ.fields {
                            if field.name == expr.rhs.name {
                                return b.types_type_c_name(field.typ)
                            }
                        }
                    }
                }
            }
        }
    }
    return 'unknown'
}

// type_id_to_receiver_name converts an SSA TypeID to a C-style receiver name
// for method resolution (e.g., 'string', 'array', 'int', struct names).
fn (mut b Builder) type_id_to_receiver_name(typ TypeID) string {
    // Check against known struct types (reverse lookup)
    for name, id in b.struct_types {
        if id == typ {
            return name
        }
    }
    // Check the SSA type kind for primitives
    if int(typ) >= 0 && int(typ) < b.mod.type_store.types.len {
        t := b.mod.type_store.types[int(typ)]
        match t.kind {
            .int_t {
                if t.is_unsigned {
                    return match t.width {
                        8 { 'u8' }
                        16 { 'u16' }
                        64 { 'u64' }
                        else { 'u32' }
                    }
                }
                return match t.width {
                    8 { 'i8' }
                    16 { 'i16' }
                    64 { 'i64' }
                    else { 'int' }
                }
            }
            .float_t {
                return if t.width == 32 { 'f32' } else { 'f64' }
            }
            .ptr_t {
                return 'unknown'
            }
            else {
                return 'unknown'
            }
        }
    }
    return 'unknown'
}

fn (mut b Builder) build_selector(expr ast.SelectorExpr) ValueID {
    // Check for enum shorthand: .field in certain contexts
    if expr.lhs is ast.EmptyExpr || (expr.lhs is ast.Ident && expr.lhs.name == '') {
        // Enum shorthand — try to look up a resolved name
        field_name := expr.rhs.name
        // Collect all matching enum values (not just the first)
        suffix := '__${field_name}'
        mut match_keys := []string{}
        mut match_vals := []int{}
        for key, val in b.enum_values {
            if key.ends_with(suffix) {
                match_keys << key
                match_vals << val
            }
        }
        if match_keys.len == 1 {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), match_vals[0].str())
        }
        if match_keys.len > 1 {
            // Disambiguate: prefer enum from current module
            if b.cur_module != '' {
                if b.cur_module == 'main' {
                    // Main-module enums are registered without module prefix (`Enum__field`).
                    // Prefer those over similarly-named fields from imported modules.
                    for i, mk in match_keys {
                        if mk.split('__').len == 2 {
                            return b.mod.get_or_add_const(b.mod.type_store.get_int(32),
                                match_vals[i].str())
                        }
                    }
                } else {
                    for i, mk in match_keys {
                        if mk.starts_with('${b.cur_module}__') {
                            return b.mod.get_or_add_const(b.mod.type_store.get_int(32),
                                match_vals[i].str())
                        }
                    }
                }
            }
            // Fallback: use the first match
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), match_vals[0].str())
        }
        return b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')
    }

    // Check for qualified enum access: EnumType.value
    if expr.lhs is ast.Ident {
        // Try: EnumType__value (local) or module__EnumType__value (qualified)
        enum_key := '${expr.lhs.name}__${expr.rhs.name}'
        if enum_key in b.enum_values {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32),
                b.enum_values[enum_key].str())
        }
        qualified_key := '${b.cur_module}__${enum_key}'
        if qualified_key in b.enum_values {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32),
                b.enum_values[qualified_key].str())
        }
    }

    // C constant/global access: C.SEEK_END, C.stdout, C.stderr, etc.
    if expr.lhs is ast.Ident && expr.lhs.name == 'C' {
        c_name := expr.rhs.name
        // Well-known C preprocessor constants — emit inline integer values
        // since the native backend cannot resolve C macros.
        c_const_val := match c_name {
            'SEEK_SET' { '0' }
            'SEEK_CUR' { '1' }
            'SEEK_END' { '2' }
            'EOF' { '-1' }
            'NULL' { '0' }
            'O_RDONLY' { '0' }
            'O_WRONLY' { '1' }
            'O_RDWR' { '2' }
            'O_CREAT' { '512' }
            'O_TRUNC' { '1024' }
            'O_EXCL' { '2048' }
            'O_APPEND' { '8' }
            'S_IRUSR' { '256' }
            'S_IWUSR' { '128' }
            'S_IXUSR' { '64' }
            'S_IREAD' { '256' }
            'S_IWRITE' { '128' }
            'S_IEXEC' { '64' }
            'PROT_READ' { '1' }
            'PROT_WRITE' { '2' }
            'SIGTERM' { '15' }
            'SIGKILL' { '9' }
            'SIGINT' { '2' }
            'STDIN_FILENO' { '0' }
            'STDOUT_FILENO' { '1' }
            'STDERR_FILENO' { '2' }
            'DT_DIR' { '4' }
            'DT_REG' { '8' }
            'DT_LNK' { '10' }
            'DT_UNKNOWN' { '0' }
            'ENOENT' { '2' }
            'EXIT_SUCCESS' { '0' }
            'EXIT_FAILURE' { '1' }
            // Termios
            'ICANON' { '256' }
            'ECHO' { '8' }
            'TCSANOW' { '0' }
            'ISIG' { '128' }
            'IEXTEN' { '1024' }
            'TOSTOP' { '4194304' }
            // ioctl
            'TIOCGWINSZ' { '1074295912' }
            // Time
            'CLOCK_MONOTONIC' { '6' }
            'CLOCK_REALTIME' { '0' }
            // System
            '_SC_PAGESIZE' { '29' }
            '_SC_NPROCESSORS_ONLN' { '58' }
            '_SC_PHYS_PAGES' { '200' }
            // Errno
            'EINTR' { '4' }
            'EINVAL' { '22' }
            'EAGAIN' { '35' }
            'EWOULDBLOCK' { '35' }
            'EINPROGRESS' { '36' }
            'EACCES' { '13' }
            'EFAULT' { '14' }
            'EBUSY' { '16' }
            'ETIMEDOUT' { '60' }
            // Stat mode bits (macOS)
            'S_IFBLK' { '24576' }
            'S_IFCHR' { '8192' }
            'S_IFDIR' { '16384' }
            'S_IFIFO' { '4096' }
            'S_IFLNK' { '40960' }
            'S_IFMT' { '61440' }
            'S_IFREG' { '32768' }
            'S_IFSOCK' { '49152' }
            'S_IRGRP' { '32' }
            'S_IROTH' { '4' }
            'S_IWGRP' { '16' }
            'S_IWOTH' { '2' }
            'S_IXGRP' { '8' }
            'S_IXOTH' { '1' }
            // Ptrace
            'PT_DETACH' { '11' }
            'PT_TRACE_ME' { '0' }
            // Signals
            'SIG_ERR' { '-1' }
            'SIG_BLOCK' { '1' }
            'SIG_UNBLOCK' { '2' }
            'SIG_SETMASK' { '3' }
            'SIGCONT' { '19' }
            'SIGSTOP' { '17' }
            // Wait
            'WNOHANG' { '1' }
            // I/O buffering
            '_IOFBF' { '0' }
            '_IOLBF' { '1' }
            '_IONBF' { '2' }
            // File flags
            'O_NONBLOCK' { '4' }
            'O_CLOEXEC' { '16777216' }
            else { '' }
        }

        if c_const_val.len > 0 {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(32), c_const_val)
        }
        // _wyp: wyhash secret array from wyhash.h. Our wyhash stub uses
        // hardcoded constants, so this just needs to be a valid pointer.
        if c_name == '_wyp' {
            i64_t := b.mod.type_store.get_int(64)
            return b.mod.get_or_add_const(i64_t, '0')
        }
        // macOS errno: (*__error()) — call __error() which returns int*
        if c_name == 'errno' {
            i32_t := b.mod.type_store.get_int(32)
            ptr_i32 := b.mod.type_store.get_ptr(i32_t)
            err_fn := b.get_or_create_fn_ref('__error', ptr_i32)
            call_val := b.mod.add_instr(.call, b.cur_block, ptr_i32, [err_fn])
            return b.mod.add_instr(.load, b.cur_block, i32_t, [call_val])
        }
        // Map C standard I/O streams to macOS-specific symbol names
        macos_name := match c_name {
            'stdout' { '__stdoutp' }
            'stderr' { '__stderrp' }
            'stdin' { '__stdinp' }
            else { c_name }
        }

        // Not a known constant — emit as a global reference (e.g. C.stdout, C.stderr)
        i8_t := b.mod.type_store.get_int(8)
        ptr_t := b.mod.type_store.get_ptr(i8_t)
        glob := b.mod.add_value_node(.global, ptr_t, macos_name, 0)
        b.global_refs[macos_name] = glob
        return glob
    }

    // Module-qualified constant/global access: os.args, pref.Backend, etc.
    // When LHS is a module name, resolve module__field as a constant or global.
    if expr.lhs is ast.Ident {
        mod_name := expr.lhs.name.replace('.', '_')
        qualified := '${mod_name}__${expr.rhs.name}'
        // Try as float constant (inline as f64)
        if fval := b.float_const_values[qualified] {
            return b.mod.get_or_add_const(b.mod.type_store.get_float(64), fval)
        }
        // Try as compile-time constant
        if qualified in b.const_values {
            ct := if qualified in b.const_value_types {
                b.const_value_types[qualified]
            } else {
                b.mod.type_store.get_int(64)
            }
            return b.mod.get_or_add_const(ct, b.const_values[qualified].str())
        }
        // Try as string constant
        if qualified in b.string_const_values {
            return b.build_string_literal(ast.StringLiteral{
                kind:  .v
                value: b.string_const_values[qualified]
            })
        }
        // Try as constant array global (return pointer directly for indexing)
        if qualified in b.const_array_globals {
            if glob_id := b.find_global(qualified) {
                return glob_id
            }
        }
        // Try as global variable (runtime-initialized constants like os.args)
        if glob_id := b.find_global(qualified) {
            glob_typ := b.mod.values[glob_id].typ
            elem_typ := b.mod.type_store.types[glob_typ].elem_type
            return b.mod.add_instr(.load, b.cur_block, elem_typ, [glob_id])
        }
    }

    // Check for const array global .len access — return compile-time element count
    if expr.rhs.name == 'len' && expr.lhs is ast.Ident {
        lhs_name := expr.lhs.name
        if count := b.const_array_elem_count[lhs_name] {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), count.str())
        }
        qualified := '${b.cur_module}__${lhs_name}'
        if count := b.const_array_elem_count[qualified] {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), count.str())
        }
        builtin_name := 'builtin__${lhs_name}'
        if count := b.const_array_elem_count[builtin_name] {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), count.str())
        }
    }

    // Use extractvalue for struct field access
    mut base := b.build_expr(expr.lhs)
    // Check for fixed-size array .len access — return compile-time constant
    base_typ_raw := b.mod.values[base].typ
    if base_typ_raw < b.mod.type_store.types.len {
        mut check_typ := b.mod.type_store.types[base_typ_raw]
        // Also handle ptr(array_t) — e.g. when fixed array is behind a pointer
        if check_typ.kind == .ptr_t && check_typ.elem_type < b.mod.type_store.types.len {
            check_typ = b.mod.type_store.types[check_typ.elem_type]
        }
        if check_typ.kind == .array_t && expr.rhs.name == 'len' {
            return b.mod.get_or_add_const(b.mod.type_store.get_int(64), check_typ.len.str())
        }
    }
    // If base is a pointer to struct (mut param or heap alloc), auto-deref
    base_typ := b.mod.values[base].typ
    if base_typ < b.mod.type_store.types.len && b.mod.type_store.types[base_typ].kind == .ptr_t {
        pointee := b.mod.type_store.types[base_typ].elem_type
        if pointee < b.mod.type_store.types.len && b.mod.type_store.types[pointee].kind == .struct_t {
            base = b.mod.add_instr(.load, b.cur_block, pointee, [base])
        }
    }
    field_idx := b.field_index(expr, base)
    // Determine result type: prefer SSA struct field type for struct bases,
    // fall back to type environment.
    // The type environment may have the smartcast variant type (e.g., int) for a
    // sumtype field access, while the SSA struct has the correct field type.
    mut result_type := TypeID(0)
    actual_base_type := b.mod.values[base].typ
    if actual_base_type < b.mod.type_store.types.len {
        typ := b.mod.type_store.types[actual_base_type]
        if typ.kind == .struct_t && field_idx < typ.fields.len {
            result_type = typ.fields[field_idx]
        }
    }
    if result_type == 0 {
        result_type = b.expr_type(ast.Expr(expr))
    }
    return b.mod.add_instr(.extractvalue, b.cur_block, result_type, [base,
        b.mod.get_or_add_const(b.mod.type_store.get_int(32), field_idx.str())])
}

fn (mut b Builder) field_index(expr ast.SelectorExpr, base ValueID) int {
    rhs_name := expr.rhs.name
    // Use type environment to find field index
    if b.env != unsafe { nil } {
        pos := expr.lhs.pos()
        if pos.id != 0 {
            if typ := b.env.get_expr_type(pos.id) {
                st := b.unwrap_to_struct(typ)
                if st.name != '' {
                    for i, f in st.fields {
                        if f.name == rhs_name {
                            return i
                        }
                    }
                }
            }
        }
    }
    // Fallback: look up field name in the SSA struct type of the base value
    base_type_id := b.mod.values[base].typ
    if base_type_id < b.mod.type_store.types.len {
        mut ssa_typ := b.mod.type_store.types[base_type_id]
        // Dereference pointer(s) to get to the struct type
        for ssa_typ.kind == .ptr_t && ssa_typ.elem_type < b.mod.type_store.types.len {
            ssa_typ = b.mod.type_store.types[ssa_typ.elem_type]
        }
        if ssa_typ.kind == .struct_t {
            for i, name in ssa_typ.field_names {
                if name == rhs_name {
                    return i
                }
            }
        }
    }
    // Tuple field access: the transformer generates `_tuple_tN.arg0`, `.arg1`, etc.
    // Tuples have no named fields in the SSA type, so parse the index from `argN`.
    if rhs_name.starts_with('arg') {
        idx_str := rhs_name[3..]
        if idx_str.len > 0 && idx_str[0] >= `0` && idx_str[0] <= `9` {
            return int(parse_const_int_literal(idx_str))
        }
    }
    return 0
}

// is_struct_field checks whether a field name exists as a struct field of the
// receiver expression's type. Used to distinguish function pointer field calls
// (e.g., m.hash_fn(pkey)) from method calls.
fn (mut b Builder) is_struct_field(receiver_expr ast.Expr, field_name string) bool {
    // Try type environment first
    if b.env != unsafe { nil } {
        pos := receiver_expr.pos()
        if pos.id != 0 {
            if typ := b.env.get_expr_type(pos.id) {
                st := b.unwrap_to_struct(typ)
                if st.name != '' {
                    for f in st.fields {
                        if f.name == field_name {
                            return true
                        }
                    }
                }
            }
        }
    }
    return false
}

fn (mut b Builder) unwrap_to_struct(t types.Type) types.Struct {
    match t {
        types.Struct {
            return t
        }
        types.Pointer {
            return b.unwrap_to_struct(t.base_type)
        }
        types.Alias {
            return b.unwrap_to_struct(t.base_type)
        }
        types.Map {
            // Map is a builtin struct type. Look up the 'map' struct from
            // the type checker's scope to get its fields (hash_fn, key_eq_fn, etc).
            if b.env != unsafe { nil } {
                if scope := b.env.get_scope('builtin') {
                    if obj := scope.lookup_parent('map', 0) {
                        obj_type := obj.typ()
                        if obj_type is types.Struct {
                            return obj_type
                        }
                    }
                }
            }
            return types.Struct{}
        }
        else {
            return types.Struct{}
        }
    }
}

// unwrap_to_array_elem_ssa unwraps Pointer and Alias types to find an Array type,
// converts its elem_type to SSA TypeID, and returns it. Returns 0 if not found.
fn (mut b Builder) unwrap_to_array_elem_ssa(t types.Type) TypeID {
    match t {
        types.Array {
            return b.type_to_ssa(t.elem_type)
        }
        types.Pointer {
            return b.unwrap_to_array_elem_ssa(t.base_type)
        }
        types.Alias {
            return b.unwrap_to_array_elem_ssa(t.base_type)
        }
        else {
            return 0
        }
    }
}

fn (mut b Builder) build_index(expr ast.IndexExpr) ValueID {
    mut base_val := b.build_expr(expr.lhs)
    index := b.build_expr(expr.expr)
    mut result_type := b.expr_type(ast.Expr(expr))

    base_type_id := b.mod.values[base_val].typ
    array_type := b.get_array_type()

    // If base is a pointer to a dynamic array (mut []T param), deref first
    if array_type != 0 && base_type_id != array_type {
        if base_type_id < b.mod.type_store.types.len {
            base_typ := b.mod.type_store.types[base_type_id]
            if base_typ.kind == .ptr_t && base_typ.elem_type == array_type {
                base_val = b.mod.add_instr(.load, b.cur_block, array_type, [base_val])
            }
        }
    }

    // Re-check base type after potential deref
    base_type_id2 := b.mod.values[base_val].typ

    // Check if base is a dynamic array (array struct) — need to access .data field
    if array_type != 0 && base_type_id2 == array_type {
        // If result_type is i64 (fallback), try to infer the actual element type
        // from the array expression's checker type. This is needed for transformer-
        // generated IndexExprs (e.g., for-in-array lowering) that have no position ID.
        i64_t := b.mod.type_store.get_int(64)
        if result_type == i64_t {
            // Also try the index expression's own position for type inference
            idx_pos := expr.pos
            if b.env != unsafe { nil } && idx_pos.id != 0 {
                if idx_typ := b.env.get_expr_type(idx_pos.id) {
                    inferred2 := b.type_to_ssa(idx_typ)
                    if inferred2 != 0 && inferred2 != i64_t {
                        result_type = inferred2
                    }
                }
            }
        }
        if result_type == i64_t {
            if b.env != unsafe { nil } {
                lhs_pos := expr.lhs.pos()
                if lhs_pos.id != 0 {
                    if arr_typ := b.env.get_expr_type(lhs_pos.id) {
                        // Unwrap pointer/alias types to get to the array type
                        inferred := b.unwrap_to_array_elem_ssa(arr_typ)
                        if inferred != 0 {
                            result_type = inferred
                        }
                    }
                }
            }
        }
        // If LHS is an array__slice call (transformer-lowered slice), trace
        // back to the original array argument to infer element type.
        if result_type == i64_t {
            if expr.lhs is ast.CallExpr {
                call_lhs := expr.lhs as ast.CallExpr
                if call_lhs.lhs is ast.Ident {
                    call_name := (call_lhs.lhs as ast.Ident).name
                    if call_name == 'array__slice' && call_lhs.args.len >= 1 {
                        if b.env != unsafe { nil } {
                            arr_pos := call_lhs.args[0].pos()
                            if arr_pos.id != 0 {
                                if arr_typ := b.env.get_expr_type(arr_pos.id) {
                                    inferred := b.unwrap_to_array_elem_ssa(arr_typ)
                                    if inferred != 0 {
                                        result_type = inferred
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        // Fallback: use array element type tracked from function parameter declarations.
        // This handles transformer-generated functions (e.g., Array_int_str) where
        // the checker has no position info for the generated IndexExpr.
        if result_type == i64_t {
            if expr.lhs is ast.Ident {
                if elem_t := b.array_elem_types[expr.lhs.name] {
                    result_type = elem_t
                }
            }
        }
        // Extract .data field (index 0), cast to element pointer, then GEP
        i8_t := b.mod.type_store.get_int(8)
        void_ptr := b.mod.type_store.get_ptr(i8_t)
        data_ptr := b.mod.add_instr(.extractvalue, b.cur_block, void_ptr, [base_val,
            b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')])
        // Cast void* to element*
        elem_ptr_type := b.mod.type_store.get_ptr(result_type)
        typed_ptr := b.mod.add_instr(.bitcast, b.cur_block, elem_ptr_type, [data_ptr])
        // GEP to the element
        elem_addr := b.mod.add_instr(.get_element_ptr, b.cur_block, elem_ptr_type, [
            typed_ptr,
            index,
        ])
        // Load the element
        return b.mod.add_instr(.load, b.cur_block, result_type, [elem_addr])
    }

    // Check if base is a string struct — index into .str (field 0) data pointer
    str_type := b.get_string_type()
    if str_type != 0 && base_type_id2 == str_type {
        // Extract .str field (field 0) — pointer to u8 data
        // Use unsigned u8 type so byte comparisons (>= 0x80) work correctly
        u8_t := b.mod.type_store.get_uint(8)
        u8_ptr := b.mod.type_store.get_ptr(u8_t)
        data_ptr := b.mod.add_instr(.extractvalue, b.cur_block, u8_ptr, [base_val,
            b.mod.get_or_add_const(b.mod.type_store.get_int(32), '0')])
        // GEP to the byte at index (scale = 1 for u8)
        elem_addr := b.mod.add_instr(.get_element_ptr, b.cur_block, u8_ptr, [
            data_ptr,
            index,
        ])
        // Load the byte as unsigned u8
        return b.mod.add_instr(.load, b.cur_block, u8_t, [elem_addr])
    }

    // Handle fixed-size array values (from [1,2,3]! load): base is array_t, not ptr_t.
    // Trace back through the load instruction to find the original alloca pointer,
    // then use the pointer-based GEP+load path.
    if base_type_id > 0 && base_type_id < b.mod.type_store.types.len {
        base_typ := b.mod.type_store.types[base_type_id]
        if base_typ.kind == .array_t && base_typ.elem_type != 0 {
            base_value := b.mod.values[base_val]
            if base_value.kind == .instruction {
                instr := b.mod.instrs[base_value.index]
                if instr.op == .load && instr.operands.len > 0 {
                    // Found the original alloca pointer — use it for GEP+load
                    alloca_ptr := instr.operands[0]
                    elem_type := base_typ.elem_type
                    elem_ptr_type := b.mod.type_store.get_ptr(elem_type)
                    elem_addr := b.mod.add_instr(.get_element_ptr, b.cur_block, elem_ptr_type, [
                        alloca_ptr,
                        index,
                    ])
                    return b.mod.add_instr(.load, b.cur_block, elem_type, [elem_addr])
                }
                if instr.op == .extractvalue && instr.operands.len >= 2 {
                    // Base is extractvalue(struct_val, field_idx) producing an array_t.
                    // This happens for union/struct field access like u.b[i] where b is [4]u8.
                    // The extractvalue produces a VALUE, not a pointer, so GEP can't work on it.
                    // Fix: trace back to the struct's alloca, GEP to the field, then index.
                    struct_val := instr.operands[0]
                    field_idx_val := instr.operands[1]
                    struct_value := b.mod.values[struct_val]
                    if struct_value.kind == .instruction {
                        struct_instr := b.mod.instrs[struct_value.index]
                        if struct_instr.op == .load && struct_instr.operands.len > 0 {
                            // struct_val came from load(alloca_ptr)
                            struct_ptr := struct_instr.operands[0]
                            // GEP to the array field within the struct
                            arr_ptr_type := b.mod.type_store.get_ptr(base_type_id)
                            field_addr := b.mod.add_instr(.get_element_ptr, b.cur_block,
                                arr_ptr_type, [struct_ptr, field_idx_val])
                            // GEP to the element within the array
                            elem_type := base_typ.elem_type
                            elem_ptr_type := b.mod.type_store.get_ptr(elem_type)
                            elem_addr := b.mod.add_instr(.get_element_ptr, b.cur_block,
                                elem_ptr_type, [field_addr, index])
                            return b.mod.add_instr(.load, b.cur_block, elem_type, [
                                elem_addr,
                            ])
                        }
                    }
                }
            }
        }
    }

    // Check if base is a pointer (e.g., from alloca for fixed-size array literal)
    // For ptr(T), element type is T — use that instead of expr_type fallback
    if base_type_id < b.mod.type_store.types.len {
        base_typ := b.mod.type_store.types[base_type_id]
        if base_typ.kind == .ptr_t && base_typ.elem_type != 0 {
            mut elem_type := base_typ.elem_type
            // If pointed-to type is a fixed-size array (array_t), extract its element type.
            // ptr(array(i32, 5))[i] should load an i32, not an array(i32, 5).
            if elem_type < b.mod.type_store.types.len {
                inner_typ := b.mod.type_store.types[elem_type]
                if inner_typ.kind == .array_t && inner_typ.elem_type != 0 {
                    elem_type = inner_typ.elem_type
                }
            }
            // GEP to the element address, then load
            elem_ptr_type := b.mod.type_store.get_ptr(elem_type)
            elem_addr := b.mod.add_instr(.get_element_ptr, b.cur_block, elem_ptr_type, [
                base_val,
                index,
            ])
            return b.mod.add_instr(.load, b.cur_block, elem_type, [elem_addr])
        }
    }

    return b.mod.add_instr(.get_element_ptr, b.cur_block, result_type, [base_val, index])
}

// infer_if_expr_type tries to infer the result type of a transformer-generated
// IfExpr that has no position annotation (so expr_type returns i64 fallback).
// Checks both then and else branches for type information.
fn (mut b Builder) infer_if_expr_type(node ast.IfExpr, i64_t TypeID) TypeID {
    // Try to infer from branch expressions — recursively walk the entire
    // if-else-if chain so we check ALL branches (not just the first two).
    // This is essential for match expressions lowered to if-else-if chains
    // where the type-bearing expression may be in a deeply nested branch.
    mut branches := [][]ast.Stmt{cap: 8}
    branches << node.stmts
    mut cur_else := node.else_expr
    for {
        if cur_else is ast.IfExpr {
            else_if := cur_else as ast.IfExpr
            branches << else_if.stmts
            cur_else = else_if.else_expr
        } else {
            break
        }
    }
    for branch_stmts in branches {
        if branch_stmts.len == 0 {
            continue
        }
        last := branch_stmts[branch_stmts.len - 1]
        if last !is ast.ExprStmt {
            continue
        }
        // Unwrap PrefixExpr (e.g., -f has the same type as f)
        mut expr := (last as ast.ExprStmt).expr
        for expr is ast.PrefixExpr {
            expr = (expr as ast.PrefixExpr).expr
        }
        if expr is ast.StringLiteral || expr is ast.StringInterLiteral {
            str_type := b.get_string_type()
            if str_type != 0 {
                return str_type
            }
        } else if expr is ast.Ident {
            ident_name := (expr as ast.Ident).name
            if alloca_id := b.vars[ident_name] {
                alloca_val := b.mod.values[alloca_id]
                if alloca_val.typ > 0 && alloca_val.typ < b.mod.type_store.types.len {
                    alloca_typ := b.mod.type_store.types[alloca_val.typ]
                    if alloca_typ.kind == .ptr_t && alloca_typ.elem_type > 0
                        && alloca_typ.elem_type < b.mod.type_store.types.len {
                        elem := b.mod.type_store.types[alloca_typ.elem_type]
                        if elem.kind == .struct_t || elem.kind == .float_t {
                            return alloca_typ.elem_type
                        }
                    }
                }
            }
        } else if expr is ast.BasicLiteral {
            bl := expr as ast.BasicLiteral
            if bl.kind == .number && bl.value.contains('.') {
                return b.mod.type_store.get_float(64)
            }
        } else if expr is ast.InitExpr {
            // Sum type init: check the struct type of the InitExpr
            inferred := b.expr_type(expr)
            if inferred != i64_t && inferred != 0 {
                return inferred
            }
            // Try to find the sum type from the field names (_tag, _data)
            init := expr as ast.InitExpr
            if init.fields.len >= 2 {
                for fi in init.fields {
                    if fi.name == '_tag' || fi.name == '_data' {
                        // This is a sum type init — look up the type from the typ expr
                        // (e.g., Ident{name: 'Expr'} → 'ast__Expr' in struct_types)
                        type_name := init.typ.name()
                        if type_name.len > 0 {
                            if tid := b.struct_types[type_name] {
                                return tid
                            }
                            qualified2 := '${b.cur_module}__${type_name}'
                            if tid := b.struct_types[qualified2] {
                                return tid
                            }
                            for sname, sid in b.struct_types {
                                if sname.ends_with('__${type_name}') {
                                    return sid
                                }
                            }
                        }
                        break
                    }
                }
            }
        } else if expr is ast.CallExpr {
            // Check call return type from registered functions
            call_expr := expr as ast.CallExpr
            fn_name := b.resolve_call_name(call_expr)
            if fn_name in b.fn_index {
                fn_idx := b.fn_index[fn_name]
                fn_ret := b.mod.funcs[fn_idx].typ
                if fn_ret != 0 && fn_ret != i64_t {
                    return fn_ret
                }
            }
            // Also try expr_type
            inferred := b.expr_type(expr)
            if inferred != i64_t && inferred != 0 {
                return inferred
            }
        } else {
            inferred := b.expr_type(expr)
            if inferred != i64_t && inferred != 0 {
                return inferred
            }
        }
    }
    return i64_t
}

fn (mut b Builder) build_if_expr(node ast.IfExpr) ValueID {
    // If used as expression, returns a value
    mut result_type := b.expr_type(ast.Expr(node))
    // If result_type is i64 (fallback), try to infer from branch contents.
    // This handles match-on-string expressions where the transformer creates
    // IfExpr chains without position IDs, so expr_type returns i64 fallback.
    i64_t := b.mod.type_store.get_int(64)
    if result_type == i64_t {
        result_type = b.infer_if_expr_type(node, i64_t)
    }

    then_block := b.mod.add_block(b.cur_func, 'ifx_then')
    merge_block := b.mod.add_block(b.cur_func, 'ifx_merge')
    has_else := node.else_expr !is ast.EmptyExpr
    else_block := if has_else {
        b.mod.add_block(b.cur_func, 'ifx_else')
    } else {
        merge_block
    }

    cond := b.build_expr(node.cond)
    b.mod.add_instr(.br, b.cur_block, 0,
        [cond, b.mod.blocks[then_block].val_id, b.mod.blocks[else_block].val_id])
    b.add_edge(b.cur_block, then_block)
    b.add_edge(b.cur_block, else_block)

    // Then
    b.cur_block = then_block
    mut then_val := ValueID(0)
    if node.stmts.len > 0 {
        for i := 0; i < node.stmts.len - 1; i++ {
            b.build_stmt(node.stmts[i])
        }
        last := node.stmts[node.stmts.len - 1]
        if last is ast.ExprStmt {
            then_val = b.build_expr(last.expr)
        } else {
            b.build_stmt(last)
        }
    }
    then_end_block := b.cur_block
    if !b.block_has_terminator(b.cur_block) {
        b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[merge_block].val_id])
        b.add_edge(b.cur_block, merge_block)
    }

    // Else
    mut else_val := ValueID(0)
    mut else_end_block := b.cur_block
    if has_else {
        b.cur_block = else_block
        if node.else_expr is ast.IfExpr {
            else_if := node.else_expr as ast.IfExpr
            if else_if.cond is ast.EmptyExpr {
                // Pure else
                if else_if.stmts.len > 0 {
                    for i := 0; i < else_if.stmts.len - 1; i++ {
                        b.build_stmt(else_if.stmts[i])
                    }
                    last := else_if.stmts[else_if.stmts.len - 1]
                    if last is ast.ExprStmt {
                        else_val = b.build_expr(last.expr)
                    } else {
                        b.build_stmt(last)
                    }
                }
            } else {
                else_val = b.build_if_expr(else_if)
            }
        } else {
            else_val = b.build_expr(node.else_expr)
        }
        else_end_block = b.cur_block
        if !b.block_has_terminator(b.cur_block) {
            b.mod.add_instr(.jmp, b.cur_block, 0, [b.mod.blocks[merge_block].val_id])
            b.add_edge(b.cur_block, merge_block)
        }
    }

    // Merge block: use phi to select result (no alloca/store/load)
    b.cur_block = merge_block
    // If both branches produce values, use a phi node
    if then_val != 0 && else_val != 0 {
        return b.mod.add_instr(.phi, merge_block, result_type, [then_val, b.mod.blocks[then_end_block].val_id,
            else_val, b.mod.blocks[else_end_block].val_id])
    } else if then_val != 0 {
        // Only then branch has a value; use zero for the else side
        zero := b.mod.get_or_add_const(result_type, '0')
        return b.mod.add_instr(.phi, merge_block, result_type, [then_val, b.mod.blocks[then_end_block].val_id,
            zero, b.mod.blocks[else_end_block].val_id])
    } else if else_val != 0 {
        // Only else branch has a value
        zero := b.mod.get_or_add_const(result_type, '0')
        return b.mod.add_instr(.phi, merge_block, result_type, [zero, b.mod.blocks[then_end_block].val_id,
            else_val, b.mod.blocks[else_end_block].val_id])
    }
    // Neither branch produced a value - return zero constant
    return b.mod.get_or_add_const(result_type, '0')
}

fn (mut b Builder) build_array_init_expr(expr ast.ArrayInitExpr) ValueID {
    // If the array init has elements, alloca a fixed-size array on the stack,
    // store each element, and return the pointer.
    if expr.exprs.len > 0 {
        mut elem_vals := []ValueID{cap: expr.exprs.len}
        for e in expr.exprs {
            elem_vals << b.build_expr(e)
        }
        mut elem_type := b.mod.type_store.get_int(32) // default int
        // Try to get the declared element type from the array type annotation.
        // This is important when the value type is narrower than the element type
        // (e.g., pushing u8 into []rune where rune is i32).
        mut has_declared_type := false
        if expr.typ is ast.Type {
            if expr.typ is ast.ArrayType {
                arr_typ := expr.typ as ast.ArrayType
                declared_elem := b.ast_type_to_ssa(arr_typ.elem_type)
                if declared_elem > 0 {
                    elem_type = declared_elem
                    has_declared_type = true
                }
            }
        }
        if !has_declared_type && elem_vals.len > 0 {
            elem_type = b.mod.values[elem_vals[0]].typ
        }
        // Convert element values to match the declared/inferred element type.
        // This handles: int→wider int (zext), int→float (sitofp), f64→f32 (trunc).
        {
            elem_kind := b.mod.type_store.types[elem_type].kind
            elem_width := b.mod.type_store.types[elem_type].width
            for i, val in elem_vals {
                val_type := b.mod.values[val].typ
                if val_type == elem_type {
                    continue
                }
                val_kind := b.mod.type_store.types[val_type].kind
                val_width := b.mod.type_store.types[val_type].width
                if val_kind == .int_t && elem_kind == .float_t {
                    // int → float (e.g., 15 in []f32 → f32(15.0))
                    elem_vals[i] = b.mod.add_instr(.sitofp, b.cur_block, elem_type, [
                        val,
                    ])
                } else if val_kind == .float_t && elem_kind == .float_t && val_width > elem_width {
                    // f64 → f32 narrowing
                    elem_vals[i] = b.mod.add_instr(.trunc, b.cur_block, elem_type, [
                        val,
                    ])
                } else if val_kind == .float_t && elem_kind == .float_t && val_width < elem_width {
                    // f32 → f64 widening
                    elem_vals[i] = b.mod.add_instr(.zext, b.cur_block, elem_type, [
                        val,
                    ])
                } else if val_kind == .int_t && elem_kind == .int_t && val_width > 0
                    && val_width < elem_width {
                    // int → wider int (e.g., u8 in []rune)
                    elem_vals[i] = b.mod.add_instr(.zext, b.cur_block, elem_type, [
                        val,
                    ])
                }
            }
        }
        // Allocate fixed-size array on stack and store each element.
        // Use array_t so that GEP uses element-size scaling (not struct-field offsets).
        arr_fixed_type := b.mod.type_store.get_array(elem_type, elem_vals.len)
        ptr_type := b.mod.type_store.get_ptr(arr_fixed_type)
        alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
        // Store each element via GEP + store.
        // GEP result type is ptr(elem_type) - a pointer to one element, not the whole array.
        elem_ptr_type := b.mod.type_store.get_ptr(elem_type)
        i32_t := b.mod.type_store.get_int(32)
        for i, val in elem_vals {
            idx := b.mod.get_or_add_const(i32_t, i.str())
            gep := b.mod.add_instr(.get_element_ptr, b.cur_block, elem_ptr_type, [
                alloca,
                idx,
            ])
            b.mod.add_instr(.store, b.cur_block, 0, [val, gep])
        }
        // For fixed arrays ([1, 2]!), return the array VALUE (not the pointer).
        // This ensures variables store actual array data so that:
        // 1. &a gives the address of the data (the variable alloca), enabling memcmp
        // 2. a == b compares values, not pointer addresses
        // The ARM64 backend handles array_t values > 8 bytes via memcpy-style
        // load/store, similar to struct_t handling.
        // build_index handles indexing into array_t values by tracing back to
        // the original alloca pointer.
        mut is_fixed := false
        if expr.len is ast.PostfixExpr {
            postfix := expr.len as ast.PostfixExpr
            if postfix.op == .not {
                is_fixed = true
            }
        }
        if !is_fixed && expr.typ is ast.Type && expr.typ is ast.ArrayFixedType {
            is_fixed = true
        }
        if is_fixed {
            return b.mod.add_instr(.load, b.cur_block, arr_fixed_type, [alloca])
        }
        return alloca
    }

    // Check if this is a fixed-size array type (e.g., [5]u8{}).
    // These need stack allocation via alloca, not a dynamic array struct.
    if expr.typ is ast.Type {
        if expr.typ is ast.ArrayFixedType {
            fixed_typ := expr.typ as ast.ArrayFixedType
            elem_type := b.ast_type_to_ssa(fixed_typ.elem_type)
            arr_len := if fixed_typ.len is ast.BasicLiteral {
                int(parse_const_int_literal(fixed_typ.len.value))
            } else if fixed_typ.len is ast.Ident {
                b.resolve_const_int(fixed_typ.len.name)
            } else {
                0
            }
            if arr_len > 0 {
                arr_fixed_type := b.mod.type_store.get_array(elem_type, arr_len)
                ptr_type := b.mod.type_store.get_ptr(arr_fixed_type)
                alloca := b.mod.add_instr(.alloca, b.cur_block, ptr_type, []ValueID{})
                // For small arrays (<=16 elements), zero-initialize element by element.
                // For larger arrays, the codegen will bulk-zero the alloca slot.
                if arr_len <= 16 {
                    zero := b.mod.get_or_add_const(elem_type, '0')
                    elem_ptr_type := b.mod.type_store.get_ptr(elem_type)
                    i32_t := b.mod.type_store.get_int(32)
                    for i in 0 .. arr_len {
                        idx := b.mod.get_or_add_const(i32_t, i.str())
                        gep := b.mod.add_instr(.get_element_ptr, b.cur_block, elem_ptr_type, [
                            alloca,
                            idx,
                        ])
                        b.mod.add_instr(.store, b.cur_block, 0, [zero, gep])
                    }
                }
                return alloca
            }
        }
    }

    // Empty dynamic array with len/cap - these should have been
    // transformed to __new_array_with_default_noscan calls by the transformer.
    // Return zero-initialized array struct as fallback.
    arr_type := b.get_array_type()
    return b.mod.get_or_add_const(arr_type, '0')
}

fn (mut b Builder) collect_init_expr_values(expr ast.InitExpr) (TypeID, []ValueID) {
    // Resolve the struct type
    mut struct_type := b.ast_type_to_ssa(expr.typ)
    if struct_type == b.mod.type_store.get_int(64) {
        env_type := b.expr_type(ast.Expr(expr))
        if env_type != b.mod.type_store.get_int(64) {
            struct_type = env_type
        }
    }

    // Get the type info for field name lookup
    typ_info := b.mod.type_store.types[struct_type]
    num_fields := typ_info.field_names.len

    if num_fields == 0 {
        return struct_type, []ValueID{}
    }

    // Build field values in declaration order
    mut field_vals := []ValueID{cap: num_fields}
    mut initialized_fields := map[string]int{} // field name -> index in expr.fields

    // Check if this is positional initialization (all field names empty)
    mut is_positional := expr.fields.len > 0
    for field in expr.fields {
        if field.name.len > 0 {
            is_positional = false
            break
        }
    }

    // Map explicit field inits by name
    // Handle sumtype _data._variant fields by mapping to _data
    if is_positional {
        // Positional init: match by index using struct field names
        for fi, field in expr.fields {
            if fi < num_fields {
                initialized_fields[typ_info.field_names[fi]] = fi
            }
            _ = field
        }
    } else {
        for fi, field in expr.fields {
            fname := if field.name.starts_with('_data.') {
                '_data'
            } else {
                field.name
            }
            initialized_fields[fname] = fi
        }
    }