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

import v2.ast
import v2.types
import v2.token

fn is_numeric_literal_expr(expr ast.Expr) bool {
	match expr {
		ast.BasicLiteral {
			return expr.kind == .number
		}
		ast.PrefixExpr {
			return expr.op == .minus && expr.expr is ast.BasicLiteral && expr.expr.kind == .number
		}
		ast.ParenExpr {
			return is_numeric_literal_expr(expr.expr)
		}
		else {
			return false
		}
	}
}

fn (mut t Transformer) synth_selector(lhs ast.Expr, field_name string, typ types.Type) ast.Expr {
	pos := t.next_synth_pos()
	t.register_synth_type(pos, typ)
	return ast.Expr(ast.SelectorExpr{
		lhs: lhs
		rhs: ast.Ident{
			name: field_name
		}
		pos: pos
	})
}

// synth_selector_from_struct creates a typed SelectorExpr by looking up the field type
// from the named struct in the environment. Falls back to a pos-only synth node if
// the field type cannot be resolved.
fn (mut t Transformer) synth_selector_from_struct(lhs ast.Expr, field_name string, struct_name string) ast.Expr {
	pos := t.next_synth_pos()
	if field_typ := t.lookup_struct_field_type(struct_name, field_name) {
		t.register_synth_type(pos, field_typ)
	}
	return ast.Expr(ast.SelectorExpr{
		lhs: lhs
		rhs: ast.Ident{
			name: field_name
		}
		pos: pos
	})
}

// lookup_struct_field_type returns the raw types.Type for a struct field.
fn transformer_object_type(obj types.Object) ?types.Type {
	match obj {
		types.Type {
			return types.Type(obj)
		}
		types.TypeObject {
			return obj.typ
		}
		else {}
	}

	return none
}

fn (t &Transformer) lookup_struct_field_type(struct_name string, field_name string) ?types.Type {
	if struct_name.len == 0 || field_name.len == 0 || struct_name.len > 1024
		|| field_name.len > 1024 || !transformer_string_has_valid_data(struct_name)
		|| !transformer_string_has_valid_data(field_name) {
		return none
	}
	if field_type := t.lookup_struct_field_generic_decl_type(struct_name, field_name) {
		return field_type
	}
	mut sname := struct_name
	mut mod := ''
	dunder := struct_name.last_index('__') or { -1 }
	if dunder >= 0 {
		mod = struct_name[..dunder]
		sname = struct_name[dunder + 2..]
		if field_type := t.cached_struct_field_types[struct_field_lookup_cache_key(mod, sname,
			field_name)]
		{
			return field_type
		}
		if field_type := t.cached_struct_field_types[struct_field_generic_decl_key(struct_name,
			field_name)]
		{
			return field_type
		}
	} else if dot := struct_name.last_index('.') {
		mod = struct_name[..dot]
		sname = struct_name[dot + 1..]
		if field_type := t.cached_struct_field_types[struct_field_lookup_cache_key(mod, sname,
			field_name)]
		{
			return field_type
		}
		dot_name := struct_name.replace('.', '__')
		if field_type := t.cached_struct_field_types[struct_field_generic_decl_key(dot_name,
			field_name)]
		{
			return field_type
		}
	} else if t.cur_module != '' {
		if field_type := t.cached_struct_field_types[struct_field_lookup_cache_key(t.cur_module,
			sname, field_name)]
		{
			return field_type
		}
	}
	// Try module scope first if qualified
	if mod != '' {
		if scope := t.cached_scopes[mod] {
			if obj := scope.objects[sname] {
				if typ := transformer_object_type(obj) {
					if typ is types.Struct {
						if field_type := t.struct_field_type(typ, field_name) {
							return field_type
						}
					}
				}
			}
		}
	}
	// For unqualified names, try the current module first to avoid
	// collisions (e.g., ast.OptionType vs types.OptionType).
	if mod == '' && t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin' {
		if cur_scope := t.cached_scopes[t.cur_module] {
			if obj := cur_scope.objects[sname] {
				if typ := transformer_object_type(obj) {
					if typ is types.Struct {
						if field_type := t.struct_field_type(typ, field_name) {
							return field_type
						}
					}
				}
			}
		}
	}
	// Fallback: scan all scopes
	for sk in t.cached_scope_keys {
		scope := t.cached_scopes[sk] or { continue }
		if obj := scope.objects[struct_name] {
			if typ := transformer_object_type(obj) {
				if typ is types.Struct {
					if field_type := t.struct_field_type(typ, field_name) {
						return field_type
					}
				}
			}
		}
		if sname != struct_name {
			if obj := scope.objects[sname] {
				if typ := transformer_object_type(obj) {
					if typ is types.Struct {
						if field_type := t.struct_field_type(typ, field_name) {
							return field_type
						}
					}
				}
			}
		}
	}
	return none
}

fn (t &Transformer) lookup_struct_field_generic_decl_type(struct_name string, field_name string) ?types.Type {
	if struct_name == '' || field_name == '' {
		return none
	}
	if field_type := t.struct_field_generic_decl_type_for_candidate(struct_name, field_name) {
		return field_type
	}
	if struct_name.contains('__') {
		short_name := struct_name.all_after_last('__')
		if short_name != '' && short_name != struct_name {
			if field_type := t.struct_field_generic_decl_type_for_candidate(short_name, field_name) {
				return field_type
			}
		}
	}
	if struct_name.index_u8(`.`) >= 0 {
		dot_name := struct_name.replace('.', '__')
		if dot_name != struct_name {
			if field_type := t.struct_field_generic_decl_type_for_candidate(dot_name, field_name) {
				return field_type
			}
		}
		short_name := struct_name.all_after_last('.')
		if short_name != '' && short_name != struct_name && short_name != dot_name {
			if field_type := t.struct_field_generic_decl_type_for_candidate(short_name, field_name) {
				return field_type
			}
		}
	}
	return none
}

fn (t &Transformer) struct_field_generic_decl_type_for_candidate(struct_name string, field_name string) ?types.Type {
	key := struct_field_generic_decl_key(struct_name, field_name)
	field_type := t.struct_field_generic_decl_types[key] or { return none }
	return field_type
}

fn (t &Transformer) lookup_struct_field_generic_decl_bindings(struct_name string, field_name string) ?map[string]types.Type {
	if struct_name == '' || field_name == '' {
		return none
	}
	if bindings := t.struct_field_generic_decl_bindings_for_candidate(struct_name, field_name) {
		return bindings
	}
	if struct_name.contains('__') {
		short_name := struct_name.all_after_last('__')
		if short_name != '' && short_name != struct_name {
			if bindings := t.struct_field_generic_decl_bindings_for_candidate(short_name,
				field_name)
			{
				return bindings
			}
		}
	}
	if struct_name.index_u8(`.`) >= 0 {
		dot_name := struct_name.replace('.', '__')
		if dot_name != struct_name {
			if bindings := t.struct_field_generic_decl_bindings_for_candidate(dot_name, field_name) {
				return bindings
			}
		}
		short_name := struct_name.all_after_last('.')
		if short_name != '' && short_name != struct_name && short_name != dot_name {
			if bindings := t.struct_field_generic_decl_bindings_for_candidate(short_name,
				field_name)
			{
				return bindings
			}
		}
	}
	return none
}

fn (t &Transformer) struct_field_generic_decl_bindings_for_candidate(struct_name string, field_name string) ?map[string]types.Type {
	key := struct_field_generic_decl_key(struct_name, field_name)
	if bindings := t.struct_field_generic_decl_bindings[key] {
		return bindings.clone()
	}
	return none
}

fn struct_field_lookup_candidates(struct_name string) []string {
	mut candidates := []string{}
	if struct_name != '' {
		candidates << struct_name
		if struct_name.contains('__') {
			short_name := struct_name.all_after_last('__')
			if short_name != '' && short_name !in candidates {
				candidates << short_name
			}
		}
		if struct_name.contains('.') {
			dot_name := struct_name.replace('.', '__')
			if dot_name !in candidates {
				candidates << dot_name
			}
			short_name := struct_name.all_after_last('.')
			if short_name != '' && short_name !in candidates {
				candidates << short_name
			}
		}
	}
	return candidates
}

fn embedded_type_name_matches(embedded_name string, field_name string) bool {
	if embedded_name == field_name {
		return true
	}
	if embedded_name.contains('__') && embedded_name.all_after_last('__') == field_name {
		return true
	}
	if embedded_name.contains('.') && embedded_name.all_after_last('.') == field_name {
		return true
	}
	return false
}

fn (t &Transformer) live_embedded_struct_type(embedded types.Struct) types.Struct {
	if embedded.name != '' {
		if live_type := t.lookup_struct_type_any_module(embedded.name) {
			return live_type
		}
		if live_type := t.lookup_type(embedded.name) {
			if live_type is types.Struct {
				return live_type
			}
		}
		if embedded.name.contains('__') {
			short_name := embedded.name.all_after_last('__')
			if live_type := t.lookup_struct_type_any_module(short_name) {
				return live_type
			}
			if live_type := t.lookup_type(short_name) {
				if live_type is types.Struct {
					return live_type
				}
			}
		}
	}
	return embedded
}

fn (t &Transformer) struct_field_type(struct_type types.Struct, field_name string) ?types.Type {
	mut seen := map[string]bool{}
	return t.struct_field_type_inner(struct_type, field_name, mut seen)
}

fn (t &Transformer) struct_field_type_inner(struct_type types.Struct, field_name string, mut seen map[string]bool) ?types.Type {
	if struct_type.name != '' {
		if struct_type.name in seen {
			return none
		}
		seen[struct_type.name] = true
	}
	for field in struct_type.fields {
		if !transformer_string_has_valid_data(field.name) {
			continue
		}
		if field.name == field_name {
			return field.typ
		}
	}
	for embedded in struct_type.embedded {
		live_embedded := t.live_embedded_struct_type(embedded)
		if embedded_type_name_matches(live_embedded.name, field_name) {
			return types.Type(live_embedded)
		}
		if field_type := t.struct_field_type_inner(live_embedded, field_name, mut seen) {
			return field_type
		}
	}
	return none
}

