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

import v2.ast
import v2.pref as vpref
import v2.token
import v2.types
import strings
import os

fn is_empty_expr(e ast.Expr) bool {
    return e is ast.EmptyExpr
}

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

fn is_none_like_expr(expr ast.Expr) bool {
    if is_none_expr(expr) {
        return true
    }
    if expr is ast.Type && expr is ast.NoneType {
        return true
    }
    return false
}

fn is_numeric_literal(expr ast.Expr) bool {
    if expr is ast.BasicLiteral {
        return expr.kind == .number
    }
    if expr is ast.CastExpr {
        return is_numeric_literal(expr.expr)
    }
    if expr is ast.CallOrCastExpr {
        return is_numeric_literal(expr.expr)
    }
    if expr is ast.ParenExpr {
        return is_numeric_literal(expr.expr)
    }
    return false
}

fn is_nil_like_expr(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            return expr.name == 'nil'
        }
        ast.BasicLiteral {
            return expr.kind == .number && expr.value == '0'
        }
        ast.ParenExpr {
            return is_nil_like_expr(expr.expr)
        }
        ast.ModifierExpr {
            return is_nil_like_expr(expr.expr)
        }
        ast.CastExpr {
            return is_nil_like_expr(expr.expr)
        }
        ast.CallOrCastExpr {
            // CallOrCastExpr can be a type cast wrapping 0
            return is_nil_like_expr(expr.expr)
        }
        ast.Type {
            return expr is ast.NilType
        }
        ast.UnsafeExpr {
            if expr.stmts.len == 0 {
                return false
            }
            last := expr.stmts[expr.stmts.len - 1]
            if last is ast.ExprStmt {
                return is_nil_like_expr(last.expr)
            }
            return false
        }
        else {
            return false
        }
    }
}

fn (g &Gen) interface_method_by_name(iface_name string, method_name string) ?InterfaceMethodInfo {
    mut candidates := []string{}
    if iface_name != '' {
        candidates << iface_name
        short_name := iface_name.all_after_last('__')
        if short_name != iface_name {
            candidates << short_name
        }
        if g.cur_module != '' && g.cur_module != 'main' {
            candidates << '${g.cur_module}__${short_name}'
        }
        candidates << 'builtin__${short_name}'
    }
    for candidate in candidates {
        if methods := g.interface_methods[candidate] {
            for method in methods {
                if method.name == method_name {
                    return method
                }
            }
        }
    }
    return none
}

// find_method_on_any_interface searches all registered interfaces for a method by name.
// Used for interface-to-interface narrowing where the method is on the target interface.
fn (g &Gen) find_method_on_any_interface(method_name string) ?InterfaceMethodInfo {
    for _, methods in g.interface_methods {
        for method in methods {
            if method.name == method_name {
                return method
            }
        }
    }
    return none
}

fn (g &Gen) is_interface_type(type_name string) bool {
    // Array/Map/option/result types are never interfaces, even if their element type is.
    if type_name.starts_with('Array_') || type_name.starts_with('Map_')
        || type_name.starts_with('_option_') || type_name.starts_with('_result_') {
        return false
    }
    mut interface_candidates := []string{}
    if type_name != '' {
        interface_candidates << type_name
        short_name := type_name.all_after_last('__')
        if short_name != type_name {
            interface_candidates << short_name
        }
        if g.cur_module != '' && g.cur_module != 'main' {
            interface_candidates << '${g.cur_module}__${short_name}'
        }
        interface_candidates << 'builtin__${short_name}'
    }
    if g.env == unsafe { nil } {
        for candidate in interface_candidates {
            if candidate in g.interface_methods {
                return true
            }
        }
        return false
    }
    // Try the type name as-is in the current module scope
    if mut scope := g.env_scope(g.cur_module) {
        if obj := scope.lookup_parent(type_name, 0) {
            if obj is types.Type && obj is types.Interface {
                return true
            }
        }
        // Also try stripping module prefix: rand__PRNG -> PRNG
        if type_name.contains('__') {
            short_name := type_name.all_after_last('__')
            if obj := scope.lookup_parent(short_name, 0) {
                if obj is types.Type && obj is types.Interface {
                    return true
                }
            }
        }
    }
    // Also check interface_methods registry.
    for candidate in interface_candidates {
        if candidate in g.interface_methods {
            return true
        }
    }
    return false
}

// is_interface_vtable_method checks if a method is a vtable (abstract) method
// of an interface, as opposed to a concrete method defined on the interface type.
fn (g &Gen) is_interface_vtable_method(iface_name string, method_name string) bool {
    // Every interface value carries a synthetic type_name(void*) callback in its
    // runtime header, even when not declared in the interface method set.
    if method_name == 'type_name' {
        return true
    }
    return g.interface_method_by_name(iface_name, method_name) != none
}

fn (mut g Gen) selector_method_value_name(node ast.SelectorExpr) ?string {
    if raw := g.get_raw_type(ast.Expr(node)) {
        mut is_fn_value := false
        match raw {
            types.FnType {
                is_fn_value = true
            }
            types.Alias {
                alias_raw := raw
                if alias_raw.base_type is types.FnType {
                    is_fn_value = true
                }
            }
            else {}
        }

        _ = is_fn_value
    }
    recv_type := g.get_expr_type(node.lhs)
    if recv_type == '' {
        return none
    }
    mut base := recv_type
    if base.ends_with('*') {
        base = base[..base.len - 1]
    }
    mut candidates := []string{}
    candidates << '${base}__${node.rhs.name}'
    if base.contains('__') {
        candidates << '${base.all_after_last('__')}__${node.rhs.name}'
    }
    for candidate in candidates {
        if candidate in g.fn_return_types || candidate in g.fn_param_is_ptr {
            return candidate
        }
    }
    return none
}

fn (mut g Gen) gen_bound_method_value_expr(node ast.SelectorExpr, expected_c_type string) bool {
    method_name := g.selector_method_value_name(node) or { return false }
    method_params := g.fn_param_types[method_name] or { return false }
    if method_params.len == 0 {
        return false
    }
    receiver_type := method_params[0]
    if receiver_type == '' {
        return false
    }
    lhs_type := g.get_expr_type(node.lhs)
    if lhs_type == '' {
        return false
    }
    lhs_base := lhs_type.trim_right('*')
    recv_base := receiver_type.trim_right('*')
    // Only bind true method values where LHS matches receiver.
    if lhs_base != recv_base && short_type_name(lhs_base) != short_type_name(recv_base) {
        return false
    }
    g.mark_called_fn_name(method_name)
    callback_param_types := method_params[1..]
    mut ret_type := g.fn_return_types[method_name] or { 'void' }
    if ret_type == '' {
        ret_type = 'void'
    }
    bind_id := g.tmp_counter
    g.tmp_counter++
    recv_store := '_bound_recv_${bind_id}'
    wrapper_name := '_bound_method_${bind_id}'
    mut def := strings.new_builder(256)
    def.writeln('static ${receiver_type} ${recv_store};')
    def.write_string('static ${ret_type} ${wrapper_name}(')
    if callback_param_types.len == 0 {
        def.write_string('void')
    } else {
        for i, ptyp in callback_param_types {
            if i > 0 {
                def.write_string(', ')
            }
            def.write_string('${ptyp} _arg${i}')
        }
    }
    def.writeln(') {')
    def.write_string('\t')
    if ret_type != 'void' {
        def.write_string('return ')
    }
    def.write_string('${method_name}(${recv_store}')
    for i in 0 .. callback_param_types.len {
        def.write_string(', _arg${i}')
    }
    def.writeln(');')
    def.writeln('}')
    def.writeln('')
    g.anon_fn_defs << def.str()
    g.sb.write_string('(({ ${recv_store} = ')
    if receiver_type.ends_with('*') {
        if lhs_type.ends_with('*') {
            g.expr(node.lhs)
        } else {
            g.sb.write_u8(`&`)
            g.expr(node.lhs)
        }
    } else {
        if lhs_type.ends_with('*') {
            g.sb.write_string('(*')
            g.expr(node.lhs)
            g.sb.write_string(')')
        } else {
            g.expr(node.lhs)
        }
    }
    g.sb.write_string('; ((${expected_c_type})${wrapper_name}); }))')
    return true
}

fn (mut g Gen) gen_sum_variant_tag_path_check(expr ast.Expr, path []SumVariantTagStep, positive bool) {
    if path.len == 0 {
        g.sb.write_string(if positive { 'false' } else { 'true' })
        return
    }
    if !positive {
        g.sb.write_string('!')
    }
    g.sb.write_string('(')
    mut access := g.expr_to_string(expr)
    mut sep := if g.expr_is_pointer(expr) { '->' } else { '.' }
    for i, step in path {
        if i > 0 {
            g.sb.write_string(' && ')
        }
        g.sb.write_string('(${access}${sep}_tag == ${step.tag})')
        access = '(((${step.payload_type}*)(${access}${sep}_data._${step.variant_field})))'
        sep = '->'
    }
    g.sb.write_string(')')
}

fn (mut g Gen) gen_nested_sum_as_cast(inner_str string, expr ast.Expr, target_type string, path []SumVariantTagStep) bool {
    if path.len <= 1 {
        return false
    }
    mut access := '(${inner_str})'
    mut sep := if g.expr_is_pointer(expr) { '->' } else { '.' }
    for i, step in path {
        payload_ptr := '(${access}${sep}_data._${step.variant_field})'
        if i == path.len - 1 {
            if !g.is_scalar_sum_payload_type(target_type) && target_type != 'string' {
                g.sb.write_string('(${payload_ptr} ? (*((${target_type}*)${payload_ptr})) : (${target_type}){0})')
            } else {
                g.sb.write_string('(*((${target_type}*)${payload_ptr}))')
            }
            return true
        }
        access = '(*(${step.payload_type}*)${payload_ptr})'
        sep = '.'
    }
    return false
}

fn (mut g Gen) gen_nested_sum_as_cast_for_selector_source(expr ast.Expr, target_type_name string) bool {
    unwrapped := g.unwrap_parens(expr)
    if unwrapped !is ast.SelectorExpr {
        return false
    }
    sel := unwrapped as ast.SelectorExpr
    mut source_types := []string{}
    for candidate in [
        g.selector_storage_field_type(sel).trim_right('*'),
        g.selector_declared_field_type(sel).trim_right('*'),
        g.selector_field_type(sel).trim_right('*'),
        g.get_expr_type(sel).trim_right('*'),
    ] {
        if candidate != '' && candidate !in source_types
            && g.get_sum_type_variants_for(candidate).len > 0 {
            source_types << candidate
        }
    }
    for source_type in source_types {
        if g.sum_type_has_direct_variant(source_type, target_type_name) {
            return false
        }
        path := g.sum_variant_tag_path(source_type, target_type_name, []string{}) or { continue }
        if path.len <= 1 {
            continue
        }
        nested_target_type := path[path.len - 1].payload_type
        if g.gen_nested_sum_as_cast(g.raw_selector_expr_code(sel), sel, nested_target_type, path) {
            return true
        }
    }
    return false
}

fn (mut g Gen) nested_sum_path_from_narrowed_source(source_sum_type string, target_type string) ?[]SumVariantTagStep {
    if source_sum_type == '' || target_type == '' {
        return none
    }
    for sum_name, _ in g.sum_type_variants {
        path := g.sum_variant_tag_path(sum_name, target_type, []string{}) or { continue }
        if path.len <= 1 {
            continue
        }
        first := path[0]
        if first.payload_type == source_sum_type || first.variant_field == source_sum_type
            || first.payload_type.all_after_last('__') == source_sum_type.all_after_last('__') {
            return path
        }
    }
    return none
}

fn vector_field_index(field string) int {
    return match field {
        'x' { 0 }
        'y' { 1 }
        'z' { 2 }
        'w' { 3 }
        else { -1 }
    }
}

fn vector_elem_type_for_name(type_name string) string {
    base := type_name.trim_right('*')
    if base.ends_with('SimdFloat4') || base.ends_with('SimdFloat2') {
        return 'f32'
    }
    if base.ends_with('SimdInt4') || base.ends_with('SimdI32_2') {
        return 'i32'
    }
    if base.ends_with('SimdU32_4') || base.ends_with('SimdUint2') {
        return 'u32'
    }
    return ''
}

fn (mut g Gen) interface_target_cast_inner_expr(type_name string, value_expr ast.Expr) ?ast.Expr {
    if value_expr is ast.CastExpr
        && g.expr_type_to_c(value_expr.typ) in [type_name, 'builtin__${type_name}'] {
        return value_expr.expr
    }
    if value_expr is ast.CallOrCastExpr && g.call_or_cast_lhs_is_type(value_expr.lhs)
        && g.expr_type_to_c(value_expr.lhs) in [type_name, 'builtin__${type_name}'] {
        return value_expr.expr
    }
    if value_expr is ast.ParenExpr {
        return value_expr.expr
    }
    return none
}

fn (mut g Gen) raw_concrete_type_for_interface_value(type_name string, value_expr ast.Expr) string {
    if inner := g.interface_target_cast_inner_expr(type_name, value_expr) {
        return g.raw_concrete_type_for_interface_value(type_name, inner)
    }
    mut concrete_type := g.get_expr_type(value_expr)
    if value_expr is ast.PrefixExpr && value_expr.op == .amp && value_expr.expr is ast.Ident {
        inner := value_expr.expr as ast.Ident
        if local_type := g.get_local_var_c_type(inner.name) {
            local_base := local_type.trim_right('*')
            if local_type != '' && local_type != 'int' && !g.is_interface_type(local_base) {
                concrete_type = '${local_type}*'
            }
        }
    }
    if value_expr is ast.Ident {
        if local_type := g.get_local_var_c_type(value_expr.name) {
            local_base := local_type.trim_right('*')
            current_base := concrete_type.trim_right('*')
            if local_type != '' && local_type != 'int' && !g.is_interface_type(local_base)
                && (concrete_type == '' || concrete_type == 'int'
                || current_base == type_name || local_type.contains('_T_')) {
                concrete_type = local_type
            }
        }
    }
    mut raw_concrete := ''
    if raw := g.get_raw_type(value_expr) {
        raw_concrete = g.types_type_to_c(raw)
    }
    raw_base := raw_concrete.trim_right('*')
    current_base := concrete_type.trim_right('*')
    if raw_base != '' && raw_base != 'int'
        && (current_base == '' || current_base == 'int' || current_base == type_name) {
        concrete_type = raw_concrete
    }
    // For dereference expressions (*ptr), strip one pointer level from the type.
    // E.g., `*sw` where sw is `SubWindow*` → concrete type is `SubWindow`, not `SubWindow*`.
    if value_expr is ast.PrefixExpr && value_expr.op == .mul && concrete_type.ends_with('*') {
        concrete_type = concrete_type[..concrete_type.len - 1]
    }
    return concrete_type
}

fn (mut g Gen) ierror_concrete_base_for_expr(value_expr ast.Expr) string {
    return g.qualify_ierror_concrete_base(g.raw_concrete_type_for_interface_value('IError',
        value_expr).trim_right('*'))
}

// build_ierror_base_index indexes fn_return_types by the `base` of every `X__base__msg` function,
// storing the smallest matching `X__base` per base (the original scan sorted the keys and took the
// first). fn_return_types is final after collect_fn_signatures_to_fixed_point, so this builds once.
fn (mut g Gen) build_ierror_base_index() {
    mut idx := map[string]string{}
    for fn_name, _ in g.fn_return_types {
        if !fn_name.ends_with('__msg') {
            continue
        }
        stripped := fn_name[..fn_name.len - '__msg'.len] // X__base
        if !stripped.contains('__') {
            continue // need a real `__base` suffix, matching ends_with('__${base}__msg')
        }
        base := stripped.all_after_last('__')
        if base == '' {
            continue
        }
        if existing := idx[base] {
            if stripped < existing {
                idx[base] = stripped
            }
        } else {
            idx[base] = stripped
        }
    }
    g.ierror_base_index = idx.move()
}

fn (g &Gen) qualify_ierror_concrete_base(base string) string {
    normalized_base := g.normalize_builtin_qualified_c_type(base)
    if normalized_base != base {
        return normalized_base
    }
    if base == '' || base == 'int' || base.contains('__') {
        return base
    }
    if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
        qualified := '${g.cur_module}__${base}'
        if '${qualified}__msg' in g.fn_return_types || 'body_${qualified}' in g.emitted_types {
            return qualified
        }
    }
    // Index lookup replaces a per-call `fn_return_types.keys().sort()` + scan. The index stores,
    // per base, the smallest `X__base` (the original returned the first sorted `*__base__msg`
    // minus the `__msg` suffix).
    if qualified := g.ierror_base_index[base] {
        return qualified
    }
    if g.ierror_base_index.len == 0 {
        if qualified := g.scan_ierror_concrete_base(base) {
            return qualified
        }
    }
    body_suffix := '__${base}'
    mut body_keys := g.emitted_types.keys()
    body_keys.sort()
    for body_key in body_keys {
        if body_key.starts_with('body_') && body_key.ends_with(body_suffix) {
            return body_key['body_'.len..]
        }
    }
    mut pending_body_keys := g.pending_late_body_keys.keys()
    pending_body_keys.sort()
    for body_key in pending_body_keys {
        if body_key.starts_with('body_') && body_key.ends_with(body_suffix) {
            return body_key['body_'.len..]
        }
    }
    return base
}

