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

fn is_zero_number_expr(expr ast.Expr) bool {
	return expr is ast.BasicLiteral && expr.kind == .number && expr.value == '0'
}

fn decl_lhs_name(expr ast.Expr) string {
	match expr {
		ast.Ident {
			return expr.name
		}
		ast.ModifierExpr {
			return decl_lhs_name(expr.expr)
		}
		else {
			return ''
		}
	}
}

fn decl_lhs_has_modifier(expr ast.Expr, kind token.Token) bool {
	match expr {
		ast.ModifierExpr {
			return expr.kind == kind || decl_lhs_has_modifier(expr.expr, kind)
		}
		else {
			return false
		}
	}
}

fn decl_lhs_storage_prefix(expr ast.Expr) string {
	if decl_lhs_has_modifier(expr, .key_static) {
		return 'static '
	}
	return ''
}

fn is_array_result_call_name(call_name string) bool {
	if call_name in ['__new_array_with_default_noscan', '__new_array_with_default',
		'builtin____new_array_with_default_noscan', 'builtin____new_array_with_default',
		'new_array_from_c_array', 'builtin__new_array_from_c_array',
		'builtin__new_array_from_c_array_noscan', 'array__slice', 'array__slice_ni'] {
		return true
	}
	return call_name.starts_with('Array_')
		&& (call_name.ends_with('__slice') || call_name.ends_with('__slice_ni'))
}

fn (g &Gen) c_type_needs_typed_zero_expr(typ string) bool {
	t := typ.trim_space()
	if t == '' || t in primitive_types || t.ends_with('*') || g.is_enum_type(t) {
		return false
	}
	if t in ['void*', 'char*', 'u8*', 'byteptr', 'charptr', 'voidptr'] {
		return false
	}
	return true
}

fn (mut g Gen) gen_array_push_elem_arg(rhs ast.Expr, elem_type string) {
	if elem_type.ends_with('*') && !g.can_take_address(rhs) {
		addr_type := unmangle_c_ptr_type(elem_type)
		g.sb.write_string('&((${addr_type}[1]){')
		g.expr(rhs)
		g.sb.write_string('}[0])')
		return
	}
	base_elem_type := elem_type.trim_space().trim_right('*')
	if base_elem_type != '' && g.get_sum_type_variants_for(base_elem_type).len > 0 {
		g.sb.write_string('&(${elem_type}[1]){')
		if elem_type.ends_with('*') {
			rhs_type := g.get_expr_type(rhs).trim_space()
			if rhs_type == elem_type {
				g.expr(rhs)
			} else {
				value_expr := g.unwrap_addr_of_value_expr(rhs) or { rhs }
				heap_name := '_heap_t${g.tmp_counter}'
				g.tmp_counter++
				malloc_call := g.c_heap_malloc_call('sizeof(${base_elem_type})')
				g.sb.write_string('({ ${base_elem_type}* ${heap_name} = (${base_elem_type}*)${malloc_call}; *${heap_name} = ')
				g.gen_type_cast_expr(base_elem_type, value_expr)
				g.sb.write_string('; ${heap_name}; })')
			}
		} else {
			g.gen_type_cast_expr(elem_type, rhs)
		}
		g.sb.write_string('}')
		return
	}
	g.gen_addr_of_expr(rhs, elem_type)
}

fn (mut g Gen) option_result_payload_type(wrapper_type string) string {
	if wrapper_type.starts_with('_result_') {
		return g.result_value_type(wrapper_type)
	}
	if wrapper_type.starts_with('_option_') {
		return option_value_type(wrapper_type)
	}
	return ''
}

fn valid_decl_cast_type(typ string) bool {
	return typ != '' && typ != 'void' && typ != 'int_literal' && typ != 'float_literal'
}

fn (mut g Gen) option_result_data_cast_type(wrapper_type string, lhs_type string, rhs_type string) string {
	payload_type := g.option_result_payload_type(wrapper_type)
	if valid_decl_cast_type(payload_type) {
		return payload_type
	}
	if valid_decl_cast_type(lhs_type) {
		return lhs_type
	}
	if valid_decl_cast_type(rhs_type) {
		return rhs_type
	}
	return 'int'
}

fn (mut g Gen) option_result_wrapper_type_for_selector(lhs ast.Expr, fallback string) string {
	lhs_type := g.get_expr_type(lhs)
	if lhs_type.starts_with('_result_') || lhs_type.starts_with('_option_') {
		return lhs_type
	}
	if fallback.starts_with('_result_') || fallback.starts_with('_option_') {
		return fallback
	}
	if lhs is ast.Ident {
		if local_type := g.get_local_var_c_type(lhs.name) {
			if local_type.starts_with('_result_') || local_type.starts_with('_option_') {
				return local_type
			}
		}
	}
	return lhs_type
}

fn (mut g Gen) option_result_rhs_type(rhs ast.Expr) string {
	rhs_type := g.get_expr_type(rhs)
	if rhs_type.starts_with('_result_') || rhs_type.starts_with('_option_') {
		return rhs_type
	}
	if rhs is ast.SelectorExpr {
		return g.option_result_wrapper_type_for_selector(rhs.lhs, rhs_type)
	}
	return rhs_type
}

fn (mut g Gen) decl_rhs_has_concrete_type(rhs ast.Expr) bool {
	match rhs {
		ast.InitExpr {
			typ := g.expr_type_to_c(rhs.typ)
			return typ != '' && typ != 'void'
		}
		ast.SelectorExpr, ast.CastExpr, ast.InfixExpr {
			return true
		}
		ast.PrefixExpr {
			return rhs.op in [.amp, .mul] && g.decl_rhs_has_concrete_type(rhs.expr)
		}
		ast.UnsafeExpr {
			if typ := g.unsafe_expr_result_type(rhs) {
				return typ != '' && typ !in ['void', 'void*', 'voidptr']
			}
		}
		ast.CallExpr {
			if ret := g.get_call_return_type(rhs.lhs, rhs.args) {
				return ret != '' && ret !in ['void*', 'voidptr']
			}
		}
		ast.CallOrCastExpr {
			if g.call_or_cast_lhs_is_type(rhs.lhs) {
				return true
			}
			if ret := g.get_call_return_type(rhs.lhs, [rhs.expr]) {
				return ret != '' && ret !in ['void*', 'voidptr']
			}
		}
		else {}
	}

	return false
}

fn (mut g Gen) decl_lhs_scope_raw_type(lhs ast.Expr) ?types.Type {
	if lhs is ast.Ident {
		if mut fn_scope := g.ensure_cur_fn_scope() {
			if obj := fn_scope.lookup_parent(lhs.name, 0) {
				if obj is types.Module {
					return none
				}
				return obj.typ()
			}
		}
		return none
	}
	return g.get_raw_type(lhs)
}

fn valid_decl_env_type(typ string) bool {
	return typ != '' && typ !in ['void', 'void*', 'voidptr', 'int /*corrupt type*/']
}

fn (mut g Gen) decl_lhs_synth_env_type(lhs ast.Expr) ?string {
	if lhs is ast.Ident && lhs.pos.id < 0 {
		typ := g.get_env_c_type(lhs) or { return none }
		if valid_decl_env_type(typ) {
			return typ
		}
	}
	return none
}

fn (mut g Gen) decl_selector_rhs_type(rhs ast.SelectorExpr) string {
	if g.comptime_field_var != '' {
		ct_type := g.get_comptime_selector_type(rhs)
		if ct_type != '' {
			return ct_type
		}
	}
	field_name := rhs.rhs.name
	if field_name == 'err' {
		lhs_type := g.get_expr_type(rhs.lhs)
		is_or_tmp := rhs.lhs is ast.Ident && rhs.lhs.name.starts_with('_or_t')
		if lhs_type.starts_with('_result_') || lhs_type.starts_with('_option_') || is_or_tmp {
			return 'IError'
		}
	}
	if field_name.starts_with('arg') {
		lhs_type := g.get_expr_type(rhs.lhs)
		if lhs_type.starts_with('Tuple_') {
			if field_types := g.tuple_aliases[lhs_type] {
				idx := field_name['arg'.len..].int()
				if idx >= 0 && idx < field_types.len {
					return field_types[idx]
				}
			}
		}
	}
	declared := g.selector_declared_field_type(rhs)
	if declared != '' && !is_generic_placeholder_c_type_name(declared) {
		return declared
	}
	field_type := g.selector_field_type(rhs)
	if field_type != '' && !is_generic_placeholder_c_type_name(field_type) {
		return field_type
	}
	return ''
}

