// 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])