// open_scope creates a new nested scope
fn (mut t Transformer) apply_smartcast_field_access_ctx(sumtype_expr ast.Expr, field_name string, ctx SmartcastContext) ast.Expr {
	// variant (short name) is used for union member access
	// variant_full (full name) is used for type cast
	variant_short := ctx.variant
	// Extract simple variant name for _data._ accessor
	// Union fields use: _Null (same-module Ident), _time__Time (cross-module SelectorExpr),
	// _Array_json2__Any (composite). Only strip module prefix for same-module types.
	// Union fields use the name as seen from the declaring module:
	// same-module Ident → _Null, cross-module SelectorExpr → _time__Time.
	// Strip module prefix when the variant's module matches the sumtype's module,
	// because those variants were declared as Idents (no module prefix in the union).
	sumtype_module := if ctx.sumtype.contains('__') {
		ctx.sumtype.all_before_last('__')
	} else {
		''
	}
	variant_simple := if variant_short.starts_with('Array_') || variant_short.starts_with('Map_') {
		// For composite types, use the short name to match union member
		variant_short
	} else if variant_short.contains('__') {
		mod_prefix := variant_short.all_before_last('__')
		if mod_prefix == sumtype_module {
			variant_short.all_after_last('__')
		} else {
			variant_short
		}
	} else {
		variant_short
	}
	// Use full variant name for type cast from context
	mangled_variant := if ctx.variant_full != '' {
		ctx.variant_full
	} else if variant_short.contains('__') {
		variant_short // Already has module prefix
	} else if t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin' {
		'${t.cur_module}__${variant_short}'
	} else {
		variant_short
	}
	// For nested smartcasts, we need to transform the base of sumtype_expr to apply outer smartcasts
	// E.g., for stmt.receiver.typ with outer smartcast on stmt, we need to transform stmt.receiver first.
	// Temporarily remove this exact context to avoid applying it recursively.
	removed_ctxs := t.remove_matching_smartcasts(ctx)
	transformed_base := t.transform_expr(sumtype_expr)
	t.restore_smartcasts(removed_ctxs)
	if t.expr_is_casted_to_type(transformed_base, '${mangled_variant}*') {
		return t.synth_selector_from_struct(transformed_base, field_name, mangled_variant)
	}
	// Already concretely casted to this variant by an outer smartcast context.
	if t.expr_is_casted_to_type(transformed_base, mangled_variant) {
		return t.synth_selector_from_struct(transformed_base, field_name, mangled_variant)
	}
	// For interface smartcasts, use _object instead of _data
	is_interface_ctx := ctx.sumtype.starts_with('__iface__')
	if is_interface_ctx {
		object_access := t.synth_selector(transformed_base, '_object', types.Type(types.voidptr_))
		cast_expr := ast.CastExpr{
			typ:  ast.Ident{
				name: '${mangled_variant}*'
			}
			expr: object_access
		}
		return t.synth_selector_from_struct(ast.ParenExpr{
			expr: cast_expr
		}, field_name, mangled_variant)
	}
	// Create data access.
	// For native backends (arm64/x64): _data is a plain i64 (void pointer) in the SSA struct.
	// No union variant sub-field exists, so just use _data directly.
	// For C backends: _data is a union, so access _data._variant for the specific member.
	is_native_backend := t.pref != unsafe { nil } && t.is_native_be
	data_access := t.synth_selector(transformed_base, '_data', types.Type(types.voidptr_))
	variant_access := if is_native_backend {
		data_access
	} else {
		t.synth_selector(data_access, '_${variant_simple}', types.Type(types.voidptr_))
	}
	if t.is_eval_backend() {
		return t.synth_selector_from_struct(variant_access, field_name, mangled_variant)
	}
	// Create: (mangled_variant*)variant_access
	cast_expr := ast.CastExpr{
		typ:  ast.Ident{
			name: '${mangled_variant}*'
		}
		expr: variant_access
	}
	// Create: cast_expr->field_name (cleanc will handle pointer arrow vs dot)
	return t.synth_selector_from_struct(ast.Expr(cast_expr), field_name, mangled_variant)
}

