// 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.token
import v2.types

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

const fixed_array_empty_literal_element_store_threshold = 16

fn enum_field_symbol_name(name string) string {
    n := if name.len > 0 && name[0] == `@` { 'at_${name[1..]}' } else { name }
    mut escaped := n.replace('*', 'ptr')
    escaped = escaped.replace('&', 'ref')
    escaped = escaped.replace('@', 'at_')
    escaped = escaped.replace(' ', '_')
    escaped = escaped.replace('.', '__')
    if escaped in enum_field_c_keywords {
        return '_${escaped}'
    }
    return escaped
}

fn normalize_target_os_name(target_os string) string {
    return match target_os.to_lower() {
        'macos', 'darwin' { 'macos' }
        else { target_os.to_lower() }
    }
}

fn (b &Builder) is_macos_target() bool {
    return normalize_target_os_name(b.target_os) == 'macos'
}

fn (b &Builder) is_linux_target() bool {
    return normalize_target_os_name(b.target_os) == 'linux'
}

fn (b &Builder) is_windows_target() bool {
    return normalize_target_os_name(b.target_os) == 'windows'
}

fn (mut b Builder) build_c_errno_addr() ?ValueID {
    if !b.is_macos_target() && !b.is_linux_target() && !b.is_windows_target() {
        return none
    }
    i32_t := b.mod.type_store.get_int(32)
    ptr_i32 := b.mod.type_store.get_ptr(i32_t)
    err_fn_name := if b.is_macos_target() {
        '__error'
    } else if b.is_windows_target() {
        '_errno'
    } else {
        '__errno_location'
    }
    err_fn := b.get_or_create_fn_ref(err_fn_name, ptr_i32)
    return b.mod.add_instr(.call, b.cur_block, ptr_i32, [err_fn])
}

fn (mut b Builder) build_windows_c_macro_const(name string) ?ValueID {
    if !b.is_windows_target() {
        return none
    }
    // WinAPI GetStdHandle constants are DWORD macros, not linkable symbols.
    win_std_handle_val := match name {
        'STD_INPUT_HANDLE' { '4294967286' }
        'STD_OUTPUT_HANDLE' { '4294967285' }
        'STD_ERROR_HANDLE' { '4294967284' }
        else { '' }
    }

    if win_std_handle_val.len > 0 {
        return b.mod.get_or_add_const(b.mod.type_store.get_uint(32), win_std_handle_val)
    }
    if name == 'INVALID_HANDLE_VALUE' {
        i8_t := b.mod.type_store.get_int(8)
        voidptr_t := b.mod.type_store.get_ptr(i8_t)
        return b.mod.get_or_add_const(voidptr_t, '-1')
    }
    return none
}

fn (mut b Builder) build_raw_c_global_addr(name string, typ TypeID) ValueID {
    if glob_id := b.find_global(name) {
        return glob_id
    }
    glob := b.mod.add_external_global(name, typ)
    b.global_refs[name] = glob
    return glob
}

fn (mut b Builder) build_c_errno_storage_addr() ValueID {
    if errno_addr := b.build_c_errno_addr() {
        return errno_addr
    }
    i32_t := b.mod.type_store.get_int(32)
    return b.build_raw_c_global_addr('errno', i32_t)
}

fn ssa_module_storage_name(module_name string, name string) string {
    if name == '' || name.starts_with('C.') {
        return name
    }
    if module_name == 'C' {
        return 'C.${name}'
    }
    if module_name != '' && module_name != 'main' {
        return '${module_name}__${name}'
    }
    return name
}

fn ssa_module_storage_field_is_c_extern(node ast.GlobalDecl, field ast.FieldDecl) bool {
    return field.name.starts_with('C.') || node.attributes.has('c_extern')
        || field.attributes.has('c_extern')
}

// cursor_attrs_has (s237, fixed s246) reports whether an attribute list (a
// CursorList of .aux_attribute nodes) contains an attribute named `name`.
// Cursor mirror of `[]Attribute.has(name)`: an attribute matches when its
// name_id equals `name`, OR (the `@[flag]`/`@[c_extern]` shape) when name_id is
// empty and its value (edge 0) is an Ident whose name equals `name`. The earlier
// name_id-only version silently missed `@[flag]`/`@[c_extern]`, since the parser
// stores those as `Attribute{name:'', value: Ident{name:...}}`.
fn cursor_attrs_has(attrs ast.CursorList, name string) bool {
    for i in 0 .. attrs.len() {
        attr := attrs.at(i)
        if attr.name() == name {
            return true
        }
        if attr.name() == '' {
            val := attr.edge(0)
            if val.kind() == .expr_ident && val.name() == name {
                return true
            }
        }
    }
    return false
}

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
}

struct SelectorAddr {
    addr      ValueID
    base_type TypeID
}

struct EmbeddedFieldSpan {
    source_type TypeID
    start       int
    len         int
}

struct StructInitFieldPlan {
    source_idx  int
    target_idx  int
    expand_len  int
    source_type TypeID
}

struct MatchExprIncoming {
    value ValueID
    block BlockID
}

struct MatchSumtypeBranchInfo {
    tag          int
    variant_type TypeID
}

const unsupported_captured_fn_literal_symbol = 'v2_unsupported_captured_fn_literal'

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
    // Optional path fragments for skip_modules. When populated for a module,
    // the skip only applies to files whose path matches the fragment.
    skip_module_file_fragments map[string]string
    // Native self-hosted builds use the SSA sumtype layout directly; guard
    // against null large-variant payloads before matching types.Type.
    guard_invalid_type_payloads bool
    // Target OS for lowering target-specific C globals.
    target_os string
    // When set, native Windows PE builds rely on markused instead of retaining
    // broad builtin runtime modules before linking.
    minimal_runtime_roots bool
    // When set, the backend zeroes large fixed-array allocas as a bulk operation,
    // so SSA can keep IR size bounded by skipping per-element zero stores.
    native_backend_bulk_zero_alloca bool
mut:
    env       &types.Environment = unsafe { nil }
    cur_func  int                = -1
    cur_block BlockID            = -1
    // Checker function-scope key for the function currently being lowered.
    cur_fn_scope_key string
    // 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
    // Flattened embedded field ranges by owner struct TypeID.
    struct_embedded_spans map[int][]EmbeddedFieldSpan
    // Type alias name -> resolved SSA base TypeID
    type_aliases map[string]TypeID
    // Enum name -> field values
    enum_values map[string]int
    // Function name -> SSA function index
    fn_index        map[string]int
    module_fn_names map[string]string
    // Function name -> dynamic array element type by argument index.
    fn_param_array_elem_types map[string][]TypeID
    // Function name -> SSA func_ref value
    fn_refs map[string]ValueID
    // Current file's selective imports: short symbol name -> primary mangled function name.
    selective_import_fn_names map[string]string
    // Current file's selective imports: short symbol name -> ordered mangled function candidates.
    selective_import_fn_candidates map[string][]string
    // Current file's module imports: local alias/tail name -> mangled module name.
    module_import_aliases map[string]string
    // 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
    // Branch-local smartcasts from `if x is T` while lowering SSA.
    local_smartcasts map[string]TypeID
    // 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
    // Array element types by SSA value id for dynamic array values that came from
    // typed fields/selectors but have the erased builtin `array` SSA layout.
    array_value_elem_types map[int]TypeID
    // Struct field dynamic-array element types keyed by `struct_type_id:field_name`.
    struct_field_array_elem_types map[string]TypeID
    // Expected element type for the array literal currently being built.
    array_literal_elem_type_hint TypeID
    // Current array literal is a temporary element buffer for a voidptr argument
    // such as array.push_noscan, not a dynamic array value.
    array_literal_as_element_buffer bool
}

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{}
        struct_embedded_spans:          map[int][]EmbeddedFieldSpan{}
        type_aliases:                   map[string]TypeID{}
        enum_values:                    map[string]int{}
        fn_index:                       map[string]int{}
        module_fn_names:                map[string]string{}
        fn_param_array_elem_types:      map[string][]TypeID{}
        fn_refs:                        map[string]ValueID{}
        selective_import_fn_names:      map[string]string{}
        selective_import_fn_candidates: map[string][]string{}
        module_import_aliases:          map[string]string{}
        global_refs:                    map[string]ValueID{}
        skip_modules:                   map[string]bool{}
        skip_module_file_fragments:     map[string]string{}
        option_wrapper_types:           map[string]TypeID{}
        result_wrapper_types:           map[string]TypeID{}
        array_value_elem_types:         map[int]TypeID{}
        struct_field_array_elem_types:  map[string]TypeID{}
        local_smartcasts:               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
        target_os:                       b.target_os
        minimal_runtime_roots:           b.minimal_runtime_roots
        native_backend_bulk_zero_alloca: b.native_backend_bulk_zero_alloca
        struct_types:                    b.struct_types.clone()
        struct_embedded_spans:           b.struct_embedded_spans.clone()
        type_aliases:                    b.type_aliases.clone()
        enum_values:                     b.enum_values.clone()
        fn_index:                        b.fn_index.clone()
        module_fn_names:                 b.module_fn_names.clone()
        selective_import_fn_names:       b.selective_import_fn_names.clone()
        selective_import_fn_candidates:  b.selective_import_fn_candidates.clone()
        module_import_aliases:           b.module_import_aliases.clone()
        fn_param_array_elem_types:       b.fn_param_array_elem_types.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()
        struct_field_array_elem_types:   b.struct_field_array_elem_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{}
        local_smartcasts: map[string]TypeID{}
    }
}

pub fn imported_symbol_fn_name(module_name string, name string) string {
    normalized_module_name := module_name_to_ssa_name(module_name)
    if normalized_module_name == '' || normalized_module_name == 'main' {
        return name
    }
    return '${normalized_module_name}__${name}'
}

fn (b &Builder) resolve_module_call_fn_name(module_name string, name string) string {
    full_name := imported_symbol_fn_name(module_name, name)
    if full_name in b.fn_index {
        return full_name
    }
    if module_name.contains('.') {
        leaf_name := imported_symbol_fn_name(module_name.all_after_last('.'), name)
        if leaf_name in b.fn_index {
            return leaf_name
        }
    }
    return full_name
}

fn module_name_to_ssa_name(module_name string) string {
    return module_name.replace('.', '_')
}

fn checked_type_name_to_ssa_name(type_name string) string {
    if type_name == '' {
        return ''
    }
    if type_name.contains('__') {
        separator_idx := type_name.last_index('__') or { -1 }
        module_name := type_name[..separator_idx]
        name := type_name[separator_idx + 2..]
        return imported_symbol_fn_name(module_name, name)
    }
    if type_name.contains('.') {
        dot_idx := type_name.last_index('.') or { -1 }
        module_name := type_name[..dot_idx]
        name := type_name[dot_idx + 1..]
        return imported_symbol_fn_name(module_name, name)
    }
    return type_name
}

fn generic_token_part_name(name string) string {
    if name == '' {
        return 'Type'
    }
    mut out := []u8{cap: name.len}
    mut wrote_sep := false
    for i in 0 .. name.len {
        ch := name[i]
        if (ch >= `a` && ch <= `z`) || (ch >= `A` && ch <= `Z`) || (ch >= `0` && ch <= `9`) {
            out << ch
            wrote_sep = false
        } else if !wrote_sep {
            out << `_`
            wrote_sep = true
        }
    }
    mut tok := out.bytestr().trim('_')
    if tok == '' {
        tok = 'Type'
    }
    return tok
}

fn import_module_name(imp ast.ImportStmt) string {
    return imp.name
}

fn selective_import_module_name(imp ast.ImportStmt) string {
    if imp.is_aliased {
        return imp.name.all_after_last('.')
    }
    if imp.alias != '' {
        return imp.alias
    }
    return imp.name.all_after_last('.')
}

pub fn module_import_aliases_from_imports(imports []ast.ImportStmt) map[string]string {
    mut aliases := map[string]string{}
    for imp in imports {
        alias := if imp.alias != '' { imp.alias } else { imp.name.all_after_last('.') }
        if !ssa_string_ok(alias) || imp.name.len == 0 {
            continue
        }
        module_name := import_module_name(imp)
        if !ssa_string_ok(module_name) {
            continue
        }
        aliases[alias] = module_name
    }
    return aliases
}

pub fn selective_import_fn_names_from_imports(imports []ast.ImportStmt) map[string]string {
    mut names := map[string]string{}
    for imp in imports {
        if imp.symbols.len == 0 {
            continue
        }
        module_name := import_module_name(imp)
        for symbol in imp.symbols {
            if symbol is ast.Ident {
                names[symbol.name] = imported_symbol_fn_name(module_name, symbol.name)
            }
        }
    }
    return names
}

pub fn selective_import_fn_candidates_from_imports(imports []ast.ImportStmt) map[string][]string {
    mut names := map[string][]string{}
    for imp in imports {
        if imp.symbols.len == 0 {
            continue
        }
        full_module_name := import_module_name(imp)
        leaf_module_name := selective_import_module_name(imp)
        for symbol in imp.symbols {
            if symbol is ast.Ident {
                full_name := imported_symbol_fn_name(full_module_name, symbol.name)
                leaf_name := imported_symbol_fn_name(leaf_module_name, symbol.name)
                mut candidates := []string{cap: 2}
                candidates << full_name
                if leaf_name != full_name {
                    candidates << leaf_name
                }
                names[symbol.name] = candidates
            }
        }
    }
    return names
}

fn (b &Builder) selective_import_fn_name(name string) ?string {
    if candidates := b.selective_import_fn_candidates[name] {
        for candidate in candidates {
            if candidate in b.fn_index {
                return candidate
            }
        }
        return none
    }
    if imported := b.selective_import_fn_names[name] {
        if imported in b.fn_index {
            return imported
        }
    }
    return none
}

fn module_fn_key(module_name string, name string) string {
    return '${module_name}:${name}'
}

fn (b &Builder) current_module_fn_name(name string) ?string {
    if name == '' {
        return none
    }
    if target := b.module_fn_names[module_fn_key(b.cur_module, name)] {
        if target in b.fn_index {
            return target
        }
    }
    return none
}

pub fn (mut b Builder) set_selective_import_fn_names(names map[string]string) {
    b.selective_import_fn_names = names.clone()
    mut candidates := map[string][]string{}
    for name, imported in names {
        candidates[name] = [imported]
    }
    b.selective_import_fn_candidates = candidates.clone()
}

pub fn (mut b Builder) set_selective_import_fn_candidates(candidates map[string][]string) {
    b.selective_import_fn_candidates = candidates.clone()
}

pub fn (mut b Builder) set_module_import_aliases(aliases map[string]string) {
    b.module_import_aliases = aliases.clone()
}

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)

    // Pre-register libSystem stdio externs on the main module so that worker
    // modules inherit them and the arm64 backend emits GOT-indirect loads when
    // `C.stdout` / `C.stdin` / `C.stderr` are referenced.
    for stdio_sym in ['__stdoutp', '__stdinp', '__stderrp'] {
        glob := b.mod.add_external_global(stdio_sym, ptr_t)
        b.global_refs[stdio_sym] = glob
    }

    // 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: Register type aliases after all pass-1 type names are known.
    for file in files {
        b.cur_module = file_module_name(file)
        b.register_type_aliases(file)
    }
    // Phase 1d: 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)
    }
    // Embedded structs from imported modules can appear earlier in file order
    // than the embedded type's own field pass. A second idempotent pass lets
    // those now-filled embedded fields flatten without expression lowering.
    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.minimal_runtime_roots {
        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)
    }
    b.generate_referenced_synthetic_runtime_stubs()

    // 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_from_flat is the flat-input counterpart of `build_all`. Phases