fn (g &Gen) scan_ierror_concrete_base(base string) ?string {
    suffix := '__${base}__msg'
    mut fn_names := g.fn_return_types.keys()
    fn_names.sort()
    for fn_name in fn_names {
        if !fn_name.ends_with(suffix) {
            continue
        }
        return fn_name[..fn_name.len - '__msg'.len]
    }
    return none
}

fn (mut g Gen) concrete_type_for_interface_value(type_name string, value_expr ast.Expr) string {
    mut concrete_type := g.raw_concrete_type_for_interface_value(type_name, value_expr)
    if type_name in ['IError', 'builtin__IError'] {
        base := g.qualify_ierror_concrete_base(concrete_type.trim_right('*'))
        if base != '' && base != 'int' && base != concrete_type.trim_right('*') {
            if concrete_type.ends_with('*') {
                concrete_type = '${base}*'
            } else {
                concrete_type = base
            }
        }
    }
    return concrete_type
}

// gen_heap_interface_cast generates a heap-allocated interface struct for &InterfaceType(value) patterns.
// Returns true if the type is an interface and the cast was generated.
fn (mut g Gen) gen_heap_interface_cast(type_name string, value_expr ast.Expr) bool {
    if !g.is_interface_type(type_name) {
        return false
    }
    iface_malloc_call := g.c_heap_malloc_call('sizeof(${type_name})')
    if is_nil_like_expr(value_expr) || is_none_like_expr(value_expr) {
        g.sb.write_string('({ ${type_name}* _iface_t = (${type_name}*)${iface_malloc_call}; *_iface_t = ((${type_name}){0}); _iface_t; })')
        return true
    }
    mut concrete_type := g.concrete_type_for_interface_value(type_name, value_expr)
    if concrete_type == '' || concrete_type == 'int' {
        return false
    }
    base_concrete := if concrete_type.ends_with('*') {
        concrete_type[..concrete_type.len - 1]
    } else {
        concrete_type
    }
    if type_name in ['IError', 'builtin__IError'] {
        g.ierror_wrapper_bases[base_concrete] = true
        g.needed_ierror_wrapper_bases[base_concrete] = true
    }
    if type_name in ['IError', 'builtin__IError'] && base_concrete != type_name
        && g.concrete_ierror_base_for_c_type(concrete_type) != '' {
        g.sb.write_string('({ ${type_name}* _iface_t = (${type_name}*)${iface_malloc_call}; *_iface_t = ')
        g.gen_ierror_from_concrete_expr(value_expr, concrete_type)
        g.sb.write_string('; _iface_t; })')
        return true
    }
    // IError constants like `none__ = IError(&None__{})` may be emitted before
    // embedded Error metadata is available. Still use the IError wrapper shape so
    // the generated C references wrapper functions, not missing direct methods.
    if type_name in ['IError', 'builtin__IError'] && base_concrete != type_name {
        base := g.qualify_ierror_concrete_base(base_concrete)
        if base != '' && base != 'int' {
            g.sb.write_string('({ ${type_name}* _iface_t = (${type_name}*)${iface_malloc_call}; *_iface_t = ')
            g.gen_ierror_from_base_expr(base, value_expr, concrete_type)
            g.sb.write_string('; _iface_t; })')
            return true
        }
    }
    // Generate: ({ InterfaceType* _iface = malloc(sizeof(InterfaceType));
    //             *_iface = (InterfaceType){._object = (void*)value, ...}; _iface; })
    g.sb.write_string('({ ${type_name}* _iface_t = (${type_name}*)${iface_malloc_call}; *_iface_t = ((${type_name}){._object = ')
    if concrete_type.ends_with('*') {
        g.sb.write_string('(void*)(')
        g.expr(value_expr)
        g.sb.write_string(')')
    } else {
        g.sb.write_string('(void*)&(')
        g.expr(value_expr)
        g.sb.write_string(')')
    }
    type_short := if base_concrete.contains('__') {
        base_concrete.all_after_last('__')
    } else {
        base_concrete
    }
    type_id := interface_type_id_for_name(type_short)
    g.sb.write_string(', ._type_id = ${type_id}')
    if methods := g.interface_methods[type_name] {
        for method in methods {
            mut fn_name := '${base_concrete}__${method.name}'
            mut uses_embedded_method := false
            if fn_name !in g.fn_param_is_ptr && fn_name !in g.fn_return_types {
                resolved := g.resolve_embedded_method(base_concrete, method.name)
                if resolved != '' {
                    fn_name = resolved
                    uses_embedded_method = true
                }
            }
            mut target_name := fn_name
            if ptr_params := g.fn_param_is_ptr[fn_name] {
                if uses_embedded_method || (ptr_params.len > 0 && !ptr_params[0]) {
                    target_name = interface_wrapper_name(type_name, base_concrete, method.name)
                    g.needed_interface_wrappers[target_name] = true
                    if target_name !in g.interface_wrapper_specs {
                        g.interface_wrapper_specs[target_name] = InterfaceWrapperSpec{
                            fn_name:       fn_name
                            concrete_type: base_concrete
                            method:        method
                        }
                    }
                }
            }
            g.sb.write_string(', .${method.name} = (${method.cast_signature})${target_name}')
        }
    }
    g.sb.write_string('}); _iface_t; })')
    return true
}

fn (mut g Gen) gen_interface_cast(type_name string, value_expr ast.Expr) bool {
    if !g.is_interface_type(type_name) {
        return false
    }
    mut cast_value_expr := value_expr
    for {
        inner := g.interface_target_cast_inner_expr(type_name, cast_value_expr) or { break }
        cast_value_expr = inner
    }
    if is_nil_like_expr(cast_value_expr) || is_none_like_expr(cast_value_expr) {
        g.sb.write_string('((${type_name}){0})')
        return true
    }
    // Get the concrete type name
    mut concrete_type := g.concrete_type_for_interface_value(type_name, cast_value_expr)
    if concrete_type == '' || concrete_type == 'int' {
        return false
    }
    // Strip pointer suffix for method name construction
    base_concrete := if concrete_type.ends_with('*') {
        concrete_type[..concrete_type.len - 1]
    } else {
        concrete_type
    }
    if type_name in ['IError', 'builtin__IError'] {
        g.ierror_wrapper_bases[base_concrete] = true
        g.needed_ierror_wrapper_bases[base_concrete] = true
    }
    if base_concrete == type_name {
        g.expr(value_expr)
        return true
    }
    // Interface-to-interface casting (e.g., Layout -> ScrollableWidget)
    // requires runtime dispatch: check _type_id to find the concrete type,
    // then construct the target interface from it.
    if g.is_interface_type(base_concrete) {
        return g.gen_iface_to_iface_cast(base_concrete, type_name, cast_value_expr)
    }
    // Generate: (InterfaceType){._object = (void*)&expr, .method = ConcreteType__method, ...}
    // For rvalue expressions (function calls, struct init, etc.), store in a temp
    // to allow taking the address, and reuse the temp for data field pointers.
    // When concrete_type is a pointer and the value_expr is a deref (*ptr),
    // unwrap the deref: for _object we want the pointer, for data fields we use ->.
    mut effective_value := cast_value_expr
    if concrete_type.ends_with('*') && cast_value_expr is ast.PrefixExpr
        && cast_value_expr.op == .mul {
        effective_value = cast_value_expr.expr
    }
    if type_name in ['IError', 'builtin__IError'] {
        if g.gen_ierror_from_concrete_expr(effective_value, concrete_type) {
            return true
        }
        // See the heap IError cast path above: fallback to wrapper-based IError
        // construction even when embedded method metadata could not prove it.
        base := g.qualify_ierror_concrete_base(base_concrete)
        if base != '' && base != 'int' {
            if g.gen_ierror_from_base_expr(base, effective_value, concrete_type) {
                return true
            }
        }
    }
    is_rvalue := !concrete_type.ends_with('*') && !g.can_take_address(effective_value)
    // Use a temp variable when there are data fields and the expression is complex
    // (e.g., a function call returning a pointer). This avoids re-evaluating the
    // expression for each data field reference, preventing exponential code blowup.
    data_fields := g.interface_data_fields[type_name]
    needs_ptr_tmp := concrete_type.ends_with('*') && data_fields.len > 0
        && !g.is_simple_addressable(effective_value)
    mut rvalue_tmp := ''
    if is_rvalue {
        rvalue_tmp = '_iface_obj${g.tmp_counter}'
        g.tmp_counter++
        g.sb.write_string('({ ${base_concrete} ${rvalue_tmp} = ')
        g.expr(effective_value)
        g.sb.write_string('; (${type_name}){._object = (void*)&${rvalue_tmp}')
    } else if needs_ptr_tmp {
        rvalue_tmp = '_iface_ptr${g.tmp_counter}'
        g.tmp_counter++
        g.sb.write_string('({ ${base_concrete}* ${rvalue_tmp} = ')
        g.expr(effective_value)
        g.sb.write_string('; (${type_name}){._object = (void*)(${rvalue_tmp})')
    } else {
        g.sb.write_string('((${type_name}){._object = ')
        if concrete_type.ends_with('*') {
            g.sb.write_string('(void*)(')
            g.expr(effective_value)
            g.sb.write_string(')')
        } else {
            g.sb.write_string('(void*)&(')
            g.expr(effective_value)
            g.sb.write_string(')')
        }
    }
    type_short := if base_concrete.contains('__') {
        base_concrete.all_after_last('__')
    } else {
        base_concrete
    }
    type_id := interface_type_id_for_name(type_short)
    g.sb.write_string(', ._type_id = ${type_id}')
    // Generate method function pointers from stored interface info
    if methods := g.interface_methods[type_name] {
        for method in methods {
            mut fn_name := '${base_concrete}__${method.name}'
            mut uses_embedded_method := false
            // If the method doesn't exist on the concrete type directly,
            // try resolving through embedded structs (e.g. ssl__SSLConn embeds
            // openssl__SSLConn, so ssl__SSLConn__addr → openssl__SSLConn__addr).
            if fn_name !in g.fn_param_is_ptr && fn_name !in g.fn_return_types {
                resolved := g.resolve_embedded_method(base_concrete, method.name)
                if resolved != '' {
                    fn_name = resolved
                    uses_embedded_method = true
                }
            }
            mut target_name := fn_name
            if ptr_params := g.fn_param_is_ptr[fn_name] {
                if uses_embedded_method || (ptr_params.len > 0 && !ptr_params[0]) {
                    target_name = interface_wrapper_name(type_name, base_concrete, method.name)
                    g.needed_interface_wrappers[target_name] = true
                    if target_name !in g.interface_wrapper_specs {
                        g.interface_wrapper_specs[target_name] = InterfaceWrapperSpec{
                            fn_name:       fn_name
                            concrete_type: base_concrete
                            method:        method
                        }
                    }
                }
            }
            g.sb.write_string(', .${method.name} = (${method.cast_signature})${target_name}')
        }
    }
    // Generate data field pointers: .field = &(concrete->field)
    if data_fields.len > 0 {
        sep := if concrete_type.ends_with('*') { '->' } else { '.' }
        for df in data_fields {
            embedded_owner := g.embedded_owner_for(base_concrete, df.name)
            g.sb.write_string(', .${df.name} = &(')
            if rvalue_tmp != '' {
                // Use the temp variable instead of re-evaluating the expression
                g.sb.write_string(rvalue_tmp)
            } else {
                g.expr(effective_value)
            }
            if embedded_owner != '' {
                g.sb.write_string('${sep}${embedded_owner}.${df.name})')
            } else {
                g.sb.write_string('${sep}${df.name})')
            }
        }
    }
    if rvalue_tmp != '' {
        g.sb.write_string('}; })')
    } else {
        g.sb.write_string('})')
    }
    return true
}

fn c_static_v_string_expr(raw string) string {
    return c_static_v_string_expr_from_c_literal(c_string_literal_content_to_c(raw))
}

fn c_empty_v_string_expr() string {
    return c_v_string_expr_from_ptr_len('""', '0', true)
}

fn expr_to_int_str(e ast.Expr) string {
    if e is ast.BasicLiteral {
        return e.value
    }
    return '0'
}

fn (mut g Gen) known_module_runtime_symbol(module_name string, symbol_name string) ?string {
    if module_name == '' || symbol_name == '' {
        return none
    }
    if scope := g.env_scope(module_name) {
        if obj := scope.lookup(symbol_name) {
            if obj is types.Const || obj is types.Global || obj is types.Fn {
                return module_name
            }
        }
    }
    return none
}

fn (mut g Gen) module_selector_storage_c_name(module_name string, symbol_name string) string {
    c_name := if symbol_name.starts_with('${module_name}__') {
        symbol_name
    } else {
        '${module_name}__${symbol_name}'
    }
    if raw_c_name := g.c_extern_module_storage[c_name] {
        return raw_c_name
    }
    return c_name
}

// expr_to_int_str_with_env resolves fixed-array size expressions, handling
// both literal numbers and named constants (looked up via type environment).
fn (g &Gen) expr_to_int_str_with_env(e ast.Expr) string {
    if e is ast.BasicLiteral {
        return e.value
    }
    if e is ast.Ident {
        // Try to resolve the constant from the module scope.
        if g.env != unsafe { nil } {
            if scope := g.env_scope(g.cur_module) {
                if obj := scope.lookup_parent(e.name, 0) {
                    if obj is types.Const {
                        if obj.int_val != 0 {
                            return obj.int_val.str()
                        }
                    }
                }
            }
        }
    }
    return '0'
}

fn (mut g Gen) local_var_c_type_for_expr(expr ast.Expr) ?string {
    unwrapped := strip_expr_wrappers(expr)
    if unwrapped !is ast.Ident {
        return none
    }
    name := unwrapped.name()
    if name == '' {
        return none
    }
    return g.get_local_var_c_type(name)
}

fn (mut g Gen) fn_type_alias_name_for_base_expr(base ast.Expr) ?string {
    mut candidates := []string{}
    base_c := g.expr_type_to_c(base).trim_space()
    if base_c != '' {
        candidates << base_c
    }
    base_name := base.name()
    if base_name != '' {
        candidates << base_name
        if base_name.contains('.') {
            candidates << base_name.replace('.', '__')
        } else if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
            && !base_name.contains('__') {
            candidates << '${g.cur_module}__${base_name}'
        }
    }
    for candidate in candidates {
        if candidate in g.fn_type_aliases {
            return candidate
        }
    }
    for candidate in candidates {
        short_name := if candidate.contains('__') {
            candidate.all_after_last('__')
        } else {
            candidate
        }
        if short_name == '' {
            continue
        }
        for alias_name, _ in g.fn_type_aliases {
            if alias_name == short_name || alias_name.ends_with('__${short_name}') {
                return alias_name
            }
        }
    }
    return none
}

fn (mut g Gen) exact_fn_type_alias_cast_target_name(typ ast.Expr) ?string {
    mut candidates := []string{}
    base_name := typ.name()
    if base_name != '' && !base_name.contains('.') && g.cur_module != '' && g.cur_module != 'main'
        && g.cur_module != 'builtin' && !base_name.contains('__') {
        candidates << '${g.cur_module}__${base_name}'
    }
    base_c := g.expr_type_to_c(typ).trim_space()
    if base_c != '' {
        candidates << base_c
        if base_c.ends_with('*') && !param_type_is_pointer_expr(typ) {
            candidates << base_c[..base_c.len - 1].trim_space()
        }
    }
    if base_name != '' {
        if base_name.contains('.') {
            candidates << base_name.replace('.', '__')
        } else {
            candidates << base_name
        }
    }
    for candidate in candidates {
        if g.c_type_is_fn_pointer_alias(candidate) {
            return candidate
        }
    }
    return none
}

fn (mut g Gen) local_non_fn_alias_homonym_cast_target_name(typ ast.Expr, type_name string) ?string {
    name := type_name.trim_space()
    mut fn_alias_type := ''
    if g.c_type_is_fn_pointer_alias(name) {
        fn_alias_type = name
    } else if name.len > 1 && name.ends_with('*') {
        base_type := name[..name.len - 1].trim_space()
        if g.c_type_is_fn_pointer_alias(base_type) {
            fn_alias_type = base_type
        }
    }
    if fn_alias_type == '' {
        return none
    }
    base_name := typ.name()
    if base_name == '' || base_name.contains('.') || base_name.contains('__') {
        return none
    }
    if g.cur_module == '' || g.cur_module == 'main' || g.cur_module == 'builtin' {
        return none
    }
    local_type := '${g.cur_module}__${base_name}'
    if !g.is_type_name(local_type) || g.c_type_is_fn_pointer_alias(local_type) {
        return none
    }
    return local_type
}

fn (mut g Gen) fn_type_alias_name_from_generic_name(name string) ?string {
    mut base_name := name
    if name.ends_with('_T') {
        base_name = name[..name.len - 2]
    } else if name.contains('_T_') {
        base_name = name.all_before('_T_')
    } else {
        return none
    }
    if g.has_generic_fn_decl_by_base_name(base_name) {
        return none
    }
    return g.fn_type_alias_name_for_base_expr(ast.Ident{
        name: base_name
    })
}