fn (mut t Transformer) transform_array_init_expr(expr ast.ArrayInitExpr) ast.Expr {
	if !expr_array_has_valid_data(expr.exprs) {
		return ast.Expr(expr)
	}
	is_native_backend := t.pref != unsafe { nil } && t.is_native_be
	native_interface_elem_type := if is_native_backend {
		t.get_interface_array_init_concrete_type(&expr) or { '' }
	} else {
		''
	}
	// Transform value expressions
	mut exprs := []ast.Expr{cap: expr.exprs.len}
	for e in expr.exprs {
		if native_interface_elem_type != '' {
			if inner := t.get_interface_cast_inner_expr(e) {
				exprs << t.transform_expr(inner)
				continue
			}
		}
		exprs << t.transform_expr(e)
	}

	// Check if this is a fixed-size array
	mut is_fixed := false
	mut array_typ := expr.typ
	mut elem_type_expr := ast.empty_expr
	has_fixed_marker := array_init_has_fixed_len_marker(expr)
	// Check for ArrayFixedType or ArrayType (expr.typ is ast.Type sum type)
	if expr.typ is ast.Type {
		if expr.typ is ast.ArrayFixedType {
			is_fixed = true
		} else if expr.typ is ast.ArrayType {
			elem_type_expr = expr.typ.elem_type
		}
	}
	// For untyped `[]` literals, use checker-inferred type from context (assign/call/return).
	if array_typ is ast.EmptyExpr {
		if !has_fixed_marker {
			if literal_type := t.get_array_init_expr_type(expr) {
				if literal_type is types.Array {
					array_typ = t.type_to_ast_type_expr(literal_type)
					elem_type_expr = t.type_to_ast_type_expr(literal_type.elem_type)
				}
			}
		}
	}
	if array_typ is ast.EmptyExpr {
		if inferred := t.get_expr_type(ast.Expr(expr)) {
			inferred_base := t.unwrap_alias_and_pointer_type(inferred)
			match inferred_base {
				types.Array {
					array_typ = t.type_to_ast_type_expr(inferred_base)
					elem_type_expr = t.type_to_ast_type_expr(inferred_base.elem_type)
				}
				types.ArrayFixed {
					array_typ = t.type_to_ast_type_expr(inferred_base)
					elem_type_expr = t.type_to_ast_type_expr(inferred_base.elem_type)
					is_fixed = true
				}
				else {}
			}
		}
	}
	if native_interface_elem_type != '' {
		elem_type_expr = ast.Expr(ast.Ident{
			name: native_interface_elem_type
		})
		array_typ = ast.Expr(ast.Type(ast.ArrayType{
			elem_type: elem_type_expr
		}))
	}
	// Also check for [x, y, z]! syntax - parser marks this with len: PostfixExpr{op: .not}
	if has_fixed_marker {
		is_fixed = true
		if expr.typ is ast.EmptyExpr {
			array_typ = ast.Expr(ast.empty_expr)
		}
		if array_typ is ast.Type && array_typ is ast.ArrayType {
			array_typ = ast.Expr(ast.Type(ast.ArrayFixedType{
				len:       ast.BasicLiteral{
					kind:  .number
					value: '${expr.exprs.len}'
				}
				elem_type: elem_type_expr
			}))
		} else if array_typ is ast.EmptyExpr {
			if elem_type := t.get_array_init_elem_expr_type(if expr.exprs.len > 0 {
				expr.exprs[0]
			} else {
				expr.init
			})
			{
				array_typ = ast.Expr(ast.Type(ast.ArrayFixedType{
					len:       ast.BasicLiteral{
						kind:  .number
						value: '${expr.exprs.len}'
					}
					elem_type: t.type_to_ast_type_expr(elem_type)
				}))
			} else if elem_type_expr !is ast.EmptyExpr {
				array_typ = ast.Expr(ast.Type(ast.ArrayFixedType{
					len:       ast.BasicLiteral{
						kind:  .number
						value: '${expr.exprs.len}'
					}
					elem_type: elem_type_expr
				}))
			}
		}
	}

	if is_fixed {
		// Fixed-size array: keep as ArrayInitExpr
		return ast.ArrayInitExpr{
			typ:   array_typ
			exprs: exprs
			init:  t.transform_expr(expr.init)
			cap:   if expr.cap !is ast.EmptyExpr { t.transform_expr(expr.cap) } else { expr.cap }
			len:   if expr.len !is ast.EmptyExpr { t.transform_expr(expr.len) } else { expr.len }
			pos:   expr.pos
		}
	}

	if t.is_eval_backend() {
		return ast.ArrayInitExpr{
			typ:         array_typ
			exprs:       exprs
			init:        if expr.init !is ast.EmptyExpr {
				t.transform_expr(expr.init)
			} else {
				expr.init
			}
			cap:         if expr.cap !is ast.EmptyExpr {
				t.transform_expr(expr.cap)
			} else {
				expr.cap
			}
			len:         if expr.len !is ast.EmptyExpr {
				t.transform_expr(expr.len)
			} else {
				expr.len
			}
			update_expr: if expr.update_expr !is ast.EmptyExpr {
				t.transform_expr(expr.update_expr)
			} else {
				expr.update_expr
			}
			pos:         expr.pos
		}
	}

	// Spread syntax `[...base, e1, e2]` — lower to
	// builtin__new_array_from_array_and_c_array(array__clone_to_depth(&base, depth),
	//   n, sizeof(elem), {e1, e2}).
	if expr.update_expr !is ast.EmptyExpr {
		return t.transform_array_spread_expr(expr, exprs, elem_type_expr)
	}

	// Dynamic array: transform to builtin__new_array_from_c_array_noscan(len, cap, sizeof(elem), values)
	arr_len := exprs.len

	// Handle empty dynamic arrays: lower to __new_array_with_default_noscan(len, cap, sizeof(elem), init)
	if arr_len == 0 {
		sizeof_expr := if elem_type_expr !is ast.EmptyExpr {
			elem_type_expr
		} else {
			ast.Expr(ast.Ident{
				name: 'int'
			})
		}
		len_expr := ast.Expr(if expr.len !is ast.EmptyExpr {
			t.transform_expr(expr.len)
		} else {
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '0'
			})
		})
		cap_expr := ast.Expr(if expr.cap !is ast.EmptyExpr {
			t.transform_expr(expr.cap)
		} else {
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '0'
			})
		})
		mut init_expr := ast.Expr(if expr.init !is ast.EmptyExpr {
			t.transform_expr(expr.init)
		} else {
			ast.Expr(ast.Ident{
				name: 'nil'
			})
		})
		if expr.init !is ast.EmptyExpr && is_numeric_literal_expr(init_expr) {
			init_expr = ast.Expr(ast.CastExpr{
				typ:  sizeof_expr
				expr: init_expr
			})
		}
		// If init expression uses `index`, expand to a for-loop that assigns each element.
		if expr.init !is ast.EmptyExpr && t.expr_contains_ident_named(init_expr, 'index') {
			return t.expand_array_init_with_index(len_expr, cap_expr, sizeof_expr, init_expr,
				expr.pos)
		}
		// When element type is a reference type (array or map) and no explicit init,
		// synthesize a proper default so inner elements get initialized correctly
		// (not zero-filled via NULL, which leaves element_size=0 or hash_fn=null).
		// sizeof_expr holds elem_type_expr before smartcasting, so use it to avoid issues.
		elem_is_nested_array := elem_type_expr is ast.Type && elem_type_expr is ast.ArrayType
		elem_is_map := elem_type_expr is ast.Type && elem_type_expr is ast.MapType
		if expr.init is ast.EmptyExpr && elem_is_nested_array {
			init_expr = ast.Expr(t.transform_array_init_expr(ast.ArrayInitExpr{
				typ: sizeof_expr
			}))
		}
		if expr.init is ast.EmptyExpr && elem_is_map {
			init_expr = ast.Expr(t.transform_map_init_expr(ast.MapInitExpr{
				typ: sizeof_expr
			}))
		}
		// When element type is a struct with map fields and no explicit init,
		// synthesize a struct default and use for-loop expansion so each element
		// gets its own map allocation (memcpy would share internal pointers).
		if expr.init is ast.EmptyExpr && !elem_is_nested_array && !elem_is_map {
			if elem_type := t.get_expr_type(elem_type_expr) {
				elem_base := t.unwrap_alias_and_pointer_type(elem_type)
				if elem_base is types.Struct {
					mut field_inits := []ast.FieldInit{}
					for field in elem_base.fields {
						if field.typ is types.Map {
							map_type_expr := t.type_to_ast_type_expr(field.typ)
							map_init := t.transform_map_init_expr(ast.MapInitExpr{
								typ: map_type_expr
							})
							field_inits << ast.FieldInit{
								name:  field.name
								value: map_init
							}
						}
					}
					if field_inits.len > 0 {
						struct_init := ast.Expr(ast.InitExpr{
							typ:    elem_type_expr
							fields: field_inits
						})
						return t.expand_array_init_with_index(len_expr, cap_expr, sizeof_expr,
							struct_init, expr.pos)
					}
				}
			}
		}
		// When init value is an array, use __new_array_with_array_default for deep cloning
		// (shallow memcpy would share data pointers between all elements)
		mut init_is_array := expr.init is ast.ArrayInitExpr
		if !init_is_array && elem_is_nested_array && expr.init is ast.EmptyExpr {
			init_is_array = true
		}
		if !init_is_array {
			if init_type := t.get_expr_type(expr.init) {
				init_base := t.unwrap_alias_and_pointer_type(init_type)
				init_is_array = init_base is types.Array
			}
		}
		if init_is_array {
			return ast.CallExpr{
				lhs:  ast.Ident{
					name: '__new_array_with_array_default'
				}
				args: [
					len_expr,
					cap_expr,
					ast.Expr(ast.KeywordOperator{
						op:    .key_sizeof
						exprs: [sizeof_expr]
					}),
					init_expr,
					// depth parameter for clone_to_depth
					ast.Expr(ast.BasicLiteral{
						kind:  .number
						value: '3'
					}),
				]
				pos:  expr.pos
			}
		}
		return ast.CallExpr{
			lhs:  ast.Ident{
				name: '__new_array_with_default_noscan'
			}
			args: [
				len_expr,
				cap_expr,
				ast.Expr(ast.KeywordOperator{
					op:    .key_sizeof
					exprs: [sizeof_expr]
				}),
				init_expr,
			]
			pos:  expr.pos
		}
	}

	// Determine element type name and sizeof argument
	// First, try to get the array type from the type checker's annotations
	mut elem_type_name := 'int'
	mut elem_type_expr_resolved := elem_type_expr
	if elem_type_expr_resolved is ast.EmptyExpr && exprs.len > 0 {
		if arr_type := t.env.get_expr_type(expr.pos.id) {
			match arr_type {
				types.Array {
					tn := t.type_to_c_name(arr_type.elem_type)
					if tn != '' {
						elem_type_name = tn
						elem_type_expr_resolved = ast.Expr(ast.Ident{
							name: tn
						})
					}
				}
				types.ArrayFixed {
					tn := t.type_to_c_name(arr_type.elem_type)
					if tn != '' {
						elem_type_name = tn
						elem_type_expr_resolved = ast.Expr(ast.Ident{
							name: tn
						})
					}
				}
				else {}
			}
		}
		// If env lookup failed, try getting element type from the ORIGINAL (untransformed)
		// first expression, which preserves CastExpr and other type-annotated nodes
		if elem_type_expr_resolved is ast.EmptyExpr {
			orig_first := expr.exprs[0]
			if elem_type := t.get_expr_type(orig_first) {
				tn := t.type_to_c_name(elem_type)
				if tn != '' {
					elem_type_name = tn
					elem_type_expr_resolved = ast.Expr(ast.Ident{
						name: tn
					})
				}
			} else {
			}
			// If still not resolved, check if first expr is a CallExpr and look up its return type
			if elem_type_expr_resolved is ast.EmptyExpr {
				first := exprs[0]
				if first is ast.CallExpr || first is ast.CallOrCastExpr {
					if ret_type := t.get_method_return_type(first) {
						tn := t.type_to_c_name(ret_type)
						if tn != '' {
							elem_type_name = tn
							elem_type_expr_resolved = ast.Expr(ast.Ident{
								name: tn
							})
						}
					} else if first is ast.CallExpr {
						// Try looking up by function name for plain function calls
						fn_name := if first.lhs is ast.Ident {
							first.lhs.name
						} else {
							''
						}
						if fn_name != '' {
							if ret_type2 := t.get_fn_return_type(fn_name) {
								tn := t.type_to_c_name(ret_type2)
								if tn != '' {
									elem_type_name = tn
									elem_type_expr_resolved = ast.Expr(ast.Ident{
										name: tn
									})
								}
							}
						}
					}
				}
			}
		}
	}
	sizeof_arg := if elem_type_expr_resolved !is ast.EmptyExpr {
		elem_type_name = t.expr_to_type_name(elem_type_expr_resolved)
		elem_type_expr_resolved
	} else if exprs.len > 0 {
		// Infer from first element
		first := exprs[0]
		if first is ast.BasicLiteral {
			if first.kind == .number {
				if first.value.contains('.') || first.value.contains('e')
					|| first.value.contains('E') {
					elem_type_name = 'f64'
				} else {
					elem_type_name = 'int'
				}
			} else if first.kind == .string {
				elem_type_name = 'string'
			}
			ast.Expr(ast.Ident{
				name: elem_type_name
			})
		} else if first is ast.StringLiteral {
			elem_type_name = 'string'
			ast.Expr(ast.Ident{
				name: 'string'
			})
		} else if first is ast.SelectorExpr {
			// For enum values like .trim_left, use int for sizeof
			// Try to get actual enum type from environment
			if enum_type := t.get_expr_type(first) {
				type_name := t.type_to_c_name(enum_type)
				if type_name != '' {
					elem_type_name = type_name
					ast.Expr(ast.Ident{
						name: type_name
					})
				} else {
					elem_type_name = 'int'
					ast.Expr(ast.Ident{
						name: 'int'
					})
				}
			} else {
				elem_type_name = 'int'
				ast.Expr(ast.Ident{
					name: 'int'
				})
			}
		} else if first is ast.Ident {
			// Try to get type from scope
			var_type := t.get_var_type_name(first.name)
			if var_type != '' {
				elem_type_name = var_type
				ast.Expr(ast.Ident{
					name: var_type
				})
			} else {
				// Default: use int
				ast.Expr(ast.Ident{
					name: 'int'
				})
			}
		} else if first is ast.CallOrCastExpr {
			// Handle cast expressions like u8(`0`) - infer element type from cast type
			if first.lhs is ast.Ident {
				cast_type := first.lhs.name
				// Check if this is a primitive type cast
				if cast_type in ['u8', 'i8', 'u16', 'i16', 'u32', 'i32', 'u64', 'i64', 'f32', 'f64',
					'int', 'bool', 'byte', 'rune', 'voidptr', 'charptr', 'byteptr', 'usize', 'isize',
					'string'] {
					elem_type_name = cast_type
					ast.Expr(ast.Ident{
						name: cast_type
					})
				} else {
					// Could be a struct cast - use the type name
					elem_type_name = cast_type
					ast.Expr(ast.Ident{
						name: cast_type
					})
				}
			} else {
				// Default: use int
				ast.Expr(ast.Ident{
					name: 'int'
				})
			}
		} else if first is ast.CastExpr {
			// Handle explicit CastExpr nodes
			elem_type_name = t.expr_to_type_name(first.typ)
			ast.Expr(first.typ)
		} else if first is ast.IndexExpr {
			// Handle index expressions like s[i] - try to infer element type from the indexed container
			// Also handle slice expressions like s[..i] which become IndexExpr with RangeExpr
			// Extract first.lhs to avoid double smartcast in if-guard expansions
			first_lhs := first.lhs
			mut idx_sizeof := ast.Expr(ast.Ident{
				name: 'int'
			})
			if first.expr is ast.RangeExpr {
				// Slicing: s[a..b] returns the same type as s
				if expr_type := t.get_expr_type(first_lhs) {
					type_name := t.type_to_c_name(expr_type)
					if type_name != '' {
						elem_type_name = type_name
						idx_sizeof = ast.Expr(ast.Ident{
							name: type_name
						})
					}
				}
			} else if expr_type := t.get_expr_type(first_lhs) {
				type_name := t.type_to_c_name(expr_type)
				if type_name == 'string' {
					// String indexing returns u8
					elem_type_name = 'u8'
					idx_sizeof = ast.Expr(ast.Ident{
						name: 'u8'
					})
				} else if type_name.starts_with('Array_') {
					// Array indexing returns element type
					arr_elem := type_name[6..] // Remove 'Array_' prefix
					elem_type_name = arr_elem
					idx_sizeof = ast.Expr(ast.Ident{
						name: arr_elem
					})
				}
			}
			idx_sizeof
		} else if first is ast.CallExpr {
			// Handle function calls - try to infer return type
			if expr_type := t.get_expr_type(first) {
				type_name := t.type_to_c_name(expr_type)
				if type_name != '' {
					elem_type_name = type_name
					ast.Expr(ast.Ident{
						name: type_name
					})
				} else {
					ast.Expr(ast.Ident{
						name: 'int'
					})
				}
			} else {
				// Try to infer from function name for common patterns
				mut fn_name := ''
				if first.lhs is ast.Ident {
					fn_name = first.lhs.name
				} else if first.lhs is ast.SelectorExpr {
					fn_name = first.lhs.rhs.name
				}
				// Dynamic array construction functions return 'array' type
				if fn_name in ['builtin__new_array_from_c_array_noscan',
					'builtin__new_array_from_c_array', '__new_array_with_default_noscan',
					'new_array_from_c_array'] {
					elem_type_name = 'array'
					ast.Expr(ast.Ident{
						name: 'array'
					})
				} else if fn_name in ['substr', 'substr_unsafe', 'trim', 'trim_left', 'trim_right',
					'to_upper', 'to_lower', 'replace', 'reverse', 'clone', 'repeat'] {
					// String methods that return string
					elem_type_name = 'string'
					ast.Expr(ast.Ident{
						name: 'string'
					})
				} else {
					ast.Expr(ast.Ident{
						name: 'int'
					})
				}
			}
		} else if first is ast.InitExpr {
			// Struct literal - get the type name from the struct type
			init_type_name := t.expr_to_type_name(first.typ)
			if init_type_name != '' {
				elem_type_name = init_type_name
				ast.Expr(ast.Ident{
					name: init_type_name
				})
			} else {
				ast.Expr(ast.Ident{
					name: 'int'
				})
			}
		} else {
			// Default: use int
			ast.Expr(ast.Ident{
				name: 'int'
			})
		}
	} else {
		ast.Expr(ast.Ident{
			name: 'int'
		})
	}

	// Create proper array type for the inner ArrayInitExpr.
	// Use the resolved elem_type expression when available (preserves structured AST
	// type info like ArrayType, PrefixExpr for &T, etc.). Only fall back to the mangled
	// name string when no structured expression exists — the name-based path can lose
	// type structure (e.g., 'Array_int*' gets misinterpreted as ptr(array) in SSA).
	inner_elem_type := if elem_type_expr_resolved !is ast.EmptyExpr {
		elem_type_expr_resolved
	} else {
		ast.Expr(ast.Ident{
			name: elem_type_name
		})
	}
	inner_array_typ := ast.Type(ast.ArrayType{
		elem_type: inner_elem_type
	})

	return ast.CallExpr{
		lhs:  ast.Ident{
			name: 'builtin__new_array_from_c_array_noscan'
		}
		args: [
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '${arr_len}'
			}),
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '${arr_len}'
			}),
			ast.Expr(ast.KeywordOperator{
				op:    .key_sizeof
				exprs: [sizeof_arg]
			}),
			ast.Expr(ast.ArrayInitExpr{
				typ:   ast.Expr(inner_array_typ)
				exprs: exprs
			}),
		]
		pos:  expr.pos
	}
}