fn (mut g Gen) gen_map_index_assign_fallback(lhs ast.IndexExpr, rhs ast.Expr) bool {
	mut key_type := ''
	mut value_type := ''
	mut lhs_is_ptr := g.expr_is_pointer(lhs.lhs)
	mut lhs_c_type := g.get_expr_type(lhs.lhs).trim_space()
	if lhs_c_type.ends_with('*') {
		lhs_is_ptr = true
	}
	if raw_type := g.get_raw_type(lhs.lhs) {
		match raw_type {
			types.Map {
				key_type = g.types_type_to_c(raw_type.key_type)
				value_type = g.types_type_to_c(raw_type.value_type)
			}
			types.Pointer {
				lhs_is_ptr = true
				match raw_type.base_type {
					types.Map {
						key_type = g.types_type_to_c(raw_type.base_type.key_type)
						value_type = g.types_type_to_c(raw_type.base_type.value_type)
					}
					types.Alias {
						if raw_type.base_type.base_type is types.Map {
							key_type = g.types_type_to_c(raw_type.base_type.base_type.key_type)
							value_type = g.types_type_to_c(raw_type.base_type.base_type.value_type)
						}
					}
					else {}
				}
			}
			types.Alias {
				if raw_type.base_type is types.Map {
					key_type = g.types_type_to_c(raw_type.base_type.key_type)
					value_type = g.types_type_to_c(raw_type.base_type.value_type)
				}
			}
			else {}
		}
	}
	if key_type == '' || value_type == '' {
		mut map_c_type := lhs_c_type
		if local_type := g.local_var_c_type_for_expr(lhs.lhs) {
			local_map_type := local_type.trim_space()
			if local_map_type != '' && local_map_type != 'int' {
				map_c_type = local_map_type
			}
		}
		if lhs.lhs is ast.SelectorExpr {
			mut selector_type := g.selector_storage_field_type(lhs.lhs).trim_space()
			if selector_type == '' {
				selector_type = g.selector_field_type(lhs.lhs).trim_space()
			}
			if selector_type == '' || selector_type == 'int' {
				if plain_selector_type := g.plain_local_selector_type(lhs.lhs) {
					selector_type = plain_selector_type.trim_space()
				}
			}
			if selector_type != '' {
				map_c_type = selector_type
			}
		}
		if map_c_type.ends_with('*') {
			map_c_type = map_c_type[..map_c_type.len - 1].trim_space()
		}
		if map_c_type.starts_with('Map_') {
			key, value := g.parse_map_kv_types(map_c_type['Map_'.len..])
			key_type = key
			value_type = value
		}
	}
	if key_type == '' || value_type == '' {
		return false
	}
	key_tmp := '_map_key${g.tmp_counter}'
	g.tmp_counter++
	value_tmp := '_map_val${g.tmp_counter}'
	g.tmp_counter++
	g.write_indent()
	g.sb.write_string('{ ${key_type} ${key_tmp} = ')
	g.expr(lhs.expr)
	g.sb.write_string('; ${value_type} ${value_tmp} = ')
	g.expr(rhs)
	g.sb.write_string('; map__set(')
	if lhs_is_ptr {
		g.expr(lhs.lhs)
	} else {
		g.sb.write_string('&(')
		g.expr(lhs.lhs)
		g.sb.write_string(')')
	}
	g.sb.writeln(', (void*)&${key_tmp}, (void*)&${value_tmp}); }')
	return true
}

fn (mut g Gen) gen_overloaded_compound_assign(lhs ast.Expr, rhs ast.Expr, op token.Token) bool {
	if lhs !is ast.Ident {
		return false
	}
	lhs_ident := lhs as ast.Ident
	op_name := match op {
		.plus_assign { 'op_plus' }
		.minus_assign { 'op_minus' }
		.mul_assign { 'op_mul' }
		.div_assign { 'op_div' }
		.mod_assign { 'op_mod' }
		else { '' }
	}

	if op_name == '' {
		return false
	}
	mut lhs_type := g.get_expr_type(lhs)
	if local_type := g.get_local_var_c_type(lhs_ident.name) {
		lhs_type = local_type
	}
	if lhs_type == '' || lhs_type in primitive_types || lhs_type == 'string'
		|| lhs_type.ends_with('*') || lhs_type.ends_with('ptr') {
		return false
	}
	mut rhs_type := g.get_expr_type(rhs)
	if rhs is ast.Ident {
		rhs_ident := rhs as ast.Ident
		if local_type := g.get_local_var_c_type(rhs_ident.name) {
			rhs_type = local_type
		}
	}
	if rhs_type != '' && rhs_type != 'int' && rhs_type != lhs_type {
		return false
	}
	method_fn := '${lhs_type}__${op_name}'
	if method_fn !in g.fn_return_types && method_fn !in g.fn_param_is_ptr {
		return false
	}
	g.write_indent()
	g.expr(lhs)
	g.sb.write_string(' = ${method_fn}(')
	g.expr(lhs)
	g.sb.write_string(', ')
	g.expr(rhs)
	g.sb.writeln(');')
	return true
}

fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
	lhs := node.lhs[0]
	rhs := node.rhs[0]
	// Multi-assignment with parallel RHS values (non-declaration):
	// `p, q = q, p` needs temp variables for correct swap semantics.
	if node.op != .decl_assign && node.lhs.len > 1 && node.rhs.len == node.lhs.len {
		swap_id := g.tmp_counter
		// First, evaluate all RHS values into temporaries
		for i, rhs_expr in node.rhs {
			mut typ := g.get_expr_type(rhs_expr)
			if typ == '' || typ == 'int_literal' {
				typ = 'int'
			}
			if typ == 'float_literal' {
				typ = 'f64'
			}
			g.write_indent()
			g.sb.write_string('${typ} _swap_${swap_id}_${i} = ')
			g.expr(rhs_expr)
			g.sb.writeln(';')
		}
		// Then assign from temporaries to LHS
		for i, lhs_expr in node.lhs {
			if lhs_expr is ast.Ident && lhs_expr.name == '_' {
				g.write_indent()
				g.sb.writeln('(void)_swap_${swap_id}_${i};')
				continue
			}
			g.write_indent()
			g.expr(lhs_expr)
			g.sb.writeln(' = _swap_${swap_id}_${i};')
		}
		g.tmp_counter++
		return
	}

	// Multi-declaration with parallel RHS values:
	// `a, b := x, y` should declare both variables (not just the first one).
	if node.op == .decl_assign && node.lhs.len > 1 && node.rhs.len == node.lhs.len {
		for i, lhs_expr in node.lhs {
			rhs_expr := node.rhs[i]
			mut name := decl_lhs_name(lhs_expr)
			if name == '_' {
				g.write_indent()
				g.sb.write_string('(void)(')
				g.expr(rhs_expr)
				g.sb.writeln(');')
				continue
			}
			mut typ := g.get_expr_type(lhs_expr)
			if typ == '' || typ == 'int' {
				typ = g.get_expr_type(rhs_expr)
			}
			if typ == '' || typ == 'int_literal' {
				typ = 'int'
			}
			if typ == 'float_literal' {
				typ = 'f64'
			}
			c_name := c_local_name(name)
			g.write_indent()
			g.sb.write_string('${typ} ${c_name} = ')
			if is_zero_number_expr(rhs_expr) && g.c_type_needs_typed_zero_expr(typ) {
				g.sb.write_string(zero_value_for_type(typ))
			} else {
				g.expr(rhs_expr)
			}
			g.sb.writeln(';')
			g.remember_runtime_local_type(name, typ)
		}
		return
	}

	mut tuple_lhs := []ast.Expr{}
	if node.lhs.len > 1 {
		tuple_lhs = shallow_copy_exprs(node.lhs)
	} else if node.lhs.len == 1 && node.lhs[0] is ast.Tuple {
		lhs_tuple := node.lhs[0] as ast.Tuple
		tuple_lhs = shallow_copy_exprs(lhs_tuple.exprs)
	}
	if tuple_lhs.len > 1 && node.rhs.len == 1 {
		mut tuple_type := g.get_expr_type(rhs)
		// For tuple-LHS assignments, prefer explicit call return metadata even when
		// positional inference produced a scalar type.
		if rhs is ast.CallExpr {
			if ret := g.get_call_return_type(rhs.lhs, rhs.args) {
				if ret != '' && ret != 'int' {
					tuple_type = ret
				}
			}
			// For interface vtable method calls, look up the method's return type
			if (tuple_type == '' || tuple_type == 'int') && rhs.lhs is ast.SelectorExpr {
				receiver_type := g.get_expr_type(rhs.lhs.lhs).trim_right('*')
				if g.is_interface_type(receiver_type) {
					method_name := rhs.lhs.rhs.name
					if method := g.interface_method_by_name(receiver_type, method_name) {
						if method.ret_type != '' && method.ret_type != 'int'
							&& method.ret_type != 'void' {
							tuple_type = method.ret_type
						}
					}
				}
			}
		} else if rhs is ast.UnsafeExpr {
			// Handle inline or-block expansion: the transformer wraps or-blocks in
			// UnsafeExpr (GCC statement expressions) when it can't expand them to
			// separate statements. The stmts are: [_or_t := call(), if error, _or_t.data]
			// Extract the call return type from the first AssignStmt inside.
			for stmt_inner in rhs.stmts {
				if stmt_inner is ast.AssignStmt && stmt_inner.op == .decl_assign
					&& stmt_inner.rhs.len == 1 {
					inner_rhs := stmt_inner.rhs[0]
					mut inner_ret := ''
					if inner_rhs is ast.CallExpr {
						if ret := g.get_call_return_type(inner_rhs.lhs, inner_rhs.args) {
							inner_ret = ret
						}
					}
					// Strip _option_/_result_ wrapper since the UnsafeExpr already
					// unwraps the value (last expr is _or_t.data)
					if inner_ret.starts_with('_option_') {
						tuple_type = option_value_type(inner_ret)
					} else if inner_ret.starts_with('_result_') {
						tuple_type = g.result_value_type(inner_ret)
					}
					break
				}
			}
		}
		if tuple_type == 'int' {
			if rhs is ast.CastExpr {
				cast_type := g.expr_type_to_c(rhs.typ)
				if cast_type != '' {
					tuple_type = cast_type
				}
			}
		}
		// Function pointer call: tuple_type may be the fn pointer typedef name
		// (e.g. 'ui__CanvasLayoutSizeFn') or 'int' (unresolved) instead of the actual
		// return type (e.g. 'Tuple_int_int'). Resolve via the raw type's return type.
		if tuple_type !in g.tuple_aliases && rhs is ast.CallExpr {
			// Method 1: Use fn_pointer_return_type on the callee expression
			fn_ptr_ret := g.fn_pointer_return_type(rhs.lhs)
			if fn_ptr_ret != '' && fn_ptr_ret != 'int' && fn_ptr_ret in g.tuple_aliases {
				tuple_type = fn_ptr_ret
			}
			// Method 2: For selector-based fn pointer calls, resolve the field's
			// fn type from the receiver struct and extract the return type.
			if tuple_type !in g.tuple_aliases && rhs.lhs is ast.SelectorExpr {
				if receiver_raw := g.get_raw_type(rhs.lhs.lhs) {
					base_raw := if receiver_raw is types.Pointer {
						receiver_raw.base_type
					} else {
						receiver_raw
					}
					if base_raw is types.Struct {
						field_name := rhs.lhs.rhs.name
						fn_ret := g.resolve_struct_field_fn_return(base_raw, field_name)
						if fn_ret != '' && fn_ret in g.tuple_aliases {
							tuple_type = fn_ret
						}
					}
				}
			}
			// Method 3: Try raw type resolution on the callee expression directly
			if tuple_type !in g.tuple_aliases {
				if fn_raw := g.get_raw_type(rhs.lhs) {
					fn_ret_type := match fn_raw {
						types.FnType {
							if rt := fn_raw.get_return_type() {
								g.fn_return_type_to_c(rt)
							} else {
								''
							}
						}
						types.Alias {
							if fn_raw.base_type is types.FnType {
								if rt := fn_raw.base_type.get_return_type() {
									g.fn_return_type_to_c(rt)
								} else {
									''
								}
							} else {
								''
							}
						}
						else {
							''
						}
					}

					if fn_ret_type != '' && fn_ret_type != 'int' && fn_ret_type in g.tuple_aliases {
						tuple_type = fn_ret_type
					}
				}
			}
		}
		// If tuple_type is still unresolved (empty, 'int', or 'void'), synthesize from LHS types
		if (tuple_type == '' || tuple_type == 'int' || tuple_type == 'void')
			&& tuple_type !in g.tuple_aliases {
			mut lhs_types := []string{cap: tuple_lhs.len}
			mut all_resolved := true
			for lhs_expr in tuple_lhs {
				mut lhs_t := g.get_expr_type(lhs_expr)
				if (lhs_t == '' || lhs_t == 'int') && lhs_expr is ast.Ident {
					lhs_t = g.get_local_var_c_type(lhs_expr.name) or { lhs_t }
				}
				if lhs_t == '' {
					all_resolved = false
					break
				}
				lhs_types << lhs_t
			}
			if all_resolved && lhs_types.len > 1 {
				synthesized := g.register_tuple_alias(lhs_types)
				if synthesized != '' {
					tuple_type = synthesized
				}
			}
		}
		mut wrapped_tuple_type := ''
		if tuple_type.starts_with('_result_') {
			base := g.result_value_type(tuple_type)
			if base in g.tuple_aliases {
				wrapped_tuple_type = tuple_type
				tuple_type = base
			}
		} else if tuple_type.starts_with('_option_') {
			base := option_value_type(tuple_type)
			if base in g.tuple_aliases {
				wrapped_tuple_type = tuple_type
				tuple_type = base
			}
		}
		if field_types := g.tuple_aliases[tuple_type] {
			tmp_name := '_tuple_tmp_${g.tmp_counter}'
			g.tmp_counter++
			g.write_indent()
			if wrapped_tuple_type != '' {
				res_tmp := '_tuple_res_tmp_${g.tmp_counter}'
				g.tmp_counter++
				g.sb.write_string('${wrapped_tuple_type} ${res_tmp} = ')
				g.expr(rhs)
				g.sb.writeln(';')
				g.write_indent()
				g.sb.writeln('${tuple_type} ${tmp_name} = (*(${tuple_type}*)(((u8*)(&${res_tmp}.err)) + sizeof(IError)));')
			} else {
				g.sb.write_string('${tuple_type} ${tmp_name} = ')
				g.expr(rhs)
				g.sb.writeln(';')
			}
			for i, lhs_expr in tuple_lhs {
				g.write_indent()
				if node.op == .decl_assign {
					mut name := decl_lhs_name(lhs_expr)
					if name == '_' {
						g.sb.writeln('(void)${tmp_name}.arg${i};')
						continue
					}
					elem_type := if i < field_types.len { field_types[i] } else { 'int' }
					if elem_type.starts_with('Array_fixed_') {
						g.sb.writeln('${elem_type} ${c_local_name(name)};')
						g.write_indent()
						g.sb.writeln('memcpy(${c_local_name(name)}, ${tmp_name}.arg${i}, sizeof(${elem_type}));')
						g.remember_runtime_local_type(name, elem_type)
						continue
					}
					g.sb.writeln('${elem_type} ${c_local_name(name)} = ${tmp_name}.arg${i};')
					g.remember_runtime_local_type(name, elem_type)
				} else {
					mut assign_name := ''
					if lhs_expr is ast.Ident {
						assign_name = lhs_expr.name
					}
					if assign_name == '_' {
						g.sb.writeln('(void)${tmp_name}.arg${i};')
						continue
					}
					elem_type := if i < field_types.len { field_types[i] } else { '' }
					if elem_type.starts_with('Array_fixed_') {
						g.sb.write_string('memcpy(')
						g.expr(lhs_expr)
						g.sb.writeln(', ${tmp_name}.arg${i}, sizeof(${elem_type}));')
						continue
					}
					g.expr(lhs_expr)
					g.sb.writeln(' = ${tmp_name}.arg${i};')
				}
			}
			return
		}
	}

	// Check for blank identifier
	if lhs is ast.Ident && lhs.name == '_' {
		g.write_indent()
		g.sb.write_string('(void)(')
		g.expr(rhs)
		g.sb.writeln(');')
		return
	}

	if node.op == .assign && lhs is ast.IndexExpr {
		if g.gen_map_index_assign_fallback(lhs, rhs) {
			return
		}
	}

	g.write_indent()
	if node.op == .decl_assign {
		// Variable declaration: type name = expr
		mut name := decl_lhs_name(lhs)
		storage_prefix := decl_lhs_storage_prefix(lhs)
		// Rename V variables that clash with C type names
		if name == 'array' {
			name = '_v_array'
		}
		decl_c_name := c_local_name(name)
		if rhs is ast.IndexExpr {
			if g.gen_decl_assign_from_local_index(name, storage_prefix, decl_c_name, rhs) {
				return
			}
		}
		// Keep fixed-size arrays as C arrays in local declarations.
		if rhs is ast.ArrayInitExpr {
			array_init := rhs as ast.ArrayInitExpr
			if (array_init.typ is ast.Type && array_init.typ is ast.ArrayFixedType)
				|| array_init_has_fixed_len_marker(array_init) {
				mut elem_type := ''
				mut fixed_len := ast.Expr(ast.BasicLiteral{
					kind:  .number
					value: '${array_init.exprs.len}'
				})
				if array_init.typ is ast.Type && array_init.typ is ast.ArrayFixedType {
					fixed_typ := array_init.typ as ast.ArrayFixedType
					elem_type = g.expr_type_to_c(fixed_typ.elem_type)
					fixed_len = fixed_typ.len
				} else {
					elem_type = g.extract_array_elem_type(array_init.typ)
					if elem_type == '' && array_init.exprs.len > 0 {
						elem_type = g.get_expr_type(array_init.exprs[0])
						if elem_type == 'int_literal' {
							elem_type = 'int'
						} else if elem_type == 'float_literal' {
							elem_type = 'f64'
						}
					}
				}
				if elem_type == '' {
					elem_type = 'int'
				}
				mut fixed_arr_size := array_init.exprs.len
				if fixed_arr_size == 0 {
					// For init-based fixed arrays, get size from the type annotation
					if fixed_len is ast.BasicLiteral && fixed_len.kind == .number {
						fixed_arr_size = fixed_len.value.int()
					}
				}
				fixed_name := 'Array_fixed_' + mangle_alias_component(elem_type) + '_' +
					fixed_arr_size.str()
				g.register_alias_type(fixed_name)
				g.collected_fixed_array_types[fixed_name] = FixedArrayInfo{
					elem_type: elem_type
					size:      fixed_arr_size
				}
				g.remember_runtime_local_type(name, fixed_name)
				is_literal_size := fixed_len is ast.BasicLiteral
					&& (fixed_len as ast.BasicLiteral).kind == .number
				g.sb.write_string('${storage_prefix}${elem_type} ${decl_c_name}[')
				g.expr(fixed_len)
				if array_init.exprs.len == 0 {
					if array_init.init !is ast.EmptyExpr && is_literal_size {
						// Has init: clause - expand to repeated init values
						g.sb.write_string('] = ')
						g.gen_array_init_expr(array_init)
						g.sb.writeln(';')
					} else if is_literal_size {
						g.sb.writeln('] = {0};')
					} else {
						// Non-literal sizes are VLAs in C99 and cannot use = {0}
						g.sb.writeln('];')
						g.write_indent()
						g.sb.writeln('memset(${decl_c_name}, 0, sizeof(${decl_c_name}));')
					}
				} else {
					g.sb.write_string('] = {')
					for i in 0 .. array_init.exprs.len {
						expr := array_init.exprs[i]
						if i > 0 {
							g.sb.write_string(', ')
						}
						if !(elem_type.starts_with('Array_fixed_')
							&& g.gen_fixed_array_initializer_from_expr(expr)) {
							g.expr(expr)
						}
					}
					g.sb.writeln('};')
				}
				return
			}
		}
		if rhs is ast.CallExpr {
			if orm_ret := g.orm_create_call_result_type(rhs) {
				g.sb.write_string('${orm_ret} ${decl_c_name} = ')
				g.expr(rhs)
				g.sb.writeln(';')
				g.remember_runtime_local_type(name, orm_ret)
				if orm_ret.starts_with('_result_') || orm_ret.starts_with('_option_') {
					g.register_alias_type(orm_ret)
				}
				return
			}
		}
		mut typ := g.get_expr_type(rhs)
		if rhs is ast.InitExpr && rhs.typ is ast.Ident {
			if g.type_expr_has_metadata(rhs.typ) {
				// Position metadata is authoritative for synthesized type expressions.
			} else if fn_local_type := g.current_fn_module_local_type_name(rhs.typ.name) {
				typ = fn_local_type
			}
		}
		lhs_env_type := g.get_expr_type_from_env(lhs) or { '' }
		lhs_synth_env_type := g.decl_lhs_synth_env_type(lhs) or { '' }
		if lhs_synth_env_type != '' {
			typ = lhs_synth_env_type
		}
		lhs_env_type_is_decl := valid_decl_env_type(lhs_env_type)
			&& ((!name.starts_with('_or_t') && !name.starts_with('_tmp_')
			&& !name.starts_with('_defer_t') && !name.starts_with('_assoc_t'))
			|| lhs_synth_env_type != '')
		if rhs is ast.CallExpr {
			if ret := g.get_call_return_type(rhs.lhs, rhs.args) {
				if ret.starts_with('_result_') || ret.starts_with('_option_')
					|| (ret != '' && ret != 'void' && ret != 'int' && !(ret in ['void*', 'voidptr']
					&& typ !in ['', 'int', 'void*', 'voidptr'])) {
					typ = ret
				}
			}
			if typ == '' || typ == 'int' || typ == 'array' {
				call_name := g.resolve_call_name(rhs.lhs, rhs.args.len)
				if is_array_result_call_name(call_name) {
					elem_type := g.infer_array_elem_type_from_expr(rhs)
					if elem_type != '' && elem_type != 'array' && elem_type != 'int'
						&& elem_type != 'void' {
						typ = 'Array_' + mangle_alias_component(elem_type)
						g.register_alias_type(typ)
					}
				}
			}
		} else if rhs is ast.CallOrCastExpr && !g.call_or_cast_lhs_is_type(rhs.lhs) {
			if ret := g.get_call_return_type(rhs.lhs, [rhs.expr]) {
				if ret.starts_with('_result_') || ret.starts_with('_option_')
					|| (ret != '' && ret != 'void' && ret != 'int' && !(ret in ['void*', 'voidptr']
					&& typ !in ['', 'int', 'void*', 'voidptr'])) {
					typ = ret
				}
			}
		}
		mut elem_type_from_array := false
		mut typ_from_active_generic_init := false
		if rhs is ast.InitExpr && g.active_generic_types.len > 0 {
			init_type_name := rhs.typ.name()
			if concrete := g.active_generic_types[init_type_name] {
				concrete_type := g.types_type_to_c(concrete).trim_space()
				if concrete_type != '' {
					typ = concrete_type
					typ_from_active_generic_init = true
				}
			}
		}
		// For Ident RHS referencing a struct-typed constant (e.g., `col := no_color`
		// where no_color is `#define`d as a Color struct literal), use the const type.
		if (typ == 'int' || typ == '') && rhs is ast.Ident {
			if ct := g.const_types[rhs.name] {
				typ = ct
			} else if g.cur_module != '' {
				qualified := g.cur_module + '__' + rhs.name
				if ct := g.const_types[qualified] {
					typ = ct
				}
			}
		}
		// For CastExpr RHS (e.g., `(i64)(0)`), derive type from the cast target.
		if rhs is ast.CastExpr {
			cast_type := g.expr_type_to_c(rhs.typ)
			if cast_type != '' {
				typ = cast_type
			}
		}
		if rhs is ast.IndexExpr {
			index_elem_type := g.infer_array_elem_type_from_expr(rhs.lhs)
			if index_elem_type != '' && index_elem_type !in ['array', 'int', 'void'] {
				specialized := specialized_generic_elem_type_from_value(typ, index_elem_type)
				if typ == '' || typ == 'int' || typ == 'void*' || typ == 'voidptr'
					|| specialized != '' {
					typ = if specialized != '' { specialized } else { index_elem_type }
					elem_type_from_array = true
				}
			}
		}
		// For temp variables registered by the transformer with a specific type,
		// prefer the scope-registered type over the RHS expression type.
		if name.starts_with('_or_t') || name.starts_with('_tmp_') || name.starts_with('_defer_t')
			|| name.starts_with('_assoc_t') {
			if lhs_synth_env_type != '' {
				typ = lhs_synth_env_type
				if typ.starts_with('_result_') || typ.starts_with('_option_') {
					g.register_alias_type(typ)
				}
			} else if raw_type := g.decl_lhs_scope_raw_type(lhs) {
				scope_type := g.types_type_to_c(raw_type)
				if scope_type != '' && scope_type != 'int' && scope_type !in ['void*', 'voidptr'] {
					typ_is_wrapper := typ.starts_with('_result_') || typ.starts_with('_option_')
					scope_type_is_wrapper := scope_type.starts_with('_result_')
						|| scope_type.starts_with('_option_')
					if typ_is_wrapper && scope_type_is_wrapper && typ != scope_type {
						g.register_alias_type(typ)
					} else {
						typ = scope_type
						// Ensure result/option wrapper types are registered so their
						// typedef and struct definitions get emitted in the C output.
						if scope_type_is_wrapper {
							g.register_alias_type(scope_type)
						}
					}
				} else if scope_type == 'int' && typ == 'bool' {
					// Fix: literal like `1` mistyped as bool in env
					typ = 'int'
				}
			}
			// Transformer-created temp vars may not exist in the checker's scope.
			// Try to infer the type from the RHS: if RHS is an Ident referencing
			// another temp var already registered in runtime_local_types, use that.
			if typ == 'int' || typ == '' {
				if rhs is ast.Ident {
					if rhs_local_type := g.runtime_local_types[rhs.name] {
						if rhs_local_type != '' && rhs_local_type != 'int' {
							typ = rhs_local_type
						}
					}
				}
			}
			// For UnsafeExpr RHS (GCC statement expression from nested or-expressions),
			// the result type is determined by the last ExprStmt. Find its declaration
			// in the preceding stmts to extract the type.
			if typ == 'int' || typ == '' {
				if rhs is ast.UnsafeExpr && rhs.stmts.len > 1 {
					last_s := rhs.stmts[rhs.stmts.len - 1]
					if last_s is ast.ExprStmt && last_s.expr is ast.Ident {
						result_name := last_s.expr.name
						// Scan preceding stmts for the decl_assign of the result variable
						for inner_stmt in rhs.stmts[..rhs.stmts.len - 1] {
							if inner_stmt is ast.AssignStmt && inner_stmt.op == .decl_assign
								&& inner_stmt.lhs.len == 1 {
								inner_lhs := inner_stmt.lhs[0]
								if inner_lhs is ast.Ident && inner_lhs.name == result_name {
									inner_typ := g.get_expr_type(inner_stmt.rhs[0])
									if inner_typ != '' && inner_typ != 'int' {
										typ = inner_typ
									}
									break
								}
							}
						}
					}
				}
			}
			// For _or_t vars where RHS is a call through a function pointer variable,
			// infer the return type from the function pointer's type.
			if typ == 'int' || typ == '' {
				if rhs is ast.CallExpr {
					fn_ptr_ret := g.fn_pointer_return_type(rhs.lhs)
					if fn_ptr_ret != '' && fn_ptr_ret != 'int' && fn_ptr_ret != 'void' {
						typ = fn_ptr_ret
					}
				}
			}
		}
		// Fix: &T(x) pattern - the checker may assign only the inner type T instead of T*.
		// Derive the pointer type directly from the expression structure.
		if rhs is ast.PrefixExpr && rhs.op == .amp && rhs.expr is ast.CastExpr {
			target_type := g.expr_type_to_c(rhs.expr.typ)
			if target_type != '' {
				typ = target_type + '*'
			}
		}
		if rhs is ast.CallExpr {
			if rhs.lhs is ast.Ident
				&& rhs.lhs.name in ['array__pop', 'array__pop_left', 'array__first', 'array__last'] {
				if rhs.args.len > 0 {
					pop_elem := g.infer_array_elem_type_from_expr(rhs.args[0])
					if pop_elem != '' {
						typ = pop_elem
						elem_type_from_array = true
					}
				}
			} else if rhs.lhs is ast.SelectorExpr
				&& rhs.lhs.rhs.name in ['pop', 'pop_left', 'first', 'last'] {
				arr_expr := if rhs.args.len > 0 { rhs.args[0] } else { rhs.lhs.lhs }
				pop_elem := g.infer_array_elem_type_from_expr(arr_expr)
				if pop_elem != '' {
					typ = pop_elem
					elem_type_from_array = true
				}
			}
		}
		if typ == 'array' {
			mut elem_type := g.infer_array_elem_type_from_expr(rhs)
			if elem_type == '' && rhs is ast.CallExpr {
				call_name := g.resolve_call_name(rhs.lhs, rhs.args.len)
				if call_name in ['new_array_from_c_array', 'builtin__new_array_from_c_array', 'builtin__new_array_from_c_array_noscan']
					&& rhs.args.len > 3 {
					elem_type = g.infer_array_elem_type_from_expr(rhs.args[3])
				}
			}
			if elem_type != '' && elem_type != 'array' && elem_type != 'void' {
				typ = 'Array_' + mangle_alias_component(elem_type)
				g.register_alias_type(typ)
			}
		}
		if typ in ['void*', 'voidptr'] {
			// Handle array__first/array__last/pop/pop_left for element type inference
			if rhs is ast.CallExpr {
				if rhs.lhs is ast.SelectorExpr {
					if rhs.lhs.rhs.name in ['first', 'last', 'pop', 'pop_left'] {
						arr2 := if rhs.args.len > 0 { rhs.args[0] } else { rhs.lhs.lhs }
						elem := g.infer_array_elem_type_from_expr(arr2)
						if elem != '' {
							typ = elem
						}
					}
				}
			}
			mut call_name := ''
			mut arr_expr := rhs
			mut has_arr_expr := false
			if rhs is ast.CallExpr {
				call_name = g.resolve_call_name(rhs.lhs, rhs.args.len)
				if rhs.args.len > 0 {
					arr_expr = rhs.args[0]
					has_arr_expr = true
				} else if rhs.lhs is ast.SelectorExpr {
					arr_expr = rhs.lhs.lhs
					has_arr_expr = true
				}
			}
			if has_arr_expr
				&& call_name in ['array__pop', 'array__pop_left', 'array__first', 'array__last'] {
				pop_elem := g.infer_array_elem_type_from_expr(arr_expr)
				if pop_elem != '' {
					typ = pop_elem
				}
			}
		}
		// Check scope-resolved type first (most reliable for declarations).
		// Treat `void*`/`voidptr` as an "unknown" fallback when we have a concrete
		// type from the (checker/transformer) scope; this is important for patterns
		// like `tmp := map__get_check(...)` where the C builtin returns `void*` but
		// the variable is known to be `T*`.
		// But skip if element type was already inferred from array methods.
		// Also skip for tuple field selectors (_tuple_tN.argN) where the field type
		// is authoritative — scope lookup may find a wrong-scoped variable of the same name.
		mut type_from_tuple_field := false
		if rhs is ast.SelectorExpr {
			sel_rhs := rhs as ast.SelectorExpr
			if sel_rhs.rhs.name.starts_with('arg') && sel_rhs.lhs is ast.Ident {
				sel_lhs := sel_rhs.lhs as ast.Ident
				type_from_tuple_field = sel_lhs.name.starts_with('_tuple_t')
			}
		}
		rhs_has_concrete_type := g.decl_rhs_has_concrete_type(rhs)
		if lhs_env_type_is_decl && (typ == '' || typ == 'int_literal'
			|| typ == 'float_literal' || typ == 'void*' || typ == 'voidptr'
			|| (typ == 'int' && !rhs_has_concrete_type)) {
			typ = lhs_env_type
		}
		if !elem_type_from_array && !type_from_tuple_field && !typ_from_active_generic_init
			&& name != '' && g.cur_fn_scope != unsafe { nil } {
			if obj := g.cur_fn_scope.lookup_parent(name, 0) {
				if obj !is types.Module {
					obj_type := obj.typ()
					if obj_type !is types.Alias {
						scoped_type := g.types_type_to_c(obj_type)
						generic_container_fallback :=
							(typ == 'array' && scoped_type.starts_with('Array_'))
							|| (typ == 'map' && scoped_type.starts_with('Map_'))
						typ_needs_scope := typ == '' || typ == 'int_literal'
							|| typ == 'void*' || typ == 'voidptr'
							|| generic_container_fallback
							|| (typ == 'int' && !rhs_has_concrete_type && !lhs_env_type_is_decl)
						if typ_needs_scope && scoped_type != ''
							&& scoped_type !in ['int', 'void', 'void*', 'voidptr'] {
							typ = scoped_type
						}
					}
				}
			}
		}
		// For decl_assign (:=), the LHS is a brand new variable, so don't use
		// cached types from runtime_local_types (which may hold stale types
		// from a previous variable with the same name, e.g. _filter_it).
		if node.op != .decl_assign {
			lhs_typ := g.get_expr_type(lhs)
			if lhs_typ != '' && lhs_typ !in ['int', 'int_literal', 'float_literal']
				&& lhs_typ != 'void'
				&& (typ == '' || typ == 'int' || typ == 'void*' || typ == 'voidptr') {
				typ = lhs_typ
			}
		}
		if !elem_type_from_array && rhs is ast.CallExpr {
			if ret := g.get_call_return_type(rhs.lhs, rhs.args) {
				call_is_string_slice := rhs.lhs is ast.Ident && rhs.lhs.name == 'array__slice'
					&& rhs.args.len > 0
					&& g.expr_resolves_to_string(rhs.args[0], g.get_expr_type(rhs.args[0]).trim_right('*'))
				if call_is_string_slice {
					typ = 'string'
				} else if (ret == 'array' && typ.starts_with('Array_'))
					|| (ret == 'map' && typ.starts_with('Map_')) {
					// Preserve more specific local container types inferred from call arguments.
				} else if ret != ''
					&& (ret != 'int' || typ in ['', 'void*', 'voidptr'] || typ.starts_with('Array_')
					|| typ.starts_with('Map_')) {
					if !(ret in ['void*', 'voidptr'] && typ !in ['', 'int', 'void*', 'voidptr']) {
						typ = ret
					}
				}
			}
			// For interface vtable method calls (e.g., w->size(w->_object)),
			// look up the method's return type from the interface declaration.
			if (typ == '' || typ == 'int') && rhs.lhs is ast.SelectorExpr {
				receiver_type := g.get_expr_type(rhs.lhs.lhs).trim_right('*')
				if g.is_interface_type(receiver_type) {
					iface_method_name := rhs.lhs.rhs.name
					if method := g.interface_method_by_name(receiver_type, iface_method_name) {
						if method.ret_type != '' && method.ret_type != 'int'
							&& method.ret_type != 'void' {
							typ = method.ret_type
						}
					}
				}
			}
		} else if !elem_type_from_array && rhs is ast.CallOrCastExpr
			&& !g.call_or_cast_lhs_is_type(rhs.lhs) {
			if ret := g.get_call_return_type(rhs.lhs, [rhs.expr]) {
				if ret != ''
					&& (ret != 'int' || typ in ['', 'void*', 'voidptr'] || typ.starts_with('Array_')
					|| typ.starts_with('Map_')) {
					if !(ret in ['void*', 'voidptr'] && typ !in ['', 'int', 'void*', 'voidptr']) {
						typ = ret
					}
				}
			}
		}
		if rhs is ast.KeywordOperator && rhs.op in [.key_sizeof, .key_offsetof] {
			typ = 'usize'
		}
		mut rhs_type := g.option_result_rhs_type(rhs)
		if rhs is ast.IfExpr {
			if_type := g.get_if_expr_type(&rhs)
			if if_type != '' && if_type != 'int' {
				rhs_type = if_type
			}
		}
		if rhs_type == 'int' {
			if rhs is ast.CallExpr {
				if ret := g.get_call_return_type(rhs.lhs, rhs.args) {
					rhs_type = ret
				}
			} else if rhs is ast.CallOrCastExpr && !g.call_or_cast_lhs_is_type(rhs.lhs) {
				if ret := g.get_call_return_type(rhs.lhs, [rhs.expr]) {
					rhs_type = ret
				}
			}
		}
		if rhs is ast.SelectorExpr && rhs.rhs.name == 'err' {
			container_type := g.get_expr_type(rhs.lhs)
			is_or_tmp := rhs.lhs is ast.Ident && rhs.lhs.name.starts_with('_or_t')
			if container_type.starts_with('_result_') || container_type.starts_with('_option_')
				|| is_or_tmp {
				rhs_type = 'IError'
				typ = 'IError'
			}
		}
		if name != '' && rhs is ast.SelectorExpr && rhs.rhs.name == 'data' {
			container_type := g.option_result_wrapper_type_for_selector(rhs.lhs, rhs_type)
			is_or_tmp := rhs.lhs is ast.Ident && rhs.lhs.name.starts_with('_or_t')
			if container_type.starts_with('_result_') || container_type.starts_with('_option_')
				|| is_or_tmp {
				cast_type := g.option_result_data_cast_type(container_type, typ, rhs_type)
				if cast_type.starts_with('Array_fixed_') {
					g.sb.write_string('${cast_type} ${decl_c_name}; memcpy(${decl_c_name}, (${cast_type}*)(((u8*)(&')
					g.expr(rhs.lhs)
					g.sb.writeln('.err)) + sizeof(IError)), sizeof(${cast_type}));')
					g.remember_runtime_local_type(name, cast_type)
					return
				}
				g.sb.write_string('${cast_type} ${decl_c_name} = (*(${cast_type}*)(((u8*)(&')
				g.expr(rhs.lhs)
				g.sb.writeln('.err)) + sizeof(IError)));')
				g.remember_runtime_local_type(name, cast_type)
				return
			}
		}
		if !elem_type_from_array && (typ == '' || typ == 'int'
			|| typ == 'int_literal' || typ == 'void*' || typ == 'voidptr') && rhs_type != ''
			&& rhs_type !in ['int', 'int_literal', 'float_literal']
			&& !rhs_type.starts_with('_result_') && !rhs_type.starts_with('_option_') {
			typ = rhs_type
		}
		if !elem_type_from_array && typ != '' && rhs_type.starts_with('${typ}_T_') {
			typ = rhs_type
		}
		if (typ == '' || typ == 'int' || typ == 'int_literal') && rhs is ast.InfixExpr {
			inferred := g.infer_numeric_expr_type(rhs)
			if inferred != '' && inferred !in ['int', 'int_literal'] {
				typ = inferred
			}
		}
		typ = unmangle_c_ptr_type(typ)
		if name != '' && rhs_type.starts_with('_result_') && !typ.starts_with('_result_') {
			if typ.starts_with('Array_fixed_') {
				g.sb.write_string('${typ} ${decl_c_name}; { ${rhs_type} _tmp = ')
				g.expr(rhs)
				g.sb.writeln('; memcpy(${decl_c_name}, (${typ}*)(((u8*)(&_tmp.err)) + sizeof(IError)), sizeof(${typ})); }')
				g.remember_runtime_local_type(name, typ)
				return
			}
			g.sb.write_string('${typ} ${decl_c_name} = ({ ${rhs_type} _tmp = ')
			g.expr(rhs)
			g.sb.writeln('; (*(${typ}*)(((u8*)(&_tmp.err)) + sizeof(IError))); });')
			g.remember_runtime_local_type(name, typ)
			return
		}
		if name != '' && rhs_type.starts_with('_option_') && !typ.starts_with('_option_') {
			if typ.starts_with('Array_fixed_') {
				g.sb.write_string('${typ} ${decl_c_name}; { ${rhs_type} _tmp = ')
				g.expr(rhs)
				g.sb.writeln('; memcpy(${decl_c_name}, (${typ}*)(((u8*)(&_tmp.err)) + sizeof(IError)), sizeof(${typ})); }')
				g.remember_runtime_local_type(name, typ)
				return
			}
			g.sb.write_string('${typ} ${decl_c_name} = ({ ${rhs_type} _tmp = ')
			g.expr(rhs)
			g.sb.writeln('; (*(${typ}*)(((u8*)(&_tmp.err)) + sizeof(IError))); });')
			g.remember_runtime_local_type(name, typ)
			return
		}
		if rhs is ast.IfExpr {
			if typ.starts_with('Array_fixed_') && rhs.else_expr !is ast.EmptyExpr {
				g.sb.writeln('${typ} ${decl_c_name};')
				if name != '' {
					g.remember_runtime_local_type(name, typ)
				}
				g.gen_decl_if_expr(decl_c_name, typ, &rhs)
				return
			}
			if !g.if_expr_can_be_ternary(&rhs) && rhs.else_expr !is ast.EmptyExpr {
				// If type is void/empty, infer from the branch's last expression
				if typ == 'void' || typ == '' {
					if rhs.stmts.len > 0 {
						last := rhs.stmts[rhs.stmts.len - 1]
						if last is ast.ExprStmt {
							branch_type := g.get_expr_type(last.expr)
							if branch_type != '' && branch_type != 'void' {
								typ = branch_type
							}
						}
					}
				}
				g.sb.writeln('${typ} ${decl_c_name};')
				if name != '' {
					g.remember_runtime_local_type(name, typ)
				}
				g.gen_decl_if_expr(decl_c_name, typ, &rhs)
				return
			}
		}
		// `ptr := &local` where `ptr` is returned from this function must not
		// keep a stack address. Heap-clone the local value for that binding.
		if name != '' && name in g.cur_fn_returned_idents && typ.ends_with('*')
			&& rhs is ast.PrefixExpr && rhs.op == .amp && rhs.expr is ast.Ident {
			prefix_rhs := rhs as ast.PrefixExpr
			base_type := typ.trim_right('*')
			if base_type != '' && base_type != 'void' {
				heap_name := '_heap_t${g.tmp_counter}'
				g.tmp_counter++
				malloc_call := g.c_heap_malloc_call('sizeof(${base_type})')
				g.sb.write_string('${typ} ${decl_c_name} = ({ ${base_type}* ${heap_name} = (${base_type}*)${malloc_call}; *${heap_name} = ')
				g.expr(prefix_rhs.expr)
				g.sb.writeln('; ${heap_name}; });')
				g.remember_runtime_local_type(name, typ)
				return
			}
		}
		if typ.ends_with('**') && rhs is ast.PrefixExpr && rhs.op == .amp {
			prefix_rhs := rhs as ast.PrefixExpr
			g.sb.write_string('${typ} ${decl_c_name} = ((${typ})(')
			g.expr(prefix_rhs.expr)
			g.sb.writeln('));')
			if name != '' {
				g.remember_runtime_local_type(name, typ)
			}
			return
		}
		if name != '' && rhs is ast.PrefixExpr && rhs.op == .amp && rhs.expr is ast.SelectorExpr {
			prefix_rhs := rhs as ast.PrefixExpr
			sel := prefix_rhs.expr as ast.SelectorExpr
			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) {
					target_type := g.expr_type_to_c(call_expr.lhs)
					if target_type != '' && target_type != 'int' {
						mut field_type := typ.trim_right('*')
						if field_type == 'voidptr' {
							field_type = 'void*'
						}
						if field_type == '' || field_type == 'void' {
							field_type = 'void*'
						}
						g.sb.write_string('${field_type} ${decl_c_name} = ((${target_type}*)(')
						g.expr(call_expr.args[0])
						g.sb.writeln('))->${escape_c_keyword(sel.rhs.name)};')
						g.remember_runtime_local_type(name, field_type)
						return
					}
				}
			} 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' {
					mut field_type := typ.trim_right('*')
					if field_type == 'voidptr' {
						field_type = 'void*'
					}
					if field_type == '' || field_type == 'void' {
						field_type = 'void*'
					}
					g.sb.write_string('${field_type} ${decl_c_name} = ((${target_type}*)(')
					g.expr(cast_expr.expr)
					g.sb.writeln('))->${escape_c_keyword(sel.rhs.name)};')
					g.remember_runtime_local_type(name, field_type)
					return
				}
			}
			c_typedef := g.c_typedef_for_interface_object_access(sel)
			if c_typedef != '' {
				mut field_type := typ.trim_right('*')
				if field_type == 'voidptr' {
					field_type = 'void*'
				}
				if field_type == '' || field_type == 'void' {
					field_type = 'void*'
				}
				g.sb.write_string('${field_type} ${decl_c_name} = ((${c_typedef}*)(')
				g.expr(sel.lhs)
				g.sb.writeln('))->${escape_c_keyword(sel.rhs.name)};')
				g.remember_runtime_local_type(name, field_type)
				return
			}
		}
		if typ.ends_with('*') && rhs is ast.PrefixExpr && rhs.op == .amp {
			prefix_rhs := rhs as ast.PrefixExpr
			if prefix_rhs.expr is ast.CallExpr && prefix_rhs.expr.args.len == 1 {
				g.sb.write_string('${typ} ${decl_c_name} = ((${typ})(')
				g.expr(prefix_rhs.expr.args[0])
				g.sb.writeln('));')
				if name != '' {
					g.remember_runtime_local_type(name, typ)
				}
				return
			}
			if prefix_rhs.expr is ast.CastExpr {
				g.sb.write_string('${typ} ${decl_c_name} = ((${typ})(')
				g.expr(prefix_rhs.expr.expr)
				g.sb.writeln('));')
				if name != '' {
					g.remember_runtime_local_type(name, typ)
				}
				return
			}
			if prefix_rhs.expr is ast.ParenExpr {
				if prefix_rhs.expr.expr is ast.CallExpr && prefix_rhs.expr.expr.args.len == 1 {
					g.sb.write_string('${typ} ${decl_c_name} = ((${typ})(')
					g.expr(prefix_rhs.expr.expr.args[0])
					g.sb.writeln('));')
					if name != '' {
						g.remember_runtime_local_type(name, typ)
					}
					return
				}
				if prefix_rhs.expr.expr is ast.CastExpr {
					g.sb.write_string('${typ} ${decl_c_name} = ((${typ})(')
					g.expr(prefix_rhs.expr.expr.expr)
					g.sb.writeln('));')
					if name != '' {
						g.remember_runtime_local_type(name, typ)
					}
					return
				}
			}
		}
		// FnLiteral: generate proper function pointer declaration
		if rhs is ast.FnLiteral {
			ret_type := if rhs.typ.return_type !is ast.EmptyExpr {
				g.expr_type_to_c(rhs.typ.return_type)
			} else {
				'void'
			}
			mut params_str := ''
			for i, param in rhs.typ.params {
				if i > 0 {
					params_str += ', '
				}
				params_str += g.expr_type_to_c(param.typ)
			}
			if params_str == '' {
				params_str = 'void'
			}
			g.sb.write_string('${ret_type} (*${decl_c_name})(${params_str}) = ')
			g.expr(rhs)
			g.sb.writeln(';')
			// Register the return type so map/filter can infer result type
			g.fn_return_types[name] = ret_type
			g.remember_runtime_local_type(name, 'fn_ptr')
			return
		}
		if typ.starts_with('Array_fixed_') && rhs is ast.CallExpr {
			if call_ret := g.get_call_return_type(rhs.lhs, rhs.args) {
				if call_ret == typ {
					wrapper_type := g.c_fn_return_type_from_v(typ)
					g.sb.writeln('${typ} ${decl_c_name};')
					g.write_indent()
					g.sb.write_string('{ ${wrapper_type} _tmp = ')
					g.expr(rhs)
					g.sb.writeln('; memcpy(${decl_c_name}, _tmp.ret_arr, sizeof(${typ})); }')
					g.remember_runtime_local_type(name, typ)
					return
				}
			}
		}
		if typ.starts_with('Array_fixed_') && !typ.ends_with('*') && rhs !is ast.ArrayInitExpr
			&& rhs !is ast.CallExpr {
			g.sb.writeln('${typ} ${decl_c_name};')
			g.write_indent()
			// For fixed arrays, check if RHS is a zero-init or type-incompatible pattern.
			// UnsafeExpr wrapping an array init, plain InitExpr, or dynamic array type
			// should all use memset for zero-init instead of memcpy.
			mut is_fixed_arr_zero := rhs is ast.InitExpr && rhs.fields.len == 0
			if !is_fixed_arr_zero && rhs is ast.UnsafeExpr {
				is_fixed_arr_zero = true // unsafe { [N]T{init: expr} } → memset for now
			}
			if !is_fixed_arr_zero {
				fa_rhs_type := g.get_expr_type(rhs)
				if fa_rhs_type == '' || fa_rhs_type == 'array' || fa_rhs_type == 'int' {
					is_fixed_arr_zero = true
				}
			}
			if is_fixed_arr_zero {
				g.sb.writeln('memset(${decl_c_name}, 0, sizeof(${typ}));')
			} else {
				g.sb.write_string('memcpy(${decl_c_name}, ')
				g.expr(rhs)
				g.sb.writeln(', sizeof(${typ}));')
			}
			g.remember_runtime_local_type(name, typ)
			return
		}
		if rhs is ast.CallExpr {
			call_name := g.resolve_call_name(rhs.lhs, rhs.args.len)
			if call_name in ['math__min', 'math__max'] && rhs.args.len == 2 {
				arg0_type := g.get_expr_type(rhs.args[0])
				arg1_type := g.get_expr_type(rhs.args[1])
				if !arg0_type.starts_with('f') && arg0_type != 'float_literal'
					&& !arg1_type.starts_with('f') && arg1_type != 'float_literal' {
					typ = 'int'
				}
			}
		}
		rhs_is_none := is_none_expr(rhs) || (rhs is ast.Type && rhs is ast.NoneType)
		rhs_is_option_zero := rhs is ast.BasicLiteral && rhs.value == '0'
			&& typ.starts_with('_option_')
		if rhs is ast.SelectorExpr {
			selector_typ := g.decl_selector_rhs_type(rhs)
			if selector_typ != '' {
				typ = selector_typ
			}
		}
		if (typ == '' || typ == 'int' || typ == 'int_literal') && name.starts_with('_defer_t')
			&& g.cur_fn_ret_type != '' && g.cur_fn_ret_type != 'void'
			&& (rhs_is_none || rhs_is_option_zero) {
			typ = g.cur_fn_ret_type
		}
		can_emit_none := typ.starts_with('_option_') || typ in ['IError', 'builtin__IError']
			|| is_type_name_pointer_like(typ) || typ in ['void*', 'voidptr', 'byteptr', 'charptr']
		if name != '' && (rhs_is_none || rhs_is_option_zero) && can_emit_none {
			g.sb.write_string('${typ} ${decl_c_name} = ')
			g.gen_none_literal_for_type(typ)
			g.sb.writeln(';')
			g.remember_runtime_local_type(name, typ)
			return
		}
		if typ == '' || typ == 'void' {
			typ = 'int'
		}
		typ = g.normalize_builtin_qualified_c_type(typ)
		if name != '' && is_zero_number_expr(rhs) && g.c_type_needs_typed_zero_expr(typ) {
			g.sb.write_string('${storage_prefix}${typ} ${c_local_name(name)} = ${zero_value_for_type(typ)};')
			g.remember_runtime_local_type(name, typ)
			return
		}
		// Check if declaring an interface pointer initialized with a concrete type
		if typ.ends_with('*') && name != '' {
			decl_base := typ.trim_right('*')
			if g.is_interface_type(decl_base) {
				decl_rhs_type := g.get_expr_type(rhs)
				decl_rhs_base := decl_rhs_type.trim_right('*')
				if decl_rhs_base != '' && decl_rhs_base != 'int' && decl_rhs_base != decl_base
					&& !g.is_interface_type(decl_rhs_base) {
					g.sb.write_string('${typ} ${decl_c_name} = ')
					if !g.gen_heap_interface_cast(decl_base, rhs) {
						g.expr(rhs)
					}
					g.sb.writeln(';')
					g.remember_runtime_local_type(name, typ)
					return
				}
			}
		}
		g.sb.write_string('${storage_prefix}${typ} ${c_local_name(name)} = ')
		if !g.gen_auto_deref_value_param_arg(typ, rhs) {
			g.expr_with_expected_init_type(rhs, typ)
		}
		g.sb.writeln(';')
		g.remember_runtime_local_type(name, typ)
	} else {
		// Assignment
		mut lhs_fixed_type := g.get_expr_type(lhs)
		if lhs_fixed_type == '' && lhs is ast.Ident {
			if local_type := g.get_local_var_c_type(lhs.name) {
				lhs_fixed_type = local_type
			}
		}
		// C has no string compound assignment; lower `s += x` to V's string concat helper.
		if node.op == .plus_assign && lhs_fixed_type == 'string' && g.get_expr_type(rhs) == 'string' {
			g.expr(lhs)
			g.sb.write_string(' = string__plus(')
			g.expr(lhs)
			g.sb.write_string(', ')
			g.expr(rhs)
			g.sb.writeln(');')
			return
		}
		if node.op == .assign && lhs is ast.Ident && lhs.name in g.cur_fn_returned_idents
			&& rhs is ast.PrefixExpr && rhs.op == .amp && rhs.expr is ast.Ident {
			prefix_rhs := rhs as ast.PrefixExpr
			base_type := lhs_fixed_type.trim_right('*')
			if lhs_fixed_type.ends_with('*') && base_type != '' && base_type != 'void' {
				heap_name := '_heap_t${g.tmp_counter}'
				g.tmp_counter++
				malloc_call := g.c_heap_malloc_call('sizeof(${base_type})')
				g.sb.write_string('${c_local_name(lhs.name)} = ({ ${base_type}* ${heap_name} = (${base_type}*)${malloc_call}; *${heap_name} = ')
				g.expr(prefix_rhs.expr)
				g.sb.writeln('; ${heap_name}; });')
				return
			}
		}
		if lhs_fixed_type.starts_with('Array_fixed_') && lhs !is ast.IndexExpr
			&& rhs is ast.CallExpr {
			if call_ret := g.get_call_return_type(rhs.lhs, rhs.args) {
				if call_ret == lhs_fixed_type {
					wrapper_type := g.c_fn_return_type_from_v(lhs_fixed_type)
					g.write_indent()
					g.sb.write_string('{ ${wrapper_type} _tmp = ')
					g.expr(rhs)
					g.sb.write_string('; memcpy(')
					g.expr(lhs)
					g.sb.writeln(', _tmp.ret_arr, sizeof(${lhs_fixed_type})); }')
					return
				}
			}
		}
		if lhs_fixed_type.starts_with('Array_fixed_') && lhs !is ast.IndexExpr && node.op == .assign
			&& rhs !is ast.CallExpr {
			g.write_indent()
			g.sb.write_string('memcpy(')
			g.expr(lhs)
			g.sb.write_string(', ')
			if rhs is ast.ArrayInitExpr {
				g.sb.write_string('((${lhs_fixed_type})')
				g.expr(rhs)
				g.sb.write_string(')')
			} else {
				g.expr(rhs)
			}
			g.sb.writeln(', sizeof(${lhs_fixed_type}));')
			return
		}
		if node.op == .left_shift_assign {
			is_array_append, elem_type := g.array_append_elem_type(lhs, rhs)
			if is_array_append {
				if g.expr_is_array_value(rhs) {
					rhs_tmp := '_arr_append_tmp_${g.tmp_counter}'
					g.tmp_counter++
					arr_rhs_type := g.expr_array_runtime_type(rhs)
					g.write_indent()
					g.sb.write_string('${arr_rhs_type} ${rhs_tmp} = ')
					g.expr(rhs)
					g.sb.writeln(';')
					g.write_indent()
					g.sb.write_string('array__push_many((array*)')
					g.gen_array_append_target(lhs)
					g.sb.writeln(', ${rhs_tmp}.data, ${rhs_tmp}.len);')
					return
				}
				g.write_indent()
				g.sb.write_string('array__push((array*)')
				g.gen_array_append_target(lhs)
				g.sb.write_string(', ')
				// When pushing a concrete type into an interface array, wrap it
				if g.is_interface_type(elem_type) {
					g.sb.write_string('&(${elem_type}[1]){')
					if !g.gen_interface_cast(elem_type, rhs) {
						g.expr(rhs)
					}
					g.sb.write_string('}')
				} else {
					g.gen_array_push_elem_arg(rhs, elem_type)
				}
				g.sb.writeln(');')
				return
			}
		}
		if node.op == .assign && lhs is ast.Ident && g.get_local_var_c_type(lhs.name) == none
			&& !g.is_module_ident(lhs.name) && !g.is_module_local_const_or_global(lhs.name)
			&& lhs.name !in ['errno', 'stdin', 'stdout', 'stderr', 'environ'] {
			mut decl_type := g.get_expr_type(rhs)
			mut rhs_array_elem_type := g.infer_array_method_elem_type(rhs)
			if rhs_array_elem_type != '' && decl_type in ['void*', 'voidptr'] {
				decl_type = rhs_array_elem_type
			}
			if decl_type == '' || decl_type in ['int_literal', 'float_literal'] {
				decl_type = 'int'
			}
			if decl_type in ['void', 'void*', 'voidptr'] {
				decl_type = 'int'
			}
			decl_type = unmangle_c_ptr_type(decl_type)
			g.write_indent()
			g.sb.write_string('${decl_type} ${c_local_name(lhs.name)} = ')
			if rhs_array_elem_type != '' && decl_type !in ['void*', 'voidptr']
				&& !decl_type.ends_with('*') {
				g.sb.write_string('(*(${decl_type}*)')
				g.expr(rhs)
				g.sb.write_string(')')
			} else {
				g.expr(rhs)
			}
			g.sb.writeln(';')
			g.remember_runtime_local_type(lhs.name, decl_type)
			return
		}
		// Handle result/option .data field write: _t.data = val -> unwrapped value pointer = val
		if lhs is ast.SelectorExpr && lhs.rhs.name == 'data' {
			lhs_type := g.get_expr_type(lhs.lhs)
			is_or_tmp := lhs.lhs is ast.Ident && lhs.lhs.name.starts_with('_or_t')
			if lhs_type.starts_with('_result_') || lhs_type.starts_with('_option_') || is_or_tmp {
				base := if lhs_type.starts_with('_result_') {
					g.result_value_type(lhs_type)
				} else if lhs_type.starts_with('_option_') {
					option_value_type(lhs_type)
				} else {
					g.get_expr_type(rhs)
				}
				if base != '' && base != 'void' {
					g.write_indent()
					g.sb.write_string('(*(${base}*)(((u8*)(&')
					g.expr(lhs.lhs)
					g.sb.write_string('.err)) + sizeof(IError))) = ')
					g.expr(rhs)
					g.sb.writeln(';')
					return
				}
				g.write_indent()
				g.sb.write_string('(void)(')
				g.expr(rhs)
				g.sb.writeln(');')
				return
			}
		}
		if node.op == .assign && lhs is ast.SelectorExpr {
			if g.gen_sum_common_field_assign(lhs, rhs) {
				return
			}
		}
		if g.gen_overloaded_compound_assign(lhs, rhs, node.op) {
			return
		}
		if lhs is ast.SelectorExpr {
			if g.gen_plain_selector_assign(lhs, rhs, node.op) {
				return
			}
		}
		mut lhs_needs_deref := false
		// Only dereference for plain assignment, not compound assignments (+=, -=, etc.)
		// For compound assignments on pointers (ptr += x), we want pointer arithmetic.
		if node.op == .assign && lhs is ast.Ident {
			if lhs.name in g.cur_fn_mut_params {
				lhs_needs_deref = true
			} else if local_type := g.get_local_var_c_type(lhs.name) {
				if local_type.ends_with('*') {
					rhs_type := g.get_expr_type(rhs)
					// Only dereference if we're sure the RHS is not a pointer.
					// When rhs_type is '' or 'int' (unknown), skip deref for function
					// calls or unsafe blocks which may return pointers (e.g. malloc).
					rhs_is_ptr := rhs_type.ends_with('*') || rhs_type == 'voidptr'
						|| rhs_type == 'void*'
					if !rhs_is_ptr && rhs_type != '' && rhs_type != 'int' {
						lhs_needs_deref = true
					} else if !rhs_is_ptr && rhs !is ast.CallExpr && rhs !is ast.UnsafeExpr {
						lhs_needs_deref = true
					}
				}
			}
		}
		if lhs_needs_deref {
			g.sb.write_string('*')
		}
		g.expr(lhs)
		op_str := match node.op {
			.assign { '=' }
			.plus_assign { '+=' }
			.minus_assign { '-=' }
			.mul_assign { '*=' }
			.div_assign { '/=' }
			.mod_assign { '%=' }
			.and_assign { '&=' }
			.or_assign { '|=' }
			.xor_assign { '^=' }
			.left_shift_assign { '<<=' }
			.right_shift_assign { '>>=' }
			else { '=' }
		}

		g.sb.write_string(' ${op_str} ')
		mut rhs_array_elem_type := g.infer_array_method_elem_type(rhs)
		mut assign_lhs_type := g.get_expr_type(lhs)
		if lhs is ast.Ident {
			if local_type := g.get_local_var_c_type(lhs.name) {
				assign_lhs_type = local_type
			} else {
				// For globals, use the declared type from global_var_types.
				// The env-based expr type may reflect the RHS type, not the LHS.
				mut global_name := lhs.name
				if global_name !in g.global_var_types && g.cur_module != ''
					&& g.cur_module != 'main' && g.cur_module != 'builtin' {
					global_name = '${g.cur_module}__${lhs.name}'
				}
				if global_name in g.global_var_types {
					assign_lhs_type = g.global_var_types[global_name]
				}
			}
		} else if lhs is ast.SelectorExpr {
			if assign_lhs_type == '' || assign_lhs_type == 'int' {
				field_type := g.selector_field_type(lhs)
				if field_type != '' {
					assign_lhs_type = field_type
				}
			}
		}
		if lhs_needs_deref && assign_lhs_type.ends_with('*') {
			assign_lhs_type = assign_lhs_type[..assign_lhs_type.len - 1]
		}
		if node.op == .assign && is_none_like_expr(rhs)
			&& g.gen_none_literal_for_type(assign_lhs_type) {
			g.sb.writeln(';')
			return
		}
		if node.op == .assign && g.gen_enum_shorthand_for_type(rhs, assign_lhs_type) {
			g.sb.writeln(';')
			return
		}
		// When RHS is an array method (first/last/pop/pop_left), the call emission
		// in fn.v already wraps with (*(elem_type*)call(...)). Skip the outer
		// assign-level cast to avoid double dereference.
		mut call_already_casts := false
		if rhs_array_elem_type != '' {
			if rhs is ast.CallExpr {
				if rhs.lhs is ast.Ident
					&& rhs.lhs.name in ['array__pop', 'array__pop_left', 'array__first', 'array__last']
					&& rhs.args.len > 0 {
					call_elem := g.infer_array_elem_type_from_expr(rhs.args[0])
					if call_elem != '' {
						call_already_casts = true
					}
				}
			}
		}
		if rhs_array_elem_type != '' && assign_lhs_type !in ['', 'void*', 'voidptr']
			&& !assign_lhs_type.ends_with('*') && !call_already_casts {
			g.sb.write_string('(*(${assign_lhs_type}*)')
			g.expr(rhs)
			g.sb.write_string(')')
		} else if node.op == .assign && assign_lhs_type != '' && assign_lhs_type.ends_with('*') {
			// Pointer assignment: check if LHS is a pointer to an interface type
			// and RHS is a pointer to a concrete type (e.g., Logger* = new_thread_safe_log())
			rhs_type := g.get_expr_type(rhs)
			lhs_base := assign_lhs_type.trim_right('*')
			rhs_base2 := rhs_type.trim_right('*')
			if g.is_interface_type(lhs_base) && rhs_base2 != '' && rhs_base2 != 'int'
				&& rhs_base2 != lhs_base && !g.is_interface_type(rhs_base2)
				&& !lhs_base.starts_with('Array_') && lhs_base != 'array'
				&& !lhs_base.starts_with('Map_') && lhs_base != 'map' {
				if !g.gen_heap_interface_cast(lhs_base, rhs) {
					g.expr(rhs)
				}
			} else {
				g.expr(rhs)
			}
		} else if node.op == .assign && assign_lhs_type != '' && !assign_lhs_type.ends_with('*') {
			rhs_type := g.get_expr_type(rhs)
			lhs_base := assign_lhs_type.trim_right('*')
			rhs_base2 := rhs_type.trim_right('*')
			rhs_casts_to_lhs := rhs is ast.CastExpr && g.expr_type_to_c(rhs.typ) == assign_lhs_type
			// Auto-wrap raw value into Option/Result when LHS is Option/Result and RHS is not.
			if assign_lhs_type.starts_with('_option_') && !rhs_casts_to_lhs
				&& !rhs_type.starts_with('_option_') && rhs_type !in ['', 'int', 'void']
				&& !is_none_like_expr(rhs) {
				value_type := option_value_type(assign_lhs_type)
				if value_type != '' && value_type != 'void' {
					g.sb.write_string('({ ${assign_lhs_type} _opt = (${assign_lhs_type}){ .state = 2 }; ${value_type} _val = ')
					g.expr(rhs)
					g.sb.write_string('; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; })')
					g.sb.writeln(';')
					return
				}
			}
			if assign_lhs_type.starts_with('_result_') && !rhs_casts_to_lhs
				&& !rhs_type.starts_with('_result_') && rhs_type !in ['', 'int', 'void'] {
				value_type := g.result_value_type(assign_lhs_type)
				if value_type != '' && value_type != 'void' {
					g.sb.write_string('({ ${assign_lhs_type} _res = (${assign_lhs_type}){0}; ${value_type} _val = ')
					g.expr(rhs)
					g.sb.write_string('; _result_ok(&_val, (_result*)&_res, sizeof(_val)); _res; })')
					g.sb.writeln(';')
					return
				}
			}
			if lhs_base in g.sum_type_variants && rhs_base2 != lhs_base && rhs_base2 != 'void' {
				g.gen_type_cast_expr(lhs_base, rhs)
			} else if g.is_interface_type(lhs_base) && rhs_base2 != '' && rhs_base2 != 'int'
				&& rhs_base2 != lhs_base && !g.is_interface_type(rhs_base2)
				&& !lhs_base.starts_with('Array_') && lhs_base != 'array'
				&& !lhs_base.starts_with('Map_') && lhs_base != 'map' {
				if g.gen_interface_cast(lhs_base, rhs) {
				} else {
					g.expr(rhs)
				}
			} else if rhs_type.ends_with('*') {
				rhs_base := rhs_type.trim_right('*')
				if rhs_base == assign_lhs_type
					|| short_type_name(rhs_base) == short_type_name(assign_lhs_type) {
					g.sb.write_string('(*')
					g.expr(rhs)
					g.sb.write_string(')')
				} else {
					g.expr(rhs)
				}
			} else {
				g.expr(rhs)
			}
		} else {
			g.expr(rhs)
		}
		g.sb.writeln(';')
	}
}