// 1a–3.5 (everything before fn-body building) now walk FileCursors directly
// and only rehydrate the decls each phase actually consumes — non-decl stmts
// (ModuleStmt, ImportStmt, attributes, etc.) are never decoded.
//
// Phase 4 also consumes cursors directly: function signatures are read from
// `.stmt_fn_decl` nodes and function bodies are lowered from body stmt cursors.
pub fn (mut b Builder) build_all_from_flat(flat &ast.FlatAst) {
    // 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)

    // Pre-register libSystem stdio externs on the main module so that worker
    // modules inherit them and the arm64 backend emits GOT-indirect loads when
    // `C.stdout` / `C.stdin` / `C.stderr` are referenced.
    for stdio_sym in ['__stdoutp', '__stdinp', '__stderrp'] {
        glob := b.mod.add_external_global(stdio_sym, ptr_t)
        b.global_refs[stdio_sym] = glob
    }

    // 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 fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        if b.cur_module != 'builtin' {
            continue
        }
        stmts := fc.stmts()
        for si in 0 .. stmts.len() {
            c := stmts.at(si)
            if c.kind() != .stmt_enum_decl {
                continue
            }
            // s238: cursor-native enum registration — no decode_stmt.
            b.register_enum_from_flat(c)
        }
    }
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        if b.cur_module != 'builtin' {
            continue
        }
        stmts := fc.stmts()
        for si in 0 .. stmts.len() {
            c := stmts.at(si)
            if c.kind() != .stmt_struct_decl {
                continue
            }
            // s239: cursor-native struct registration — no decode_stmt. The struct
            // name is the cursor's name_id.
            if c.name() in ['string', 'array'] {
                b.register_struct_from_flat(c)
            }
        }
    }
    // Phase 1b: Register all struct type names (forward declarations) and enums
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        b.register_types_pass1_from_flat(fc)
    }
    // Phase 1c: Register type aliases after all pass-1 type names are known.
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        b.register_type_aliases_from_flat(fc)
    }
    // Phase 1d: Fill in struct field types (now all struct names are known)
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        b.register_types_pass2_from_flat(fc)
    }
    // See the AST pass2 note above: imported embedded field layouts may only
    // become available after the first pass over all files.
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        b.register_types_pass2_from_flat(fc)
    }
    // Phase 2: Register consts and globals
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        b.register_consts_and_globals_from_flat(fc)
    }
    // Phase 2b: Re-evaluate constants with forward references
    b.resolve_forward_const_refs_from_flat(flat)
    // Build global lookup cache once before expression lowering.
    b.index_global_values()
    // Phase 3: Register function signatures
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        b.register_fn_signatures_from_flat(fc)
    }
    // Phase 3.1: Remove globals that collide with function names.
    for mut gvar in b.mod.globals {
        if gvar.name in b.fn_index {
            gvar.linkage = .external
            b.global_refs.delete(gvar.name)
        }
    }

    // Phase 3.5: Generate synthetic stubs for transformer-generated functions
    if b.hot_fn.len == 0 && !b.minimal_runtime_roots {
        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 from `.stmt_fn_decl` cursors. Signatures,
    // filters, params, and body statements all stay on the flat path.
    if !b.skip_fn_bodies {
        for fi in 0 .. flat.files.len {
            fc := flat.file_cursor(fi)
            b.cur_module = fc.mod().replace('.', '_')
            b.build_fn_bodies_from_flat(fc)
        }
    }
    b.generate_referenced_synthetic_runtime_stubs()

    // Phase 5: Generate _vinit for dynamic array constant initialization
    if b.hot_fn.len == 0 && !b.skip_fn_bodies {
        b.generate_vinit()
    }
}

// generate_referenced_synthetic_runtime_stubs materializes native-only helpers
// that are referenced after transformation or minimal-runtime pruning.
pub fn (mut b Builder) generate_referenced_synthetic_runtime_stubs() {
    if b.hot_fn.len != 0 || b.skip_fn_bodies {
        return
    }
    referenced := b.referenced_func_ref_names()
    if referenced['builtin__string__plus_two'] {
        b.generate_string_plus_two_stub()
    }
    if !b.minimal_runtime_roots {
        return
    }
    if referenced['array__eq'] {
        b.generate_array_eq_stub()
    }
    if referenced['_wymix'] {
        b.generate_wymix_stub()
    }
    if referenced['wyhash64'] {
        b.generate_wyhash64_stub()
    }
    if referenced['wyhash'] {
        b.generate_wyhash_stub()
    }
    if referenced['IError__msg'] || referenced['IError__code'] || referenced['IError__type_name'] {
        b.generate_ierror_stubs()
    }
    if referenced['FD_ZERO'] || referenced['FD_SET'] || referenced['FD_ISSET'] {
        b.generate_fd_macro_stubs()
    }
}

fn (b &Builder) referenced_func_ref_names() map[string]bool {
    mut names := map[string]bool{}
    for val in b.mod.values {
        if val.kind != .instruction {
            continue
        }
        instr := b.mod.instrs[val.index]
        for operand in instr.operands {
            if operand <= 0 || operand >= b.mod.values.len {
                continue
            }
            ref := b.mod.values[operand]
            if ref.kind == .func_ref && ref.name != '' {
                names[ref.name] = true
            }
        }
    }
    return names
}

// 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 ssa_string_ok(s string) bool {
    if s.len == 0 {
        return true
    }
    if s.len < 0 || s.len > 1024 {
        return false
    }
    ptr := unsafe { u64(s.str) }
    return ptr >= 0x10000 && ptr < 0x0000800000000000
}

fn ssa_module_tail_name(name string) string {
    if name.contains('.') {
        return name.all_after_last('.')
    }
    if name.contains('__') {
        return name.all_after_last('__')
    }
    if name.starts_with('v2_') && name.contains('_') {
        return name.all_after_last('_')
    }
    return name
}

fn ssa_is_string_struct_name(name string) bool {
    return name == 'string' || name == 'builtin__string'
}

fn ssa_is_string_str_fn_name(name string) bool {
    return name == 'string__str' || name == 'builtin__string__str'
}

fn (b &Builder) valid_value_id(val ValueID) bool {
    return val > 0 && val < b.mod.values.len
}

fn (b &Builder) valid_type_id(typ TypeID) bool {
    return typ > 0 && typ < b.mod.type_store.types.len
}

fn (mut b Builder) type_to_ssa(t types.Type) TypeID {
    if b.guard_invalid_type_payloads && !types.type_has_valid_payload(t) {
        return b.mod.type_store.get_int(64)
    }
    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 {
            if t.base_type is types.Struct {
                st := t.base_type as types.Struct
                if !ssa_string_ok(st.name) {
                    return b.mod.type_store.get_int(64)
                }
                if base := b.struct_name_to_ssa(st.name) {
                    return b.mod.type_store.get_ptr(base)
                }
            }
            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 !ssa_string_ok(t.name) {
                return b.mod.type_store.get_int(64)
            }
            if id := b.struct_name_to_ssa(t.name) {
                return id
            }
            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 {
            base := b.resolve_alias_base_type(t) or { return b.mod.type_store.get_int(64) }
            return b.type_to_ssa(base)
        }
        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 !ssa_string_ok(t.name) {
                return b.mod.type_store.get_int(32)
            }
            if id := b.struct_types[t.name] {
                return id
            }
            // Try module-qualified name
            qualified_st := '${b.cur_module}__${t.name}'
            if id := b.struct_types[qualified_st] {
                return id
            }
            // 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 {
            name := types.type_name(t)
            if name != '' {
                return b.named_type_to_ssa(name)
            }
            return b.mod.type_store.get_int(64) // fallback for unhandled
        }
    }
}

fn (mut b Builder) struct_name_to_ssa(name string) ?TypeID {
    if !ssa_string_ok(name) {
        return none
    }
    if id := b.struct_types[name] {
        return id
    }
    // Try module-qualified name: C structs are registered as "os__dirent"
    // but the type checker stores them as just "dirent".
    qualified := '${b.cur_module}__${name}'
    if id := b.struct_types[qualified] {
        return id
    }
    // Try all known module prefixes for cross-module struct access.
    for sname, sid in b.struct_types {
        if sname.ends_with('__${name}') {
            return sid
        }
    }
    return none
}

fn pointer_type_part_name(base string) string {
    if base == '' {
        return ''
    }
    return '${base}ptr'
}

fn (b &Builder) generic_ident_type_part_name(name string) string {
    if name == '' {
        return ''
    }
    normalized := name.replace('.', '__')
    if normalized.contains('__') {
        return normalized
    }
    if b.env == unsafe { nil } {
        return normalized
    }
    typ := b.lookup_checked_type_by_name(name) or { return normalized }
    match typ {
        types.Struct, types.SumType {
            typ_name := types.type_name(typ)
            if typ_name == '' {
                return normalized
            }
            return checked_type_name_to_ssa_name(typ_name)
        }
        else {
            return normalized
        }
    }
}

fn (b &Builder) generic_type_part_name(expr ast.Expr) string {
    match expr {
        ast.Ident {
            return b.generic_ident_type_part_name(expr.name)
        }
        ast.SelectorExpr {
            return b.generic_selector_type_part_name(expr)
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return pointer_type_part_name(b.generic_type_part_name(expr.expr))
            }
            return ''
        }
        ast.Type {
            match expr {
                ast.ArrayType {
                    elem_name := b.generic_type_part_name(expr.elem_type)
                    if elem_name == '' {
                        return ''
                    }
                    return 'Array_${elem_name}'
                }
                ast.ArrayFixedType {
                    elem_name := b.generic_type_part_name(expr.elem_type)
                    len_name := if expr.len is ast.BasicLiteral {
                        (expr.len as ast.BasicLiteral).value
                    } else {
                        ''
                    }
                    if elem_name == '' || len_name == '' {
                        return ''
                    }
                    return 'Array_fixed_${elem_name}_${len_name}'
                }
                ast.MapType {
                    key_name := b.generic_type_part_name(expr.key_type)
                    value_name := b.generic_type_part_name(expr.value_type)
                    if key_name == '' || value_name == '' {
                        return ''
                    }
                    return 'Map_${key_name}_${value_name}'
                }
                ast.PointerType {
                    return pointer_type_part_name(b.generic_type_part_name(expr.base_type))
                }
                ast.GenericType {
                    return b.generic_type_name(expr.name, expr.params)
                }
                ast.OptionType {
                    base_name := b.generic_type_part_name(expr.base_type)
                    if base_name == '' {
                        return ''
                    }
                    return 'Option_${base_name}'
                }
                ast.ResultType {
                    base_name := b.generic_type_part_name(expr.base_type)
                    if base_name == '' {
                        return ''
                    }
                    return 'Result_${base_name}'
                }
                else {
                    return ''
                }
            }
        }
        else {
            return ''
        }
    }
}

fn (b &Builder) generic_ident_type_arg_part_name(name string) string {
    if name == '' {
        return ''
    }
    if b.env == unsafe { nil } {
        return generic_token_part_name(name)
    }
    typ := b.lookup_checked_type_by_name(name) or { return generic_token_part_name(name) }
    match typ {
        types.Struct, types.SumType {
            typ_name := types.type_name(typ)
            if typ_name == '' {
                return generic_token_part_name(name)
            }
            return generic_token_part_name(typ_name)
        }
        else {
            return generic_token_part_name(name)
        }
    }
}

fn (b &Builder) generic_selector_type_arg_part_name(expr ast.SelectorExpr) string {
    full_name := b.generic_selector_type_part_name(expr)
    if full_name == '' {
        return ''
    }
    return generic_token_part_name(full_name)
}

fn (b &Builder) generic_type_arg_part_name(expr ast.Expr) string {
    match expr {
        ast.Ident {
            return b.generic_ident_type_arg_part_name(expr.name)
        }
        ast.SelectorExpr {
            return b.generic_selector_type_arg_part_name(expr)
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return pointer_type_part_name(b.generic_type_arg_part_name(expr.expr))
            }
            return ''
        }
        ast.Type {
            match expr {
                ast.ArrayType {
                    elem_name := b.generic_type_arg_part_name(expr.elem_type)
                    if elem_name == '' {
                        return ''
                    }
                    return 'Array_${elem_name}'
                }
                ast.ArrayFixedType {
                    elem_name := b.generic_type_arg_part_name(expr.elem_type)
                    len_name := if expr.len is ast.BasicLiteral {
                        (expr.len as ast.BasicLiteral).value
                    } else {
                        ''
                    }
                    if elem_name == '' || len_name == '' {
                        return ''
                    }
                    return 'Array_fixed_${elem_name}_${len_name}'
                }
                ast.MapType {
                    key_name := b.generic_type_arg_part_name(expr.key_type)
                    value_name := b.generic_type_arg_part_name(expr.value_type)
                    if key_name == '' || value_name == '' {
                        return ''
                    }
                    return 'Map_${key_name}_${value_name}'
                }
                ast.PointerType {
                    return pointer_type_part_name(b.generic_type_arg_part_name(expr.base_type))
                }
                ast.GenericType {
                    concrete_name := b.generic_type_name(expr.name, expr.params)
                    if concrete_name == '' {
                        return ''
                    }
                    return generic_token_part_name(concrete_name)
                }
                ast.OptionType {
                    base_name := b.generic_type_arg_part_name(expr.base_type)
                    if base_name == '' {
                        return ''
                    }
                    return 'Option_${base_name}'
                }
                ast.ResultType {
                    base_name := b.generic_type_arg_part_name(expr.base_type)
                    if base_name == '' {
                        return ''
                    }
                    return 'Result_${base_name}'
                }
                else {
                    return ''
                }
            }
        }
        else {
            return ''
        }
    }
}

fn (b &Builder) generic_selector_type_part_name(expr ast.SelectorExpr) string {
    if expr.lhs is ast.Ident {
        lhs_name := (expr.lhs as ast.Ident).name
        rhs_name := expr.rhs.name
        if lhs_name == '' || rhs_name == '' {
            return ''
        }
        if resolved_mod := b.module_import_aliases[lhs_name] {
            return imported_symbol_fn_name(resolved_mod, rhs_name)
        }
        if resolved_mod := b.selector_module_name_for_ident(lhs_name) {
            return imported_symbol_fn_name(resolved_mod, rhs_name)
        }
        return '${lhs_name.replace('.', '__')}__${rhs_name}'
    }
    return expr.name().replace('.', '__')
}

fn generic_type_name_from_parts(base string, parts []string) string {
    if base == '' || parts.len == 0 {
        return ''
    }
    return '${base}_T_${parts.join('_')}'
}

fn concrete_generic_type_suffix_name(concrete_name string) string {
    if !concrete_name.contains('_T_') {
        return ''
    }
    base := concrete_name.all_before('_T_')
    args := concrete_name.all_after('_T_')
    if base == '' || args == '' || !base.contains('__') {
        return ''
    }
    return '${base.all_after_last('__')}_T_${args}'
}

fn (b &Builder) registered_type_by_unique_concrete_suffix(concrete_name string) ?TypeID {
    suffix_name := concrete_generic_type_suffix_name(concrete_name)
    if suffix_name == '' {
        return none
    }
    mut found := TypeID(0)
    mut found_count := 0
    for registered_name, type_id in b.struct_types {
        if registered_name == suffix_name || registered_name.ends_with('__${suffix_name}') {
            found = type_id
            found_count++
        }
    }
    if found_count == 1 {
        return found
    }
    return none
}

fn (b &Builder) generic_type_name(name ast.Expr, params []ast.Expr) string {
    base := b.generic_type_part_name(name)
    mut parts := []string{cap: params.len}
    for param in params {
        part := b.generic_type_arg_part_name(param)
        if part == '' {
            return ''
        }
        parts << part
    }
    return generic_type_name_from_parts(base, parts)
}