fn (mut t Transformer) transform_array_spread_expr(expr ast.ArrayInitExpr, exprs []ast.Expr, hint_elem_type_expr ast.Expr) ast.Expr {
	update_expr := t.transform_expr(expr.update_expr)
	// Resolve element type from the base array.
	mut elem_type_expr := hint_elem_type_expr
	mut clone_depth := 0
	if base_type := t.get_expr_type(expr.update_expr) {
		base_unwrapped := t.unwrap_alias_and_pointer_type(base_type)
		if base_unwrapped is types.Array {
			if elem_type_expr is ast.EmptyExpr {
				elem_type_expr = t.type_to_ast_type_expr(base_unwrapped.elem_type)
			}
			// Match V2 `.clone()` semantics for nested arrays: deep-clone inner
			// arrays so `[...nested]` doesn't share inner storage with `nested`.
			nesting := t.get_array_nesting_depth(base_type)
			if nesting > 1 {
				clone_depth = nesting - 1
			}
		}
	}
	sizeof_arg := if elem_type_expr !is ast.EmptyExpr {
		elem_type_expr
	} else {
		ast.Expr(ast.Ident{
			name: 'int'
		})
	}
	cloned_base := ast.Expr(ast.CallExpr{
		lhs:  ast.Ident{
			name: 'array__clone_to_depth'
		}
		args: [
			update_expr,
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '${clone_depth}'
			}),
		]
		pos:  expr.pos
	})
	new_count := exprs.len
	mut data_arg := ast.Expr(ast.CastExpr{
		typ:  ast.Expr(ast.Ident{
			name: 'voidptr'
		})
		expr: ast.Expr(ast.BasicLiteral{
			kind:  .number
			value: '0'
		})
	})
	if new_count > 0 {
		inner_array_typ := ast.Type(ast.ArrayType{
			elem_type: sizeof_arg
		})
		data_arg = ast.Expr(ast.ArrayInitExpr{
			typ:   ast.Expr(inner_array_typ)
			exprs: exprs
		})
	}
	return ast.CallExpr{
		lhs:  ast.Ident{
			name: 'builtin__new_array_from_array_and_c_array'
		}
		args: [
			cloned_base,
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '${new_count}'
			}),
			ast.Expr(ast.KeywordOperator{
				op:    .key_sizeof
				exprs: [sizeof_arg]
			}),
			data_arg,
		]
		pos:  expr.pos
	}
}

fn array_expr_with_expected_type(expr ast.Expr, expected_type ast.Expr) ast.Expr {
	if expr is ast.ArrayInitExpr {
		return ast.Expr(array_init_with_expected_type(expr, expected_type))
	}
	return expr
}

fn array_init_with_expected_type(expr ast.ArrayInitExpr, expected_type ast.Expr) ast.ArrayInitExpr {
	if expected_type is ast.EmptyExpr {
		return expr
	}
	mut rewritten_exprs := []ast.Expr{cap: expr.exprs.len}
	mut elem_type := ast.Expr(ast.empty_expr)
	if expected_type is ast.Type {
		expected_ast_type := expected_type as ast.Type
		if expected_ast_type is ast.ArrayType {
			array_type := expected_ast_type as ast.ArrayType
			elem_type = array_type.elem_type
		}
	}
	for item in expr.exprs {
		if item is ast.ArrayInitExpr && elem_type !is ast.EmptyExpr {
			rewritten_exprs << ast.Expr(array_init_with_expected_type(item, elem_type))
		} else {
			rewritten_exprs << item
		}
	}
	return ast.ArrayInitExpr{
		typ:   expected_type
		exprs: rewritten_exprs
		init:  expr.init
		cap:   expr.cap
		len:   expr.len
		pos:   expr.pos
	}
}

fn (mut t Transformer) transform_map_init_expr(expr ast.MapInitExpr) ast.Expr {
	// Determine key/value types from the explicit map type when available.
	mut key_type_expr := ast.Expr(ast.Ident{
		name: 'int'
	})
	mut val_type_expr := ast.Expr(ast.Ident{
		name: 'int'
	})
	mut key_type_name := 'int'
	mut have_explicit_map_type := false
	match expr.typ {
		ast.Type {
			expr_typ := expr.typ as ast.Type
			if expr_typ is ast.MapType {
				mt := expr_typ as ast.MapType
				key_type_expr = mt.key_type
				val_type_expr = mt.value_type
				key_type_name = t.expr_to_type_name(mt.key_type)
				have_explicit_map_type = true
			}
		}
		ast.Ident {
			if explicit_map_typ := t.lookup_type(expr.typ.name) {
				if explicit_map := t.unwrap_map_type(explicit_map_typ) {
					key_type_expr = t.type_to_ast_type_expr(explicit_map.key_type)
					val_type_expr = t.type_to_ast_type_expr(explicit_map.value_type)
					key_type_name = t.type_to_c_name(explicit_map.key_type)
					have_explicit_map_type = true
				}
			}
		}
		ast.SelectorExpr {
			explicit_map_name := t.expr_to_type_name(expr.typ)
			if explicit_map_name != '' {
				if explicit_map_typ := t.lookup_type(explicit_map_name) {
					if explicit_map := t.unwrap_map_type(explicit_map_typ) {
						key_type_expr = t.type_to_ast_type_expr(explicit_map.key_type)
						val_type_expr = t.type_to_ast_type_expr(explicit_map.value_type)
						key_type_name = t.type_to_c_name(explicit_map.key_type)
						have_explicit_map_type = true
					}
				}
			}
		}
		else {}
	}

	// Empty map literals `{}` rely on checker-provided expected type.
	// Use the inferred map type from the environment when the AST node doesn't carry one.
	if !have_explicit_map_type {
		if inferred := t.get_expr_type(ast.Expr(expr)) {
			if inferred_map := t.unwrap_map_type(inferred) {
				key_type_expr = t.type_to_ast_type_expr(inferred_map.key_type)
				val_type_expr = t.type_to_ast_type_expr(inferred_map.value_type)
				key_type_name = t.type_to_c_name(inferred_map.key_type)
			}
		}
	}

	// Transform key and value expressions (if any).
	mut keys := []ast.Expr{cap: expr.keys.len}
	mut vals := []ast.Expr{cap: expr.vals.len}
	for k in expr.keys {
		keys << t.transform_expr(k)
	}
	for v in expr.vals {
		vals << t.transform_expr(array_expr_with_expected_type(v, val_type_expr))
	}

	if keys.len > 0 && key_type_name != '' && key_type_name != 'int' {
		mut needs_enum_key_resolution := false
		for key_expr in keys {
			if key_expr is ast.SelectorExpr && key_expr.lhs is ast.EmptyExpr {
				needs_enum_key_resolution = true
				break
			}
		}
		if needs_enum_key_resolution {
			for i, key_expr in keys {
				keys[i] = t.transform_expr(t.resolve_enum_shorthand(key_expr, key_type_name))
			}
		}
	}

	// Infer map type from first entry when the checker didn't provide one.
	if key_type_name == 'int' && keys.len > 0 {
		first_key := keys[0]
		first_val := vals[0]
		if first_key is ast.BasicLiteral && first_key.kind == .string {
			key_type_name = 'string'
			key_type_expr = ast.Expr(ast.Ident{
				name: 'string'
			})
		} else if first_key is ast.StringLiteral {
			key_type_name = 'string'
			key_type_expr = ast.Expr(ast.Ident{
				name: 'string'
			})
		}
		if first_val is ast.BasicLiteral && first_val.kind == .string {
			val_type_expr = ast.Expr(ast.Ident{
				name: 'string'
			})
		} else if first_val is ast.StringLiteral {
			val_type_expr = ast.Expr(ast.Ident{
				name: 'string'
			})
		}
	}

	if t.is_eval_backend() {
		return ast.MapInitExpr{
			typ:  if expr.typ !is ast.EmptyExpr { t.transform_expr(expr.typ) } else { expr.typ }
			keys: keys
			vals: vals
			pos:  expr.pos
		}
	}

	hash_fn, eq_fn, clone_fn, free_fn := map_runtime_key_fns_from_type_name(key_type_name)

	// Empty map literal `{}`: lower to `new_map(sizeof(K), sizeof(V), &hash, &eq, &clone, &free)`.
	if keys.len == 0 {
		return ast.CallExpr{
			lhs:  ast.Ident{
				name: 'new_map'
			}
			args: [
				ast.Expr(ast.KeywordOperator{
					op:    .key_sizeof
					exprs: [key_type_expr]
				}),
				ast.Expr(ast.KeywordOperator{
					op:    .key_sizeof
					exprs: [val_type_expr]
				}),
				ast.Expr(ast.PrefixExpr{
					op:   .amp
					expr: ast.Ident{
						name: hash_fn
					}
				}),
				ast.Expr(ast.PrefixExpr{
					op:   .amp
					expr: ast.Ident{
						name: eq_fn
					}
				}),
				ast.Expr(ast.PrefixExpr{
					op:   .amp
					expr: ast.Ident{
						name: clone_fn
					}
				}),
				ast.Expr(ast.PrefixExpr{
					op:   .amp
					expr: ast.Ident{
						name: free_fn
					}
				}),
			]
			pos:  expr.pos
		}
	}

	n := keys.len

	// Create array types for keys and values.
	key_array_typ := ast.Type(ast.ArrayType{
		elem_type: key_type_expr
	})
	val_array_typ := ast.Type(ast.ArrayType{
		elem_type: val_type_expr
	})

	// new_map_init_noscan_value(hash_fn, eq_fn, clone_fn, free_fn, n, key_size, val_size, keys, vals)
	return ast.CallExpr{
		lhs:  ast.Ident{
			name: 'new_map_init_noscan_value'
		}
		args: [
			ast.Expr(ast.PrefixExpr{
				op:   .amp
				expr: ast.Ident{
					name: hash_fn
				}
			}),
			ast.Expr(ast.PrefixExpr{
				op:   .amp
				expr: ast.Ident{
					name: eq_fn
				}
			}),
			ast.Expr(ast.PrefixExpr{
				op:   .amp
				expr: ast.Ident{
					name: clone_fn
				}
			}),
			ast.Expr(ast.PrefixExpr{
				op:   .amp
				expr: ast.Ident{
					name: free_fn
				}
			}),
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '${n}'
			}),
			ast.Expr(ast.KeywordOperator{
				op:    .key_sizeof
				exprs: [key_type_expr]
			}),
			ast.Expr(ast.KeywordOperator{
				op:    .key_sizeof
				exprs: [val_type_expr]
			}),
			ast.Expr(ast.ArrayInitExpr{
				typ:   ast.Expr(key_array_typ)
				exprs: keys
			}),
			ast.Expr(ast.ArrayInitExpr{
				typ:   ast.Expr(val_array_typ)
				exprs: vals
			}),
		]
		pos:  expr.pos
	}
}

