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