fn (mut b Builder) checked_sumtype_for_ssa_name(name string) ?types.SumType {
    typ := b.lookup_checked_type_by_name(name) or {
        if name.contains('_T_') {
            base_name := name.all_before('_T_')
            b.lookup_checked_type_by_name(base_name) or { return none }
        } else {
            return none
        }
    }
    if typ is types.SumType {
        return typ
    }
    return none
}

fn (mut b Builder) source_base_is_sumtype(name string) bool {
    _ := b.checked_sumtype_for_ssa_name(name) or { return false }
    return true
}

fn (mut b Builder) generic_sumtype_storage_to_ssa(base_name string, concrete_name string) ?TypeID {
    if concrete_name == '' || !ssa_string_ok(concrete_name) || !b.source_base_is_sumtype(base_name) {
        return none
    }
    if id := b.struct_name_to_ssa(concrete_name) {
        return id
    }
    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[concrete_name] = type_id
    b.mod.c_struct_names[type_id] = concrete_name
    return type_id
}

fn (mut b Builder) generic_type_to_ssa(name ast.Expr, params []ast.Expr) TypeID {
    concrete_name := b.generic_type_name(name, params)
    if concrete_name == '' || !ssa_string_ok(concrete_name) {
        return b.mod.type_store.get_int(64)
    }
    if id := b.struct_name_to_ssa(concrete_name) {
        return id
    }
    if id := b.registered_type_by_unique_concrete_suffix(concrete_name) {
        return id
    }
    base_name := b.generic_type_part_name(name)
    if id := b.generic_sumtype_storage_to_ssa(base_name, concrete_name) {
        return id
    }
    return b.mod.type_store.get_int(64)
}

fn (b &Builder) generic_type_part_name_from_flat(c ast.Cursor) string {
    match c.kind() {
        .expr_ident {
            return b.generic_ident_type_part_name(c.name())
        }
        .expr_selector {
            lhs := c.edge(0)
            rhs := c.edge(1)
            if lhs.kind() == .expr_ident && rhs.kind() == .expr_ident {
                return b.generic_selector_type_part_name_from_flat(lhs.name(), rhs.name())
            }
            return ''
        }
        .expr_prefix {
            op := unsafe { token.Token(int(c.aux())) }
            if op == .amp {
                return pointer_type_part_name(b.generic_type_part_name_from_flat(c.edge(0)))
            }
            return ''
        }
        .typ_array {
            elem_name := b.generic_type_part_name_from_flat(c.edge(0))
            if elem_name == '' {
                return ''
            }
            return 'Array_${elem_name}'
        }
        .typ_array_fixed {
            elem_name := b.generic_type_part_name_from_flat(c.edge(1))
            len_c := c.edge(0)
            len_name := if len_c.kind() == .expr_basic_literal { len_c.name() } else { '' }
            if elem_name == '' || len_name == '' {
                return ''
            }
            return 'Array_fixed_${elem_name}_${len_name}'
        }
        .typ_map {
            key_name := b.generic_type_part_name_from_flat(c.edge(0))
            value_name := b.generic_type_part_name_from_flat(c.edge(1))
            if key_name == '' || value_name == '' {
                return ''
            }
            return 'Map_${key_name}_${value_name}'
        }
        .typ_pointer {
            return pointer_type_part_name(b.generic_type_part_name_from_flat(c.edge(0)))
        }
        .typ_generic {
            return b.generic_type_name_from_flat(c)
        }
        .typ_option {
            base_name := b.generic_type_part_name_from_flat(c.edge(0))
            if base_name == '' {
                return ''
            }
            return 'Option_${base_name}'
        }
        .typ_result {
            base_name := b.generic_type_part_name_from_flat(c.edge(0))
            if base_name == '' {
                return ''
            }
            return 'Result_${base_name}'
        }
        else {
            return ''
        }
    }
}

fn (b &Builder) generic_selector_type_part_name_from_flat(lhs_name string, rhs_name string) string {
    if lhs_name == '' || rhs_name == '' {
        return ''
    }
    if resolved_mod := b.module_import_aliases[lhs_name] {
        return imported_symbol_fn_name(resolved_mod, rhs_name)
    }
    if resolved_mod := b.selector_module_name_for_ident(lhs_name) {
        return imported_symbol_fn_name(resolved_mod, rhs_name)
    }
    return '${lhs_name.replace('.', '__')}__${rhs_name}'
}

fn (b &Builder) generic_ident_type_arg_part_name_from_flat(name string) string {
    return b.generic_ident_type_arg_part_name(name)
}

fn (b &Builder) generic_selector_type_arg_part_name_from_flat(lhs_name string, rhs_name string) string {
    full_name := b.generic_selector_type_part_name_from_flat(lhs_name, rhs_name)
    if full_name == '' {
        return ''
    }
    return generic_token_part_name(full_name)
}

fn (b &Builder) generic_type_arg_part_name_from_flat(c ast.Cursor) string {
    match c.kind() {
        .expr_ident {
            return b.generic_ident_type_arg_part_name_from_flat(c.name())
        }
        .expr_selector {
            lhs := c.edge(0)
            rhs := c.edge(1)
            if lhs.kind() == .expr_ident && rhs.kind() == .expr_ident {
                return b.generic_selector_type_arg_part_name_from_flat(lhs.name(), rhs.name())
            }
            return ''
        }
        .expr_prefix {
            op := unsafe { token.Token(int(c.aux())) }
            if op == .amp {
                return pointer_type_part_name(b.generic_type_arg_part_name_from_flat(c.edge(0)))
            }
            return ''
        }
        .typ_array {
            elem_name := b.generic_type_arg_part_name_from_flat(c.edge(0))
            if elem_name == '' {
                return ''
            }
            return 'Array_${elem_name}'
        }
        .typ_array_fixed {
            if c.edge_count() < 2 {
                return ''
            }
            elem_name := b.generic_type_arg_part_name_from_flat(c.edge(1))
            len_c := c.edge(0)
            len_name := if len_c.kind() == .expr_basic_literal { len_c.name() } else { '' }
            if elem_name == '' || len_name == '' {
                return ''
            }
            return 'Array_fixed_${elem_name}_${len_name}'
        }
        .typ_map {
            if c.edge_count() < 2 {
                return ''
            }
            key_name := b.generic_type_arg_part_name_from_flat(c.edge(0))
            value_name := b.generic_type_arg_part_name_from_flat(c.edge(1))
            if key_name == '' || value_name == '' {
                return ''
            }
            return 'Map_${key_name}_${value_name}'
        }
        .typ_pointer {
            return pointer_type_part_name(b.generic_type_arg_part_name_from_flat(c.edge(0)))
        }
        .typ_generic {
            concrete_name := b.generic_type_name_from_flat(c)
            if concrete_name == '' {
                return ''
            }
            return generic_token_part_name(concrete_name)
        }
        .typ_option {
            base_name := b.generic_type_arg_part_name_from_flat(c.edge(0))
            if base_name == '' {
                return ''
            }
            return 'Option_${base_name}'
        }
        .typ_result {
            base_name := b.generic_type_arg_part_name_from_flat(c.edge(0))
            if base_name == '' {
                return ''
            }
            return 'Result_${base_name}'
        }
        else {
            return ''
        }
    }
}

fn (b &Builder) generic_type_name_from_flat(c ast.Cursor) string {
    if c.kind() != .typ_generic || c.edge_count() <= 1 {
        return ''
    }
    base := b.generic_type_part_name_from_flat(c.edge(0))
    mut parts := []string{cap: c.edge_count() - 1}
    for i in 1 .. c.edge_count() {
        part := b.generic_type_arg_part_name_from_flat(c.edge(i))
        if part == '' {
            return ''
        }
        parts << part
    }
    return generic_type_name_from_parts(base, parts)
}

fn (mut b Builder) generic_type_to_ssa_from_flat(c ast.Cursor) TypeID {
    concrete_name := b.generic_type_name_from_flat(c)
    if concrete_name == '' || !ssa_string_ok(concrete_name) {
        return b.mod.type_store.get_int(64)
    }
    if id := b.struct_name_to_ssa(concrete_name) {
        return id
    }
    if id := b.registered_type_by_unique_concrete_suffix(concrete_name) {
        return id
    }
    base_name := b.generic_type_part_name_from_flat(c.edge(0))
    if id := b.generic_sumtype_storage_to_ssa(base_name, concrete_name) {
        return id
    }
    return b.mod.type_store.get_int(64)
}

fn (mut b Builder) primitive_type_name_to_ssa(name string) ?TypeID {
    if !ssa_string_ok(name) {
        return none
    }
    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)
        }
        'isize' {
            b.mod.type_store.get_int(64)
        }
        'usize' {
            b.mod.type_store.get_uint(64)
        }
        else {
            none
        }
    }
}

fn (mut b Builder) named_type_to_ssa(name string) TypeID {
    if !ssa_string_ok(name) {
        return b.mod.type_store.get_int(64)
    }
    if type_id := b.primitive_type_name_to_ssa(name) {
        return type_id
    }
    normalized := name.replace('.', '__')
    if type_id := b.lookup_type_alias_ssa(name) {
        return type_id
    }
    if normalized != name {
        if type_id := b.lookup_type_alias_ssa(normalized) {
            return type_id
        }
    }
    if normalized in b.struct_types {
        return b.struct_types[normalized]
    }
    if b.is_enum_type(name) || b.is_enum_type(normalized) {
        return b.mod.type_store.get_int(32)
    }
    if typ := b.lookup_checked_type_by_name(name) {
        if typ is types.Alias {
            return b.type_to_ssa(typ)
        } else {
            typ_name := types.type_name(typ)
            if typ_name != name {
                return b.type_to_ssa(typ)
            }
        }
    }
    if normalized != name {
        if typ := b.lookup_checked_type_by_name(normalized) {
            if typ is types.Alias {
                return b.type_to_ssa(typ)
            } else {
                typ_name := types.type_name(typ)
                if typ_name != name && typ_name != normalized {
                    return b.type_to_ssa(typ)
                }
            }
        }
    }
    return b.mod.type_store.get_int(64)
}

fn (b &Builder) selector_module_name_for_ident(mod_name string) ?string {
    if mod_name == 'C' {
        return 'C'
    }
    if resolved_mod := b.module_import_aliases[mod_name] {
        return resolved_mod
    }
    if b.env != unsafe { nil } {
        if scope := b.env.get_scope(b.cur_module) {
            if obj := scope.lookup_parent(mod_name, 0) {
                if obj is types.Module {
                    return obj.name
                }
            }
        }
    }
    return none
}

fn (b &Builder) selector_type_alias_to_ssa(mod_name string, type_name string) ?TypeID {
    if mod_name == '' || type_name == '' || !ssa_string_ok(mod_name) || !ssa_string_ok(type_name) {
        return none
    }
    normalized_mod := mod_name.replace('.', '_')
    qualified := ssa_module_storage_name(normalized_mod, type_name)
    if type_id := b.lookup_type_alias_ssa(qualified) {
        return type_id
    }
    if normalized_mod != mod_name {
        dot_qualified := ssa_module_storage_name(mod_name, type_name)
        if type_id := b.lookup_type_alias_ssa(dot_qualified) {
            return type_id
        }
    }
    short_mod := ssa_module_tail_name(normalized_mod)
    if short_mod != '' && short_mod != normalized_mod {
        short_qualified := ssa_module_storage_name(short_mod, type_name)
        if type_id := b.lookup_type_alias_ssa(short_qualified) {
            return type_id
        }
    }
    return none
}

fn (b &Builder) lookup_type_alias_ssa(name string) ?TypeID {
    if name == '' || !ssa_string_ok(name) {
        return none
    }
    if type_id := b.type_aliases[name] {
        return type_id
    }
    if b.cur_module != '' && b.cur_module != 'main' && !name.contains('__') {
        if type_id := b.type_aliases['${b.cur_module}__${name}'] {
            return type_id
        }
        short_mod := ssa_module_tail_name(b.cur_module)
        if short_mod != '' && short_mod != b.cur_module {
            if type_id := b.type_aliases['${short_mod}__${name}'] {
                return type_id
            }
        }
    }
    if name.contains('__') {
        mod_name := name.all_before_last('__')
        type_name := name.all_after_last('__')
        short_mod := ssa_module_tail_name(mod_name)
        if short_mod != '' && short_mod != mod_name {
            if type_id := b.type_aliases['${short_mod}__${type_name}'] {
                return type_id
            }
        }
        qualified_suffix := '__${name}'
        for alias_name, type_id in b.type_aliases {
            if alias_name.ends_with(qualified_suffix) {
                return type_id
            }
        }
    }
    return none
}

fn (b &Builder) sizeof_type_alias_name(name string) ?int {
    if type_id := b.lookup_type_alias_ssa(name) {
        return b.type_byte_size(type_id)
    }
    normalized := name.replace('.', '__')
    if normalized != name {
        if type_id := b.lookup_type_alias_ssa(normalized) {
            return b.type_byte_size(type_id)
        }
    }
    return none
}

fn struct_field_array_elem_key(type_id TypeID, field_name string) string {
    return '${int(type_id)}:${field_name}'
}

fn (mut b Builder) record_struct_field_array_elem_type(type_id TypeID, field_name string, field_type ast.Expr, field_ssa_type TypeID) {
    if field_name == '' || field_ssa_type != b.get_array_type() {
        return
    }
    elem_type := b.array_elem_type_from_ast_type(field_type)
    if elem_type != 0 {
        b.struct_field_array_elem_types[struct_field_array_elem_key(type_id, field_name)] = elem_type
    }
}

// record_struct_field_array_elem_type_from_flat (s239) is the cursor mirror of
// record_struct_field_array_elem_type. `field_type_c` is the field's typ cursor;
// elem-type inference reuses array_elem_type_from_ast_type_from_flat (s233).
fn (mut b Builder) record_struct_field_array_elem_type_from_flat(type_id TypeID, field_name string, field_type_c ast.Cursor, field_ssa_type TypeID) {
    if field_name == '' || field_ssa_type != b.get_array_type() {
        return
    }
    elem_type := b.array_elem_type_from_ast_type_from_flat(field_type_c)
    if elem_type != 0 {
        b.struct_field_array_elem_types[struct_field_array_elem_key(type_id, field_name)] = elem_type
    }
}

fn (b &Builder) struct_field_array_elem_type(type_id TypeID, field_name string) TypeID {
    if field_name == '' {
        return 0
    }
    mut cur_type := type_id
    for cur_type > 0 && int(cur_type) < b.mod.type_store.types.len {
        if elem_type := b.struct_field_array_elem_types[struct_field_array_elem_key(cur_type,
            field_name)]
        {
            return elem_type
        }
        typ := b.mod.type_store.types[cur_type]
        if typ.kind == .ptr_t && typ.elem_type > 0 {
            cur_type = typ.elem_type
            continue
        }
        break
    }
    return 0
}

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 (b &Builder) module_scope_has_direct_type(module_name string, type_name string) bool {
    if b.env == unsafe { nil } {
        return false
    }
    if scope := b.env.get_scope(module_name) {
        if _ := scope.lookup_type(type_name) {
            return true
        }
    }
    return false
}

fn (b &Builder) short_type_name_is_unshadowed_builtin(name string) bool {
    if name == '' || !b.module_scope_has_direct_type('builtin', name) {
        return false
    }
    if b.cur_module != '' && b.cur_module != 'builtin'
        && b.module_scope_has_direct_type(b.cur_module, name) {
        return false
    }
    return true
}

fn (b &Builder) type_name_is_builtin_ierror(name string) bool {
    if name == 'builtin__IError' || name == 'builtin.IError' {
        return b.module_scope_has_direct_type('builtin', 'IError')
    }
    if name == 'IError' {
        return b.short_type_name_is_unshadowed_builtin('IError')
    }
    return false
}