fn (mut g Gen) fn_type_alias_cast_type(lhs ast.Expr) ?string {
    match lhs {
        ast.Ident {
            return g.fn_type_alias_name_from_generic_name(lhs.name)
        }
        ast.SelectorExpr {
            if alias_name := g.fn_type_alias_name_for_base_expr(lhs) {
                return alias_name
            }
            return g.fn_type_alias_name_from_generic_name(lhs.rhs.name)
        }
        ast.GenericArgOrIndexExpr {
            return g.fn_type_alias_name_for_base_expr(lhs.lhs)
        }
        ast.GenericArgs {
            return g.fn_type_alias_name_for_base_expr(lhs.lhs)
        }
        else {
            return none
        }
    }
}

fn (mut g Gen) call_or_cast_lhs_is_type(lhs ast.Expr) bool {
    match lhs {
        ast.Type {
            return true
        }
        ast.Ident {
            if lhs.name in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32',
                'f64', 'bool', 'byte', 'char', 'rune', 'usize', 'isize', 'string', 'byteptr',
                'charptr', 'voidptr'] {
                return true
            }
            if lhs.name in g.fn_param_is_ptr || lhs.name in g.fn_return_types {
                return false
            }
            if g.is_type_name(lhs.name) || g.is_c_type_name(lhs.name) {
                return true
            }
            for mod in [g.cur_module, 'builtin'] {
                if mod == '' {
                    continue
                }
                if mut scope := g.env_scope(mod) {
                    if obj := scope.lookup_parent(lhs.name, 0) {
                        if obj is types.Fn {
                            return false
                        }
                        if obj is types.Type {
                            return true
                        }
                    }
                }
            }
            return false
        }
        ast.SelectorExpr {
            if lhs.lhs is ast.Ident {
                mod_name := lhs.lhs.name
                if mod_name == 'C' {
                    if g.is_c_type_name(lhs.rhs.name) {
                        return true
                    }
                    // Check if a C.Type is known as a struct/type in the environment
                    if g.is_type_name(lhs.rhs.name) || g.is_type_name('C__${lhs.rhs.name}') {
                        return true
                    }
                    // C types starting with uppercase that aren't known functions
                    // are likely type casts (e.g. C.FONScontext(ptr))
                    c_name := lhs.rhs.name
                    if c_name.len > 0 && c_name[0] >= `A` && c_name[0] <= `Z`
                        && c_name !in g.fn_return_types && c_name !in g.fn_param_is_ptr {
                        return true
                    }
                    if c_name.contains('__') && c_name !in g.fn_return_types
                        && c_name !in g.fn_param_is_ptr {
                        return true
                    }
                    return false
                }
                qualified := '${mod_name}__${lhs.rhs.name}'
                if qualified in g.fn_param_is_ptr || qualified in g.fn_return_types {
                    return false
                }
                if g.is_type_name(qualified) || g.is_type_name(lhs.rhs.name) {
                    return true
                }
                if mut scope := g.env_scope(mod_name) {
                    if obj := scope.lookup_parent(lhs.rhs.name, 0) {
                        return obj is types.Type
                    }
                }
            }
            return false
        }
        ast.ParenExpr {
            return g.call_or_cast_lhs_is_type(lhs.expr)
        }
        ast.ModifierExpr {
            return g.call_or_cast_lhs_is_type(lhs.expr)
        }
        ast.PrefixExpr {
            return g.call_or_cast_lhs_is_type(lhs.expr)
        }
        ast.GenericArgOrIndexExpr {
            if _ := g.fn_type_alias_cast_type(lhs) {
                return true
            }
            return g.call_or_cast_lhs_is_type(lhs.lhs)
        }
        ast.GenericArgs {
            if _ := g.fn_type_alias_cast_type(lhs) {
                return true
            }
            return g.call_or_cast_lhs_is_type(lhs.lhs)
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) gen_call_or_cast_expr(node ast.CallOrCastExpr) {
    if node.expr is ast.EmptyExpr {
        g.call_expr(node.lhs, []ast.Expr{})
        return
    }
    if g.call_or_cast_lhs_is_type(node.lhs) {
        g.gen_type_cast_expr(g.cast_target_type_to_c(node.lhs), node.expr)
        return
    }
    g.call_expr(node.lhs, [node.expr])
}

fn (mut g Gen) gen_c_pointer_cast_selector_field_access(sel ast.SelectorExpr) bool {
    mut target_type := ''
    if sel.lhs is ast.CallOrCastExpr {
        cast_expr := sel.lhs as ast.CallOrCastExpr
        if !g.call_or_cast_lhs_is_type(cast_expr.lhs) {
            return false
        }
        target_type = g.expr_type_to_c(cast_expr.lhs)
        if target_type == '' || target_type == 'int' {
            return false
        }
        target_ptr_type := if target_type.ends_with('*') { target_type } else { '${target_type}*' }
        g.sb.write_string('((${target_ptr_type})(')
        g.expr(cast_expr.expr)
        g.sb.write_string('))->${escape_c_keyword(sel.rhs.name)}')
        return true
    } else if sel.lhs is ast.CallExpr {
        call_expr := sel.lhs as ast.CallExpr
        if call_expr.args.len != 1 || !g.call_or_cast_lhs_is_type(call_expr.lhs) {
            return false
        }
        target_type = g.expr_type_to_c(call_expr.lhs)
        if target_type == '' || target_type == 'int' {
            return false
        }
        target_ptr_type := if target_type.ends_with('*') { target_type } else { '${target_type}*' }
        g.sb.write_string('((${target_ptr_type})(')
        g.expr(call_expr.args[0])
        g.sb.write_string('))->${escape_c_keyword(sel.rhs.name)}')
        return true
    } else if sel.lhs is ast.CastExpr {
        cast_expr := sel.lhs as ast.CastExpr
        target_type = g.expr_type_to_c(cast_expr.typ)
        if target_type == '' || target_type == 'int' {
            return false
        }
        target_ptr_type := if target_type.ends_with('*') { target_type } else { '${target_type}*' }
        g.sb.write_string('((${target_ptr_type})(')
        g.expr(cast_expr.expr)
        g.sb.write_string('))->${escape_c_keyword(sel.rhs.name)}')
        return true
    } else {
        return false
    }
}

fn (mut g Gen) selector_use_ptr(lhs_expr ast.Expr) bool {
    if g.expr_is_pointer(lhs_expr) {
        return true
    }
    unwrapped := g.unwrap_parens(lhs_expr)
    if unwrapped is ast.Ident {
        if unwrapped.name in g.cur_fn_mut_params {
            return true
        }
        if local_type := g.local_var_c_type_for_expr(unwrapped) {
            return local_type.ends_with('*')
        }
    }
    lhs_type := g.get_expr_type(lhs_expr)
    if lhs_type == 'chan' {
        return true
    }
    return false
}

fn (mut g Gen) gen_channel_receive_expr(node ast.PrefixExpr) bool {
    if node.op != .arrow {
        return false
    }
    mut expr_type := g.get_expr_type(ast.Expr(node))
    mut elem_type := if expr_type.starts_with('_option_') {
        option_value_type(expr_type)
    } else if expr_type.starts_with('_result_') {
        g.result_value_type(expr_type)
    } else {
        expr_type
    }
    if elem_type == '' || elem_type == 'int' || elem_type.starts_with('_option_')
        || elem_type.starts_with('_result_') {
        elem_type = g.channel_elem_type_from_expr(node.expr) or { '' }
    }
    if elem_type == '' || elem_type == 'int' {
        elem_type = 'void*'
    }
    g.force_emit_fn_names['sync__Channel__try_pop_priv'] = true
    g.mark_called_fn_name('sync__Channel__try_pop_priv')
    g.tmp_counter++
    if expr_type.starts_with('_option_') {
        g.force_emit_fn_names['error'] = true
        g.mark_called_fn_name('error')
        opt_tmp := '_chopt_${g.tmp_counter}'
        val_tmp := '_chval_${g.tmp_counter}'
        g.sb.write_string('({ ${expr_type} ${opt_tmp} = (${expr_type}){ .state = 2, .err = error((string){.str = "channel closed", .len = sizeof("channel closed") - 1, .is_lit = 1}) }; ${elem_type} ${val_tmp} = ${zero_value_for_type(elem_type)}; if (sync__Channel__try_pop_priv((sync__Channel*)')
        g.expr(node.expr)
        g.sb.write_string(', &${val_tmp}, false) == ChanState__success) { _option_ok(&${val_tmp}, (_option*)&${opt_tmp}, sizeof(${val_tmp})); } ${opt_tmp}; })')
        return true
    }
    val_tmp := '_chval_${g.tmp_counter}'
    g.sb.write_string('({ ${elem_type} ${val_tmp} = ${zero_value_for_type(elem_type)}; sync__Channel__try_pop_priv((sync__Channel*)')
    g.expr(node.expr)
    g.sb.write_string(', &${val_tmp}, false); ${val_tmp}; })')
    return true
}

fn (mut g Gen) gen_unwrapped_value_expr(expr ast.Expr) bool {
    expr_type := g.get_expr_type(expr)
    if expr_type.starts_with('_result_') {
        base := g.result_value_type(expr_type)
        if g.gen_unwrapped_payload_expr(expr, expr_type, base) {
            return true
        }
    }
    if expr_type.starts_with('_option_') {
        base := option_value_type(expr_type)
        if g.gen_unwrapped_payload_expr(expr, expr_type, base) {
            return true
        }
    }
    return false
}

fn (mut g Gen) gen_unwrapped_payload_expr(expr ast.Expr, wrapper_type string, payload_type string) bool {
    if payload_type == '' || payload_type == 'void' {
        return false
    }
    is_addressable := match expr {
        ast.Ident, ast.SelectorExpr, ast.IndexExpr {
            true
        }
        else {
            false
        }
    }

    if is_addressable {
        g.sb.write_string('(*(${payload_type}*)(((u8*)(&')
        g.expr(expr)
        g.sb.write_string('.err)) + sizeof(IError)))')
    } else {
        g.sb.write_string('({ ${wrapper_type} _tmp = ')
        g.expr(expr)
        g.sb.write_string('; (*(${payload_type}*)(((u8*)(&_tmp.err)) + sizeof(IError))); })')
    }
    return true
}

fn (g &Gen) should_use_known_enum_field(enum_name string, field_name string) bool {
    return enum_name != '' && !is_generic_placeholder_c_type_name(enum_name)
        && g.enum_has_field(enum_name, field_name)
}

fn (mut g Gen) gen_enum_shorthand_for_type(expr ast.Expr, expected_type string) bool {
    enum_name := expected_type.trim_space().trim_right('*')
    if enum_name == '' || enum_name == 'int' || is_generic_placeholder_c_type_name(enum_name)
        || !g.is_enum_type(enum_name) {
        return false
    }
    if expr is ast.SelectorExpr {
        if expr.lhs is ast.EmptyExpr && g.enum_has_field(enum_name, expr.rhs.name) {
            g.sb.write_string(g.enum_member_c_name(enum_name, expr.rhs.name))
            return true
        }
    }
    return false
}

fn (mut g Gen) enum_type_from_expr(expr ast.Expr, fallback string) string {
    mut enum_type := fallback.trim_space().trim_right('*')
    if enum_type != '' && enum_type != 'int' && !is_generic_placeholder_c_type_name(enum_type)
        && g.is_enum_type(enum_type) {
        return enum_type
    }
    if raw_type := g.get_raw_type(expr) {
        enum_type = g.types_type_to_c(raw_type).trim_space().trim_right('*')
        if enum_type != '' && enum_type != 'int' && !is_generic_placeholder_c_type_name(enum_type)
            && g.is_enum_type(enum_type) {
            return enum_type
        }
    }
    if env_type := g.get_expr_type_from_env(expr) {
        enum_type = env_type.trim_space().trim_right('*')
        if enum_type != '' && enum_type != 'int' && !is_generic_placeholder_c_type_name(enum_type)
            && g.is_enum_type(enum_type) {
            return enum_type
        }
    }
    cast_type := extract_compare_cast_type(expr).trim_space().trim_right('*')
    if cast_type != '' && cast_type != 'int' && !is_generic_placeholder_c_type_name(cast_type)
        && g.is_enum_type(cast_type) {
        return cast_type
    }
    return ''
}

fn (mut g Gen) gen_enum_shorthand_compare(node &ast.InfixExpr, lhs_type string, rhs_type string) bool {
    if node.op !in [.eq, .ne] {
        return false
    }
    if node.rhs is ast.SelectorExpr {
        rhs_sel := node.rhs as ast.SelectorExpr
        if rhs_sel.lhs is ast.EmptyExpr {
            enum_type := g.enum_type_from_expr(node.lhs, lhs_type)
            if enum_type != '' && g.enum_has_field(enum_type, rhs_sel.rhs.name) {
                g.sb.write_string('(')
                g.expr(node.lhs)
                g.sb.write_string(if node.op == .eq { ' == ' } else { ' != ' })
                g.sb.write_string(g.enum_member_c_name(enum_type, rhs_sel.rhs.name))
                g.sb.write_string(')')
                return true
            }
        }
    }
    if node.lhs is ast.SelectorExpr {
        lhs_sel := node.lhs as ast.SelectorExpr
        if lhs_sel.lhs is ast.EmptyExpr {
            enum_type := g.enum_type_from_expr(node.rhs, rhs_type)
            if enum_type != '' && g.enum_has_field(enum_type, lhs_sel.rhs.name) {
                g.sb.write_string('(')
                g.sb.write_string(g.enum_member_c_name(enum_type, lhs_sel.rhs.name))
                g.sb.write_string(if node.op == .eq { ' == ' } else { ' != ' })
                g.expr(node.rhs)
                g.sb.write_string(')')
                return true
            }
        }
    }
    return false
}

fn (mut g Gen) gen_infix_expr(node &ast.InfixExpr) {
    mut lhs_type := ''
    if node.lhs is ast.SelectorExpr {
        lhs_type = g.plain_local_selector_type(node.lhs) or { '' }
    }
    if lhs_type == '' {
        lhs_type = g.get_expr_type(node.lhs)
    }
    mut rhs_type := ''
    if node.rhs is ast.SelectorExpr {
        rhs_type = g.plain_local_selector_type(node.rhs) or { '' }
    }
    if rhs_type == '' {
        rhs_type = g.get_expr_type(node.rhs)
    }
    if local_type := g.local_var_c_type_for_expr(node.lhs) {
        lhs_type = local_type
    }
    if local_type := g.local_var_c_type_for_expr(node.rhs) {
        rhs_type = local_type
    }
    if node.lhs is ast.IndexExpr && (lhs_type == '' || lhs_type == 'int'
        || lhs_type == 'array' || lhs_type == 'void*' || lhs_type == 'voidptr'
        || (lhs_type.starts_with('Array_') && !lhs_type.starts_with('Array_fixed_'))) {
        if elem_type := g.index_expr_elem_type_from_lhs(node.lhs) {
            lhs_type = elem_type
        }
    }
    if node.rhs is ast.IndexExpr && (rhs_type == '' || rhs_type == 'int'
        || rhs_type == 'array' || rhs_type == 'void*' || rhs_type == 'voidptr'
        || (rhs_type.starts_with('Array_') && !rhs_type.starts_with('Array_fixed_'))) {
        if elem_type := g.index_expr_elem_type_from_lhs(node.rhs) {
            rhs_type = elem_type
        }
    }
    // Channel push: ch <- value → sync__Channel__try_push_priv(ch, &(elem_type){value}, false)
    if node.op == .arrow {
        mut elem_type := g.channel_elem_type_from_expr(node.lhs) or { 'bool' }
        if elem_type == '' || elem_type == 'int' {
            elem_type = 'bool'
        }
        g.force_emit_fn_names['sync__Channel__try_push_priv'] = true
        g.mark_called_fn_name('sync__Channel__try_push_priv')
        g.sb.write_string('sync__Channel__try_push_priv((sync__Channel*)')
        g.expr(node.lhs)
        g.sb.write_string(', &(${elem_type}[]){')
        g.expr(node.rhs)
        g.sb.write_string('}, false)')
        return
    }
    if g.gen_enum_shorthand_compare(node, lhs_type, rhs_type) {
        return
    }
    if node.op in [.logical_or, .and] {
        g.sb.write_string('(')
        if !g.gen_unwrapped_value_expr(node.lhs) {
            g.expr(node.lhs)
        }
        g.sb.write_string(if node.op == .logical_or { ' || ' } else { ' && ' })
        if !g.gen_unwrapped_value_expr(node.rhs) {
            g.expr(node.rhs)
        }
        g.sb.write_string(')')
        return
    }
    if node.op in [.amp, .pipe, .xor] && node.lhs is ast.InfixExpr {
        left := node.lhs as ast.InfixExpr
        if left.op == .left_shift {
            is_array_append, elem_type := g.array_append_elem_type(left.lhs, left.rhs)
            if is_array_append {
                combined_rhs := ast.InfixExpr{
                    lhs: left.rhs
                    op:  node.op
                    rhs: node.rhs
                    pos: node.pos
                }
                g.sb.write_string('array__push((array*)')
                if g.expr_is_pointer(left.lhs) {
                    g.expr(left.lhs)
                } else {
                    g.sb.write_string('&')
                    g.expr(left.lhs)
                }
                g.sb.write_string(', ')
                g.gen_addr_of_expr(ast.Expr(combined_rhs), elem_type)
                g.sb.write_string(')')
                return
            }
        }
    }
    // Option none comparison: `opt == none` / `opt != none`.
    if node.op in [.eq, .ne] {
        if lhs_type.starts_with('_option_') && is_none_like_expr(node.rhs) {
            sep := if g.expr_is_pointer(node.lhs) { '->' } else { '.' }
            cmp := if node.op == .eq { '!=' } else { '==' }
            g.sb.write_string('(')
            g.expr(node.lhs)
            g.sb.write_string('${sep}state ${cmp} 0)')
            return
        }
        if rhs_type.starts_with('_option_') && is_none_like_expr(node.lhs) {
            sep := if g.expr_is_pointer(node.rhs) { '->' } else { '.' }
            cmp := if node.op == .eq { '!=' } else { '==' }
            g.sb.write_string('(')
            g.expr(node.rhs)
            g.sb.write_string('${sep}state ${cmp} 0)')
            return
        }
    }
    if node.op in [.eq, .ne, .key_is, .not_is] && ((node.rhs is ast.Ident && node.rhs.name == 'Eof')
        || (node.rhs is ast.SelectorExpr && node.rhs.rhs.name == 'Eof')) {
        if node.op in [.ne, .not_is] {
            g.sb.write_string('!')
        }
        g.sb.write_string('string__eq(err.type_name(err._object), ${c_static_v_string_expr('Eof')})')
        return
    }
    if node.op in [.eq, .ne, .key_is, .not_is] && node.lhs is ast.Ident && node.lhs.name == 'err'
        && node.rhs is ast.Ident {
        rhs_ident := node.rhs as ast.Ident
        if rhs_ident.name.len > 0 && rhs_ident.name[0] >= `A` && rhs_ident.name[0] <= `Z` {
            if node.op in [.ne, .not_is] {
                g.sb.write_string('!')
            }
            type_name := rhs_ident.name
            g.sb.write_string('string__eq(err.type_name(err._object), ${c_static_v_string_expr(type_name)})')
            return
        }
    }
    if node.op in [.eq, .ne, .key_is, .not_is] && lhs_type == 'IError' && node.rhs is ast.Ident {
        rhs_ident := node.rhs as ast.Ident
        if g.is_type_name(rhs_ident.name)
            || (rhs_ident.name.len > 0 && rhs_ident.name[0] >= `A` && rhs_ident.name[0] <= `Z`) {
            if node.op in [.ne, .not_is] {
                g.sb.write_string('!')
            }
            type_name := rhs_ident.name
            g.sb.write_string('string__eq(')
            g.expr(node.lhs)
            g.sb.write_string('.type_name(')
            g.expr(node.lhs)
            g.sb.write_string('._object), ${c_static_v_string_expr(type_name)})')
            return
        }
    }
    if node.op in [.eq, .ne] && node.rhs is ast.BasicLiteral {
        tag_lhs := strip_expr_wrappers(node.lhs)
        if tag_lhs is ast.SelectorExpr && tag_lhs.rhs.name == '_tag' {
            sum_expr := strip_expr_wrappers(tag_lhs.lhs)
            if sum_expr is ast.SelectorExpr {
                tag_lit := node.rhs as ast.BasicLiteral
                if tag_lit.kind == .number {
                    tag := tag_lit.value.int()
                    if tag >= 0 {
                        mut source_sum_type :=
                            g.get_expr_type(sum_expr).trim_space().trim_right('*')
                        if source_sum_type == '' {
                            source_sum_type =
                                g.selector_field_type(sum_expr).trim_space().trim_right('*')
                        }
                        variants := g.get_sum_type_variants_for(source_sum_type)
                        if tag < variants.len {
                            target_type := variants[tag]
                            for storage_sum_type in [
                                g.selector_storage_field_type(sum_expr).trim_space().trim_right('*'),
                                g.selector_declared_field_type(sum_expr).trim_space().trim_right('*'),
                            ] {
                                if storage_sum_type == '' || storage_sum_type == source_sum_type {
                                    continue
                                }
                                if path := g.sum_variant_tag_path(storage_sum_type, target_type,
                                    []string{})
                                {
                                    if path.len > 1 {
                                        g.gen_sum_variant_tag_path_check(sum_expr, path,
                                            node.op == .eq)
                                        return
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    if node.op in [.key_is, .not_is, .eq, .ne] {
        if raw_type := g.get_raw_type(node.lhs) {
            is_iface := raw_type is types.Interface
                || (raw_type is types.Pointer && raw_type.base_type is types.Interface)
            if is_iface {
                mut rhs_name := ''
                if node.rhs is ast.Ident {
                    rhs_name = node.rhs.name
                } else if node.rhs is ast.SelectorExpr {
                    rhs_name = node.rhs.rhs.name
                }
                type_id := interface_type_id_for_name(rhs_name)
                if type_id <= 0 {
                    g.sb.write_string(if node.op in [.key_is, .eq] {
                        'false'
                    } else {
                        'true'
                    })
                    return
                }
                sep := if g.expr_is_pointer(node.lhs) { '->' } else { '.' }
                g.sb.write_string('(')
                g.expr(node.lhs)
                op := if node.op in [.key_is, .eq] { '==' } else { '!=' }
                g.sb.write_string('${sep}_type_id ${op} ${type_id})')
                return
            }
        }
    }
    // Sum type checks: expr is Type and lowered expr ==/!= Type.
    rhs_can_match_sum := node.rhs is ast.Ident
        || (node.rhs is ast.SelectorExpr && node.rhs.lhs is ast.Ident)
        || node.rhs is ast.Type
    if node.op in [.key_is, .not_is] || (node.op in [.eq, .ne] && rhs_can_match_sum) {
        sum_lhs := strip_expr_wrappers(node.lhs)
        mut rhs_name := ''
        if node.rhs is ast.Ident {
            rhs_name = node.rhs.name
        } else if node.rhs is ast.SelectorExpr && node.rhs.lhs is ast.Ident {
            rhs_name = '${(node.rhs.lhs as ast.Ident).name}__${node.rhs.rhs.name}'
        } else if node.rhs is ast.Type {
            rhs_name = g.expr_type_to_c(node.rhs)
        }
        if rhs_name != '' {
            mut lhs_sum_type := g.get_expr_type(sum_lhs)
            if raw_lhs := g.get_raw_type(sum_lhs) {
                match raw_lhs {
                    types.SumType {
                        lhs_sum_type = g.types_type_to_c(raw_lhs)
                    }
                    types.Pointer {
                        if raw_lhs.base_type is types.SumType {
                            lhs_sum_type = g.types_type_to_c(raw_lhs.base_type)
                        }
                    }
                    types.Alias {
                        if raw_lhs.base_type is types.SumType {
                            lhs_sum_type = g.types_type_to_c(raw_lhs.base_type)
                        }
                    }
                    else {}
                }
            }
            if lhs_sum_type == '' {
                if lhs_env_type := g.get_expr_type_from_env(sum_lhs) {
                    lhs_sum_type = lhs_env_type
                }
            }
            if lhs_sum_type == '' && sum_lhs is ast.SelectorExpr {
                lhs_sum_type = g.selector_field_type(sum_lhs)
            }
            lhs_sum_type = lhs_sum_type.trim_space().trim_right('*')
            if sum_lhs is ast.SelectorExpr {
                mut storage_candidates := []string{}
                mut selector_has_same_sumtype_storage := false
                for candidate in [
                    g.selector_storage_field_type(sum_lhs).trim_space().trim_right('*'),
                    g.selector_declared_field_type(sum_lhs).trim_space().trim_right('*'),
                ] {
                    if candidate == '' {
                        continue
                    }
                    if candidate == lhs_sum_type {
                        selector_has_same_sumtype_storage = true
                        continue
                    }
                    if candidate !in storage_candidates
                        && g.get_sum_type_variants_for(candidate).len > 0 {
                        storage_candidates << candidate
                    }
                }
                for storage_sum_type in storage_candidates {
                    if path := g.sum_variant_tag_path(storage_sum_type, rhs_name, []string{}) {
                        if path.len <= 1 {
                            continue
                        }
                        g.gen_sum_variant_tag_path_check(sum_lhs, path, node.op in [
                            .key_is,
                            .eq,
                        ])
                        return
                    }
                }
                if !selector_has_same_sumtype_storage {
                    if path := g.nested_sum_path_from_narrowed_source(lhs_sum_type, rhs_name) {
                        if path.len > 1 {
                            g.gen_sum_variant_tag_path_check(sum_lhs, path, node.op in [
                                .key_is,
                                .eq,
                            ])
                            return
                        }
                    }
                }
            }
            mut variants := []string{}
            if vs := g.sum_type_variants[lhs_sum_type] {
                variants = vs.clone()
            } else if lhs_sum_type.contains('__') {
                short_sum := lhs_sum_type.all_after_last('__')
                if vs := g.sum_type_variants[short_sum] {
                    variants = vs.clone()
                }
            } else {
                qualified_sum := g.get_qualified_name(lhs_sum_type)
                if vs := g.sum_type_variants[qualified_sum] {
                    variants = vs.clone()
                }
            }
            if variants.len == 0 && sum_lhs is ast.SelectorExpr {
                lhs_sum_type = g.selector_field_type(sum_lhs).trim_space().trim_right('*')
                if lhs_sum_type != '' {
                    if vs := g.sum_type_variants[lhs_sum_type] {
                        variants = vs.clone()
                    } else if lhs_sum_type.contains('__') {
                        short_sum := lhs_sum_type.all_after_last('__')
                        if vs := g.sum_type_variants[short_sum] {
                            variants = vs.clone()
                        }
                    } else {
                        qualified_sum := g.get_qualified_name(lhs_sum_type)
                        if vs := g.sum_type_variants[qualified_sum] {
                            variants = vs.clone()
                        }
                    }
                }
            }
            if variants.len > 0 {
                mut tag := -1
                for i, v in variants {
                    if sum_type_variant_matches(v, rhs_name) {
                        tag = i
                        break
                    }
                }
                if tag >= 0 {
                    sep := if g.expr_is_pointer(sum_lhs) { '->' } else { '.' }
                    op := if node.op in [.key_is, .eq] { '==' } else { '!=' }
                    g.sb.write_string('(')
                    g.expr(sum_lhs)
                    g.sb.write_string('${sep}_tag ${op} ${tag})')
                    return
                }
                if path := g.sum_variant_tag_path(lhs_sum_type, rhs_name, []string{}) {
                    g.gen_sum_variant_tag_path_check(sum_lhs, path, node.op in [
                        .key_is,
                        .eq,
                    ])
                    return
                }
            }
            // Fallback: interface is-check when get_raw_type didn't resolve
            // (e.g. through smartcast chains like child.layout is Widget)
            if node.op in [.key_is, .not_is] && variants.len == 0 {
                mut field_type := lhs_sum_type
                if field_type == '' && sum_lhs is ast.SelectorExpr {
                    field_type = g.selector_field_type(sum_lhs)
                }
                if field_type != '' {
                    base_ft := field_type.trim_right('*')
                    if g.is_interface_type(base_ft) {
                        type_id := interface_type_id_for_name(rhs_name)
                        if type_id > 0 {
                            sep := if g.expr_is_pointer(sum_lhs) { '->' } else { '.' }
                            op := if node.op == .key_is { '==' } else { '!=' }
                            g.sb.write_string('(')
                            g.expr(sum_lhs)
                            g.sb.write_string('${sep}_type_id ${op} ${type_id})')
                            return
                        }
                    }
                }
            }
        }
    }
    if node.op == .left_shift {
        is_array_append, elem_type := g.array_append_elem_type(node.lhs, node.rhs)
        if is_array_append {
            if node.lhs is ast.IndexExpr
                && g.gen_map_index_array_append(node.lhs, node.rhs, elem_type) {
                return
            }
            if g.expr_is_array_value(node.rhs) {
                rhs_tmp := '_arr_append_tmp_${g.tmp_counter}'
                g.tmp_counter++
                arr_rhs_type := g.expr_array_runtime_type(node.rhs)
                g.sb.write_string('({ ${arr_rhs_type} ${rhs_tmp} = ')
                g.expr(node.rhs)
                g.sb.write_string('; array__push_many((array*)')
                g.gen_array_append_target(node.lhs)
                g.sb.write_string(', ${rhs_tmp}.data, ${rhs_tmp}.len); })')
                return
            }
            g.sb.write_string('array__push((array*)')
            g.gen_array_append_target(node.lhs)
            g.sb.write_string(', ')
            if elem_type == 'string' {
                g.sb.write_string('&(string[1]){ string__clone(')
                g.expr(node.rhs)
                g.sb.write_string(') }')
            } else {
                g.gen_array_push_elem_arg(node.rhs, elem_type)
            }
            g.sb.write_string(')')
            return
        }
    }
    if node.op == .plus && lhs_type == 'string' && rhs_type == 'string' {
        g.sb.write_string('string__plus(')
        g.expr(node.lhs)
        g.sb.write_string(', ')
        g.expr(node.rhs)
        g.sb.write_string(')')
        return
    }
    if node.op in [.key_in, .not_in] {
        if node.rhs is ast.ArrayInitExpr {
            join_op := if node.op == .key_in { ' || ' } else { ' && ' }
            g.sb.write_string('(')
            if node.rhs.exprs.len == 0 {
                g.sb.write_string(if node.op == .key_in { 'false' } else { 'true' })
            } else {
                for i in 0 .. node.rhs.exprs.len {
                    elem := node.rhs.exprs[i]
                    if i > 0 {
                        g.sb.write_string(join_op)
                    }
                    if lhs_type == 'string' {
                        if node.op == .not_in {
                            g.sb.write_string('!')
                        }
                        g.sb.write_string('string__eq(')
                        g.expr(node.lhs)
                        g.sb.write_string(', ')
                        g.expr(elem)
                        g.sb.write_string(')')
                    } else {
                        cmp_op := if node.op == .key_in { '==' } else { '!=' }
                        g.sb.write_string('(')
                        g.expr(node.lhs)
                        g.sb.write_string(' ${cmp_op} ')
                        g.expr(elem)
                        g.sb.write_string(')')
                    }
                }
            }
            g.sb.write_string(')')
            return
        }
        if rhs_type == 'map' || rhs_type.starts_with('Map_') {
            mut key_type := if lhs_type == '' { 'int' } else { lhs_type }
            if raw_map_type := g.get_raw_type(node.rhs) {
                if raw_map_type is types.Map {
                    kt := g.types_type_to_c(raw_map_type.key_type)
                    if kt != '' {
                        key_type = kt
                    }
                }
            } else if rhs_type.starts_with('Map_') {
                kv := rhs_type.all_after('Map_')
                kt, _ := g.parse_map_kv_types(kv)
                if kt != '' {
                    key_type = kt
                }
            }
            if key_type == 'bool' && node.lhs is ast.BasicLiteral {
                key_type = 'int'
            }
            if node.op == .not_in {
                g.sb.write_string('!')
            }
            if node.rhs is ast.Ident || node.rhs is ast.SelectorExpr {
                g.sb.write_string('map__exists(&')
                g.expr(node.rhs)
                g.sb.write_string(', ')
                g.gen_addr_of_expr(node.lhs, key_type)
                g.sb.write_string(')')
            } else {
                tmp_name := '_map_in_tmp_${g.tmp_counter}'
                g.tmp_counter++
                g.sb.write_string('({ map ${tmp_name} = ')
                g.expr(node.rhs)
                g.sb.write_string('; map__exists(&${tmp_name}, ')
                g.gen_addr_of_expr(node.lhs, key_type)
                g.sb.write_string('); })')
            }
            return
        }
        if rhs_type.starts_with('Array_fixed_') {
            // Fixed-size array: use a linear scan via statement expression.
            tmp := '_fixed_in_${g.tmp_counter}'
            g.tmp_counter++
            g.sb.write_string('({ bool ${tmp} = false; for (int _i = 0; _i < (int)(sizeof(')
            g.expr(node.rhs)
            g.sb.write_string(')/sizeof(')
            g.expr(node.rhs)
            g.sb.write_string('[0])); _i++) { if (')
            g.expr(node.rhs)
            g.sb.write_string('[_i] == ')
            g.expr(node.lhs)
            g.sb.write_string(') { ${tmp} = true; break; } } ')
            if node.op == .not_in {
                g.sb.write_string('!${tmp}')
            } else {
                g.sb.write_string(tmp)
            }
            g.sb.write_string('; })')
            return
        }
        if rhs_type == 'array' || rhs_type.starts_with('Array_') {
            key_type := if lhs_type == '' { 'int' } else { lhs_type }
            if node.op == .not_in {
                g.sb.write_string('!')
            }
            g.sb.write_string('array__contains(')
            g.expr(node.rhs)
            g.sb.write_string(', ')
            g.gen_addr_of_expr(node.lhs, key_type)
            g.sb.write_string(')')
            return
        }
        cmp_op := if node.op == .key_in { '==' } else { '!=' }
        g.sb.write_string('(')
        g.expr(node.lhs)
        g.sb.write_string(' ${cmp_op} ')
        g.expr(node.rhs)
        g.sb.write_string(')')
        return
    }
    is_lhs_fixed := lhs_type.starts_with('Array_fixed_')
    is_rhs_fixed := rhs_type.starts_with('Array_fixed_')
    if node.op in [.eq, .ne] && (is_lhs_fixed || is_rhs_fixed) {
        fixed_type := if is_lhs_fixed { lhs_type } else { rhs_type }
        cmp_op := if node.op == .eq { '==' } else { '!=' }
        g.sb.write_string('(memcmp(')
        g.gen_fixed_array_cmp_operand(node.lhs, fixed_type)
        g.sb.write_string(', ')
        g.gen_fixed_array_cmp_operand(node.rhs, fixed_type)
        g.sb.write_string(', sizeof(${fixed_type})) ${cmp_op} 0)')
        return
    }
    is_lhs_array := lhs_type == 'array'
        || (lhs_type.starts_with('Array_') && !lhs_type.starts_with('Array_fixed_'))
        || lhs_type in g.array_aliases
    is_rhs_array := rhs_type == 'array'
        || (rhs_type.starts_with('Array_') && !rhs_type.starts_with('Array_fixed_'))
        || rhs_type in g.array_aliases
    if node.op in [.eq, .ne] && is_lhs_array && is_rhs_array {
        if node.op == .ne {
            g.sb.write_string('!')
        }
        g.sb.write_string('__v2_array_eq(')
        if g.expr_is_pointer(node.lhs) {
            g.sb.write_string('*')
        }
        g.expr(node.lhs)
        g.sb.write_string(', ')
        if g.expr_is_pointer(node.rhs) {
            g.sb.write_string('*')
        }
        g.expr(node.rhs)
        g.sb.write_string(')')
        return
    }
    mut lhs_is_string_ptr := false
    lhs_local_type := g.local_var_c_type_for_expr(node.lhs) or { '' }
    lhs_may_need_raw_string_ptr := lhs_type == '' || lhs_type.ends_with('*')
        || lhs_type.ends_with('ptr') || lhs_local_type.ends_with('*')
        || lhs_local_type.ends_with('ptr')
    if lhs_may_need_raw_string_ptr {
        if raw_type := g.get_raw_type(node.lhs) {
            if raw_type is types.Pointer && raw_type.base_type is types.String {
                lhs_is_string_ptr = true
            }
        }
    }
    if lhs_type in ['string*', 'stringptr'] || lhs_local_type in ['string*', 'stringptr'] {
        lhs_is_string_ptr = true
    }
    mut rhs_is_string_ptr := false
    rhs_local_type := g.local_var_c_type_for_expr(node.rhs) or { '' }
    rhs_may_need_raw_string_ptr := rhs_type == '' || rhs_type.ends_with('*')
        || rhs_type.ends_with('ptr') || rhs_local_type.ends_with('*')
        || rhs_local_type.ends_with('ptr')
    if rhs_may_need_raw_string_ptr {
        if raw_type := g.get_raw_type(node.rhs) {
            if raw_type is types.Pointer && raw_type.base_type is types.String {
                rhs_is_string_ptr = true
            }
        }
    }
    if rhs_type in ['string*', 'stringptr'] || rhs_local_type in ['string*', 'stringptr'] {
        rhs_is_string_ptr = true
    }
    mut may_be_string_cmp := false
    if lhs_type == 'string' {
        may_be_string_cmp = true
    }
    if rhs_type == 'string' {
        may_be_string_cmp = true
    }
    if lhs_is_string_ptr {
        may_be_string_cmp = true
    }
    if rhs_is_string_ptr {
        may_be_string_cmp = true
    }
    if lhs_local_type == 'string' {
        may_be_string_cmp = true
    }
    if rhs_local_type == 'string' {
        may_be_string_cmp = true
    }
    mut is_string_cmp2 := false
    if may_be_string_cmp {
        // When either side is nil/0, this is a pointer comparison, not a string comparison
        mut lhs_is_nil := false
        mut rhs_is_nil := false
        if node.op in [.eq, .ne] {
            lhs_is_nil = is_nil_like_expr(node.lhs)
            rhs_is_nil = is_nil_like_expr(node.rhs)
        }
        // Also treat integer-typed operands as nil when compared with string pointers
        // (e.g., `&string == 0` where checker annotates 0 as int)
        lhs_is_nil2 := lhs_is_nil
            || (rhs_is_string_ptr && lhs_type in ['int', 'int_literal', 'i64', 'u64', 'voidptr'])
        rhs_is_nil2 := rhs_is_nil
            || (lhs_is_string_ptr && rhs_type in ['int', 'int_literal', 'i64', 'u64', 'voidptr'])
        is_string_cmp := if lhs_is_nil2 || rhs_is_nil2 {
            false
        } else if node.lhs is ast.StringLiteral || node.rhs is ast.StringLiteral {
            true
        } else {
            (lhs_type == 'string' || lhs_is_string_ptr)
                && (rhs_type == 'string' || rhs_is_string_ptr) && !g.is_enum_type(lhs_type)
                && !g.is_enum_type(rhs_type)
        }
        // Override: string pointer compared with a numeric literal (null check)
        // The checker may annotate `0` as `string` in `&string == 0` context,
        // but this is a pointer comparison, not a string comparison.
        is_string_cmp2 = if is_string_cmp && ((lhs_is_string_ptr && is_numeric_literal(node.rhs))
            || (rhs_is_string_ptr && is_numeric_literal(node.lhs))) {
            false
        } else {
            is_string_cmp
        }
    }
    if node.op in [.eq, .ne] && is_string_cmp2 {
        if node.op == .ne {
            g.sb.write_string('!')
        }
        g.sb.write_string('string__eq(')
        g.gen_string_cmp_operand(node.lhs, lhs_is_string_ptr)
        g.sb.write_string(', ')
        g.gen_string_cmp_operand(node.rhs, rhs_is_string_ptr)
        g.sb.write_string(')')
        return
    }
    if node.op in [.lt, .le, .gt, .ge] && is_string_cmp2 {
        op := match node.op {
            .gt { '>' }
            .lt { '<' }
            .ge { '>=' }
            .le { '<=' }
            else { '==' }
        }

        g.sb.write_string('(string__compare(')
        g.gen_string_cmp_operand(node.lhs, lhs_is_string_ptr)
        g.sb.write_string(', ')
        g.gen_string_cmp_operand(node.rhs, rhs_is_string_ptr)
        g.sb.write_string(') ${op} 0)')
        return
    }
    if node.op in [.lt, .le, .gt, .ge] && lhs_type in primitive_types && rhs_type in primitive_types {
        op := match node.op {
            .gt { '>' }
            .lt { '<' }
            .ge { '>=' }
            .le { '<=' }
            else { '==' }
        }

        g.sb.write_string('(')
        g.expr(node.lhs)
        g.sb.write_string(' ${op} ')
        g.expr(node.rhs)
        g.sb.write_string(')')
        return
    }
    if node.op in [.eq, .ne] && (lhs_type == 'map' || lhs_type.starts_with('Map_'))
        && (rhs_type == 'map' || rhs_type.starts_with('Map_')) {
        if node.op == .ne {
            g.sb.write_string('!')
        }
        map_eq_fn := if lhs_type.starts_with('Map_') && lhs_type == rhs_type {
            '${lhs_type}_map_eq'
        } else {
            'map_map_eq'
        }
        g.sb.write_string('${map_eq_fn}(')
        g.expr(node.lhs)
        g.sb.write_string(', ')
        g.expr(node.rhs)
        g.sb.write_string(')')
        return
    }
    mut cmp_type := ''
    if g.should_use_memcmp_eq(lhs_type, rhs_type) {
        // Use whichever type is non-empty; prefer lhs_type
        cmp_type = if lhs_type != '' { lhs_type } else { rhs_type }
    } else if node.op in [.eq, .ne] && g.should_use_memcmp_eq(lhs_type, lhs_type)
        && rhs_type == 'int' && node.rhs is ast.Ident && g.is_known_struct_type(lhs_type) {
        // RHS Ident defaulted to 'int' (unresolved constant) but LHS is a known struct
        cmp_type = lhs_type
    } else if node.op in [.eq, .ne] && g.should_use_memcmp_eq(rhs_type, rhs_type)
        && lhs_type == 'int' && node.lhs is ast.Ident && g.is_known_struct_type(rhs_type) {
        // LHS Ident defaulted to 'int' (unresolved constant) but RHS is a known struct
        cmp_type = rhs_type
    } else if node.op in [.eq, .ne] {
        lhs_cast_type := extract_compare_cast_type(node.lhs)
        rhs_cast_type := extract_compare_cast_type(node.rhs)
        if lhs_cast_type != '' && rhs_cast_type == '' {
            cmp_type = lhs_cast_type
        } else if rhs_cast_type != '' && lhs_cast_type == '' {
            cmp_type = rhs_cast_type
        } else if lhs_cast_type != '' && lhs_cast_type == rhs_cast_type {
            cmp_type = lhs_cast_type
        }
        if cmp_type in primitive_types || cmp_type == 'string' || cmp_type.ends_with('*')
            || cmp_type.ends_with('ptr') {
            cmp_type = ''
        }
    }
    if node.op in [.eq, .ne] && cmp_type != '' {
        ltmp := '_cmp_l_${g.tmp_counter}'
        g.tmp_counter++
        rtmp := '_cmp_r_${g.tmp_counter}'
        g.tmp_counter++
        g.sb.write_string('({ ${cmp_type} ${ltmp} = ')
        if !g.gen_unwrapped_value_expr(node.lhs) {
            g.expr(node.lhs)
        }
        g.sb.write_string('; ${cmp_type} ${rtmp} = ')
        if !g.gen_unwrapped_value_expr(node.rhs) {
            g.expr(node.rhs)
        }
        struct_type := g.lookup_struct_type_by_c_name(cmp_type)
        if struct_type.fields.len > 0 && g.struct_has_ref_fields(struct_type) {
            eq_expr := g.gen_struct_field_eq_expr(struct_type, ltmp, rtmp)
            if node.op == .eq {
                g.sb.write_string('; ${eq_expr}; })')
            } else {
                g.sb.write_string('; !(${eq_expr}); })')
            }
        } else {
            cmp_op := if node.op == .eq { '== 0' } else { '!= 0' }
            g.sb.write_string('; memcmp(&${ltmp}, &${rtmp}, sizeof(${cmp_type})) ${cmp_op}; })')
        }
        return
    }
    method_fn, operand_type := g.overloaded_arithmetic_method_for_infix(*node, lhs_type, rhs_type)
    if method_fn != '' {
        g.sb.write_string('${method_fn}(')
        g.gen_overloaded_arithmetic_arg(node.lhs, lhs_type, operand_type)
        g.sb.write_string(', ')
        g.gen_overloaded_arithmetic_arg(node.rhs, rhs_type, operand_type)
        g.sb.write_string(')')
        return
    }
    // Comparison operators (<, <=, >, >=) on struct types with overloaded `<` operator.
    // V derives: a < b → Type__lt(a, b), a > b → Type__lt(b, a),
    //            a <= b → !Type__lt(b, a), a >= b → !Type__lt(a, b)
    if node.op in [.lt, .le, .gt, .ge] && lhs_type != '' && rhs_type != '' && lhs_type == rhs_type
        && lhs_type !in primitive_types && lhs_type != 'string' && !lhs_type.ends_with('*')
        && !lhs_type.ends_with('ptr') {
        mut lt_fn := '${lhs_type}__op_lt'
        if lt_fn !in g.fn_return_types && lt_fn !in g.fn_param_is_ptr {
            lt_fn = '${lhs_type}__lt'
        }
        if lt_fn in g.fn_return_types || lt_fn in g.fn_param_is_ptr {
            match node.op {
                .lt {
                    g.sb.write_string('${lt_fn}(')
                    g.expr(node.lhs)
                    g.sb.write_string(', ')
                    g.expr(node.rhs)
                    g.sb.write_string(')')
                }
                .gt {
                    g.sb.write_string('${lt_fn}(')
                    g.expr(node.rhs)
                    g.sb.write_string(', ')
                    g.expr(node.lhs)
                    g.sb.write_string(')')
                }
                .le {
                    g.sb.write_string('!${lt_fn}(')
                    g.expr(node.rhs)
                    g.sb.write_string(', ')
                    g.expr(node.lhs)
                    g.sb.write_string(')')
                }
                .ge {
                    g.sb.write_string('!${lt_fn}(')
                    g.expr(node.lhs)
                    g.sb.write_string(', ')
                    g.expr(node.rhs)
                    g.sb.write_string(')')
                }
                else {}
            }

            return
        }
    }
    is_bitwise_op := node.op in [.amp, .pipe, .xor, .left_shift, .right_shift]
    lhs_is_float := lhs_type.starts_with('f') || lhs_type == 'float_literal'
    rhs_is_float := rhs_type.starts_with('f') || rhs_type == 'float_literal'
    if node.op == .mod && (lhs_is_float || rhs_is_float) {
        g.sb.write_string(if lhs_type == 'f32' || rhs_type == 'f32' { 'fmodf(' } else { 'fmod(' })
        if !g.gen_unwrapped_value_expr(node.lhs) {
            g.expr(node.lhs)
        }
        g.sb.write_string(', ')
        if !g.gen_unwrapped_value_expr(node.rhs) {
            g.expr(node.rhs)
        }
        g.sb.write_string(')')
        return
    }
    g.sb.write_string('(')
    if is_bitwise_op && lhs_is_float {
        g.sb.write_string('((u64)(')
        if !g.gen_unwrapped_value_expr(node.lhs) {
            g.expr(node.lhs)
        }
        g.sb.write_string('))')
    } else {
        if !g.gen_unwrapped_value_expr(node.lhs) {
            g.expr(node.lhs)
        }
    }
    op := match node.op {
        .plus { '+' }
        .minus { '-' }
        .mul { '*' }
        .div { '/' }
        .mod { '%' }
        .gt { '>' }
        .lt { '<' }
        .eq { '==' }
        .ne { '!=' }
        .ge { '>=' }
        .le { '<=' }
        .and { '&&' }
        .logical_or { '||' }
        .amp { '&' }
        .pipe { '|' }
        .xor { '^' }
        .left_shift { '<<' }
        .right_shift { '>>' }
        .key_is { '==' }
        .not_is { '!=' }
        .question { '==' } // match arm lowering uses ? as equality test
        else { '==' }
    }

    g.sb.write_string(' ${op} ')
    if is_bitwise_op && rhs_is_float {
        cast_type := if node.op in [.left_shift, .right_shift] {
            'int'
        } else {
            'u64'
        }
        g.sb.write_string('((${cast_type})(')
        if !g.gen_unwrapped_value_expr(node.rhs) {
            g.expr(node.rhs)
        }
        g.sb.write_string('))')
    } else {
        if !g.gen_unwrapped_value_expr(node.rhs) {
            g.expr(node.rhs)
        }
    }
    g.sb.write_string(')')
}

fn (mut g Gen) gen_string_cmp_operand(expr ast.Expr, is_string_ptr bool) {
    if is_string_ptr {
        g.sb.write_string('(*')
        g.expr(expr)
        g.sb.write_string(')')
        return
    }
    g.expr(expr)
}

fn (mut g Gen) plain_index_selector_type(sel ast.SelectorExpr) ?string {
    if g.comptime_field_var != '' || g.comptime_method_var != '' {
        return none
    }
    if sel.lhs !is ast.IndexExpr {
        return none
    }
    index_expr := sel.lhs as ast.IndexExpr
    elem_type := g.index_expr_elem_type_from_lhs(index_expr) or { return none }
    base_type := strip_pointer_type_name(elem_type)
    if base_type == '' || base_type == 'string' || base_type in primitive_types
        || base_type in ['void', 'void*', 'voidptr'] {
        return none
    }
    field_name := sel.rhs.name
    if field_name == '' {
        return none
    }
    return g.lookup_struct_field_type_by_name(base_type, field_name)
}

fn (mut g Gen) gen_plain_index_selector_expr(sel ast.SelectorExpr) bool {
    if g.comptime_field_var != '' || g.comptime_method_var != '' {
        return false
    }
    if sel.lhs !is ast.IndexExpr {
        return false
    }
    index_expr := sel.lhs as ast.IndexExpr
    elem_type := g.index_expr_elem_type_from_lhs(index_expr) or { return false }
    base_type := strip_pointer_type_name(elem_type)
    if base_type == '' || base_type == 'string' || base_type in primitive_types
        || base_type in ['void', 'void*', 'voidptr'] {
        return false
    }
    field_name := sel.rhs.name
    if field_name == '' {
        return false
    }
    _ = g.plain_index_selector_type(sel) or { return false }
    g.expr(index_expr)
    selector := if elem_type.ends_with('*') { '->' } else { '.' }
    g.sb.write_string('${selector}${escape_c_keyword(field_name)}')
    return true
}

fn (mut g Gen) gen_plain_local_selector_expr(sel ast.SelectorExpr) bool {
    if g.comptime_field_var != '' || g.comptime_method_var != '' {
        return false
    }
    parts := cleanc_selector_expr_parts(sel)
    if parts.len < 2 {
        return false
    }
    root := parts[0]
    if root == '' {
        return false
    }
    mut cur_type := g.runtime_local_types[root] or { return false }
    mut segments := []string{cap: parts.len - 1}
    for i in 1 .. parts.len {
        field_name := parts[i]
        if field_name == '' {
            return false
        }
        base_type := strip_pointer_type_name(cur_type)
        if base_type == '' || base_type == 'string' || base_type in primitive_types
            || base_type in ['void', 'void*', 'voidptr'] || base_type in g.sum_type_variants
            || g.is_interface_type(base_type) {
            return false
        }
        if cur_type.starts_with('_option_') || cur_type.starts_with('_result_') {
            return false
        }
        if base_type.starts_with('Array_fixed_') && field_name == 'len' {
            if i != parts.len - 1 {
                return false
            }
            _, fixed_len := parse_fixed_array_elem_type(base_type)
            g.sb.write_string('${fixed_len}')
            return true
        }
        field_type := g.lookup_struct_field_type_by_name(base_type, field_name) or { return false }
        if field_type == '' {
            return false
        }
        use_ptr := cur_type.ends_with('*') || cur_type == 'chan'
            || (i == 1 && root in g.cur_fn_mut_params)
        selector := if use_ptr { '->' } else { '.' }
        owner := g.embedded_owner_for(base_type, field_name)
        field_c_name := escape_c_keyword(field_name)
        if owner != '' {
            segments << '${selector}${escape_c_keyword(owner)}.${field_c_name}'
        } else {
            segments << '${selector}${field_c_name}'
        }
        cur_type = field_type
    }
    g.sb.write_string(c_local_name(root))
    for segment in segments {
        g.sb.write_string(segment)
    }
    return true
}

fn (mut g Gen) plain_local_selector_type(sel ast.SelectorExpr) ?string {
    if g.comptime_field_var != '' || g.comptime_method_var != '' {
        return none
    }
    parts := cleanc_selector_expr_parts(sel)
    if parts.len < 2 {
        return none
    }
    root := parts[0]
    if root == '' {
        return none
    }
    mut cur_type := g.runtime_local_types[root] or { return none }
    for i in 1 .. parts.len {
        field_name := parts[i]
        if field_name == '' {
            return none
        }
        base_type := strip_pointer_type_name(cur_type)
        if base_type == '' || base_type == 'string' || base_type in primitive_types
            || base_type in ['void', 'void*', 'voidptr'] || base_type in g.sum_type_variants
            || g.is_interface_type(base_type) {
            return none
        }
        if cur_type.starts_with('_option_') || cur_type.starts_with('_result_') {
            return none
        }
        cur_type = g.lookup_struct_field_type_by_name(base_type, field_name) or { return none }
    }
    return cur_type
}

// Helper to extract FnType from an Expr (handles ast.Type wrapping)
fn (mut g Gen) expr(node ast.Expr) {
    if node is ast.SelectorExpr && g.gen_plain_index_selector_expr(node) {
        return
    }
    if node is ast.SelectorExpr && g.gen_plain_local_selector_expr(node) {
        return
    }
    if !expr_has_valid_data(node) {
        g.sb.write_string('0 /* corrupt expr */')
        return
    }
    if node is ast.CallExpr && g.try_gen_orm_create_call_expr(node) {
        return
    }
    match node {
        ast.BasicLiteral {
            if node.kind == .key_true {
                g.sb.write_string('true')
            } else if node.kind == .key_false {
                g.sb.write_string('false')
            } else if node.kind == .char {
                mut raw_value := ''
                raw_value = strip_literal_quotes(node.value)
                if raw_value.len > 1 && raw_value[0] != `\\` {
                    // Multi-byte UTF-8 character: emit as numeric codepoint
                    runes := raw_value.runes()
                    if runes.len > 0 {
                        g.sb.write_string(int(runes[0]).str())
                    } else {
                        g.sb.write_string("'${raw_value}'")
                    }
                } else {
                    escaped := escape_char_literal_content(raw_value)
                    g.sb.write_u8(`'`)
                    g.sb.write_string(escaped)
                    g.sb.write_u8(`'`)
                }
            } else {
                g.sb.write_string(sanitize_c_number_literal(node.value))
            }
        }
        ast.StringLiteral {
            mut val := strip_literal_quotes(node.value)
            if node.kind == .raw {
                // Raw strings: backslash is literal, escape it for C
                val = val.replace('\\', '\\\\')
            } else {
                // Process V line continuations: `\` + newline + whitespace → strip
                val = process_line_continuations(val)
            }
            c_lit := c_string_literal_content_to_c(val)
            if node.kind == .c {
                // C string literal: emit raw C string
                g.sb.write_string(c_lit)
            } else {
                // Use sizeof on the emitted C literal so escape sequences
                // (e.g. `\t`) get the correct runtime byte length.
                g.sb.write_string(c_static_v_string_expr_from_c_literal(c_lit))
            }
        }
        ast.LifetimeExpr {
            g.sb.write_string('lt__')
            g.sb.write_string(node.name)
        }
        ast.Ident {
            g.mark_needed_ierror_wrapper_from_ident(node.name)
            if node.name == 'nil' {
                g.sb.write_string('NULL')
            } else if node.name == '@FN' || node.name == '@METHOD' || node.name == '@FUNCTION' {
                fn_name := g.cur_fn_name
                g.sb.write_string(c_static_v_string_expr(fn_name))
            } else if node.name == '@LOCATION' {
                fn_name := g.cur_fn_name
                g.sb.write_string(c_static_v_string_expr('${g.cur_module}.${fn_name}'))
            } else if node.name == '@MOD' {
                mod_name := g.cur_module
                g.sb.write_string(c_static_v_string_expr(mod_name))
            } else if node.name == '@FILE' {
                g.sb.write_string(c_v_string_expr_from_ptr_len('__FILE__', 'sizeof(__FILE__)-1',
                    true))
            } else if node.name == '@LINE' {
                g.sb.write_string('__LINE__')
            } else if node.name == '@VCURRENTHASH' || node.name == '@VHASH' {
                g.sb.write_string(c_static_v_string_expr(g.get_v_hash()))
            } else if node.name == '@VEXE' {
                g.sb.write_string(c_empty_v_string_expr())
            } else if node.name == '@VEXEROOT' || node.name == '@VROOT' {
                vroot := if g.pref != unsafe { nil } { g.pref.vroot } else { '' }
                g.sb.write_string(c_static_v_string_expr(vroot))
            } else if node.name.starts_with('__type_id_') {
                type_name := node.name['__type_id_'.len..]
                type_id := interface_type_id_for_name(type_name)
                g.sb.write_string('${type_id}')
            } else {
                is_local_var := g.get_local_var_c_type(node.name) != none
                mut handled_ident := false
                if !is_local_var {
                    if c_name := g.renamed_const_name_for_ident(node.name) {
                        g.sb.write_string(c_name)
                        handled_ident = true
                    }
                }
                if handled_ident {
                    return
                }
                const_key := 'const_${g.cur_module}__${node.name}'
                global_key := 'global_${g.cur_module}__${node.name}'
                module_storage_name := module_storage_c_name(g.cur_module, node.name)
                if !is_local_var && node.name in g.global_var_types
                    && module_storage_name !in g.global_var_types {
                    g.sb.write_string(node.name)
                } else if !is_local_var && module_storage_name in g.c_extern_module_storage {
                    g.sb.write_string(g.c_extern_module_storage[module_storage_name])
                } else if !is_local_var && module_storage_name in g.module_storage_vars {
                    g.sb.write_string(module_storage_name)
                } else if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
                    && !node.name.contains('__') && !is_local_var
                    && ((const_key in g.emitted_types || global_key in g.emitted_types)
                    || g.is_module_local_const_or_global(node.name)) {
                    g.sb.write_string('${g.cur_module}__${node.name}')
                } else if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
                    && !node.name.contains('__') && !is_local_var && !g.is_module_ident(node.name)
                    && g.is_module_local_fn(node.name) && !g.is_type_name(node.name) {
                    g.sb.write_string('${g.cur_module}__${sanitize_fn_ident(node.name)}')
                } else {
                    mut ident_name := node.name
                    if g.cur_module != '' {
                        double_prefix := '${g.cur_module}__${g.cur_module}__'
                        if ident_name.starts_with(double_prefix) {
                            ident_name = ident_name[g.cur_module.len + 2..]
                        }
                    }
                    g.sb.write_string(c_local_name(ident_name))
                }
            }
        }
        ast.ParenExpr {
            g.sb.write_string('(')
            g.expr(node.expr)
            g.sb.write_string(')')
        }
        ast.InfixExpr {
            g.gen_infix_expr(&node)
        }
        ast.PrefixExpr {
            if node.op == .arrow && g.gen_channel_receive_expr(node) {
                return
            }
            // &T(x) in unsafe contexts is used as a pointer cast in V stdlib code.
            // Emit it as (T*)(x) so `*unsafe { &T(p) }` becomes `*((T*)p)`.
            if node.op == .amp {
                if is_nil_like_expr(node.expr) {
                    g.sb.write_string('NULL')
                    return
                }
                if node.expr is ast.CastExpr {
                    cast_expr := node.expr as ast.CastExpr
                    expr_type := g.get_expr_type(cast_expr.expr)
                    if (expr_type.starts_with('_option_') && option_value_type(expr_type) != '')
                        || (expr_type.starts_with('_result_')
                        && g.result_value_type(expr_type) != '') {
                        if expr_type.starts_with('_option_')
                            && g.cur_fn_ret_type.starts_with('_option_') {
                            g.sb.write_string('({ if (')
                            g.expr(cast_expr.expr)
                            g.sb.write_string('.state != 0) { return (${g.cur_fn_ret_type}){ .state = 2 }; } &')
                            g.gen_unwrapped_value_expr(cast_expr.expr)
                            g.sb.write_string('; })')
                            return
                        }
                        g.sb.write_string('&')
                        g.gen_unwrapped_value_expr(cast_expr.expr)
                        return
                    }
                }
                // &&T(x) is a pointer-to-pointer cast pattern used in builtin code.
                // Lower it directly to (T**)(x) instead of taking address of a cast rvalue.
                if node.expr is ast.PrefixExpr && node.expr.op == .amp {
                    inner := node.expr as ast.PrefixExpr
                    if inner.expr is ast.CastExpr {
                        target_type := g.expr_type_to_c(inner.expr.typ)
                        g.sb.write_string('((${target_type}**)(')
                        g.expr(inner.expr.expr)
                        g.sb.write_string('))')
                        return
                    }
                    if inner.expr is ast.CallOrCastExpr
                        && g.call_or_cast_lhs_is_type(inner.expr.lhs) {
                        mut target_type := g.expr_type_to_c(inner.expr.lhs)
                        if !target_type.ends_with('*') {
                            target_type += '*'
                        }
                        g.sb.write_string('((${target_type}*)(')
                        g.expr(inner.expr.expr)
                        g.sb.write_string('))')
                        return
                    }
                }
                if node.expr is ast.IndexExpr {
                    idx := node.expr as ast.IndexExpr
                    if idx.lhs is ast.Ident {
                        if idx.lhs.name in g.fixed_array_globals || idx.lhs.name == 'rune_maps' {
                            g.sb.write_string('&')
                            g.expr(idx.lhs)
                            g.sb.write_string('[')
                            g.expr(idx.expr)
                            g.sb.write_string(']')
                            return
                        }
                        if raw_type := g.get_raw_type(idx.lhs) {
                            if raw_type is types.ArrayFixed {
                                // Fixed arrays: &arr[i]
                                g.sb.write_string('&')
                                g.expr(idx.lhs)
                                g.sb.write_string('[')
                                g.expr(idx.expr)
                                g.sb.write_string(']')
                                return
                            }
                        }
                        lhs_type := g.get_expr_type(idx.lhs)
                        // Fixed arrays: direct C array indexing (no .data field)
                        if lhs_type.starts_with('Array_fixed_') {
                            g.sb.write_string('&')
                            g.expr(idx.lhs)
                            g.sb.write_string('[')
                            g.expr(idx.expr)
                            g.sb.write_string(']')
                            return
                        }
                        if lhs_type == 'array' || lhs_type.starts_with('Array_') {
                            mut elem_type := g.get_expr_type(idx)
                            if elem_type == '' || elem_type == 'int' {
                                if lhs_type.starts_with('Array_') {
                                    elem_type = lhs_type['Array_'.len..].trim_right('*')
                                }
                            }
                            if elem_type == '' {
                                elem_type = 'u8'
                            }
                            g.sb.write_string('&((')
                            g.sb.write_string(elem_type)
                            g.sb.write_string('*)')
                            g.expr(idx.lhs)
                            if lhs_type.ends_with('*') {
                                g.sb.write_string('->data)[')
                            } else {
                                g.sb.write_string('.data)[')
                            }
                            g.expr(idx.expr)
                            g.sb.write_string(']')
                            return
                        }
                    }
                }
                addr_inner := unwrap_sum_common_field_address_base(node.expr)
                if addr_inner is ast.SelectorExpr {
                    sel := addr_inner as ast.SelectorExpr
                    if g.gen_sum_common_field_selector_addr(sel) {
                        return
                    }
                }
                if node.expr is ast.SelectorExpr {
                    sel := node.expr as ast.SelectorExpr
                    saved_sb := g.sb
                    g.sb = strings.new_builder(128)
                    has_cast_field_access := g.gen_c_pointer_cast_selector_field_access(sel)
                    cast_field_access := g.sb.str()
                    g.sb = saved_sb
                    if has_cast_field_access {
                        g.sb.write_string(cast_field_access)
                        return
                    }
                    c_typedef := g.c_typedef_for_interface_object_access(sel)
                    if c_typedef != '' {
                        g.sb.write_string('&(((${c_typedef}*)(')
                        g.expr(sel.lhs)
                        g.sb.write_string('))->${escape_c_keyword(sel.rhs.name)})')
                        return
                    }
                    field_idx := vector_field_index(sel.rhs.name)
                    if field_idx >= 0 {
                        mut lhs_type := g.get_expr_type(sel.lhs)
                        if lhs_type in ['', 'int'] {
                            if raw := g.get_raw_type(sel.lhs) {
                                lhs_type = g.types_type_to_c(raw)
                            }
                        }
                        mut elem_type := vector_elem_type_for_name(lhs_type)
                        if elem_type == '' && sel.lhs is ast.IndexExpr {
                            base_type := g.get_expr_type(sel.lhs.lhs)
                            if base_type.contains('Simd') {
                                elem_type = if base_type.contains('Float') {
                                    'f32'
                                } else if base_type.contains('Uint') || base_type.contains('U32') {
                                    'u32'
                                } else {
                                    'i32'
                                }
                            }
                        }
                        if elem_type != '' {
                            g.sb.write_string('(&(((')
                            g.sb.write_string(elem_type)
                            g.sb.write_string('*)(&(')
                            g.expr(sel.lhs)
                            g.sb.write_string(')))[')
                            g.sb.write_string(field_idx.str())
                            g.sb.write_string(']))')
                            return
                        }
                    }
                }
                if node.expr is ast.CallExpr {
                    if node.expr.args.len == 1 && node.expr.lhs is ast.Ident
                        && (g.is_type_name(node.expr.lhs.name)
                        || g.is_c_type_name(node.expr.lhs.name)
                        || node.expr.lhs.name.starts_with('cgltf_')) {
                        mut target_type := g.expr_type_to_c(node.expr.lhs)
                        if target_type == '' || target_type == 'int' {
                            target_type = node.expr.lhs.name
                        }
                        // `&T(value)` where value is a struct rvalue (e.g. string) cannot
                        // be lowered to `(T*)(value)` — that casts an rvalue to a pointer.
                        // Emit a temporary copy so the address is valid. Only applies when
                        // arg is a value (not pointer) and target_type is a non-pointer
                        // struct alias compatible with the arg type.
                        arg_type := g.get_expr_type(node.expr.args[0])
                        if !target_type.ends_with('*') && !arg_type.ends_with('*')
                            && arg_type == 'string' && g.alias_resolves_to_string(target_type) {
                            g.tmp_counter++
                            tmp := '_aof${g.tmp_counter}'
                            g.sb.write_string('({ ${target_type} ${tmp} = ')
                            g.expr(node.expr.args[0])
                            g.sb.write_string('; &${tmp}; })')
                            return
                        }
                        g.sb.write_string('((${target_type}*)(')
                        g.expr(node.expr.args[0])
                        g.sb.write_string('))')
                        return
                    }
                    if node.expr.args.len == 1 && node.expr.lhs is ast.SelectorExpr {
                        sel := node.expr.lhs as ast.SelectorExpr
                        arg := node.expr.args[0]
                        if sel.lhs is ast.Ident {
                            lhs_ident := sel.lhs as ast.Ident
                            if lhs_ident.name == 'C' && (g.is_c_type_name(sel.rhs.name)
                                || sel.rhs.name.starts_with('cgltf_')
                                || is_none_like_expr(arg)
                                || (arg is ast.BasicLiteral && arg.value == '0')) {
                                mut target_type := g.expr_type_to_c(node.expr.lhs)
                                if target_type == '' || target_type == 'int' {
                                    target_type = sel.rhs.name
                                }
                                g.sb.write_string('((${target_type}*)(')
                                g.expr(arg)
                                g.sb.write_string('))')
                                return
                            }
                        }
                    }
                }
                if node.expr is ast.CastExpr {
                    target_type := g.expr_type_to_c(node.expr.typ)
                    // For interface types, generate vtable construction on the heap
                    if g.gen_heap_interface_cast(target_type, node.expr.expr) {
                        return
                    }
                    if g.gen_heap_address_of_cast_expr(node.expr, target_type) {
                        return
                    }
                    // `&T(value)` where T aliases the value's type (e.g. NamedType=string)
                    // cannot be lowered to `(T*)(value)` — that casts an rvalue to a pointer.
                    // Emit a temporary copy instead. Only applies for compatible alias casts;
                    // reinterpret casts of pointer args use the original `(T*)(v)` form.
                    arg_type := g.get_expr_type(node.expr.expr)
                    if !target_type.ends_with('*') && !arg_type.ends_with('*')
                        && arg_type == 'string' && g.alias_resolves_to_string(target_type) {
                        g.tmp_counter++
                        tmp := '_aof${g.tmp_counter}'
                        g.sb.write_string('({ ${target_type} ${tmp} = ')
                        g.expr(node.expr.expr)
                        g.sb.write_string('; &${tmp}; })')
                        return
                    }
                    g.sb.write_string('((${target_type}*)(')
                    g.expr(node.expr.expr)
                    g.sb.write_string('))')
                    return
                }
                if node.expr is ast.CallOrCastExpr && g.call_or_cast_lhs_is_type(node.expr.lhs) {
                    base_target_type := g.expr_type_to_c(node.expr.lhs)
                    // `&T(value)` where T aliases the value's type (e.g. NamedType=string)
                    // cannot be lowered to `(T*)(value)` — that casts an rvalue to a pointer.
                    // Emit a temporary copy instead. Only applies for compatible alias casts.
                    arg_type := g.get_expr_type(node.expr.expr)
                    if !base_target_type.ends_with('*') && !arg_type.ends_with('*')
                        && arg_type == 'string' && g.alias_resolves_to_string(base_target_type) {
                        g.tmp_counter++
                        tmp := '_aof${g.tmp_counter}'
                        g.sb.write_string('({ ${base_target_type} ${tmp} = ')
                        g.expr(node.expr.expr)
                        g.sb.write_string('; &${tmp}; })')
                        return
                    }
                    mut target_type := base_target_type
                    if !target_type.ends_with('*') {
                        target_type += '*'
                    }
                    g.sb.write_string('((${target_type})(')
                    g.expr(node.expr.expr)
                    g.sb.write_string('))')
                    return
                }
                if node.expr is ast.ModifierExpr {
                    if node.expr.expr is ast.CastExpr {
                        target_type := g.expr_type_to_c(node.expr.expr.typ)
                        g.sb.write_string('((${target_type}*)(')
                        g.expr(node.expr.expr.expr)
                        g.sb.write_string('))')
                        return
                    }
                }
                if node.expr is ast.ParenExpr {
                    if node.expr.expr is ast.CastExpr {
                        target_type := g.expr_type_to_c(node.expr.expr.typ)
                        g.sb.write_string('((${target_type}*)(')
                        g.expr(node.expr.expr.expr)
                        g.sb.write_string('))')
                        return
                    }
                    if node.expr.expr is ast.CallExpr {
                        if node.expr.expr.args.len == 1 {
                            target_type := g.expr_type_to_c(node.expr.expr.lhs)
                            g.sb.write_string('((${target_type}*)(')
                            g.expr(node.expr.expr.args[0])
                            g.sb.write_string('))')
                            return
                        }
                    }
                }
            }
            // Handle &fn_call() where fn_call returns a struct (rvalue)
            // Can't take address of rvalue, use compound statement expression
            if node.op == .amp && node.expr is ast.CallExpr {
                if !(node.expr.args.len == 1 && node.expr.lhs is ast.Ident
                    && g.is_type_name(node.expr.lhs.name)) {
                    // This is a function call, not a type cast
                    ret_type := g.get_expr_type(node.expr)
                    if ret_type != '' && ret_type != 'void' && ret_type != 'int' {
                        tmp_name := '_sumtmp${g.tmp_counter}'
                        g.tmp_counter++
                        g.sb.write_string('({ ${ret_type} ${tmp_name} = ')
                        g.expr(node.expr)
                        g.sb.write_string('; &${tmp_name}; })')
                        return
                    }
                }
            }
            // Fixed array literal: &[1.1, 2.2]! needs type prefix for compound literal
            if node.op == .amp && node.expr is ast.ArrayInitExpr {
                if !g.is_dynamic_array_type(node.expr.typ) && node.expr.exprs.len > 0 {
                    elem_type := g.extract_array_elem_type(node.expr.typ)
                    if elem_type != '' {
                        g.sb.write_string('&(${elem_type}[${node.expr.exprs.len}]){')
                        is_iface_elem := g.is_interface_type(elem_type)
                        for i in 0 .. node.expr.exprs.len {
                            e := node.expr.exprs[i]
                            if i > 0 {
                                g.sb.write_string(', ')
                            }
                            if is_iface_elem && g.gen_interface_cast(elem_type, e) {
                                // interface wrapping handled
                            } else {
                                g.expr(e)
                            }
                        }
                        g.sb.write_string('}')
                        return
                    }
                }
                g.sb.write_string('&')
                g.expr(node.expr)
                return
            }
            // V `&Type{...}` must allocate on the heap.
            // Taking the address of a C compound literal here would create a dangling pointer.
            if node.op == .amp && node.expr is ast.InitExpr {
                type_name := g.expr_type_to_c(node.expr.typ)
                tmp_name := '_heap_t${g.tmp_counter}'
                g.tmp_counter++
                malloc_call := g.c_heap_malloc_call('sizeof(${type_name})')
                g.sb.write_string('({ ${type_name}* ${tmp_name} = (${type_name}*)${malloc_call}; *${tmp_name} = ')
                g.expr(node.expr)
                g.sb.write_string('; ${tmp_name}; })')
                return
            }
            if node.op == .mul {
                if raw_type := g.get_raw_type(node.expr) {
                    // Pointer to interface: *ptr just dereferences to get the interface struct.
                    // Do NOT extract ._object — that's for smartcasts, not plain deref.
                    if raw_type is types.Pointer && raw_type.base_type is types.Interface {
                        g.sb.write_string('(*(')
                        g.expr(node.expr)
                        g.sb.write_string('))')
                        return
                    }
                    is_iface := raw_type is types.Interface
                    if is_iface {
                        // If the expression is actually a pointer (e.g., mut for-in loop var
                        // registered as Interface but declared as Interface*), just deref normally.
                        if g.expr_is_pointer(node.expr) {
                            g.sb.write_string('(*(')
                            g.expr(node.expr)
                            g.sb.write_string('))')
                            return
                        }
                        target_type := g.get_expr_type(node)
                        if target_type != '' && target_type != 'int' {
                            g.sb.write_string('(*((')
                            g.sb.write_string(target_type)
                            g.sb.write_string('*)(')
                            g.expr(node.expr)
                            g.sb.write_string('._object)))')
                            return
                        }
                    }
                }
            }
            if node.op == .amp {
                // &*(ptr) cancellation: when taking address of a deref of a pointer,
                // the two operations cancel out. This avoids &(rvalue) errors when
                // the deref gets null-guard expansion for sum type data pointers.
                inner := g.unwrap_parens(node.expr)
                if inner is ast.PrefixExpr && inner.op == .mul {
                    if g.expr_is_pointer(inner.expr) || g.expr_produces_pointer(inner.expr) {
                        g.expr(inner.expr)
                        return
                    }
                }
                // Generate inner expression to check if it produces a GCC statement
                // expression `({...})` which is an rvalue — can't take address of rvalue.
                saved_sb := g.sb
                g.sb = strings.new_builder(256)
                g.expr(node.expr)
                inner_code := g.sb.str()
                g.sb = saved_sb
                // Detect rvalue expressions: GCC statement expressions ({...}),
                // or null-guarded ternaries (ptr ? *ptr : (T){0}) from smartcast.
                is_rvalue := inner_code.starts_with('({') || inner_code.starts_with('(({')
                    || inner_code.contains('){0})')
                if is_rvalue {
                    inner_type := g.get_expr_type(node.expr)
                    if inner_type != '' && inner_type != 'int' && inner_type != 'void' {
                        tmp_name := '_addr_t${g.tmp_counter}'
                        g.tmp_counter++
                        g.sb.write_string('({ ${inner_type} ${tmp_name} = ${inner_code}; &${tmp_name}; })')
                    } else {
                        g.sb.write_string('&${inner_code}')
                    }
                } else {
                    g.sb.write_string('&${inner_code}')
                }
            } else {
                // For dereference of a sum type data pointer (from smartcast),
                // add null guard to avoid crash on zero-initialized sum types.
                if node.op == .mul && g.is_sum_data_ptr_deref(node.expr) {
                    saved_sb := g.sb
                    g.sb = strings.new_builder(256)
                    g.expr(node.expr)
                    ptr_code := g.sb.str()
                    g.sb = saved_sb
                    cast_type := g.get_cast_expr_type_name(node.expr)
                    if cast_type != '' {
                        g.sb.write_string('(${ptr_code} ? (*(${ptr_code})) : (${cast_type}){0})')
                    } else {
                        g.sb.write_string('*(')
                        g.sb.write_string(ptr_code)
                        g.sb.write_string(')')
                    }
                } else {
                    op := match node.op {
                        .minus { '-' }
                        .not { '!' }
                        .mul { '*' }
                        .bit_not { '~' }
                        else { '' }
                    }

                    g.sb.write_string(op)
                    g.expr(node.expr)
                }
            }
        }
        ast.CallExpr {
            g.call_expr(node.lhs, node.args)
        }
        ast.CallOrCastExpr {
            g.gen_call_or_cast_expr(node)
        }
        ast.SelectorExpr {
            sel := node as ast.SelectorExpr
            sel_expr := ast.Expr(sel)
            lhs_expr := sel.lhs
            rhs_name := sel.rhs.name
            lhs_name := if lhs_expr is ast.Ident { sel.lhs.name() } else { '' }
            // Comptime field access interception: field.name, field.typ, val.$(field.name), etc.
            if g.comptime_field_var != '' {
                if g.gen_comptime_field_selector(sel) {
                    return
                }
            }
            // Comptime method access interception: method.name, method.attrs, method.args, etc.
            if g.comptime_method_var != '' {
                if g.gen_comptime_method_selector(sel) {
                    return
                }
            }
            // C.<ident> references C macros/constants directly (e.g. C.EOF -> EOF).
            if lhs_expr is ast.Ident {
                if lhs_name == 'C' {
                    g.sb.write_string(rhs_name)
                    return
                }
            }
            if rhs_name == 'bytestr' {
                if lhs_expr is ast.IndexExpr && lhs_expr.expr is ast.RangeExpr {
                    g.sb.write_string('Array_u8__bytestr(')
                    g.expr(lhs_expr)
                    g.sb.write_string(')')
                    return
                }
                if lhs_expr is ast.CallExpr && lhs_expr.lhs is ast.Ident {
                    call_lhs := lhs_expr.lhs as ast.Ident
                    if call_lhs.name in ['array__slice', 'array__slice_ni', 'builtin__array__slice',
                        'builtin__array__slice_ni'] {
                        g.sb.write_string('Array_u8__bytestr(')
                        g.expr(lhs_expr)
                        g.sb.write_string(')')
                        return
                    }
                }
                elem_type := g.infer_array_elem_type_from_expr(lhs_expr).trim_right('*')
                if elem_type == 'u8' || elem_type == 'byte' {
                    g.sb.write_string('Array_u8__bytestr(')
                    g.expr(lhs_expr)
                    g.sb.write_string(')')
                    return
                }
            }
            if g.gen_plain_index_selector_expr(sel) {
                return
            }
            if g.gen_plain_local_selector_expr(sel) {
                return
            }
            if rhs_name == 'name' {
                if lhs_expr is ast.Ident {
                    // Generic type parameter access: T.name -> string literal with type name.
                    if concrete := g.active_generic_types[lhs_name] {
                        g.sb.write_string(c_static_v_string_expr(concrete.name()))
                        return
                    }
                    if is_generic_placeholder_type_name(lhs_name) {
                        g.sb.write_string(c_static_v_string_expr(lhs_name))
                        return
                    }
                }
                if type_name := g.typeof_expr_type_name(lhs_expr) {
                    g.sb.write_string(c_static_v_string_expr(type_name))
                    return
                }
                if raw_lhs_type := g.get_raw_type(lhs_expr) {
                    if raw_lhs_type is types.Enum {
                        enum_name := g.types_type_to_c(raw_lhs_type)
                        if enum_name != '' && !is_generic_placeholder_c_type_name(enum_name) {
                            g.sb.write_string('${enum_name}__str(')
                            g.expr(lhs_expr)
                            g.sb.write_string(')')
                            return
                        }
                    }
                }
                lhs_type_for_name := g.get_expr_type(lhs_expr).trim_right('*')
                if lhs_type_for_name != '' && lhs_type_for_name != 'int'
                    && g.is_enum_type(lhs_type_for_name) {
                    g.sb.write_string('${lhs_type_for_name}__str(')
                    g.expr(lhs_expr)
                    g.sb.write_string(')')
                    return
                }
            }
            if lhs_expr is ast.Ident {
                if lhs_name in ['bool', 'string', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16',
                    'u32', 'u64', 'f32', 'f64', 'byte', 'rune'] {
                    if enum_name := g.enum_value_to_enum[rhs_name] {
                        if g.should_use_known_enum_field(enum_name, rhs_name) {
                            g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                            return
                        }
                    }
                }
                is_known_var := g.local_var_c_type_for_expr(lhs_expr) != none
                if !is_known_var && !g.is_module_ident(lhs_name) {
                    if enum_name := g.get_expr_type_from_env(sel_expr) {
                        if enum_name != '' && g.is_enum_type(enum_name) {
                            g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                            return
                        }
                    }
                    if lhs_name in ['bool', 'string', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16',
                        'u32', 'u64', 'f32', 'f64', 'byte', 'rune'] {
                        if enum_name := g.enum_value_to_enum[rhs_name] {
                            if g.should_use_known_enum_field(enum_name, rhs_name) {
                                g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                                return
                            }
                        }
                    }
                }
            }
            // If checker already resolved this selector as an enum value, use Enum__field.
            if raw_type := g.get_raw_type(sel_expr) {
                if raw_type is types.Enum {
                    // Verify the field actually belongs to this enum.
                    // The checker may annotate branch values with the match expression's
                    // enum type instead of the return type's enum.
                    mut field_valid := false
                    for f in raw_type.fields {
                        if f.name == rhs_name {
                            field_valid = true
                            break
                        }
                    }
                    if field_valid {
                        mut emit_enum_value := false
                        if lhs_expr is ast.EmptyExpr {
                            emit_enum_value = true
                        } else if lhs_expr is ast.Ident {
                            if g.is_enum_type(lhs_name) {
                                emit_enum_value = true
                            } else if !g.is_module_ident(lhs_name) {
                                emit_enum_value = g.local_var_c_type_for_expr(lhs_expr) == none
                            }
                        }
                        if emit_enum_value {
                            enum_name := g.types_type_to_c(raw_type)
                            if !is_generic_placeholder_c_type_name(enum_name) {
                                g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                                return
                            }
                        }
                    }
                }
            }
            if g.gen_sum_narrowed_selector(sel) {
                return
            }
            if g.gen_sum_narrowed_selector_lhs_field(sel) {
                return
            }
            if g.gen_sum_common_field_selector(sel) {
                return
            }
            if g.gen_sum_variant_field_selector(sel) {
                return
            }
            if lhs_expr is ast.SelectorExpr {
                lhs_sel := lhs_expr as ast.SelectorExpr
                if lhs_sel.lhs is ast.Ident {
                    lhs_mod := lhs_sel.lhs as ast.Ident
                    mut module_names := [lhs_mod.name]
                    resolved_mod_name := g.resolve_module_name(lhs_mod.name)
                    if resolved_mod_name !in module_names {
                        module_names << resolved_mod_name
                    }
                    for mod_name in module_names {
                        enum_name := '${mod_name}__${lhs_sel.rhs.name}'
                        if g.enum_has_field(enum_name, rhs_name) {
                            g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                            return
                        }
                    }
                }
            }
            if rhs_name == 'values' {
                if raw_type := g.get_raw_type(sel_expr) {
                    if raw_type is types.Array {
                        mut enum_name := ''
                        if lhs_expr is ast.Ident {
                            lhs_ident := lhs_expr as ast.Ident
                            if g.is_enum_type(lhs_ident.name) {
                                enum_name = lhs_ident.name
                            } else if g.cur_module != '' && g.cur_module != 'main'
                                && g.cur_module != 'builtin' {
                                qualified := '${g.cur_module}__${lhs_ident.name}'
                                if g.is_enum_type(qualified) {
                                    enum_name = qualified
                                }
                            }
                        } else if lhs_expr is ast.SelectorExpr {
                            lhs_sel := lhs_expr as ast.SelectorExpr
                            if lhs_sel.lhs is ast.Ident {
                                lhs_mod := lhs_sel.lhs as ast.Ident
                                mod_name := g.resolve_module_name(lhs_mod.name)
                                qualified := '${mod_name}__${lhs_sel.rhs.name}'
                                if g.is_enum_type(qualified) {
                                    enum_name = qualified
                                }
                            }
                        }
                        if enum_name != '' {
                            g.sb.write_string('${enum_name}__values_array')
                            return
                        }
                    }
                }
            }
            lhs_type := g.get_expr_type(lhs_expr)
            if rhs_name in ['x', 'y', 'z', 'w'] {
                base_lhs_type := lhs_type.trim_right('*')
                if base_lhs_type in primitive_types {
                    if lhs_type.ends_with('*') {
                        g.sb.write_string('(*')
                        g.expr(lhs_expr)
                        g.sb.write_string(')')
                    } else {
                        g.expr(lhs_expr)
                    }
                    return
                }
            }
            if rhs_name == 'data' {
                if lhs_type.starts_with('_result_') && g.result_value_type(lhs_type) != '' {
                    g.gen_unwrapped_value_expr(lhs_expr)
                    return
                }
                if lhs_type.starts_with('_option_') && option_value_type(lhs_type) != '' {
                    g.gen_unwrapped_value_expr(lhs_expr)
                    return
                }
                if lhs_expr is ast.Ident && lhs_expr.name.starts_with('_or_t') {
                    payload_type := g.get_expr_type(sel_expr)
                    if payload_type != ''
                        && payload_type !in ['int_literal', 'float_literal', 'void'] {
                        if g.gen_unwrapped_payload_expr(lhs_expr, '', payload_type) {
                            return
                        }
                    }
                }
            }
            // Transformer-generated or-block temps (`_or_t*`) can end up with a
            // field-name mismatch when the checker resolved the call to the wrong
            // overload (e.g. `header.get` typed as `http.get`). Trust the temp's
            // actual C type and rewrite the field name accordingly.
            if lhs_expr is ast.Ident && lhs_expr.name.starts_with('_or_t') {
                if rhs_name == 'is_error' && lhs_type.starts_with('_option_') {
                    g.sb.write_string(lhs_expr.name)
                    g.sb.write_string('.state')
                    return
                }
                if rhs_name == 'state' && lhs_type.starts_with('_result_') {
                    g.sb.write_string(lhs_expr.name)
                    g.sb.write_string('.is_error')
                    return
                }
            }
            if variant_field := g.sum_data_variant_selector_field(sel) {
                g.expr(lhs_expr)
                g.sb.write_string('.${variant_field}')
                return
            }
            if lhs_type.trim_right('*') == 'chan' && rhs_name in ['len', 'closed'] {
                if rhs_name == 'len' {
                    g.sb.write_string('((int)atomic_load_u32(&((sync__Channel*)(')
                    g.expr(lhs_expr)
                    g.sb.write_string('))->read_avail))')
                } else {
                    g.sb.write_string('(atomic_load_u16(&((sync__Channel*)(')
                    g.expr(lhs_expr)
                    g.sb.write_string('))->closed) != 0)')
                }
                return
            }
            lhs_string_type := g.builtin_string_field_lhs_type(lhs_expr, rhs_name)
            if lhs_string_type != '' {
                use_ptr := lhs_string_type.ends_with('*')
                selector := if use_ptr { '->' } else { '.' }
                g.expr(lhs_expr)
                g.sb.write_string('${selector}${escape_c_keyword(rhs_name)}')
                return
            }
            // Fixed-size array `.len` becomes compile-time length.
            if rhs_name == 'len' {
                if lhs_expr is ast.Ident {
                    lhs_ident := lhs_expr as ast.Ident
                    mut fixed_name := lhs_ident.name
                    module_const_key := 'const_${g.cur_module}__${lhs_ident.name}'
                    if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin'
                        && module_const_key in g.emitted_types {
                        fixed_name = '${g.cur_module}__${lhs_ident.name}'
                    }
                    if fixed_name in g.fixed_array_globals {
                        g.sb.write_string('((int)(sizeof(${fixed_name}) / sizeof(${fixed_name}[0])))')
                        return
                    }
                    if fixed_name in ['strconv__pow5_inv_split_32', 'strconv__pow5_split_32',
                        'strconv__pow5_inv_split_64_x', 'strconv__pow5_split_64_x'] {
                        g.sb.write_string('((int)(sizeof(${fixed_name}) / sizeof(${fixed_name}[0])))')
                        return
                    }
                }
                if lhs_expr is ast.SelectorExpr {
                    lhs_sel := lhs_expr as ast.SelectorExpr
                    if lhs_sel.lhs is ast.Ident {
                        lhs_mod := lhs_sel.lhs as ast.Ident
                        if g.is_module_ident(lhs_mod.name) {
                            mod_name := g.resolve_module_name(lhs_mod.name)
                            fixed_name := '${mod_name}__${lhs_sel.rhs.name}'
                            if fixed_name in g.fixed_array_globals {
                                g.sb.write_string('((int)(sizeof(${fixed_name}) / sizeof(${fixed_name}[0])))')
                                return
                            }
                        }
                    }
                    if g.is_fixed_array_selector(lhs_sel) {
                        g.sb.write_string('((int)(sizeof(')
                        g.expr(lhs_expr)
                        g.sb.write_string(') / sizeof((')
                        g.expr(lhs_expr)
                        g.sb.write_string(')[0])))')
                        return
                    }
                }
                if raw_type := g.get_raw_type(lhs_expr) {
                    if raw_type is types.ArrayFixed {
                        g.sb.write_string('((int)(sizeof(')
                        g.expr(lhs_expr)
                        g.sb.write_string(') / sizeof((')
                        g.expr(lhs_expr)
                        g.sb.write_string(')[0])))')
                        return
                    }
                }
            }
            // Enum shorthand: `.field` -> `EnumName__field` (using type checker info).
            if lhs_expr is ast.EmptyExpr {
                // The enum_value_to_enum map definitively tells us which enum owns a field.
                // Use it to validate/override type checker results that may be wrong
                // (e.g., match branch values annotated with the match expression's enum type
                // instead of the return type's enum).
                known_enum := g.enum_value_to_enum[rhs_name] or { '' }
                if raw_type := g.get_raw_type(sel_expr) {
                    if raw_type is types.Enum {
                        enum_name := g.types_type_to_c(raw_type)
                        if !is_generic_placeholder_c_type_name(enum_name)
                            && g.enum_has_field(enum_name, rhs_name) {
                            g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                            return
                        }
                    }
                }
                if enum_name := g.get_expr_type_from_env(sel_expr) {
                    if enum_name != '' && enum_name != 'int'
                        && !is_generic_placeholder_c_type_name(enum_name)
                        && g.is_enum_type(enum_name) {
                        if g.enum_has_field(enum_name, rhs_name) {
                            g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                            return
                        }
                    }
                }
                // Use the definitive enum field mapping
                if g.should_use_known_enum_field(known_enum, rhs_name) {
                    g.sb.write_string(g.enum_member_c_name(known_enum, rhs_name))
                    return
                }
                // Last resort: use function return type as context
                if g.cur_fn_ret_type != '' && g.is_enum_type(g.cur_fn_ret_type) {
                    g.sb.write_string(g.enum_member_c_name(g.cur_fn_ret_type, rhs_name))
                    return
                }
            }
            // module.const / module.var => module__const / module__var
            if lhs_expr is ast.Ident {
                lhs_ident := lhs_expr as ast.Ident
                is_local := g.local_var_c_type_for_expr(lhs_expr) != none
                if g.is_module_ident(lhs_ident.name) && !is_local {
                    mod_name := g.resolve_module_name(lhs_ident.name)
                    g.sb.write_string(g.module_selector_storage_c_name(mod_name, rhs_name))
                    return
                }
                if !is_local {
                    if mod_name := g.known_module_runtime_symbol(lhs_ident.name, rhs_name) {
                        g.sb.write_string(g.module_selector_storage_c_name(mod_name, rhs_name))
                        return
                    }
                }
            }
            // Method value in expression position: `obj.method` -> `Type__method`.
            // Prefer regular field access when a concrete field exists (e.g. `string.str`).
            if g.selector_field_type(sel) == '' {
                if method_value_name := g.selector_method_value_name(sel) {
                    mut target_type := g.get_expr_type(sel_expr)
                    if (target_type == '' || target_type == 'int') && g.env != unsafe { nil } {
                        if raw := g.get_raw_type(sel_expr) {
                            if raw is types.Alias {
                                alias_raw := raw
                                if alias_raw.base_type is types.FnType {
                                    target_type = alias_raw.name
                                }
                            }
                        }
                    }
                    if target_type != '' && target_type !in ['int', 'void*', 'voidptr'] {
                        if g.gen_bound_method_value_expr(sel, target_type) {
                            return
                        }
                        g.sb.write_string('((${target_type})${method_value_name})')
                    } else {
                        g.sb.write_string(method_value_name)
                    }
                    return
                }
            }
            if _ := g.selector_interface_data_field(sel) {
                mut use_ptr := g.selector_use_ptr(lhs_expr)
                if lhs_name in g.cur_fn_mut_params {
                    use_ptr = true
                } else if local_type := g.local_var_c_type_for_expr(lhs_expr) {
                    use_ptr = local_type.ends_with('*') || local_type == 'chan'
                }
                lhs_struct := g.selector_struct_name(lhs_expr)
                owner := g.embedded_owner_for(lhs_struct, rhs_name)
                field_name := escape_c_keyword(rhs_name)
                selector := if use_ptr { '->' } else { '.' }
                g.sb.write_string('(*(')
                g.expr(lhs_expr)
                if owner != '' {
                    g.sb.write_string('${selector}${escape_c_keyword(owner)}.${field_name}')
                } else {
                    g.sb.write_string('${selector}${field_name}')
                }
                g.sb.write_string('))')
                return
            }
            // Check if LHS is an enum type name -> emit EnumName__field
            if lhs_expr is ast.Ident {
                is_local_var := g.local_var_c_type_for_expr(lhs_expr) != none
                    || lhs_name in g.cur_fn_mut_params
                if !is_local_var && g.is_enum_type(lhs_name) {
                    enum_name := g.get_qualified_name(lhs_name)
                    g.sb.write_string(g.enum_member_c_name(enum_name, rhs_name))
                } else {
                    mut use_ptr := g.selector_use_ptr(lhs_expr)
                    if lhs_name in g.cur_fn_mut_params {
                        use_ptr = true
                    } else if local_type := g.local_var_c_type_for_expr(lhs_expr) {
                        // Local declaration type is authoritative for value vs pointer access.
                        use_ptr = local_type.ends_with('*') || local_type == 'chan'
                    }
                    lhs_struct := g.selector_struct_name(lhs_expr)
                    owner := g.embedded_owner_for(lhs_struct, rhs_name)
                    field_name := escape_c_keyword(rhs_name)
                    selector := if use_ptr { '->' } else { '.' }
                    g.expr(lhs_expr)
                    if owner != '' {
                        g.sb.write_string('${selector}${escape_c_keyword(owner)}.${field_name}')
                    } else {
                        g.sb.write_string('${selector}${field_name}')
                    }
                }
            } else {
                use_ptr := g.selector_use_ptr(lhs_expr)
                lhs_struct := g.selector_struct_name(lhs_expr)
                owner := g.embedded_owner_for(lhs_struct, rhs_name)
                field_name := escape_c_keyword(rhs_name)
                selector := if use_ptr { '->' } else { '.' }
                g.expr(lhs_expr)
                if owner != '' {
                    g.sb.write_string('${selector}${escape_c_keyword(owner)}.${field_name}')
                } else {
                    g.sb.write_string('${selector}${field_name}')
                }
            }
        }
        ast.IfExpr {
            g.gen_if_expr_value(&node)
        }
        ast.PostfixExpr {
            op := match node.op {
                .inc { '++' }
                .dec { '--' }
                else { '' }
            }

            if node.expr is ast.Ident && node.expr.name in g.cur_fn_mut_params {
                local_type := (g.get_local_var_c_type(node.expr.name) or { '' }).trim_space()
                if local_type.ends_with('*') {
                    g.sb.write_string('(*')
                    g.expr(node.expr)
                    g.sb.write_string(')')
                    g.sb.write_string(op)
                    return
                }
            }
            g.expr(node.expr)
            g.sb.write_string(op)
        }
        ast.ModifierExpr {
            g.expr(node.expr)
        }
        ast.CastExpr {
            g.gen_cast_expr(node)
        }
        ast.IndexExpr {
            g.gen_index_expr(node)
        }
        ast.ArrayInitExpr {
            g.gen_array_init_expr(node)
        }
        ast.InitExpr {
            g.gen_init_expr(node)
        }
        ast.MapInitExpr {
            panic('bug in v2 compiler: MapInitExpr should have been lowered in v2.transformer')
        }
        ast.MatchExpr {
            panic('bug in v2 compiler: MatchExpr should have been lowered in v2.transformer')
        }
        ast.UnsafeExpr {
            g.gen_unsafe_expr(node)
        }
        ast.OrExpr {
            panic('bug in v2 compiler: OrExpr should have been expanded in v2.transformer (${g.cur_file_name}:${g.cur_fn_name} pos=${node.pos} expr=${node.expr.name()})')
        }
        ast.AsCastExpr {
            g.gen_as_cast_expr(node)
        }
        ast.StringInterLiteral {
            g.gen_string_inter_literal(node)
        }
        ast.FnLiteral {
            g.gen_fn_literal(node)
        }
        ast.LambdaExpr {
            g.sb.write_string('/* [TODO] LambdaExpr */ NULL')
        }
        ast.ComptimeExpr {
            if node.expr is ast.IfExpr {
                g.gen_comptime_if_expr(node.expr)
                return
            }
            g.gen_comptime_expr(node)
        }
        ast.Keyword {
            g.gen_keyword(node)
        }
        ast.KeywordOperator {
            g.gen_keyword_operator(node)
        }
        ast.RangeExpr {
            panic('bug in v2 compiler: RangeExpr should have been lowered in v2.transformer (${g.cur_file_name}:${g.cur_fn_name} pos=${node.pos})')
        }
        ast.SelectExpr {
            g.sb.write_string('/* [TODO] SelectExpr */ 0')
        }
        ast.LockExpr {
            panic('bug in v2 compiler: LockExpr should have been lowered in v2.transformer')
        }
        ast.Type {
            if node is ast.NilType {
                g.sb.write_string('NULL')
            } else {
                g.sb.write_string('/* [TODO] Type */ 0')
            }
        }
        ast.AssocExpr {
            panic('bug in v2 compiler: AssocExpr should have been lowered in v2.transformer')
        }
        ast.Tuple {
            tuple_type := g.get_expr_type(node)
            g.sb.write_string('((${tuple_type}){')
            for i in 0 .. node.exprs.len {
                expr := node.exprs[i]
                if i > 0 {
                    g.sb.write_string(', ')
                }
                g.sb.write_string('.arg${i} = ')
                g.expr(expr)
            }
            g.sb.write_string('})')
        }
        ast.FieldInit {
            panic('bug in v2 compiler: FieldInit in expression position should have been lowered in v2.transformer (${g.cur_file_name}:${g.cur_fn_name} field=${node.name})')
        }
        ast.IfGuardExpr {
            panic('bug in v2 compiler: IfGuardExpr should have been expanded in v2.transformer')
        }
        ast.GenericArgs {
            if g.generic_args_expr_is_index(node) {
                g.gen_index_expr(ast.IndexExpr{
                    lhs:  node.lhs
                    expr: node.args[0]
                    pos:  node.pos
                })
                return
            }
            if g.try_emit_generic_fn_value(node) {
                return
            }
            g.expr(node.lhs)
        }
        ast.GenericArgOrIndexExpr {
            is_index_expr := g.generic_arg_or_index_expr_is_index(node)
            if is_index_expr {
                g.gen_index_expr(ast.IndexExpr{
                    lhs:  node.lhs
                    expr: node.expr
                    pos:  node.pos
                })
                return
            }
            if g.try_emit_generic_fn_value(node) {
                return
            }
            if !is_index_expr && g.try_emit_generic_fn_value(node.lhs) {
                return
            }
            if raw_type := g.get_raw_type(node.lhs) {
                match raw_type {
                    types.FnType {
                        g.expr(node.lhs)
                        return
                    }
                    types.Struct {
                        if raw_type.generic_params.len > 0 {
                            g.expr(node.lhs)
                            return
                        }
                    }
                    types.Alias {
                        if raw_type.base_type is types.FnType {
                            g.expr(node.lhs)
                            return
                        }
                        if raw_type.base_type is types.Struct
                            && raw_type.base_type.generic_params.len > 0 {
                            g.expr(node.lhs)
                            return
                        }
                    }
                    else {}
                }
            }
            g.gen_index_expr(ast.IndexExpr{
                lhs:  node.lhs
                expr: node.expr
                pos:  node.pos
            })
        }
        ast.SqlExpr {
            g.gen_sql_expr_placeholder(node)
        }
        ast.EmptyExpr {}
    }
}

fn generic_fn_value_base_expr(expr ast.Expr) ast.Expr {
    return match expr {
        ast.GenericArgs {
            expr.lhs
        }
        ast.GenericArgOrIndexExpr {
            expr.lhs
        }
        else {
            expr
        }
    }
}

fn raw_type_is_indexable_for_generic_disambiguation(raw_type types.Type) bool {
    mut typ := raw_type
    for {
        if typ is types.Alias {
            typ = typ.base_type
            continue
        }
        break
    }
    return typ is types.Array || typ is types.ArrayFixed || typ is types.Map || typ is types.String
        || typ is types.Pointer
}

fn c_type_is_indexable_for_generic_disambiguation(c_type string) bool {
    typ := c_type.trim_space().trim_right('*')
    return typ == 'string' || typ.starts_with('Array_') || typ.starts_with('Map_')
}

fn (mut g Gen) exp