fn (mut t Transformer) transform_init_expr(expr ast.InitExpr) ast.Expr {
	// Typed empty map init: `map[K]V{}`.
	// Lower here so backends do not need to special-case map InitExpr nodes.
	if expr.fields.len == 0 {
		match expr.typ {
			ast.Type {
				expr_typ := expr.typ as ast.Type
				if expr_typ is ast.MapType {
					if t.is_eval_backend() {
						return ast.Expr(ast.MapInitExpr{
							typ:  ast.Expr(ast.Type(expr.typ))
							keys: []ast.Expr{}
							vals: []ast.Expr{}
							pos:  expr.pos
						})
					}
					mt := expr_typ as ast.MapType
					key_type_name := t.expr_to_type_name(mt.key_type)
					hash_fn, eq_fn, clone_fn, free_fn :=
						map_runtime_key_fns_from_type_name(key_type_name)
					return ast.Expr(ast.CallExpr{
						lhs:  ast.Ident{
							name: 'new_map'
						}
						args: [
							ast.Expr(ast.KeywordOperator{
								op:    .key_sizeof
								exprs: [mt.key_type]
							}),
							ast.Expr(ast.KeywordOperator{
								op:    .key_sizeof
								exprs: [mt.value_type]
							}),
							ast.Expr(ast.PrefixExpr{
								op:   .amp
								expr: ast.Ident{
									name: hash_fn
								}
							}),
							ast.Expr(ast.PrefixExpr{
								op:   .amp
								expr: ast.Ident{
									name: eq_fn
								}
							}),
							ast.Expr(ast.PrefixExpr{
								op:   .amp
								expr: ast.Ident{
									name: clone_fn
								}
							}),
							ast.Expr(ast.PrefixExpr{
								op:   .amp
								expr: ast.Ident{
									name: free_fn
								}
							}),
						]
						pos:  expr.pos
					})
				}
			}
			else {}
		}
	}

	mut init_typ_expr := expr.typ
	if concrete_typ_expr := t.concrete_generic_struct_type_expr(expr.typ) {
		init_typ_expr = concrete_typ_expr
	}
	typed_expr := ast.InitExpr{
		typ: init_typ_expr
		pos: expr.pos
	}
	if expr.pos.id != 0 {
		if init_typ := t.type_from_init_expr(typed_expr) {
			t.synth_types[expr.pos.id] = init_typ
		}
	}
	// Get the struct type name for field type lookups
	struct_type_name := t.get_init_expr_type_name(init_typ_expr)

	// Transform field values recursively
	// Note: ArrayInitExpr is NOT transformed here because cleanc uses field type info
	// to determine if it's a fixed-size array (which transformer doesn't have access to)
	mut fields := []ast.FieldInit{cap: expr.fields.len}
	positional_field_names := t.struct_positional_field_names(struct_type_name)
	mut positional_idx := 0
	for field in expr.fields {
		mut lookup_field_name := field.name
		if lookup_field_name == '' {
			if positional_idx < positional_field_names.len {
				lookup_field_name = positional_field_names[positional_idx]
			}
			positional_idx++
		}
		// Check if this field is a sum type and needs wrapping
		mut field_type_name := t.get_struct_field_type_name(struct_type_name, lookup_field_name)
		mut expected_field_type := types.Type(types.int_)
		mut has_expected_field_type := false
		mut pretransformed_value := ast.empty_expr
		mut has_pretransformed_value := false
		if direct_type := t.lookup_struct_field_type(struct_type_name, lookup_field_name) {
			expected_field_type = direct_type
			has_expected_field_type = true
			field_type_name = t.type_to_c_name(direct_type)
		} else if direct_type := t.get_init_expr_field_type(init_typ_expr, lookup_field_name) {
			expected_field_type = direct_type
			has_expected_field_type = true
			field_type_name = t.type_to_c_name(direct_type)
		} else if field_type_name != '' {
			if expected_typ := t.lookup_type(field_type_name) {
				expected_field_type = expected_typ
				has_expected_field_type = true
			}
		} else {
			// Fallback to direct type lookup from the init expression type.
			field_type_name = t.get_init_expr_field_type_name(expr.typ, lookup_field_name)
			if field_type_name != '' {
				if expected_typ := t.lookup_type(field_type_name) {
					expected_field_type = expected_typ
					has_expected_field_type = true
				}
			}
		}
		mut field_value := field.value
		is_sumtype_field := t.is_sum_type(field_type_name)
		mut use_direct_sumtype_value := false
		mut direct_sumtype_value := ast.empty_expr
		if has_expected_field_type {
			field_value = t.resolve_expr_with_expected_type(field_value, expected_field_type)
			fv_pos := field_value.pos()
			if !is_sumtype_field && fv_pos.id != 0 {
				t.synth_types[fv_pos.id] = expected_field_type
			}
			if t.is_eval_backend() {
				if expected_field_type is types.OptionType
					|| expected_field_type is types.ResultType {
					base_type_name := t.type_to_c_name(expected_field_type.base_type())
					if t.is_sum_type(base_type_name) {
						if wrapped := t.wrap_sumtype_value(field_value, base_type_name) {
							pretransformed_value = wrapped
							has_pretransformed_value = true
						}
					}
				}
			}
		}
		if is_sumtype_field {
			if direct_value := t.transform_declared_sumtype_value(field_value, field_type_name) {
				direct_sumtype_value = direct_value
				use_direct_sumtype_value = true
			}
			// This is a sum type field - wrap the value in sum type initialization
			if !use_direct_sumtype_value {
				if wrapped := t.wrap_sumtype_value(field_value, field_type_name) {
					fields << ast.FieldInit{
						name:  field.name
						value: wrapped
					}
					continue
				}
			}
		}

		transformed_value := if has_pretransformed_value {
			pretransformed_value
		} else if use_direct_sumtype_value {
			direct_sumtype_value
		} else if field_value is ast.ArrayInitExpr {
			arr_value := field_value as ast.ArrayInitExpr
			// If the array has len/cap but no literal elements (e.g., []int{len: 4}),
			// use the normal transform_expr path which handles __new_array_with_default_noscan
			if arr_value.exprs.len == 0
				&& (arr_value.len !is ast.EmptyExpr || arr_value.cap !is ast.EmptyExpr) {
				t.transform_expr(field_value)
			} else {
				// Transform array elements with sumtype wrapping if needed.
				elem_sumtype := t.get_field_array_elem_sumtype_name(struct_type_name,
					lookup_field_name)
				elem_interface_typ := t.get_field_array_elem_interface_type(struct_type_name,
					lookup_field_name)
				mut new_exprs := []ast.Expr{cap: arr_value.exprs.len}
				for e in arr_value.exprs {
					mut transformed := t.transform_expr(e)
					if elem_sumtype != '' {
						if wrapped := t.wrap_sumtype_value_transformed(transformed, elem_sumtype) {
							new_exprs << wrapped
							continue
						}
					}
					if iface_typ := elem_interface_typ {
						if !t.is_interface_cast(transformed) {
							transformed = ast.Expr(ast.CallOrCastExpr{
								lhs:  t.type_to_ast_type_expr(iface_typ)
								expr: transformed
							})
						}
					}
					new_exprs << transformed
				}
				// Set elem type from struct field so
				// transform_array_init_with_exprs uses the correct element type.
				// This is critical when elements were wrapped in a sum type above,
				// as the C array type must match the wrapped (sum type) elements.
				mut arr_with_type := arr_value
				elem_c_name := t.get_field_array_elem_c_name(struct_type_name, lookup_field_name)
				if elem_c_name != '' {
					arr_with_type = ast.ArrayInitExpr{
						typ:   ast.Expr(ast.Type(ast.ArrayType{
							elem_type: ast.Ident{
								name: elem_c_name
							}
						}))
						exprs: arr_value.exprs
						init:  arr_value.init
						cap:   arr_value.cap
						len:   arr_value.len
						pos:   arr_value.pos
					}
				}
				// Use transform_array_init_with_exprs which handles both fixed and dynamic:
				// - Fixed arrays stay as ArrayInitExpr for cleanc
				// - Dynamic arrays are lowered to builtin__new_array_from_c_array_noscan
				t.transform_array_init_with_exprs(arr_with_type, new_exprs)
			}
		} else {
			t.transform_expr(field_value)
		}
		final_value := if has_expected_field_type {
			t.deref_init_field_value_if_needed(transformed_value, expected_field_type)
		} else {
			transformed_value
		}
		field_name := t.rewrite_embedded_default_field_name(struct_type_name, field.name)
		fields << ast.FieldInit{
			name:  field_name
			value: final_value
		}
	}
	fields = t.add_missing_struct_field_defaults(struct_type_name, fields)

	return ast.InitExpr{
		typ:    init_typ_expr
		fields: fields
		pos:    expr.pos
	}
}

fn (t &Transformer) struct_positional_field_names(struct_name string) []string {
	if struct_name == '' {
		return []string{}
	}
	struct_type := t.lookup_type(struct_name) or { return []string{} }
	base_type := t.unwrap_alias_and_pointer_type(struct_type)
	if base_type !is types.Struct {
		return []string{}
	}
	info := base_type as types.Struct
	mut names := []string{cap: info.fields.len}
	for field in info.fields {
		names << field.name
	}
	return names
}

fn (t &Transformer) type_resolves_to_pointer(typ types.Type) bool {
	mut cur := typ
	for {
		match cur {
			types.Pointer {
				return true
			}
			types.Alias {
				cur = t.live_alias_base_type(cur) or { return false }
			}
			else {
				return false
			}
		}
	}
	return false
}

fn (t &Transformer) deref_init_field_value_if_needed(value ast.Expr, expected types.Type) ast.Expr {
	if t.type_resolves_to_pointer(expected) {
		return value
	}
	expected_base := t.unwrap_alias_and_pointer_type(expected)
	expected_base_c := t.type_to_c_name(expected_base)
	value_typ := t.get_expr_type(value) or { return value }
	if value_typ is types.Pointer {
		value_base := t.unwrap_alias_and_pointer_type(value_typ.base_type)
		value_base_c := t.type_to_c_name(value_base)
		value_short := if value_base_c.contains('__') {
			value_base_c.all_after_last('__')
		} else {
			value_base_c
		}
		expected_short := if expected_base_c.contains('__') {
			expected_base_c.all_after_last('__')
		} else {
			expected_base_c
		}
		if expected_base_c == value_base_c || expected_short == value_short {
			return ast.PrefixExpr{
				op:   .mul
				expr: value
			}
		}
	}
	return value
}