fn (b &Builder) type_name_is_builtin_error(name string) bool {
    if name == 'builtin__Error' || name == 'builtin.Error' {
        return b.module_scope_has_direct_type('builtin', 'Error')
    }
    if name == 'Error' {
        return b.short_type_name_is_unshadowed_builtin('Error')
    }
    return false
}

fn (mut b Builder) type_is_ierror_like(typ types.Type) bool {
    unwrapped := b.unwrap_alias_type(typ)
    match unwrapped {
        types.Interface {
            return b.type_name_is_builtin_ierror(unwrapped.name)
        }
        types.Pointer {
            return b.type_is_ierror_like(unwrapped.base_type)
        }
        types.Struct {
            if b.type_name_is_builtin_error(unwrapped.name) {
                return true
            }
            for embedded in unwrapped.embedded {
                if b.type_name_is_builtin_error(embedded.name) {
                    return true
                }
            }
            return false
        }
        else {
            return false
        }
    }
}

fn (mut b Builder) expr_is_ierror_like(expr ast.Expr) bool {
    typ := b.get_checked_expr_type(expr) or { return false }
    return b.type_is_ierror_like(typ)
}

fn (mut b Builder) cursor_is_ierror_like(c ast.Cursor) bool {
    typ := b.get_checked_expr_type_from_flat(c) or { return false }
    return b.type_is_ierror_like(typ)
}

fn (mut b Builder) type_is_ierror_interface(typ types.Type) bool {
    unwrapped := b.unwrap_alias_type(typ)
    match unwrapped {
        types.Interface {
            return b.type_name_is_builtin_ierror(unwrapped.name)
        }
        else {
            return false
        }
    }
}

fn (mut b Builder) type_is_concrete_ierror(typ types.Type) bool {
    unwrapped := b.unwrap_alias_type(typ)
    match unwrapped {
        types.Pointer {
            return b.type_is_concrete_ierror(unwrapped.base_type)
        }
        types.Struct {
            if b.type_name_is_builtin_error(unwrapped.name) {
                return true
            }
            for embedded in unwrapped.embedded {
                if b.type_name_is_builtin_error(embedded.name) {
                    return true
                }
            }
            return false
        }
        else {
            return false
        }
    }
}

fn (mut b Builder) checked_type_for_ssa_type(type_id TypeID) ?types.Type {
    if !b.valid_type_id(type_id) {
        return none
    }
    type_name := b.mod.c_struct_names[int(type_id)] or { return none }
    return b.lookup_checked_type_by_name(type_name)
}

fn (mut b Builder) ierror_tag_for_checked_type(typ types.Type) ?ValueID {
    if !b.type_is_concrete_ierror(typ) {
        return none
    }
    unwrapped := b.unwrap_alias_type(typ)
    concrete_type := match unwrapped {
        types.Pointer {
            b.unwrap_alias_type(unwrapped.base_type)
        }
        else {
            unwrapped
        }
    }

    type_id := b.type_to_ssa(concrete_type)
    if !b.valid_type_id(type_id) || int(type_id) == 0 {
        return none
    }
    i64_t := b.mod.type_store.get_int(64)
    return b.mod.get_or_add_const(i64_t, int(type_id).str())
}

fn (mut b Builder) ierror_tag_for_ssa_type(type_id TypeID) ?ValueID {
    typ := b.checked_type_for_ssa_type(type_id) or { return none }
    return b.ierror_tag_for_checked_type(typ)
}

fn (mut b Builder) ierror_tag_for_type_expr(expr ast.Expr) ?ValueID {
    type_id := b.ast_type_to_ssa(expr)
    return b.ierror_tag_for_ssa_type(type_id)
}

fn (mut b Builder) ierror_tag_for_type_cursor(c ast.Cursor) ?ValueID {
    type_id := b.ast_type_to_ssa_from_flat(c)
    return b.ierror_tag_for_ssa_type(type_id)
}

fn (mut b Builder) type_expr_is_ierror_interface(expr ast.Expr) bool {
    name := match expr {
        ast.Ident {
            expr.name
        }
        ast.SelectorExpr {
            expr.name().replace('.', '__')
        }
        else {
            ''
        }
    }

    if b.type_name_is_builtin_ierror(name) {
        return true
    }
    if name != '' {
        return false
    }
    typ := b.get_checked_expr_type(expr) or { return false }
    return b.type_is_ierror_interface(typ)
}

fn (mut b Builder) type_cursor_is_ierror_interface(c ast.Cursor) bool {
    name := match c.kind() {
        .expr_ident {
            c.name()
        }
        .expr_selector {
            lhs := c.edge(0)
            rhs := c.edge(1)
            if lhs.kind() == .expr_ident {
                '${lhs.name()}__${rhs.name()}'
            } else {
                rhs.name()
            }
        }
        else {
            ''
        }
    }

    if b.type_name_is_builtin_ierror(name) {
        return true
    }
    if name != '' {
        return false
    }
    typ := b.get_checked_expr_type_from_flat(c) or { return false }
    return b.type_is_ierror_interface(typ)
}

fn (mut b Builder) ierror_tag_for_expr(expr ast.Expr) ?ValueID {
    match expr {
        ast.CallOrCastExpr {
            if b.type_expr_is_ierror_interface(expr.lhs) {
                return b.ierror_tag_for_expr(expr.expr)
            }
        }
        ast.CastExpr {
            if b.type_expr_is_ierror_interface(expr.typ) {
                return b.ierror_tag_for_expr(expr.expr)
            }
        }
        ast.ParenExpr {
            return b.ierror_tag_for_expr(expr.expr)
        }
        ast.ModifierExpr {
            return b.ierror_tag_for_expr(expr.expr)
        }
        else {}
    }

    typ := b.get_checked_expr_type(expr) or { return none }
    return b.ierror_tag_for_checked_type(typ)
}

fn (mut b Builder) ierror_tag_for_cursor(c ast.Cursor) ?ValueID {
    match c.kind() {
        .expr_call_or_cast {
            if b.type_cursor_is_ierror_interface(c.edge(0)) {
                return b.ierror_tag_for_cursor(c.edge(1))
            }
        }
        .expr_cast {
            if b.type_cursor_is_ierror_interface(c.edge(0)) {
                return b.ierror_tag_for_cursor(c.edge(1))
            }
        }
        .expr_paren, .expr_modifier {
            return b.ierror_tag_for_cursor(c.edge(0))
        }
        else {}
    }

    typ := b.get_checked_expr_type_from_flat(c) or { return none }
    return b.ierror_tag_for_checked_type(typ)
}

fn (mut b Builder) build_ierror_concrete_compare(subject ValueID, subject_expr ast.Expr, variant_expr ast.Expr, op token.Token) ?ValueID {
    if op !in [.eq, .ne, .key_is, .not_is] {
        return none
    }
    subject_type := b.get_checked_expr_type(subject_expr) or { return none }
    if !b.type_is_ierror_interface(subject_type) {
        return none
    }
    expected := b.ierror_tag_for_type_expr(variant_expr) or { return none }
    bool_type := b.mod.type_store.get_int(1)
    cmp_op := if op in [.eq, .key_is] { OpCode.eq } else { OpCode.ne }
    return b.mod.add_instr(cmp_op, b.cur_block, bool_type, [subject, expected])
}

fn (mut b Builder) build_ierror_concrete_compare_from_flat(subject ValueID, subject_c ast.Cursor, variant_c ast.Cursor, op token.Token) ?ValueID {
    if op !in [.eq, .ne, .key_is, .not_is] {
        return none
    }
    subject_type := b.get_checked_expr_type_from_flat(subject_c) or { return none }
    if !b.type_is_ierror_interface(subject_type) {
        return none
    }
    expected := b.ierror_tag_for_type_cursor(variant_c) or { return none }
    bool_type := b.mod.type_store.get_int(1)
    cmp_op := if op in [.eq, .key_is] { OpCode.eq } else { OpCode.ne }
    return b.mod.add_instr(cmp_op, b.cur_block, bool_type, [subject, expected])
}

fn (mut b Builder) wrapper_value_is_valid_payload(val ValueID, wrapper_type TypeID) bool {
    if !b.wrapper_has_data(wrapper_type) {
        return false
    }
    if val <= 0 || val >= b.mod.values.len {
        return false
    }
    return b.mod.values[val].typ == b.wrapper_data_type(wrapper_type)
}

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 b.is_result_wrapper_type(wrapper_type) && b.expr_is_ierror_like(expr)
        && !b.wrapper_value_is_valid_payload(val, wrapper_type) {
        err_payload := b.ierror_tag_for_expr(expr) or { val }
        return b.build_wrapper_value(wrapper_type, false, err_payload, false)
    }
    if val > 0 && val < b.mod.values.len && b.mod.values[val].typ == wrapper_type {
        if payload := b.wrapper_payload_bitcast_source(val, wrapper_type) {
            return b.build_wrapper_value(wrapper_type, true, payload, true)
        }
        match b.mod.values[val].kind {
            .argument, .global, .instruction {
                return val
            }
            else {}
        }
    }
    return b.build_wrapper_value(wrapper_type, true, val, true)
}

fn (b &Builder) wrapper_payload_bitcast_source(val ValueID, wrapper_type TypeID) ?ValueID {
    if val <= 0 || val >= b.mod.values.len || !b.wrapper_has_data(wrapper_type) {
        return none
    }
    value := b.mod.values[val]
    if value.kind != .instruction || value.typ != wrapper_type {
        return none
    }
    instr := b.mod.instrs[value.index]
    if instr.op != .bitcast || instr.operands.len != 1 {
        return none
    }
    payload := instr.operands[0]
    if payload <= 0 || payload >= b.mod.values.len {
        return none
    }
    payload_type := b.mod.values[payload].typ
    if payload_type == wrapper_type || b.is_wrapper_type(payload_type) {
        return none
    }
    return payload
}

fn (mut b Builder) expr_type(e ast.Expr) TypeID {
    if !builder_expr_ok(e) {
        return b.mod.type_store.get_int(64)
    }
    if typ := b.get_checked_expr_type(e) {
        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_typ := obj.typ()
                obj_type := b.type_to_ssa(obj_typ)
                if obj_type != 0 {
                    return obj_type
                }
            }
        }
    }
    return b.expr_type(value)
}

// const_field_type_from_flat (s235) is the cursor mirror of const_field_type:
// the scope lookup is name-only, the fallback uses expr_type_from_flat (pos-only).
fn (mut b Builder) const_field_type_from_flat(field_name string, value_c ast.Cursor) TypeID {
    if b.env != unsafe { nil } {
        if scope := b.env.get_scope(b.cur_module) {
            if obj := scope.lookup_parent(field_name, 0) {
                obj_typ := obj.typ()
                obj_type := b.type_to_ssa(obj_typ)
                if obj_type != 0 {
                    return obj_type
                }
            }
        }
    }
    return b.expr_type_from_flat(value_c)
}

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

fn (mut b Builder) global_field_type(field ast.FieldDecl) TypeID {
    scope_type := b.scope_field_type(field.name)
    if scope_type != 0 {
        return scope_type
    }
    if builder_expr_ok(field.typ) && field.typ !is ast.EmptyExpr {
        return b.ast_type_to_ssa(field.typ)
    }
    if field.value is ast.ArrayInitExpr {
        arr := field.value as ast.ArrayInitExpr
        if builder_expr_ok(arr.typ) && arr.typ !is ast.EmptyExpr {
            return b.ast_type_to_ssa(arr.typ)
        }
    }
    if builder_expr_ok(field.value) && field.value !is ast.EmptyExpr {
        return b.expr_type(field.value)
    }
    return b.mod.type_store.get_int(64)
}

// global_field_type_from_flat (s237) is the cursor mirror of global_field_type.
// field_c is an .aux_field_decl: name in name_id, typ at edge(0), value at edge(1).
// `field.typ !is ast.EmptyExpr` maps to `edge(0).kind() != .expr_empty`; the
// ArrayInitExpr.typ check uses value_c.edge(0). scope/ssa/expr lookups identical.
fn (mut b Builder) global_field_type_from_flat(field_c ast.Cursor) TypeID {
    scope_type := b.scope_field_type(field_c.name())
    if scope_type != 0 {
        return scope_type
    }
    typ_c := field_c.edge(0)
    if typ_c.kind() != .expr_empty {
        return b.ast_type_to_ssa_from_flat(typ_c)
    }
    value_c := field_c.edge(1)
    if value_c.kind() == .expr_array_init {
        arr_typ_c := value_c.edge(0)
        if arr_typ_c.kind() != .expr_empty {
            return b.ast_type_to_ssa_from_flat(arr_typ_c)
        }
    }
    if value_c.kind() != .expr_empty {
        return b.expr_type_from_flat(value_c)
    }
    return b.mod.type_store.get_int(64)
}

fn (mut b Builder) types_type_c_name(t types.Type) string {
    if !types.type_has_valid_payload(t) {
        return 'unknown'
    }
    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 {
            base := b.resolve_alias_base_type(t) or {
                return if t.name != '' { t.name } else { 'unknown' }
            }
            return b.types_type_c_name(base)
        }
        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 {
                if stmt.variants.len > 0 {
                    b.register_sumtype(stmt)
                }
            }
            else {}
        }
    }
}

// register_types_pass1_from_flat is the flat-cursor counterpart of
// `register_types_pass1`. It walks one file's top-level stmts via FileCursor
// without rehydrating the file, and rehydrates only the StructDecl /
// EnumDecl / TypeDecl nodes via `flat.decode_stmt`. ModuleStmt, FnDecl,
// ConstDecl, GlobalDecl, ImportStmt, etc. are skipped entirely — never
// decoded — which is the actual allocation reduction over the legacy walker.
fn (mut b Builder) register_types_pass1_from_flat(file_cursor ast.FileCursor) {
    stmts := file_cursor.stmts()
    for si in 0 .. stmts.len() {
        c := stmts.at(si)
        match c.kind() {
            .stmt_struct_decl {
                // s239: cursor-native struct-name registration — no decode_stmt.
                b.register_struct_name_from_flat(c)
            }
            .stmt_enum_decl {
                // s238: cursor-native enum registration — no decode_stmt.
                b.register_enum_from_flat(c)
            }
            .stmt_type_decl {
                // s240: cursor-native sumtype registration — no decode_stmt.
                // TypeDecl variants list is edge3 (list_at(3)).
                if c.list_at(3).len() > 0 {
                    b.register_sumtype_from_flat(c)
                }
            }
            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) {
    b.module_import_aliases = module_import_aliases_from_imports(file.imports)
    nstmts := file.stmts.len
    for si in 0 .. nstmts {
        stmt := file.stmts[si]
        if stmt is ast.StructDecl {
            b.register_struct_fields(stmt)
        }
    }
}

// register_types_pass2_from_flat is the flat-cursor counterpart of
// `register_types_pass2`. Same shape as `register_types_pass1_from_flat`
// (s169) but filtered to `.stmt_struct_decl` only — pass2 only fills in
// struct field types. Non-StructDecl stmts (ModuleStmt, FnDecl, ConstDecl,
// EnumDecl, TypeDecl, etc.) are never decoded.
fn (mut b Builder) register_types_pass2_from_flat(file_cursor ast.FileCursor) {
    b.module_import_aliases =
        module_import_aliases_from_imports(file_cursor.imports().import_stmts())
    stmts := file_cursor.stmts()
    for si in 0 .. stmts.len() {
        c := stmts.at(si)
        if c.kind() == .stmt_struct_decl {
            // s239: cursor-native struct-fields registration — no decode_stmt.
            b.register_struct_fields_from_flat(c)
        }
    }
}

fn (mut b Builder) struct_mangled_name(decl ast.StructDecl) string {
    if !ssa_string_ok(decl.name) || decl.name == '' {
        return ''
    }
    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
    }
}

// struct_mangled_name_from_flat (s239) is the cursor mirror of struct_mangled_name.
// The struct name is the cursor's name_id.
fn (mut b Builder) struct_mangled_name_from_flat(c ast.Cursor) string {
    name_str := c.name()
    if !ssa_string_ok(name_str) || name_str == '' {
        return ''
    }
    return if b.cur_module == 'builtin'
        && name_str in ['array', 'string', 'map', 'DenseArray', 'IError', 'Error', 'MessageError', 'None__', '_option', '_result', 'Option'] {
        name_str
    } else if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${name_str}'
    } else {
        name_str
    }
}