fn (mut g Gen) gen_plain_selector_assign(lhs ast.SelectorExpr, rhs ast.Expr, op token.Token) bool {
	if op != .assign || lhs.rhs.name == 'data' {
		return false
	}
	local_type := g.local_var_c_type_for_expr(lhs.lhs) or { return false }
	lhs_struct := strip_pointer_type_name(local_type)
	if lhs_struct == '' {
		return false
	}
	field_type := g.lookup_struct_field_type_by_name(lhs_struct, lhs.rhs.name) or { return false }
	if field_type.starts_with('Array_fixed_') || field_type.starts_with('_option_')
		|| field_type.starts_with('_result_') || field_type in g.sum_type_variants
		|| g.is_interface_type(field_type.trim_right('*')) {
		return false
	}
	g.write_indent()
	g.gen_selector_lvalue(lhs, local_type, lhs_struct)
	g.sb.write_string(' = ')
	if !g.gen_enum_shorthand_for_type(rhs, field_type) {
		g.expr(rhs)
	}
	g.sb.writeln(';')
	return true
}

fn (mut g Gen) gen_selector_lvalue(sel ast.SelectorExpr, local_type string, lhs_struct string) {
	mut use_ptr := g.selector_use_ptr(sel.lhs)
	if sel.lhs is ast.Ident && sel.lhs.name in g.cur_fn_mut_params {
		use_ptr = true
	} else {
		use_ptr = local_type.ends_with('*') || local_type == 'chan'
	}
	owner := g.embedded_owner_for(lhs_struct, sel.rhs.name)
	field_name := escape_c_keyword(sel.rhs.name)
	selector := if use_ptr { '->' } else { '.' }
	g.expr(sel.lhs)
	if owner != '' {
		g.sb.write_string('${selector}${escape_c_keyword(owner)}.${field_name}')
	} else {
		g.sb.write_string('${selector}${field_name}')
	}
}