fn (t &Transformer) get_init_expr_field_type(init_typ_expr ast.Expr, field_name string) ?types.Type {
	if !transformer_string_has_valid_data(field_name) {
		return none
	}
	if field_typ := t.generic_init_expr_field_type(init_typ_expr, field_name) {
		return field_typ
	}
	init_typ := t.get_expr_type(init_typ_expr) or { return none }
	base_typ := t.unwrap_alias_and_pointer_type(init_typ)
	if base_typ is types.Struct {
		if field_typ := t.lookup_struct_field_type(base_typ.name, field_name) {
			return field_typ
		}
	}
	return none
}

fn (t &Transformer) get_init_expr_field_type_name(init_typ_expr ast.Expr, field_name string) string {
	if !transformer_string_has_valid_data(field_name) {
		return ''
	}
	if field_typ := t.generic_init_expr_field_type(init_typ_expr, field_name) {
		return t.type_to_name(field_typ)
	}
	init_typ := t.get_expr_type(init_typ_expr) or { return '' }
	base_typ := t.unwrap_alias_and_pointer_type(init_typ)
	if base_typ is types.Struct {
		if field_typ := t.lookup_struct_field_type(base_typ.name, field_name) {
			return t.type_to_name(field_typ)
		}
	}
	return ''
}

fn (t &Transformer) generic_init_expr_field_type(init_typ_expr ast.Expr, field_name string) ?types.Type {
	mut lhs := ast.empty_expr
	mut args := []ast.Expr{}
	match init_typ_expr {
		ast.GenericArgs {
			lhs = init_typ_expr.lhs
			args = init_typ_expr.args.clone()
		}
		ast.GenericArgOrIndexExpr {
			lhs = init_typ_expr.lhs
			args = [init_typ_expr.expr]
		}
		ast.IndexExpr {
			lhs = init_typ_expr.lhs
			args = [init_typ_expr.expr]
		}
		else {
			return none
		}
	}

	base := t.lookup_type_from_expr(lhs) or { return none }
	if base is types.Struct {
		field := struct_field_by_name(base, field_name) or { return none }
		bindings := t.generic_type_arg_bindings(base.generic_params, args) or { return field.typ }
		return substitute_type(field.typ, bindings)
	}
	return none
}

fn (mut t Transformer) add_missing_struct_field_defaults(struct_name string, fields []ast.FieldInit) []ast.FieldInit {
	if struct_name == '' {
		return fields
	}
	struct_type := t.lookup_type(struct_name) or {
		if struct_name.contains('Scope') || struct_name.contains('DenseArray')
			|| struct_name.contains('Env') {
		}
		return fields
	}
	base_type := t.unwrap_alias_and_pointer_type(struct_type)
	if base_type !is types.Struct {
		if struct_name.contains('Scope') || struct_name.contains('DenseArray')
			|| struct_name.contains('Env') {
		}
		return fields
	}
	struct_info := base_type as types.Struct
	mut existing := map[string]bool{}
	mut positional_idx := 0
	for field in fields {
		if field.name == '' {
			// Positional field — map it to the corresponding struct field name
			if positional_idx < struct_info.fields.len {
				positional_name := struct_info.fields[positional_idx].name
				existing[positional_name] = true
				existing[t.rewrite_embedded_default_field_name(struct_name, positional_name)] = true
			}
			positional_idx++
		} else {
			existing[field.name] = true
			existing[t.rewrite_embedded_default_field_name(struct_name, field.name)] = true
		}
	}
	mut out := []ast.FieldInit{cap: fields.len}
	for field in fields {
		out << field
	}
	for struct_field in struct_info.fields {
		field_name := t.rewrite_embedded_default_field_name(struct_name, struct_field.name)
		if struct_field.name in existing || field_name in existing {
			continue
		}
		if struct_field.default_expr !is ast.EmptyExpr
			&& t.is_supported_struct_default_expr(struct_field.default_expr) {
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_struct_field_default_value(struct_name,
					struct_field.default_expr, struct_field.typ)
			}
			continue
		}
		if t.is_pointer_type(struct_field.typ) {
			continue
		}
		field_type := t.unwrap_alias_and_pointer_type(struct_field.typ)
		if field_type is types.Map {
			if struct_name.contains('Scope') || struct_name.contains('Env') {
			}
			map_init := ast.Expr(ast.MapInitExpr{
				typ: t.type_to_ast_type_expr(field_type)
			})
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_expr(map_init)
			}
			continue
		}
		if field_type is types.Array {
			array_init := ast.Expr(ast.ArrayInitExpr{
				typ: t.type_to_ast_type_expr(field_type)
			})
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_expr(array_init)
			}
			continue
		}
		if field_type is types.OptionType {
			option_none := ast.Expr(ast.InitExpr{
				typ:    t.type_to_ast_type_expr(field_type)
				fields: [
					ast.FieldInit{
						name:  'state'
						value: ast.BasicLiteral{
							kind:  token.Token.number
							value: '2'
						}
					},
				]
			})
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_expr(option_none)
			}
			continue
		}
		if field_type is types.String {
			out << ast.FieldInit{
				name:  field_name
				value: ast.StringLiteral{
					kind:  .v
					value: "''"
				}
			}
		}
	}
	// Also fill defaults for fields from embedded structs.
	for emb in struct_info.embedded {
		resolved_emb := t.resolve_embedded_struct_for_default_fields(struct_name, emb)
		for struct_field in resolved_emb.fields {
			raw_field_name := embedded_default_field_name_with_owner(emb.name, struct_field.name)
			field_name := t.embedded_default_field_name(struct_name, emb.name, struct_field.name)
			if struct_field.name in existing || raw_field_name in existing || field_name in existing {
				continue
			}
			if struct_field.default_expr !is ast.EmptyExpr
				&& t.is_supported_struct_default_expr(struct_field.default_expr) {
				mut emb_struct_name := struct_name
				if resolved_emb.name != '' {
					emb_struct_name = t.type_to_c_name(types.Type(resolved_emb))
				}
				out << ast.FieldInit{
					name:  field_name
					value: t.transform_struct_field_default_value(emb_struct_name,
						struct_field.default_expr, struct_field.typ)
				}
				continue
			}
			if t.is_pointer_type(struct_field.typ) {
				continue
			}
			field_type := t.unwrap_alias_and_pointer_type(struct_field.typ)
			if field_type is types.Map {
				map_init := ast.Expr(ast.MapInitExpr{
					typ: t.type_to_ast_type_expr(field_type)
				})
				out << ast.FieldInit{
					name:  field_name
					value: t.transform_expr(map_init)
				}
				continue
			}
			if field_type is types.Array {
				array_init := ast.Expr(ast.ArrayInitExpr{
					typ: t.type_to_ast_type_expr(field_type)
				})
				out << ast.FieldInit{
					name:  field_name
					value: t.transform_expr(array_init)
				}
				continue
			}
			if field_type is types.OptionType {
				option_none := ast.Expr(ast.InitExpr{
					typ:    t.type_to_ast_type_expr(field_type)
					fields: [
						ast.FieldInit{
							name:  'state'
							value: ast.BasicLiteral{
								kind:  token.Token.number
								value: '2'
							}
						},
					]
				})
				out << ast.FieldInit{
					name:  field_name
					value: t.transform_expr(option_none)
				}
				continue
			}
			if field_type is types.String {
				out << ast.FieldInit{
					name:  field_name
					value: ast.StringLiteral{
						kind:  .v
						value: "''"
					}
				}
			}
		}
		if resolved_emb.fields.len == 0 {
			if info := t.resolve_embedded_decl_for_default_fields(struct_name, emb) {
				out = t.add_missing_embedded_decl_defaults(struct_name, emb, info, out, existing)
			}
		}
	}
	return out
}

fn embedded_default_field_name_with_owner(embedded_name string, field_name string) string {
	if field_name.contains('.') {
		return field_name
	}
	owner := embedded_concrete_owner_name_from_type_name(embedded_name)
	if owner == '' {
		return field_name
	}
	return '${owner}.${field_name}'
}

fn (t &Transformer) embedded_default_field_name(parent_struct_name string, embedded_name string, field_name string) string {
	if field_name.contains('.') {
		return t.rewrite_embedded_default_field_name(parent_struct_name, field_name)
	}
	mut owner := embedded_concrete_owner_name_from_type_name(embedded_name)
	if concrete_owner := t.concrete_embedded_owner_name(parent_struct_name, owner) {
		owner = concrete_owner
	}
	if owner == '' {
		return field_name
	}
	return '${owner}.${field_name}'
}

fn (t &Transformer) resolve_embedded_struct_for_default_fields(parent_struct_name string, embedded types.Struct) types.Struct {
	owner := embedded_concrete_owner_name_from_type_name(embedded.name)
	if concrete_owner := t.concrete_embedded_owner_name(parent_struct_name, owner) {
		if concrete_owner != owner {
			module_name := embedded_struct_module_name(embedded.name, owner)
			if resolved := t.lookup_struct_type_in_module(module_name, concrete_owner) {
				return resolved
			}
		}
	}
	return t.live_embedded_struct_type(embedded)
}

fn (t &Transformer) resolve_embedded_decl_for_default_fields(parent_struct_name string, embedded types.Struct) ?StructDefaultDeclInfo {
	owner := embedded_concrete_owner_name_from_type_name(embedded.name)
	if concrete_owner := t.concrete_embedded_owner_name(parent_struct_name, owner) {
		if concrete_owner != owner {
			module_name := embedded_struct_module_name(embedded.name, owner)
			if module_name != '' {
				if info := t.lookup_struct_default_decl_info('${module_name}__${concrete_owner}') {
					return info
				}
			}
			if info := t.lookup_struct_default_decl_info(concrete_owner) {
				return info
			}
		}
	}
	if info := t.lookup_struct_default_decl_info(embedded.name) {
		return info
	}
	if embedded.name.contains('__') {
		return t.lookup_struct_default_decl_info(embedded.name.all_after_last('__'))
	}
	return none
}

fn (t &Transformer) lookup_struct_default_decl_info(name string) ?StructDefaultDeclInfo {
	if name == '' {
		return none
	}
	return t.struct_default_decl_infos[name] or { return none }
}