// 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 == '' || !ssa_string_ok(name) {
        return
    }

    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_name_from_flat (s239) is the cursor mirror of register_struct_name.
// StructDecl flat = (.stmt_struct_decl, name in name_id, is_union in flags,
// [edge0=attrs, edge1=implements, edge2=embedded, edge3=generic_params, edge4=fields]).
fn (mut b Builder) register_struct_name_from_flat(c ast.Cursor) {
    name := b.struct_mangled_name_from_flat(c)
    if name == '' || !ssa_string_ok(name) {
        return
    }
    if name in b.struct_types {
        return
    }
    type_id := b.mod.type_store.register(Type{
        kind:     .struct_t
        is_union: c.flag(ast.flag_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)
    if name == '' || !ssa_string_ok(name) {
        return
    }

    type_id := b.struct_types[name] or { return }
    n_embedded := decl.embedded.len

    // 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 && n_embedded == 0 {
        return
    }

    mut field_types := []TypeID{}
    mut field_names := []string{}
    n_fields := decl.fields.len
    b.struct_embedded_spans.delete(int(type_id))

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

    for fi in 0 .. n_fields {
        ft := b.ast_type_to_ssa(decl.fields[fi].typ)
        field_types << ft
        field_name := decl.fields[fi].name
        field_names << if ssa_string_ok(field_name) { field_name } else { '' }
        b.record_struct_field_array_elem_type(type_id, field_name, decl.fields[fi].typ, ft)
    }
    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_fields_from_flat (s239) is the cursor mirror of
// register_struct_fields. embedded = c.list_at(2); fields = c.list_at(4)
// (.aux_field_decl: name in name_id, typ at edge0).
fn (mut b Builder) register_struct_fields_from_flat(c ast.Cursor) {
    name := b.struct_mangled_name_from_flat(c)
    if name == '' || !ssa_string_ok(name) {
        return
    }

    type_id := b.struct_types[name] or { return }
    embedded := c.list_at(2)

    // 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 && embedded.len() == 0 {
        return
    }

    mut field_types := []TypeID{}
    mut field_names := []string{}
    fields := c.list_at(4)
    b.struct_embedded_spans.delete(int(type_id))

    // Flatten embedded struct fields first (e.g., ObjectCommon in Const)
    if embedded.len() > 0 {
        b.record_embedded_field_spans_from_flat(type_id, embedded, field_names.len)
        b.collect_embedded_fields_from_flat(embedded, mut field_names, mut field_types)
    }

    for fi in 0 .. fields.len() {
        field_c := fields.at(fi)
        typ_c := field_c.edge(0)
        ft := b.ast_type_to_ssa_from_flat(typ_c)
        field_types << ft
        field_name := field_c.name()
        field_names << if ssa_string_ok(field_name) { field_name } else { '' }
        b.record_struct_field_array_elem_type_from_flat(type_id, field_name, typ_c, ft)
    }
    b.mod.type_store.types[type_id] = Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
        is_union:    c.flag(ast.flag_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 == '' || !ssa_string_ok(name) {
        return
    }

    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 fi in 0 .. decl.fields.len {
        ft := b.ast_type_to_ssa(decl.fields[fi].typ)
        field_types << ft
        field_name := decl.fields[fi].name
        field_names << if ssa_string_ok(field_name) { field_name } else { '' }
        // This combined path registers the struct after fields are collected,
        // so array element metadata is recorded below once type_id exists.
    }

    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
    for fi in 0 .. decl.fields.len {
        field_name := decl.fields[fi].name
        if ssa_string_ok(field_name) {
            b.record_struct_field_array_elem_type(type_id, field_name, decl.fields[fi].typ,
                field_types[fi])
        }
    }
}

// register_struct_from_flat (s239) is the cursor mirror of register_struct
// (the combined name+fields path). embedded = c.list_at(2); fields = c.list_at(4).
// The second loop's `field_types[fi]` indexing matches the AST exactly (fi indexes
// the decl fields but field_types has the embedded fields prepended).
fn (mut b Builder) register_struct_from_flat(c ast.Cursor) {
    name := b.struct_mangled_name_from_flat(c)
    if name == '' || !ssa_string_ok(name) {
        return
    }
    if name in b.struct_types {
        return
    }

    mut field_types := []TypeID{}
    mut field_names := []string{}
    embedded := c.list_at(2)
    fields := c.list_at(4)

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

    for fi in 0 .. fields.len() {
        typ_c := fields.at(fi).edge(0)
        ft := b.ast_type_to_ssa_from_flat(typ_c)
        field_types << ft
        field_name := fields.at(fi).name()
        field_names << if ssa_string_ok(field_name) { field_name } else { '' }
    }

    type_id := b.mod.type_store.register(Type{
        kind:        .struct_t
        fields:      field_types
        field_names: field_names
        is_union:    c.flag(ast.flag_is_union)
    })
    b.struct_types[name] = type_id
    b.mod.c_struct_names[type_id] = name
    for fi in 0 .. fields.len() {
        field_c := fields.at(fi)
        field_name := field_c.name()
        if ssa_string_ok(field_name) {
            b.record_struct_field_array_elem_type_from_flat(type_id, field_name, field_c.edge(0),
                field_types[fi])
        }
    }
}

fn (mut b Builder) embedded_type_id_from_expr(emb ast.Expr) ?TypeID {
    if emb is ast.Ident {
        if !ssa_string_ok(emb.name) {
            return none
        }
        return b.lookup_embedded_type_id_by_name(emb.name)
    }
    if emb is ast.SelectorExpr && emb.lhs is ast.Ident {
        lhs_name := (emb.lhs as ast.Ident).name
        if !ssa_string_ok(lhs_name) || !ssa_string_ok(emb.rhs.name) {
            return none
        }
        if type_id := b.selector_type_name_to_ssa(lhs_name, emb.rhs.name) {
            if b.valid_type_id(type_id) {
                return type_id
            }
        }
        if resolved_mod := b.module_import_aliases[lhs_name] or {
            b.selector_module_name_for_ident(lhs_name) or { '' }
        }
        {
            if resolved_mod == '' {
                return none
            }
            qualified := imported_symbol_fn_name(resolved_mod, emb.rhs.name)
            if type_id := b.struct_types[qualified] {
                return type_id
            }
            if type_id := b.selector_type_name_to_ssa(resolved_mod, emb.rhs.name) {
                if b.valid_type_id(type_id) {
                    return type_id
                }
            }
        }
    }
    return none
}

fn (mut b Builder) embedded_type_id_from_flat(emb ast.Cursor) ?TypeID {
    if emb.kind() == .expr_ident {
        n := emb.name()
        if !ssa_string_ok(n) {
            return none
        }
        return b.lookup_embedded_type_id_by_name(n)
    }
    if emb.kind() == .expr_selector && emb.edge(0).kind() == .expr_ident {
        lhs_name := emb.edge(0).name()
        rhs_name := emb.edge(1).name()
        if !ssa_string_ok(lhs_name) || !ssa_string_ok(rhs_name) {
            return none
        }
        if type_id := b.selector_type_name_to_ssa(lhs_name, rhs_name) {
            if b.valid_type_id(type_id) {
                return type_id
            }
        }
        if resolved_mod := b.module_import_aliases[lhs_name] or {
            b.selector_module_name_for_ident(lhs_name) or { '' }
        }
        {
            if resolved_mod == '' {
                return none
            }
            qualified := imported_symbol_fn_name(resolved_mod, rhs_name)
            if type_id := b.struct_types[qualified] {
                return type_id
            }
            if type_id := b.selector_type_name_to_ssa(resolved_mod, rhs_name) {
                if b.valid_type_id(type_id) {
                    return type_id
                }
            }
        }
    }
    return none
}

fn (mut b Builder) lookup_embedded_type_id_by_name(emb_name string) ?TypeID {
    if b.cur_module != '' && b.cur_module != 'main' {
        qualified := '${b.cur_module}__${emb_name}'
        if qualified in b.struct_types {
            return b.struct_types[qualified]
        }
    }
    if emb_name in b.struct_types {
        return b.struct_types[emb_name]
    }
    return none
}

fn (mut b Builder) record_embedded_field_spans(owner_type TypeID, embedded []ast.Expr, start_idx int) {
    mut offset := start_idx
    for emb in embedded {
        emb_type_id := b.embedded_type_id_from_expr(emb) or { continue }
        if emb_type_id <= 0 || emb_type_id >= b.mod.type_store.types.len {
            continue
        }
        emb_typ := b.mod.type_store.types[emb_type_id]
        if emb_typ.kind != .struct_t || emb_typ.field_names.len == 0 {
            continue
        }
        mut spans := b.struct_embedded_spans[int(owner_type)] or { []EmbeddedFieldSpan{} }
        spans << EmbeddedFieldSpan{
            source_type: emb_type_id
            start:       offset
            len:         emb_typ.field_names.len
        }
        b.struct_embedded_spans[int(owner_type)] = spans
        offset += emb_typ.field_names.len
    }
}

fn (mut b Builder) record_embedded_field_spans_from_flat(owner_type TypeID, embedded ast.CursorList, start_idx int) {
    mut offset := start_idx
    for ei in 0 .. embedded.len() {
        emb_type_id := b.embedded_type_id_from_flat(embedded.at(ei)) or { continue }
        if emb_type_id <= 0 || emb_type_id >= b.mod.type_store.types.len {
            continue
        }
        emb_typ := b.mod.type_store.types[emb_type_id]
        if emb_typ.kind != .struct_t || emb_typ.field_names.len == 0 {
            continue
        }
        mut spans := b.struct_embedded_spans[int(owner_type)] or { []EmbeddedFieldSpan{} }
        spans << EmbeddedFieldSpan{
            source_type: emb_type_id
            start:       offset
            len:         emb_typ.field_names.len
        }
        b.struct_embedded_spans[int(owner_type)] = spans
        offset += emb_typ.field_names.len
    }
}

// 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 {
        emb_type_id := b.embedded_type_id_from_expr(emb) or { 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)
                    }
                }
            }
        }
    }
}

// collect_embedded_fields_from_flat (s239) is the cursor mirror of
// collect_embedded_fields. Each embedded entry is an `.expr_ident` (`emb.name()`)
// or an `.expr_selector` with an Ident lhs (`edge(0).name()` / rhs `edge(1).name()`).
// The struct_types lookup + field-copy logic is identical (type-store reads only).
fn (mut b Builder) collect_embedded_fields_from_flat(embedded ast.CursorList, mut field_names []string, mut field_types []TypeID) {
    for ei in 0 .. embedded.len() {
        emb := embedded.at(ei)
        emb_type_id := b.embedded_type_id_from_flat(emb) or { 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) {
    if !ssa_string_ok(decl.name) || decl.name == '' {
        return
    }
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${decl.name}'
    } else {
        decl.name
    }
    if !ssa_string_ok(name) {
        return
    }

    is_flag := decl.attributes.has('flag')
    for i, field in decl.fields {
        if !ssa_string_ok(field.name) || field.name == '' {
            continue
        }
        key := '${name}__${enum_field_symbol_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
        }
    }
}

// register_enum_from_flat (s238) is the cursor mirror of register_enum. EnumDecl
// flat = (.stmt_enum_decl, name in name_id, [edge0=as_type, edge1=attrs,
// edge2=fields]). Values come from the field INDEX (matching the AST, which
// ignores field.value), so the `flag` power-of-2 numbering and the skip-on-bad-
// name behaviour are index-identical. `flag` attr via cursor_attrs_has (s237).
fn (mut b Builder) register_enum_from_flat(c ast.Cursor) {
    name_str := c.name()
    if !ssa_string_ok(name_str) || name_str == '' {
        return
    }
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${name_str}'
    } else {
        name_str
    }
    if !ssa_string_ok(name) {
        return
    }

    is_flag := cursor_attrs_has(c.list_at(1), 'flag')
    fields := c.list_at(2)
    for i in 0 .. fields.len() {
        field_name := fields.at(i).name()
        if !ssa_string_ok(field_name) || field_name == '' {
            continue
        }
        key := '${name}__${enum_field_symbol_name(field_name)}'
        if is_flag {
            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_type_aliases(file ast.File) {
    for stmt in file.stmts {
        if stmt is ast.TypeDecl && stmt.variants.len == 0 {
            b.register_type_alias(stmt)
        }
    }
}

fn (mut b Builder) register_type_aliases_from_flat(file_cursor ast.FileCursor) {
    stmts := file_cursor.stmts()
    for si in 0 .. stmts.len() {
        c := stmts.at(si)
        if c.kind() == .stmt_type_decl {
            // s236: TypeDecl flat = (.stmt_type_decl, name in name_id,
            // [edge0=base_type, edge1=attrs, edge2=generic_params, edge3=variants]).
            // Aliases have no variants — dispatch cursor-natively, no decode_stmt.
            if c.list_at(3).len() == 0 {
                b.register_type_alias_from_flat(c)
            }
        }
    }
}

fn (mut b Builder) register_type_alias(decl ast.TypeDecl) {
    if !ssa_string_ok(decl.name) || decl.name == '' || !builder_expr_ok(decl.base_type) {
        return
    }
    base_type := b.ast_type_to_ssa(decl.base_type)
    if base_type == 0 {
        return
    }
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${decl.name}'
    } else {
        decl.name
    }
    if ssa_string_ok(name) {
        b.type_aliases[name] = base_type
    }
    short_mod := ssa_module_tail_name(b.cur_module)
    if short_mod != '' && short_mod != b.cur_module && b.cur_module != 'main' {
        short_name := '${short_mod}__${decl.name}'
        if ssa_string_ok(short_name) {
            b.type_aliases[short_name] = base_type
        }
    }
    if b.cur_module == '' || b.cur_module == 'main' {
        b.type_aliases[decl.name] = base_type
    }
}

// register_type_alias_from_flat (s236) is the cursor mirror of register_type_alias.
// `c` is the .stmt_type_decl cursor: name in name_id, base_type at edge(0). The
// builder_expr_ok corruption guard is unnecessary for a valid cursor; the
// ssa_string_ok / base_type==0 guards and the map writes are identical.
fn (mut b Builder) register_type_alias_from_flat(c ast.Cursor) {
    name_str := c.name()
    if !ssa_string_ok(name_str) || name_str == '' {
        return
    }
    base_type := b.ast_type_to_ssa_from_flat(c.edge(0))
    if base_type == 0 {
        return
    }
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${name_str}'
    } else {
        name_str
    }
    if ssa_string_ok(name) {
        b.type_aliases[name] = base_type
    }
    short_mod := ssa_module_tail_name(b.cur_module)
    if short_mod != '' && short_mod != b.cur_module && b.cur_module != 'main' {
        short_name := '${short_mod}__${name_str}'
        if ssa_string_ok(short_name) {
            b.type_aliases[short_name] = base_type
        }
    }
    if b.cur_module == '' || b.cur_module == 'main' {
        b.type_aliases[name_str] = base_type
    }
}

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

    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
}