fn (mut g Gen) gen_decl_assign_from_local_index(name string, storage_prefix string, decl_c_name string, rhs ast.IndexExpr) bool {
	if name == '' || rhs.expr is ast.RangeExpr || rhs.lhs !is ast.Ident {
		return false
	}
	lhs_ident := rhs.lhs as ast.Ident
	local_type := g.get_local_var_c_type(lhs_ident.name) or { return false }
	local_c_type := local_type.trim_space()
	if local_c_type == '' || local_c_type.ends_with('*') {
		return false
	}
	elem_type := g.array_alias_elem_type_from_c_type(local_c_type)
	if elem_type == '' || elem_type == 'array' || elem_type == 'void' {
		return false
	}
	g.write_indent()
	g.sb.write_string('${storage_prefix}${elem_type} ${decl_c_name} = ')
	if local_c_type.starts_with('Array_fixed_') {
		g.expr(rhs.lhs)
		g.sb.write_string('[')
	} else {
		g.sb.write_string('((${elem_type}*)')
		g.expr(rhs.lhs)
		g.sb.write_string('.data)[')
	}
	g.gen_index_expr_value(rhs.expr)
	g.sb.writeln('];')
	g.remember_runtime_local_type(name, elem_type)
	return true
}

// resolve_struct_field_fn_return looks up a field by name in a struct type,
// checks if it's a function pointer (possibly wrapped in an alias), and
// returns the C type name of the function's return type.
fn (mut g Gen) resolve_struct_field_fn_return(st types.Struct, field_name string) string {
	for field in st.fields {
		if field.name == field_name {
			ft := field.typ
			if ft is types.FnType {
				if rt := ft.get_return_type() {
					return g.fn_return_type_to_c(rt)
				}
			} else if ft is types.Alias {
				if ft.base_type is types.FnType {
					fn_t := ft.base_type as types.FnType
					if rt := fn_t.get_return_type() {
						return g.fn_return_type_to_c(rt)
					}
				}
			}
			break
		}
	}
	return ''
}