fn (mut t Transformer) add_missing_embedded_decl_defaults(parent_struct_name string, embedded types.Struct, info StructDefaultDeclInfo, fields []ast.FieldInit, existing map[string]bool) []ast.FieldInit {
	mut out := fields.clone()
	base_owner := embedded_concrete_owner_name_from_type_name(embedded.name)
	mut concrete_owner := base_owner
	if rewritten_owner := t.concrete_embedded_owner_name(parent_struct_name, base_owner) {
		concrete_owner = rewritten_owner
	}
	emb_struct_name := generic_struct_decl_c_name(info.decl, info.module_name)
	for field in info.decl.fields {
		if field.name == '' {
			continue
		}
		raw_field_name := '${base_owner}.${field.name}'
		field_name := '${concrete_owner}.${field.name}'
		if raw_field_name in existing || field_name in existing {
			continue
		}
		if field.value !is ast.EmptyExpr && t.is_supported_struct_default_expr(field.value) {
			field_type := t.struct_decl_field_type(info, field) or { continue }
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_struct_field_default_value(emb_struct_name, field.value,
					field_type)
			}
			continue
		}
		field_type := t.struct_decl_field_type(info, field) or { continue }
		if t.is_pointer_type(field_type) {
			continue
		}
		base_type := t.unwrap_alias_and_pointer_type(field_type)
		if base_type is types.Map {
			map_init := ast.Expr(ast.MapInitExpr{
				typ: t.type_to_ast_type_expr(base_type)
			})
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_expr(map_init)
			}
			continue
		}
		if base_type is types.Array {
			array_init := ast.Expr(ast.ArrayInitExpr{
				typ: t.type_to_ast_type_expr(base_type)
			})
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_expr(array_init)
			}
			continue
		}
		if base_type is types.OptionType {
			option_none := ast.Expr(ast.InitExpr{
				typ:    t.type_to_ast_type_expr(base_type)
				fields: [
					ast.FieldInit{
						name:  'state'
						value: ast.BasicLiteral{
							kind:  token.Token.number
							value: '2'
						}
					},
				]
			})
			out << ast.FieldInit{
				name:  field_name
				value: t.transform_expr(option_none)
			}
			continue
		}
		if base_type is types.String {
			out << ast.FieldInit{
				name:  field_name
				value: ast.StringLiteral{
					kind:  .v
					value: "''"
				}
			}
		}
	}
	return out
}

fn (mut t Transformer) struct_decl_field_type(info StructDefaultDeclInfo, field ast.FieldDecl) ?types.Type {
	old_module := t.cur_module
	old_scope := t.scope
	t.cur_module = info.module_name
	if scope := t.get_module_scope(info.module_name) {
		t.scope = scope
	} else {
		t.scope = unsafe { nil }
	}
	field_type := t.lookup_type_from_expr(field.typ) or {
		t.cur_module = old_module
		t.scope = old_scope
		return none
	}
	t.cur_module = old_module
	t.scope = old_scope
	return field_type
}

fn embedded_struct_module_name(type_name string, owner string) string {
	if type_name == '' || owner == '' {
		return ''
	}
	suffix := '__${owner}'
	if type_name.ends_with(suffix) {
		return type_name[..type_name.len - suffix.len]
	}
	if type_name.contains('__') {
		return type_name.all_before_last('__')
	}
	return ''
}

fn (t &Transformer) lookup_struct_type_in_module(module_name string, type_name string) ?types.Struct {
	if module_name != '' {
		for candidate in [module_name, module_name.replace('__', '.')] {
			if scope := t.get_module_scope(candidate) {
				if typ := scope.lookup_type(type_name) {
					if typ is types.Struct {
						return typ
					}
				}
			}
		}
	}
	if typ := t.lookup_type(type_name) {
		if typ is types.Struct {
			return typ
		}
	}
	return none
}

fn (mut t Transformer) transform_struct_field_default_value(struct_name string, expr ast.Expr, expected types.Type) ast.Expr {
	resolved := t.resolve_expr_with_expected_type(expr, expected)
	base := t.unwrap_alias_and_pointer_type(expected)
	if base is types.Interface && !t.is_interface_cast(resolved) {
		return t.transform_expr(ast.CallOrCastExpr{
			lhs:  t.type_to_ast_type_expr(expected)
			expr: resolved
			pos:  resolved.pos()
		})
	}
	return t.transform_struct_field_default_expr(struct_name, resolved)
}

fn (mut t Transformer) transform_struct_field_default_expr(struct_name string, expr ast.Expr) ast.Expr {
	if struct_name.contains('__') {
		module_name := struct_name.all_before_last('__')
		if module_name != '' && module_name != t.cur_module {
			// Cross-module const defaults like `ast.empty_expr` must be qualified.
			if expr is ast.Ident {
				if expr.name.contains('__') {
					return expr
				}
				return ast.SelectorExpr{
					lhs: ast.Ident{
						name: module_name
					}
					rhs: expr
				}
			}
			old_module := t.cur_module
			t.cur_module = module_name
			transformed := t.transform_expr(expr)
			t.cur_module = old_module
			return transformed
		}
	}
	return t.transform_expr(expr)
}

fn (t &Transformer) get_init_expr_type_name(typ ast.Expr) string {
	if generic_type_name := t.generic_init_type_name(typ) {
		return t.qualify_type_name(generic_type_name)
	}
	if typ is ast.Ident {
		if synth_typ := t.get_synth_type(typ.pos) {
			return t.type_to_c_name(synth_typ)
		}
		base_name := typ.name
		if t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin' {
			if scope := t.cached_scopes[t.cur_module] {
				if obj := scope.objects[base_name] {
					if obj is types.Type {
						return '${t.cur_module}__${base_name}'
					}
				}
			}
			if t.lookup_method_cached('${t.cur_module}__${base_name}', 'msg') != none {
				return '${t.cur_module}__${base_name}'
			}
		}
		return t.qualify_type_name(base_name)
	}
	if typ is ast.SelectorExpr {
		// Module-qualified: os.Eof -> os__Eof
		if typ.lhs is ast.Ident {
			return '${typ.lhs.name}__${typ.rhs.name}'
		}
		return typ.rhs.name
	}
	return ''
}