// register_sumtype_from_flat (s240) is the cursor mirror of register_sumtype.
// `c` is a .stmt_type_decl with variants (variants list = edge3). The variant
// types are not read (the AST also ignores them) — a sum type lowers to a
// {_tag, _data} two-i64 struct. Caller already gates on variants present.
fn (mut b Builder) register_sumtype_from_flat(c ast.Cursor) {
    if c.list_at(3).len() == 0 {
        return
    }
    name_str := c.name()
    if !ssa_string_ok(name_str) || name_str == '' {
        return
    }
    name := if b.cur_module != '' && b.cur_module != 'main' {
        '${b.cur_module}__${name_str}'
    } else {
        name_str
    }
    if !ssa_string_ok(name) {
        return
    }

    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 {
                b.register_const_decl(stmt)
            }
            ast.GlobalDecl {
                b.register_global_decl(stmt)
            }
            else {}
        }
    }
}

// register_consts_and_globals_from_flat is the flat-cursor counterpart of
// `register_consts_and_globals`. Walks one file's top-level stmts via
// FileCursor and only rehydrates `.stmt_const_decl` / `.stmt_global_decl`
// nodes via `flat.decode_stmt`. ModuleStmt, FnDecl, StructDecl, EnumDecl,
// TypeDecl, ImportStmt etc. are never decoded.
fn (mut b Builder) register_consts_and_globals_from_flat(file_cursor ast.FileCursor) {
    stmts := file_cursor.stmts()
    for si in 0 .. stmts.len() {
        c := stmts.at(si)
        match c.kind() {
            .stmt_const_decl {
                // s242: cursor-native const registration — no decode_stmt.
                b.register_const_decl_from_flat(c)
            }
            .stmt_global_decl {
                // s237: cursor-native global registration — no decode_stmt.
                b.register_global_decl_from_flat(c)
            }
            else {}
        }
    }
}

// register_const_decl extracts the per-ConstDecl body from
// `register_consts_and_globals` so both the legacy walker and the
// flat-cursor port can dispatch through a single implementation.
fn (mut b Builder) register_const_decl(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
        }
    }
}

// register_const_decl_from_flat (s242) is the cursor mirror of register_const_decl
// (the last decode_stmt in builder.v). ConstDecl flat = one edge -> aux_list of
// `.aux_field_init` (field name in name_id, value at edge(0)). Uses the s235
// (try_eval_const_int / const_field_type / is_zero_literal) and s241
// (try_eval_const_string / is_float_cast_expr / try_eval_computed_float /
// is_float_array / try_serialize_const_array) cursor helpers. Every branch
// (string / float / int / sumtype-const / fixed+dynamic const-array) mirrors the
// AST exactly; ArrayInitExpr exprs are edges 5..n and InitExpr fields edges 1..n.
fn (mut b Builder) register_const_decl_from_flat(c ast.Cursor) {
    fields := c.list_at(0)
    for fidx in 0 .. fields.len() {
        field_c := fields.at(fidx)
        field_name := field_c.name()
        value_c := field_c.edge(0)
        value_kind := value_c.kind()
        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_from_flat(field_name, value_c)
        // Check if this is a string constant - store for inline resolution
        str_val := b.try_eval_const_string_from_flat(value_c)
        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 value_kind == .expr_basic_literal
            && unsafe { token.Token(int(value_c.aux())) } == .number
            && (value_c.name().contains('.') || (!value_c.name().starts_with('0x')
            && !value_c.name().starts_with('0X')
            && (value_c.name().contains('e') || value_c.name().contains('E')))) {
            b.float_const_values[const_name] = value_c.name()
            b.float_const_values[field_name] = value_c.name()
        } else if b.is_float_cast_expr_from_flat(value_c) {
            if fval := b.try_eval_computed_float_from_flat(value_c) {
                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_from_flat(value_c)
        // Detect sum type constants (Case 1: InitExpr{_tag,...}; Case 2: cast to sum type).
        mut is_sumtype_const := false
        if value_kind == .expr_init {
            n_init_fields := value_c.edge_count() - 1
            for ifi := 0; ifi < n_init_fields; ifi++ {
                if value_c.edge(1 + ifi).name() == '_tag' {
                    is_sumtype_const = true
                    break
                }
            }
        }
        if !is_sumtype_const {
            mut cast_type_name := ''
            if value_kind == .expr_cast {
                if value_c.edge(0).kind() == .expr_ident {
                    cast_type_name = value_c.edge(0).name()
                }
            } else if value_kind == .expr_call_or_cast {
                if value_c.edge(0).kind() == .expr_ident {
                    cast_type_name = value_c.edge(0).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
                                const_type = st_type
                                break
                            }
                        }
                    }
                }
            }
        }
        // For sum type constants detected via InitExpr, also fix const_type
        if is_sumtype_const && value_kind == .expr_init {
            if value_c.edge(0).kind() == .expr_ident {
                type_name := value_c.edge(0).name()
                if st_type := b.struct_types[type_name] {
                    const_type = st_type
                } else {
                    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 value_kind == .expr_array_init && (value_c.edge_count() - 5) > 0 {
            n_arr_exprs := value_c.edge_count() - 5
            mut is_fixed_array := true
            // Check type environment to see if this is a dynamic array
            if b.env != unsafe { nil } {
                fpos := value_c.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_from_flat(value_c)
            if arr_data.len > 0 {
                elem_size := arr_data.len / n_arr_exprs
                is_float_arr := b.is_float_array_from_flat(value_c)
                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] = n_arr_exprs
                    b.const_array_elem_count[field_name] = n_arr_exprs
                    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:       n_arr_exprs
                        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_from_flat(value_c)) {
            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
        }
    }
}

// register_global_decl extracts the per-GlobalDecl body from
// `register_consts_and_globals` so both the legacy walker and the
// flat-cursor port can dispatch through a single implementation.
fn (mut b Builder) register_global_decl(stmt ast.GlobalDecl) {
    for field in stmt.fields {
        glob_type := b.global_field_type(field)
        if field.name.starts_with('C.') {
            continue
        }
        if ssa_module_storage_field_is_c_extern(stmt, field) {
            glob_id := b.mod.add_external_global(field.name, glob_type)
            b.global_refs[field.name] = glob_id
            qualified_name := ssa_module_storage_name(b.cur_module, field.name)
            if qualified_name != field.name {
                b.global_refs[qualified_name] = glob_id
            }
            continue
        }
        glob_name := ssa_module_storage_name(b.cur_module, field.name)
        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)
    }
}

// register_global_decl_from_flat (s237) is the cursor mirror of
// register_global_decl. GlobalDecl flat = (.stmt_global_decl, [edge0=attrs,
// edge1=fields]); each field is an .aux_field_decl (name in name_id, edge0=typ,
// edge1=value, edge2=attrs). The c_extern check mirrors
// ssa_module_storage_field_is_c_extern via cursor_attrs_has on the decl-level
// (edge0) and field-level (field edge2) attribute lists; the value uses
// try_eval_const_int_from_flat (s235). Bit-identical to the AST path.
fn (mut b Builder) register_global_decl_from_flat(c ast.Cursor) {
    node_attrs := c.list_at(0)
    fields := c.list_at(1)
    for fi in 0 .. fields.len() {
        field_c := fields.at(fi)
        field_name := field_c.name()
        glob_type := b.global_field_type_from_flat(field_c)
        if field_name.starts_with('C.') {
            continue
        }
        is_c_extern := field_name.starts_with('C.') || cursor_attrs_has(node_attrs, 'c_extern')
            || cursor_attrs_has(field_c.list_at(2), 'c_extern')
        if is_c_extern {
            glob_id := b.mod.add_external_global(field_name, glob_type)
            b.global_refs[field_name] = glob_id
            qualified_name := ssa_module_storage_name(b.cur_module, field_name)
            if qualified_name != field_name {
                b.global_refs[qualified_name] = glob_id
            }
            continue
        }
        glob_name := ssa_module_storage_name(b.cur_module, field_name)
        value_c := field_c.edge(1)
        initial_value := if value_c.kind() != .expr_empty {
            b.try_eval_const_int_from_flat(value_c)
        } else {
            i64(0)
        }
        b.mod.add_global_with_value(glob_name, glob_type, false, initial_value)
    }
}

// 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_forward_const_refs_from_flat is the flat-cursor counterpart of
// `resolve_forward_const_refs`. Walks each file's top-level stmts via
// FileCursor and only rehydrates `.stmt_const_decl` nodes via
// `flat.decode_stmt`. Non-ConstDecl stmts are never decoded.
fn (mut b Builder) resolve_forward_const_refs_from_flat(flat &ast.FlatAst) {
    for fi in 0 .. flat.files.len {
        fc := flat.file_cursor(fi)
        b.cur_module = fc.mod().replace('.', '_')
        stmts := fc.stmts()
        for si in 0 .. stmts.len() {
            c := stmts.at(si)
            if c.kind() != .stmt_const_decl {
                continue
            }
            // s235: walk the const-decl field-inits via cursors — no decode_stmt.
            // ConstDecl flat = one edge -> aux_list of .aux_field_init (field name in
            // name_id, value expr at edge(0)).
            fields := c.list_at(0)
            for fidx in 0 .. fields.len() {
                field_c := fields.at(fidx)
                field_name := field_c.name()
                value_c := field_c.edge(0)
                const_name := if b.cur_module != '' && b.cur_module != 'main' {
                    '${b.cur_module}__${field_name}'
                } else {
                    field_name
                }
                if const_name in b.const_values {
                    continue
                }
                if b.is_zero_literal_from_flat(value_c) {
                    continue
                }
                if value_c.kind() == .expr_init {
                    mut has_tag := false
                    n_init_fields := value_c.edge_count() - 1
                    for ifi := 0; ifi < n_init_fields; ifi++ {
                        if value_c.edge(1 + ifi).name() == '_tag' {
                            has_tag = true
                            break
                        }
                    }
                    if has_tag {
                        continue
                    }
                }
                new_value := b.try_eval_const_int_from_flat(value_c)
                if new_value != 0 {
                    b.const_values[const_name] = new_value
                    b.const_values[field_name] = new_value
                    ct := b.const_field_type_from_flat(field_name, value_c)
                    b.const_value_types[const_name] = ct
                    b.const_value_types[field_name] = ct
                    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
}

// is_float_array_from_flat (s241) is the cursor mirror of is_float_array.
// ArrayInitExpr flat = (.expr_array_init, [edge0=typ, edge1=init, edge2=cap,
// edge3=len, edge4=update_expr, edge5..n=exprs]); first element = edge(5).
fn (b &Builder) is_float_array_from_flat(c ast.Cursor) bool {
    if c.edge_count() > 5 {
        first := c.edge(5)
        if first.kind() == .expr_call_or_cast {
            lhs_c := first.edge(0)
            if lhs_c.kind() == .expr_ident {
                return lhs_c.name() in ['f32', 'f64']
            }
        } else if first.kind() == .expr_cast {
            typ_c := first.edge(0)
            if typ_c.kind() == .expr_ident {
                return typ_c.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{}
    }
    // Untyped integer literals default to V `int`, which is 32-bit.
    mut elem_size := 4
    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_serialize_const_array_from_flat (s241) is the cursor mirror of
// try_serialize_const_array. ArrayInitExpr exprs are edges 5..n; element size /
// float-ness come from the first element's CallOrCast/Cast Ident type name; values
// via try_eval_const_float_from_flat / try_eval_const_int_from_flat. Byte layout
// (little-endian per element) is identical to the AST.
fn (mut b Builder) try_serialize_const_array_from_flat(c ast.Cursor) []u8 {
    n_exprs := c.edge_count() - 5
    if n_exprs <= 0 {
        return []u8{}
    }
    mut elem_size := 8
    mut is_float := false
    first := c.edge(5)
    if first.kind() == .expr_call_or_cast {
        lhs_c := first.edge(0)
        if lhs_c.kind() == .expr_ident {
            match lhs_c.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.kind() == .expr_cast {
        typ_c := first.edge(0)
        if typ_c.kind() == .expr_ident {
            match typ_c.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: n_exprs * elem_size}
    for ei in 0 .. n_exprs {
        expr_c := c.edge(5 + ei)
        if is_float {
            fval := b.try_eval_const_float_from_flat(expr_c)
            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_from_flat(expr_c)
            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
}

// try_eval_const_float_from_flat (s241) is the cursor mirror of try_eval_const_float.
fn (b &Builder) try_eval_const_float_from_flat(c ast.Cursor) f64 {
    match c.kind() {
        .expr_basic_literal {
            kind := unsafe { token.Token(int(c.aux())) }
            if kind == .number {
                return c.name().f64()
            }
        }
        .expr_call_or_cast {
            // f64(0.5), f32(1.0), etc. — inner value at edge(1).
            return b.try_eval_const_float_from_flat(c.edge(1))
        }
        .expr_prefix {
            op := unsafe { token.Token(int(c.aux())) }
            if op == .minus {
                return -b.try_eval_const_float_from_flat(c.edge(0))
            }
        }
        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
}

// is_float_cast_expr_from_flat (s241) is the cursor mirror of is_float_cast_expr.
// The AST's mutually-exclusive `if expr is X` chain becomes a match on c.kind().
fn (b &Builder) is_float_cast_expr_from_flat(c ast.Cursor) bool {
    match c.kind() {
        .expr_cast {
            typ_c := c.edge(0)
            if typ_c.kind() == .expr_ident {
                return typ_c.name() == 'f64' || typ_c.name() == 'f32'
            }
        }
        .expr_call_or_cast {
            lhs_c := c.edge(0)
            if lhs_c.kind() == .expr_ident {
                return lhs_c.name() == 'f64' || lhs_c.name() == 'f32'
            }
        }
        .expr_basic_literal {
            kind := unsafe { token.Token(int(c.aux())) }
            if kind == .number {
                value := c.name()
                return value.contains('.')
                    || (!value.starts_with('0x') && !value.starts_with('0X')
                    && (value.contains('e') || value.contains('E')))
            }
        }
        .expr_prefix {
            return b.is_float_cast_expr_from_flat(c.edge(0))
        }
        .expr_infix {
            return b.is_float_cast_expr_from_flat(c.edge(0))
                || b.is_float_cast_expr_from_flat(c.edge(1))
        }
        else {}
    }

    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
        }
    }
}

// try_eval_computed_float_from_flat (s241) is the cursor mirror of
// try_eval_computed_float. Infix/Prefix op in aux; Cast/CallOrCast inner at edge(1).
fn (mut b Builder) try_eval_computed_float_from_flat(c ast.Cursor) ?f64 {
    match c.kind() {
        .expr_basic_literal {
            kind := unsafe { token.Token(int(c.aux())) }
            value := c.name()
            if kind == .number && value.contains('.') {
                return value.f64()
            }
            if kind == .number {
                return f64(value.i64())
            }
            return none
        }
        .expr_ident {
            name := c.name()
            if fval := b.float_const_values[name] {
                return fval.f64()
            }
            qualified := '${b.cur_module}__${name}'
            if fval := b.float_const_values[qualified] {
                return fval.f64()
            }
            return none
        }
        .expr_infix {
            op := unsafe { token.Token(int(c.aux())) }
            lhs := b.try_eval_computed_float_from_flat(c.edge(0)) or { return none }
            rhs := b.try_eval_computed_float_from_flat(c.edge(1)) or { return none }
            return match op {
                .plus {
                    lhs + rhs
                }
                .minus {
                    lhs - rhs
                }
                .mul {
                    lhs * rhs
                }
                .div {
                    if rhs != 0.0 {
                        lhs / rhs
                    } else {
                        f64(0.0)
                    }
                }
                else {
                    return none
                }
            }
        }
        .expr_prefix {
            op := unsafe { token.Token(int(c.aux())) }
            if op == .minus {
                val := b.try_eval_computed_float_from_flat(c.edge(0)) or { return none }
                return -val
            }
            return none
        }
        .expr_cast {
            typ_c := c.edge(0)
            if typ_c.kind() == .expr_ident && (typ_c.name() == 'f64' || typ_c.name() == 'f32') {
                return b.try_eval_computed_float_from_flat(c.edge(1))
            }
            return none
        }
        .expr_call_or_cast {
            lhs_c := c.edge(0)
            if lhs_c.kind() == .expr_ident && (lhs_c.name() == 'f64' || lhs_c.name() == 'f32') {
                return b.try_eval_computed_float_from_flat(c.edge(1))
            }
            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
}

// try_eval_const_int_from_flat (s235) is the cursor mirror of try_eval_const_int.
// BasicLiteral kind in aux / value in name(); Infix/Prefix op in aux with operand
// edges; Cast/CallOrCast inner value at edge(1); Paren inner at edge(0); Init walks
// its .aux_field_init children for `_tag`. Bit-identical (same recursion, same
// const_values lookups, same literal parsing).
fn (mut b Builder) try_eval_const_int_from_flat(c ast.Cursor) i64 {
    match c.kind() {
        .expr_basic_literal {
            kind := unsafe { token.Token(int(c.aux())) }
            value := c.name()
            if kind == .number {
                if !value.starts_with('0x') && !value.starts_with('0X')
                    && (value.contains('e') || value.contains('E')
                    || value.contains('.')) {
                    return i64(value.f64())
                }
                return parse_const_int_literal(value)
            }
            if kind == .key_true {
                return 1
            }
            if kind == .key_false {
                return 0
            }
            if kind == .char {
                return b.resolve_char_const_value(value)
            }
        }
        .expr_infix {
            op := unsafe { token.Token(int(c.aux())) }
            lhs := b.try_eval_const_int_from_flat(c.edge(0))
            rhs := b.try_eval_const_int_from_flat(c.edge(1))
            result2 := match 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
        }
        .expr_prefix {
            op := unsafe { token.Token(int(c.aux())) }
            val := b.try_eval_const_int_from_flat(c.edge(0))
            return match op {
                .minus { -val }
                .bit_not { ~val }
                else { i64(0) }
            }
        }
        .expr_ident {
            name := c.name()
            if name in b.const_values {
                return b.const_values[name]
            }
            qualified := '${b.cur_module}__${name}'
            if qualified in b.const_values {
                return b.const_values[qualified]
            }
            builtin_qual := 'builtin__${name}'
            if builtin_qual in b.const_values {
                return b.const_values[builtin_qual]
            }
        }
        .expr_cast {
            return b.try_eval_const_int_from_flat(c.edge(1))
        }
        .expr_call_or_cast {
            return b.try_eval_const_int_from_flat(c.edge(1))
        }
        .expr_paren {
            return b.try_eval_const_int_from_flat(c.edge(0))
        }
        .expr_init {
            // edge0=typ, edge1..n = .aux_field_init (name in name_id, value at edge0)
            n_fields := c.edge_count() - 1
            for fi := 0; fi < n_fields; fi++ {
                field_c := c.edge(1 + fi)
                if field_c.name() == '_tag' {
                    return b.try_eval_const_int_from_flat(field_c.edge(0))
                }
            }
        }
        else {}
    }

    return 0
}

// is_zero_literal_from_flat (s235) is the cursor mirror of is_zero_literal.
fn (b &Builder) is_zero_literal_from_flat(c ast.Cursor) bool {
    if c.kind() == .expr_basic_literal {
        kind := unsafe { token.Token(int(c.aux())) }
        return kind == .number && c.name() == '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 ''
}

// try_eval_const_string_from_flat (s241) is the cursor mirror of try_eval_const_string.
// StringLiteral value is in name_id (.expr_string); a .string BasicLiteral likewise.
fn (b &Builder) try_eval_const_string_from_flat(c ast.Cursor) string {
    match c.kind() {
        .expr_string {
            mut val := c.name()
            if val.len >= 2 && ((val[0] == `'` && val[val.len - 1] == `'`)
                || (val[0] == `"` && val[val.len - 1] == `"`)) {
                val = val[1..val.len - 1]
            }
            return val
        }
        .expr_basic_literal {
            kind := unsafe { token.Token(int(c.aux())) }
            if kind == .string {
                mut val := c.name()
                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 {
            if !ssa_string_ok(typ.name) {
                return b.mod.type_store.get_int(64)
            }
            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
                if !ssa_string_ok(mod_name) || !ssa_string_ok(typ.rhs.name) {
                    return b.mod.type_store.get_int(64)
                }
                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]
                }
                if alias_type := b.selector_type_alias_to_ssa(mod_name, typ.rhs.name) {
                    return alias_type
                }
                if resolved_mod := b.selector_module_name_for_ident(mod_name) {
                    if alias_type := b.selector_type_alias_to_ssa(resolved_mod, typ.rhs.name) {
                        return alias_type
                    }
                }
                // 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.GenericType {
            return b.generic_type_to_ssa(typ.name, typ.params)
        }
        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 {
    if !ssa_string_ok(name) {
        return b.mod.type_store.get_int(64)
    }
    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 alias_type := b.lookup_type_alias_ssa(name) {
                alias_type
            } 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) {
    b.module_import_aliases = module_import_aliases_from_imports(file.imports)
    for stmt in file.stmts {
        if stmt is ast.FnDecl {
            if stmt.typ.generic_params.len > 0 {
                continue
            }
            b.register_fn_sig(stmt)
        }
    }
}

// register_fn_signatures_from_flat is the flat-cursor counterpart of
// `register_fn_signatures`. Walks one file's top-level stmts via FileCursor
// and reads `.stmt_fn_decl` signatures directly from cursor edges. Fn bodies
// are never materialized in this phase.
fn (mut b Builder) register_fn_signatures_from_flat(file_cursor ast.FileCursor) {
    b.module_import_aliases =
        module_import_aliases_from_imports(file_cursor.imports().import_stmts())
    stmts := file_cursor.stmts()
    for si in 0 .. stmts.len() {
        c := stmts.at(si)
        if c.kind() == .stmt_fn_decl {
            // s243: cursor-native fn-signature registration — no decode. FnType is
            // edge1; its generic_params list is list_at(0).
            if c.edge(1).list_at(0).len() > 0 {
                continue
            }
            b.register_fn_sig_from_flat(c)
        }
    }
}

fn (mut b Builder) register_fn_sig(decl ast.FnDecl) {
    fn_name := b.mangle_fn_name(decl)
    param_array_elem_types := b.fn_param_array_elem_types_from_decl(decl)
    if fn_name in b.fn_index {
        if param_array_elem_types.len > 0 {
            b.fn_param_array_elem_types[fn_name] = param_array_elem_types
        }
        return
    }
    if !decl.is_method && decl.language != .c && !is_generated_helper_fn_name(decl.name) {
        b.module_fn_names[module_fn_key(b.cur_module, decl.name)] = fn_name
    }

    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
    b.mod.func_set_prototype(idx, true)
    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)
    }
    if param_array_elem_types.len > 0 {
        b.fn_param_array_elem_types[fn_name] = param_array_elem_types
    }
}

// register_fn_sig_from_flat (s243) is the cursor mirror of register_fn_sig.
// FnDecl flat: edge0=receiver (.aux_parameter: name in name_id, is_mut flag,
// typ at edge0), edge1=typ (.typ_fn: edge0=generics list, edge1=params list,
// edge2=return_type); language in aux; is_method/is_static in flags.
fn (mut b Builder) register_fn_sig_from_flat(c ast.Cursor) {
    fn_name := b.mangle_fn_name_from_flat(c)
    param_array_elem_types := b.fn_param_array_elem_types_from_decl_from_flat(c)
    if fn_name in b.fn_index {
        if param_array_elem_types.len > 0 {
            b.fn_param_array_elem_types[fn_name] = param_array_elem_types
        }
        return
    }

    fntyp_c := c.edge(1)
    ret_type := b.ast_type_to_ssa_from_flat(fntyp_c.edge(2))
    language := unsafe { ast.Language(int(c.aux())) }
    if !c.flag(ast.flag_is_method) && language != .c && !is_generated_helper_fn_name(c.name()) {
        b.module_fn_names[module_fn_key(b.cur_module, c.name())] = fn_name
    }
    idx := b.mod.new_function(fn_name, ret_type, []TypeID{})
    b.fn_index[fn_name] = idx
    b.mod.func_set_prototype(idx, true)
    if language == .c {
        b.mod.func_set_c_extern(idx, true)
    }
    // For methods, add receiver as the first parameter (skip static methods).
    if c.flag(ast.flag_is_method) && !c.flag(ast.flag_is_static) {
        recv_c := c.edge(0)
        recv_type := b.ast_type_to_ssa_from_flat(recv_c.edge(0))
        actual_type := if recv_c.flag(ast.flag_is_mut) {
            b.mod.type_store.get_ptr(recv_type)
        } else {
            recv_type
        }
        recv_name := recv_c.name()
        receiver_name := if recv_name != '' { recv_name } else { 'self' }
        param_val := b.mod.add_value_node(.argument, actual_type, receiver_name, 0)
        b.mod.func_add_param(idx, param_val)
    }
    params := fntyp_c.list_at(1)
    for pi in 0 .. params.len() {
        param_c := params.at(pi)
        param_type := b.ast_type_to_ssa_from_flat(param_c.edge(0))
        actual_type := if param_c.flag(ast.flag_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_c.name(), 0)
        b.mod.func_add_param(idx, param_val)
    }
    if param_array_elem_types.len > 0 {
        b.fn_param_array_elem_types[fn_name] = param_array_elem_types
    }
}

fn (mut b Builder) fn_param_array_elem_types_from_decl(decl ast.FnDecl) []TypeID {
    mut param_array_elem_types := []TypeID{}
    if decl.is_method && !decl.is_static {
        param_array_elem_types << b.array_elem_type_from_ast_type(decl.receiver.typ)
    }
    for param in decl.typ.params {
        param_array_elem_types << b.array_elem_type_from_ast_type(param.typ)
    }
    return param_array_elem_types
}

// fn_param_array_elem_types_from_decl_from_flat (s243) is the cursor mirror.
// receiver typ = edge(0).edge(0); params list = fntyp(edge1).list_at(1); each
// param's typ = edge(0). Reuses array_elem_type_from_ast_type_from_flat (s233).
fn (mut b Builder) fn_param_array_elem_types_from_decl_from_flat(c ast.Cursor) []TypeID {
    mut param_array_elem_types := []TypeID{}
    if c.flag(ast.flag_is_method) && !c.flag(ast.flag_is_static) {
        param_array_elem_types << b.array_elem_type_from_ast_type_from_flat(c.edge(0).edge(0))
    }
    params := c.edge(1).list_at(1)
    for pi in 0 .. params.len() {
        param_array_elem_types << b.array_elem_type_from_ast_type_from_flat(params.at(pi).edge(0))
    }
    return param_array_elem_types
}

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}'
    }
    if is_generated_helper_fn_name(decl.name) {
        return 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
}

// mangle_fn_name_from_flat (s243) is the cursor mirror of mangle_fn_name. FnDecl
// flat: name in name_id, language in aux, is_method flag; receiver = edge(0)
// (.aux_parameter), its type = edge(0).edge(0).
fn (mut b Builder) mangle_fn_name_from_flat(c ast.Cursor) string {
    name_str := c.name()
    if c.flag(ast.flag_is_method) {
        receiver_name := b.receiver_type_name_from_flat(c.edge(0).edge(0))
        return '${receiver_name}__${name_str}'
    }
    if is_generated_helper_fn_name(name_str) {
        return name_str
    }
    language := unsafe { ast.Language(int(c.aux())) }
    // C functions use their bare name (no module prefix)
    if language == .c {
        return name_str
    }
    if name_str == 'main' {
        return 'main'
    }
    if b.cur_module != '' && b.cur_module != 'main' {
        if name_str.starts_with('${b.cur_module}__') {
            return name_str
        }
        return '${b.cur_module}__${name_str}'
    }
    return name_str
}

fn (mut b Builder) checked_fn_scope_key(decl ast.FnDecl) string {
    scope_fn_name := if decl.is_method {
        mut recv_name := b.receiver_type_name(decl.receiver.typ)
        if b.cur_module != '' {
            prefix := '${b.cur_module}__'
            if recv_name.starts_with(prefix) {
                recv_name = recv_name[prefix.len..]
            }
        }
        '${recv_name}__${decl.name}'
    } else {
        decl.name
    }
    if b.cur_module == '' {
        return scope_fn_name
    }
    return '${b.cur_module}__${scope_fn_name}'
}

// checked_fn_scope_key_from_flat (s244) is the cursor mirror of checked_fn_scope_key.
fn (mut b Builder) checked_fn_scope_key_from_flat(c ast.Cursor) string {
    name_str := c.name()
    scope_fn_name := if c.flag(ast.flag_is_method) {
        mut recv_name := b.receiver_type_name_from_flat(c.edge(0).edge(0))
        if b.cur_module != '' {
            prefix := '${b.cur_module}__'
            if recv_name.starts_with(prefix) {
                recv_name = recv_name[prefix.len..]
            }
        }
        '${recv_name}__${name_str}'
    } else {
        name_str
    }
    if b.cur_module == '' {
        return scope_fn_name
    }
    return '${b.cur_module}__${scope_fn_name}'
}

fn is_generated_helper_fn_name(name string) bool {
    return name.starts_with('Array_') || name.starts_with('Map_') || name.starts_with('__sort_cmp_')
        || name.starts_with('__go_wrap_') || name.starts_with('__go_entry_')
}

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'
        }
    }
}

// receiver_type_name_from_flat (s243) is the cursor mirror of receiver_type_name.
// Ident/Prefix/Modifier/Selector are expr kinds; PointerType/ArrayType receivers
// are `.typ_pointer`/`.typ_array` nodes (base/elem at edge(0)).
fn (mut b Builder) receiver_type_name_from_flat(typ_c ast.Cursor) string {
    match typ_c.kind() {
        .expr_ident {
            if b.cur_module != '' && b.cur_module != 'main' {
                return '${b.cur_module}__${typ_c.name()}'
            }
            return typ_c.name()
        }
        .expr_prefix {
            return b.receiver_type_name_from_flat(typ_c.edge(0))
        }
        .expr_modifier {
            return b.receiver_type_name_from_flat(typ_c.edge(0))
        }
        .expr_selector {
            lhs_c := typ_c.edge(0)
            lhs_name := if lhs_c.kind() == .expr_ident { lhs_c.name() } else { '' }
            rhs_name := typ_c.edge(1).name()
            return '${lhs_name}__${rhs_name}'
        }
        .typ_pointer {
            return b.receiver_type_name_from_flat(typ_c.edge(0))
        }
        .typ_array {
            elem_c := typ_c.edge(0)
            elem_name := if elem_c.kind() == .expr_ident {
                elem_c.name()
            } else {
                b.receiver_type_name_from_flat(elem_c)
            }
            prefix := if b.cur_module != '' && b.cur_module != 'main' {
                '${b.cur_module}__'
            } else {
                ''
            }
            return '${prefix}Array_${elem_name}'
        }
        else {
            return 'unknown'
        }
    }
}

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

pub fn (mut b Builder) build_fn_bodies(file ast.File) {
    b.selective_import_fn_names = selective_import_fn_names_from_imports(file.imports)
    b.selective_import_fn_candidates = selective_import_fn_candidates_from_imports(file.imports)
    b.module_import_aliases = module_import_aliases_from_imports(file.imports)
    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)
        }
    }
}

// build_fn_bodies_from_flat is the flat-cursor counterpart of `build_fn_bodies`.
// Walks one file's top-level stmts via FileCursor; only `.stmt_fn_decl` nodes
// are touched. Filtering and body building read the FnDecl cursor directly, and
// body stmts are walked via cursors.
pub fn (mut b Builder) build_fn_bodies_from_flat(file_cursor ast.FileCursor) {
    file_name := file_cursor.name()
    imports := file_cursor.imports().import_stmts()
    b.selective_import_fn_names = selective_import_fn_names_from_imports(imports)
    b.selective_import_fn_candidates = selective_import_fn_candidates_from_imports(imports)
    b.module_import_aliases = module_import_aliases_from_imports(imports)
    stmts := file_cursor.stmts()
    for si in 0 .. stmts.len() {
        c := stmts.at(si)
        if c.kind() != .stmt_fn_decl {
            continue
        }
        body := c.list_at(3)
        language := unsafe { ast.Language(int(c.aux())) }
        if language == .c && body.len() == 0 {
            continue
        }
        if c.edge(1).list_at(0).len() > 0 {
            continue
        }
        if b.hot_fn.len > 0 {
            mangled := b.mangle_fn_name_from_flat(c)
            if mangled != b.hot_fn {
                continue
            }
        }
        if !b.should_build_fn_from_flat(file_name, c) {
            continue
        }
        b.build_fn_from_flat(c)
    }
}

// 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.should_skip_module_file(file_name) {
        return false
    }
    if b.used_fn_keys.len == 0 {
        return true // No markused data — build everything
    }
    if decl.name == 'main' {
        return true
    }
    // Always build init_consts, init, deinit unless a minimal native runtime path
    // relies on markused to keep only roots that are actually reached.
    if decl.name.starts_with('__v_init_consts_') || decl.name == 'init' || decl.name == 'deinit' {
        if b.minimal_runtime_roots {
            key := markused.decl_key(b.cur_module, decl, b.env)
            return key in b.used_fn_keys
        }
        return true
    }
    // Always build functions from core modules that the runtime needs
    if !b.minimal_runtime_roots
        && 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 !b.minimal_runtime_roots && (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
}

fn (mut b Builder) should_build_fn_from_flat(file_name string, c ast.Cursor) bool {
    if b.should_skip_module_file(file_name) {
        return false
    }
    if b.used_fn_keys.len == 0 {
        return true
    }
    name := c.name()
    if name == 'main' {
        return true
    }
    if name.starts_with('__v_init_consts_') || name == 'init' || name == 'deinit' {
        if b.minimal_runtime_roots {
            key := markused.decl_key_from_cursor(b.cur_module, c, b.env)
            return key in b.used_fn_keys
        }
        return true
    }
    if !b.minimal_runtime_roots
        && b.cur_module in ['builtin', 'strings', 'strconv', 'bits', 'sha256', 'binary'] {
        return true
    }
    if file_name.ends_with('.vh') {
        return true
    }
    if c.flag(ast.flag_is_method) {
        mangled := b.mangle_fn_name_from_flat(c)
        if !b.minimal_runtime_roots && (mangled.contains('__Array_') || mangled.contains('__Map_')) {
            return true
        }
    }
    key := markused.decl_key_from_cursor(b.cur_module, c, b.env)
    return key in b.used_fn_keys
}

fn (b &Builder) should_skip_module_file(file_name string) bool {
    if b.skip_modules.len == 0 || b.cur_module !in b.skip_modules {
        return false
    }
    if b.skip_module_file_fragments.len == 0 {
        return true
    }
    fragment := b.skip_module_file_fragments[b.cur_module] or { return false }
    normalized := file_name.replace('\\', '/')
    if normalized.contains(fragment) {
        return true
    }
    if fragment.len > 0 && fragment[0] == `/` {
        return normalized.starts_with(fragment[1..])
    }
    return false
}

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
    b.cur_fn_scope_key = b.checked_fn_scope_key(decl)

    // Reset local variables
    b.vars = map[string]ValueID{}
    b.mut_ptr_params = map[string]bool{}
    b.local_smartcasts = map[string]TypeID{}
    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
        if param.is_mut && !is_already_ptr {
            b.mut_ptr_params[param.name] = true
        }

        // 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{})
        }
    }
}

// build_fn_from_flat is the flat-cursor counterpart of `build_fn`. Takes a
// `.stmt_fn_decl` cursor directly: signature fields come from cursor edges, and
// body stmts are walked via `c.list_at(3)` + `build_stmts_from_flat`. No
// `[]ast.Stmt` rehydration of the body remains.
pub fn (mut b Builder) build_fn_from_flat(c ast.Cursor) {
    // s244: read the FnDecl signature straight from the cursor — no decode.
    // FnDecl flat: name in name_id, language in aux, is_method/is_static flags;
    // edge0=receiver (.aux_parameter), edge1=typ (.typ_fn), edge3=body stmts.
    is_method := c.flag(ast.flag_is_method)
    fn_name := b.mangle_fn_name_from_flat(c)
    // Skip C-language extern functions without bodies
    if unsafe { ast.Language(int(c.aux())) } == .c {
        return
    }
    func_idx := b.fn_index[fn_name] or { return }
    body := c.list_at(3)
    body_len := body.len()
    // Skip if already built (can happen with .c.v and .v files).
    // Exception: user-defined methods always override auto-generated non-method functions.
    if b.mod.funcs[func_idx].blocks.len > 0 {
        if is_method && body_len > 0 {
            b.mod.func_clear_blocks(func_idx)
        } else {
            return
        }
    }

    // Skip functions without a body (e.g., extern declarations).
    if body_len == 0 {
        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 {
                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
    b.cur_fn_scope_key = b.checked_fn_scope_key_from_flat(c)

    // Reset per-fn state
    b.vars = map[string]ValueID{}
    b.mut_ptr_params = map[string]bool{}
    b.local_smartcasts = map[string]TypeID{}
    b.label_blocks = map[string]BlockID{}
    b.array_elem_types = map[string]TypeID{}

    b.mod.func_set_params(func_idx, []ValueID{})

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

    // Add receiver param (skip for static methods). receiver = edge0 (.aux_parameter:
    // name in name_id, is_mut flag, typ at edge0).
    if is_method && !c.flag(ast.flag_is_static) {
        recv_c := c.edge(0)
        recv_name := recv_c.name()
        receiver_name := if recv_name != '' { recv_name } else { 'self' }
        recv_type := b.ast_type_to_ssa_from_flat(recv_c.edge(0))
        actual_type := if recv_c.flag(ast.flag_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 := 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
    }

    // params = typ(.typ_fn = edge1).list_at(1); each is an .aux_parameter.
    params := c.edge(1).list_at(1)
    for pi in 0 .. params.len() {
        param_c := params.at(pi)
        param_name := param_c.name()
        typ_c := param_c.edge(0)
        param_type := b.ast_type_to_ssa_from_flat(typ_c)
        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_c.flag(ast.flag_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 := 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
        if param_c.flag(ast.flag_is_mut) && !is_already_ptr {
            b.mut_ptr_params[param_name] = true
        }

        if typ_c.kind() == .expr_ident {
            param_type_name := typ_c.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 via flat cursors — no []ast.Stmt rehydration
    b.build_stmts_from_flat(body)

    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 {
    if block < 0 || block >= b.mod.blocks.len {
        return true
    }
    instrs := b.mod.blocks[block].instrs
    if instrs.len == 0 {
        return false
    }
    last := instrs[instrs.len - 1]
    if !b.valid_value_id(last) {
        return false
    }
    last_val := b.mod.values[last]
    if last_val.kind != .instruction || last_val.index < 0 || last_val.index >= b.mod.instrs.len {
        return false
    }
    last_instr := b.mod.instrs[last_val.index]
    return last_instr.op in [.ret, .br, .jmp, .unreachable]
}

// --- Statement building ---

fn builder_sumtype_payload_word_is_valid(tag_word u64, data_word u64) bool {
    if data_word == 0 {
        return false
    }
    // Native v2 backends use `(tag, data_ptr)` for sumtypes. If the first word
    // looks like a small tag, the payload must be a real pointer, not a leaked
    // enum/default value like `3`.
    if tag_word < 256 {
        upper := data_word >> 32
        lower := data_word & u64(0xffffffff)
        if upper < 1024 && lower < 4096 {
            return false
        }
        return data_word >= 4096 && data_word < 281474976710656
    }
    return true
}

fn builder_stmt_ok(stmt ast.Stmt) bool {
    tag_word := unsafe { (&u64(&stmt))[0] }
    data_word := unsafe { (&u64(&stmt))[1] }
    return builder_sumtype_payload_word_is_valid(tag_word, data_word)
}

fn builder_expr_ok(expr ast.Expr) bool {
    tag_word := unsafe { (&u64(&expr))[0] }
    data_word := unsafe { (&u64(&expr))[1] }
    return builder_sumtype_payload_word_is_valid(tag_word, data_word)
}

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

// build_stmts_from_flat is the cursor-list counterpart of `build_stmts`.
// First step of the s175+ port arc: today every cursor decodes back to a
// legacy `ast.Stmt` and dispatches through `build_stmt`. Future sessions
// port individual statement classes (ReturnStmt, AssignStmt, IfStmt, ForStmt,
// etc.) so each kind drops its `decode_stmt` call in favour of direct
// cursor + sub-cursor walking inside the SSA builder.
fn (mut b Builder) build_stmts_from_flat(stmts ast.CursorList) {
    for si in 0 .. stmts.len() {
        b.build_stmt_from_flat(stmts.at(si))
    }
}

// build_stmt_from_flat is the cursor counterpart of `build_stmt`. As of s234
// every statement kind is dispatched explicitly: the value-producing/structural
// kinds go to their `build_<kind>_from_flat` helpers; the kinds that `build_stmt`
// treats as no-ops (decls / imports / directives / defer / comptime / asm /
// attributes / empty — all lowered or registered in earlier phases) are explicit
// no-op arms; ForInStmt panics exactly as `build_stmt` does (the transformer must
// have lowered it). No `decode_stmt` remains — build_stmt_from_flat is fully
// cursor-native. The `else` is an unreachable defensive no-op (only stmt cursors
// are ever passed here, and all stmt kinds are enumerated).
fn (mut b Builder) build_stmt_from_flat(c ast.Cursor) {
    match c.kind() {
        .stmt_return {
            b.build_return_from_flat(c)
        }
        .stmt_flow_control {
            b.build_flow_control_from_flat(c)
        }
        .stmt_label {
            b.build_label_from_flat(c)
        }
        .stmt_block {
            b.build_block_from_flat(c)
        }
        .stmt_module {
            b.build_module_from_flat(c)
        }
        .stmt_assert {
            b.build_assert_from_flat(c)
        }
        .stmt_expr {
            b.build_expr_stmt_from_flat(c)
        }
        .stmt_for {
            b.build_for_from_flat(c)
        }
        .stmt_assign {
            b.build_assign_from_flat(c)
        }
        // No-op kinds: `build_stmt` has empty bodies for these (handled by the
        // transformer / earlier registration passes), so decoding them only to
        // no-op is wasteful — match and ignore them directly.
        .stmt_import, .stmt_const_decl, .stmt_struct_decl, .stmt_enum_decl, .stmt_type_decl,
        .stmt_interface_decl, .stmt_global_decl, .stmt_fn_decl, .stmt_directive, .stmt_comptime,
        .stmt_defer, .stmt_attributes, .stmt_empty, .stmt_asm {}
        .stmt_for_in {
            panic('SSA builder: ForInStmt should have been lowered by transformer')
        }
        else {}
    }
}

// build_return_from_flat is the cursor counterpart of `build_return`. The
// flat schema stores ReturnStmt's `exprs` as direct child edges of the
// `.stmt_return` node (see `flat.v`'s ReturnStmt arm in `add_stmt`), so the
// expr count is `c.edge_count()` and each `c.edge(i)` is an expr cursor.
// Expressions are lowered through `build_expr_from_flat` so ReturnStmt no
// longer rehydrates rhs expressions before dispatch.
fn (mut b Builder) build_return_from_flat(c ast.Cursor) {
    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)
    nexprs := c.edge_count()
    if nexprs == 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 nexprs == 1 {
        ret_expr_c := c.edge(0)
        mut val := b.build_expr_from_flat(ret_expr_c)
        if (is_option_ret || is_result_ret) && b.mod.values[val].typ != fn_ret_type {
            val = b.coerce_wrapper_value_from_flat(ret_expr_c, 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 {
            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 {
        mut elem_types := []TypeID{cap: nexprs}
        mut vals := []ValueID{cap: nexprs}
        for i in 0 .. nexprs {
            ec := c.edge(i)
            v := b.build_expr_from_flat(ec)
            vals << v
            elem_types << b.mod.values[v].typ
        }
        tuple_type := b.mod.type_store.get_tuple(elem_types)
        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 (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 (b &Builder) is_none_expr_from_flat(c ast.Cursor) bool {
    match c.kind() {
        .expr_ident {
            return c.name() == 'none'
        }
        .expr_keyword {
            tok := unsafe { token.Token(int(c.aux())) }
            return tok == .key_none
        }
        .typ_none {
            return true
        }
        else {
            return false
        }
    }
}

fn (b &Builder) is_error_expr_from_flat(c ast.Cursor) bool {
    error_fn_names := ['error', 'error_posix', 'error_with_code', 'error_win32']
    match c.kind() {
        .expr_ident {
            return c.name() == 'err'
        }
        .expr_call, .expr_call_or_cast {
            lhs := c.edge(0)
            return lhs.kind() == .expr_ident && lhs.name() in error_fn_names
        }
        else {
            return false
        }
    }
}

fn (mut b Builder) coerce_wrapper_value_from_flat(c ast.Cursor, val ValueID, wrapper_type TypeID) ValueID {
    if !b.is_wrapper_type(wrapper_type) {
        return val
    }
    if b.is_none_expr_from_flat(c) {
        return b.build_wrapper_value(wrapper_type, false, 0, false)
    }
    if b.is_error_expr_from_flat(c) {
        return b.build_wrapper_value(wrapper_type, false, val, false)
    }
    if b.is_result_wrapper_type(wrapper_type) && b.cursor_is_ierror_like(c)
        && !b.wrapper_value_is_valid_payload(val, wrapper_type) {
        err_payload := b.ierror_tag_for_cursor(c) or { val }
        return b.build_wrapper_value(wrapper_type, false, err_payload, false)
    }
    if val > 0 && val < b.mod.values.len && b.mod.values[val].typ == wrapper_type {
        if payload := b.wrapper_payload_bitcast_source(val, wrapper_type) {
            return b.build_wrapper_value(wrapper_type, true, payload, true)
        }
        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) build_stmt(stmt ast.Stmt) {
    if !builder_stmt_ok(stmt) {
        return
    }
    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) assign_target_for_ident(name string) ValueID {
    if p := b.vars[name] {
        if name in b.mut_ptr_params {
            ptr_typ := b.mod.values[p].typ
            if b.valid_type_id(ptr_typ) {
                elem_typ := b.mod.type_store.types[ptr_typ].elem_type
                if elem_typ > 0 {
                    return b.mod.add_instr(.load, b.cur_block, elem_typ, [p])
                }
            }
        }
        return p
    }
    if glob_id := b.find_global_ident(name) {
        return glob_id
    }
    return 0
}

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
                    b.track_array_elem_type_for_local_value(ident.name, elem_val)
                } else if ident.name == '_' {
                    continue
                } else {
                    ptr := b.assign_target_for_ident(ident.name)
                    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
                }
                ptr := b.assign_target_for_ident(ident.name)
                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
                b.track_array_elem_type_for_local_expr(ident.name, lhs, rhs, rhs_val)
            } 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 {
                    module_const_name := ssa_module_storage_name(b.cur_module, ident.name)
                    if ident.name in b.const_array_globals
                        || module_const_name in b.const_array_globals
                        || 'builtin__${ident.name}' in b.const_array_globals {
                        continue
                    }
                }
                ptr := b.assign_target_for_ident(ident.name)
                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])
                }
            }
        }