// is_error_type_name checks if a type implements IError
// This includes types that embed Error OR types that have msg() method
fn (t &Transformer) get_struct_field_type_name(struct_name string, field_name string) string {
	// Look up the struct type in scopes.
	// For qualified names (e.g. "ast__CallExpr"), try the module scope directly first.
	dunder := struct_name.index('__') or { -1 }
	if dunder >= 0 {
		mod_name := struct_name[..dunder]
		last_dunder := struct_name.last_index('__') or { dunder }
		short_name := struct_name[last_dunder + 2..]
		if mod_scope := t.cached_scopes[mod_name] {
			if obj := mod_scope.objects[short_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
			// Also try the full qualified name
			if obj := mod_scope.objects[struct_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
		}
	}
	// Prefer the current module scope for non-qualified names
	// to avoid collisions (e.g., ast.FnType vs types.FnType both named "FnType").
	if dunder < 0 && t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin' {
		if cur_scope := t.cached_scopes[t.cur_module] {
			if obj := cur_scope.objects[struct_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
		}
	}
	// Fallback: scan all scopes
	scope_keys2 := t.cached_scopes.keys()
	for sk in scope_keys2 {
		scope := t.cached_scopes[sk] or { continue }
		if obj := scope.objects[struct_name] {
			if obj is types.Type {
				return t.get_field_type_name(obj, field_name)
			}
		}
		if dunder >= 0 {
			short_name := struct_name[struct_name.last_index('__') or { dunder } + 2..]
			if obj := scope.objects[short_name] {
				if obj is types.Type {
					return t.get_field_type_name(obj, field_name)
				}
			}
		} else if t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin' {
			mangled := '${t.cur_module}__${struct_name}'
			if obj := scope.objects[mangled] {
				if obj is types.Type {
					return t.get_field_type_name(obj, field_name)
				}
			}
		}
	}
	return ''
}

// wrap_sumtype_value wraps a value in sum type initialization if needed
// Returns the wrapped expression or none if the value type couldn't be determined
fn (t &Transformer) resolve_field_type(var_name string, field_name string) string {
	// First, check if variable is already an enum type
	if _ := t.is_var_enum(var_name) {
		// Variable is already an enum, no field access needed
		return ''
	}

	// Check if variable is smartcasted - use the smartcast variant type
	if ctx := t.find_smartcast_for_expr(var_name) {
		return t.resolve_struct_field_type(ctx.variant, field_name)
	}

	// Look up variable type from scope
	var_type_name := t.get_var_type_name(var_name)
	if var_type_name != '' {
		// Strip pointer prefix/suffix for struct lookup
		mut clean_type := var_type_name
		if clean_type.starts_with('&') {
			clean_type = clean_type[1..]
		}
		if clean_type.ends_with('*') {
			clean_type = clean_type[..clean_type.len - 1]
		}
		return t.resolve_struct_field_type(clean_type, field_name)
	}

	// Look up the variable in the current module's scope
	mut scope := t.get_current_scope() or { return '' }
	obj := scope.lookup_parent(var_name, 0) or { return '' }

	// Get the variable's type
	var_type := obj.typ()
	return t.get_field_type_name(var_type, field_name)
}

// resolve_struct_field_type looks up a field type given a struct type name
fn (t &Transformer) resolve_struct_field_type(struct_name string, field_name string) string {
	// Look up the struct type in scopes
	// Handle qualified names like "ast__SelectorExpr" - extract module and type name
	mut lookup_name := struct_name
	mut lookup_module := ''
	dunder := struct_name.index('__') or { -1 }
	if dunder >= 0 {
		lookup_module = struct_name[..dunder]
		last_dunder := struct_name.last_index('__') or { dunder }
		lookup_name = struct_name[last_dunder + 2..]
	}
	// Fast path: try the target module scope directly
	if lookup_module != '' {
		if mod_scope := t.cached_scopes[lookup_module] {
			if obj := mod_scope.objects[lookup_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
			if obj := mod_scope.objects[struct_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
		}
	}
	// Try current module scope
	if t.cur_module != '' {
		if cur_scope := t.cached_scopes[t.cur_module] {
			if obj := cur_scope.objects[struct_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
			if obj := cur_scope.objects[lookup_name] {
				if obj is types.Type {
					result := t.get_field_type_name(obj, field_name)
					if result != '' {
						return result
					}
				}
			}
		}
	}
	// Fallback: scan all scopes
	scope_keys3 := t.cached_scopes.keys()
	for sk in scope_keys3 {
		scope := t.cached_scopes[sk] or { continue }
		if obj := scope.objects[struct_name] {
			if obj is types.Type {
				return t.get_field_type_name(obj, field_name)
			}
		}
		if obj := scope.objects[lookup_name] {
			if obj is types.Type {
				return t.get_field_type_name(obj, field_name)
			}
		}
	}
	return ''
}

// get_field_type_name gets the type name of a field from a Type
fn (t &Transformer) get_field_type_name(typ types.Type, field_name string) string {
	if typ is types.Struct {
		if field_type := t.struct_field_type(typ, field_name) {
			return t.type_to_name(field_type)
		}
	}
	if typ is types.Pointer {
		// Dereference pointer and recurse
		return t.get_field_type_name(typ.base_type, field_name)
	}
	return ''
}

// get_field_array_elem_sumtype_name returns the sum type name of the array element type
// for a struct field, if the field is an array of sum types. Returns '' otherwise.
fn (t &Transformer) get_field_array_elem_sumtype_name(struct_name string, field_name string) string {
	// Compute short name once outside the loop
	dunder := struct_name.index('__') or { -1 }
	short_name := if dunder >= 0 {
		last_dunder := struct_name.last_index('__') or { dunder }
		struct_name[last_dunder + 2..]
	} else {
		struct_name
	}
	// Try module scope directly first for qualified names
	if dunder >= 0 {
		mod_name := struct_name[..dunder]
		if mod_scope := t.cached_scopes[mod_name] {
			if obj := mod_scope.objects[short_name] {
				if obj is types.Type {
					if obj is types.Struct {
						for field in obj.fields {
							if field.name == field_name {
								if field.typ is types.Array {
									field_arr := field.typ as types.Array
									elem_name := t.type_to_name(field_arr.elem_type)
									if t.is_sum_type(elem_name) {
										return elem_name
									}
								}
								return ''
							}
						}
					}
				}
			}
		}
	}
	scope_keys4 := t.cached_scopes.keys()
	for sk in scope_keys4 {
		scope := t.cached_scopes[sk] or { continue }
		if obj := scope.objects[struct_name] {
			if obj is types.Type {
				if obj is types.Struct {
					for field in obj.fields {
						if field.name == field_name {
							if field.typ is types.Array {
								field_arr := field.typ as types.Array
								elem_name := t.type_to_name(field_arr.elem_type)
								if t.is_sum_type(elem_name) {
									return elem_name
								}
							}
							return ''
						}
					}
				}
			}
		}
		if dunder >= 0 {
			if obj := scope.objects[short_name] {
				if obj is types.Type {
					if obj is types.Struct {
						for field in obj.fields {
							if field.name == field_name {
								if field.typ is types.Array {
									field_arr := field.typ as types.Array
									elem_name := t.type_to_name(field_arr.elem_type)
									if t.is_sum_type(elem_name) {
										return elem_name
									}
								}
								return ''
							}
						}
					}
				}
			}
		}
	}
	return ''
}

fn (t &Transformer) get_field_array_elem_interface_type(struct_name string, field_name string) ?types.Type {
	field_typ := t.lookup_struct_field_type(struct_name, field_name) or { return none }
	match field_typ {
		types.Array {
			et := field_typ.elem_type
			if et is types.Interface {
				return et
			}
			if et is types.Alias && et.base_type is types.Interface {
				return et
			}
		}
		types.Alias {
			if field_typ.base_type is types.Array {
				et := field_typ.base_type.elem_type
				if et is types.Interface {
					return et
				}
				if et is types.Alias && et.base_type is types.Interface {
					return et
				}
			}
		}
		else {}
	}

	return none
}

// get_field_array_elem_c_name returns the C type name for the element type of an array field
fn (t &Transformer) get_field_array_elem_c_name(struct_name string, field_name string) string {
	field_typ := t.lookup_struct_field_type(struct_name, field_name) or { return '' }
	if field_typ is types.Array {
		return t.type_to_c_name(field_typ.elem_type)
	}
	return ''
}

// type_to_name converts a Type to its name string
fn (t &Transformer) get_struct_field_type(expr ast.SelectorExpr) ?types.Type {
	// Try to get the struct type from scope (for local variables and receivers)
	mut struct_type_name := ''
	if !transformer_string_has_valid_data(expr.rhs.name) {
		return none
	}
	if smartcast_type := t.smartcast_type_for_expr(expr.lhs) {
		if field_typ := t.field_type_from_receiver_type(smartcast_type, expr.rhs.name) {
			return field_typ
		}
	}
	if expr.lhs is ast.Ident {
		lhs_name := expr.lhs.name
		if !transformer_string_has_valid_data(lhs_name) {
			return none
		}
		if lhs_type := t.lookup_var_type(lhs_name) {
			if field_typ := t.field_type_from_receiver_type(lhs_type, expr.rhs.name) {
				return field_typ
			}
			base_type := lhs_type.base_type()
			if base_type is types.Struct {
				if field_typ := t.lookup_struct_field_type(base_type.name, expr.rhs.name) {
					return field_typ
				}
			}
			struct_type_name = t.type_to_name(base_type)
		}
	}

	// If we have a type name, look it up in the environment
	if struct_type_name != '' {
		// Types are defined at module level, not function level
		// Use lookup_type which searches module scopes
		looked_up_type := t.lookup_type(struct_type_name) or { return none }
		base_type := if looked_up_type is types.Pointer {
			looked_up_type.base_type
		} else {
			looked_up_type
		}
		match base_type {
			types.Struct {
				if field_typ := t.lookup_struct_field_type(base_type.name, expr.rhs.name) {
					return field_typ
				}
			}
			else {}
		}
	}

	// Fall back to get_expr_type for module-level lookups
	struct_type := t.get_expr_type(expr.lhs) or { return none }

	// If it's a pointer, dereference to get the struct
	base_type := if struct_type is types.Pointer {
		struct_type.base_type
	} else {
		struct_type
	}

	// Look up the field in the struct
	match base_type {
		types.Struct {
			if field_typ := t.lookup_struct_field_type(base_type.name, expr.rhs.name) {
				return field_typ
			}
		}
		else {}
	}

	return none
}

// expand_array_init_with_index expands `[]T{len: n, init: expr_using_index}` into:
//   mut _awi_tN = __new_array_with_default_noscan(len, cap, sizeof(T), nil)
//   for (_v_index = 0; _v_index < _awi_tN.len; _v_index++) {
//       ((T*)_awi_tN.data)[_v_index] = init_expr  (with `index` renamed to `_v_index`)
//   }
//   <returns _awi_tN ident>
fn (mut t Transformer) expand_array_init_with_index(len_expr ast.Expr, cap_expr ast.Expr, sizeof_expr ast.Expr, init_expr ast.Expr, _pos token.Pos) ast.Expr {
	t.temp_counter++
	arr_name := '_awi_t${t.temp_counter}'
	arr_ident := ast.Ident{
		name: arr_name
	}
	idx_ident := ast.Ident{
		name: '_v_index'
	}

	// 1. mut _awi_tN = __new_array_with_default_noscan(len, cap, sizeof(T), nil)
	init_stmt := ast.Stmt(ast.AssignStmt{
		op:  .decl_assign
		lhs: [
			ast.Expr(ast.ModifierExpr{
				kind: .key_mut
				expr: arr_ident
			}),
		]
		rhs: [
			ast.Expr(ast.CallExpr{
				lhs:  ast.Ident{
					name: '__new_array_with_default_noscan'
				}
				args: [
					len_expr,
					cap_expr,
					ast.Expr(ast.KeywordOperator{
						op:    .key_sizeof
						exprs: [sizeof_expr]
					}),
					ast.Expr(ast.Ident{
						name: 'nil'
					}),
				]
			}),
		]
	})

	// 2. Build assignment: ((T*)_awi_tN.data)[_v_index] = init_expr
	//    with `index` renamed to `_v_index`
	renamed_init := t.replace_ident_named(init_expr, 'index', '_v_index')
	arr_data := t.synth_selector(arr_ident, 'data', types.Type(types.voidptr_))
	// Use a simple Ident for the cast type name so cleanc renders it as
	// ((ElemType*)data)[idx] without decomposing compound type expressions.
	cast_type_name := t.expr_to_type_name(sizeof_expr)
	elem_assign := ast.Stmt(ast.AssignStmt{
		op:  .assign
		lhs: [
			ast.Expr(ast.IndexExpr{
				lhs:  ast.CastExpr{
					typ:  ast.Ident{
						name: '${cast_type_name}*'
					}
					expr: arr_data
				}
				expr: idx_ident
			}),
		]
		rhs: [renamed_init]
	})

	// 3. for (int _v_index = 0; _v_index < _awi_tN.len; _v_index++) { ... }
	for_stmt := ast.Stmt(ast.ForStmt{
		init:  ast.AssignStmt{
			op:  .decl_assign
			lhs: [ast.Expr(idx_ident)]
			rhs: [ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '0'
			})]
		}
		cond:  ast.InfixExpr{
			op:  .lt
			lhs: idx_ident
			rhs: t.synth_selector(arr_ident, 'len', types.Type(types.int_))
		}
		post:  ast.AssignStmt{
			op:  .assign
			lhs: [ast.Expr(idx_ident)]
			rhs: [
				ast.Expr(ast.InfixExpr{
					op:  .plus
					lhs: idx_ident
					rhs: ast.BasicLiteral{
						kind:  .number
						value: '1'
					}
				}),
			]
		}
		stmts: [elem_assign]
	})

	// Emit init + for loop as pending statements
	t.pending_stmts << init_stmt
	t.pending_stmts << for_stmt

	// Return the temp array ident as the expression value
	return arr_ident
}

// replace_ident_named replaces all occurrences of an identifier named `old_name`
// with a new identifier named `new_name` in an expression tree.
fn (t &Transformer) replace_ident_named(expr ast.Expr, old_name string, new_name string) ast.Expr {
	match expr {
		ast.Ident {
			if expr.name == old_name {
				return ast.Ident{
					name: new_name
					pos:  expr.pos
				}
			}
			return expr
		}
		ast.InfixExpr {
			return ast.InfixExpr{
				op:  expr.op
				lhs: t.replace_ident_named(expr.lhs, old_name, new_name)
				rhs: t.replace_ident_named(expr.rhs, old_name, new_name)
				pos: expr.pos
			}
		}
		ast.PrefixExpr {
			return ast.PrefixExpr{
				op:   expr.op
				expr: t.replace_ident_named(expr.expr, old_name, new_name)
				pos:  expr.pos
			}
		}
		ast.ParenExpr {
			return ast.ParenExpr{
				expr: t.replace_ident_named(expr.expr, old_name, new_name)
				pos:  expr.pos
			}
		}
		ast.CallExpr {
			mut new_args := []ast.Expr{cap: expr.args.len}
			for arg in expr.args {
				new_args << t.replace_ident_named(arg, old_name, new_name)
			}
			return ast.CallExpr{
				lhs:  t.replace_ident_named(expr.lhs, old_name, new_name)
				args: new_args
				pos:  expr.pos
			}
		}
		ast.CastExpr {
			return ast.CastExpr{
				typ:  expr.typ
				expr: t.replace_ident_named(expr.expr, old_name, new_name)
				pos:  expr.pos
			}
		}
		ast.IndexExpr {
			return ast.IndexExpr{
				lhs:  t.replace_ident_named(expr.lhs, old_name, new_name)
				expr: t.replace_ident_named(expr.expr, old_name, new_name)
				pos:  expr.pos
			}
		}
		ast.SelectorExpr {
			return ast.SelectorExpr{
				lhs: t.replace_ident_named(expr.lhs, old_name, new_name)
				rhs: expr.rhs
				pos: expr.pos
			}
		}
		ast.ModifierExpr {
			return ast.ModifierExpr{
				kind: expr.kind
				expr: t.replace_ident_named(expr.expr, old_name, new_name)
				pos:  expr.pos
			}
		}
		else {
			return expr
		}
	}
}

// get_array_type_str returns the Array_T type string for an array expression using checker type info.