module transform

import v3.flat
import v3.types

// resolve_call_name resolves the function name from a .call node.
// child[0] is the function expression: .ident for plain calls, .selector for method calls.
fn (t &Transformer) resolve_call_name(node flat.Node) string {
	if node.children_count == 0 {
		return ''
	}
	fn_id := t.a.children[node.children_start]
	if int(fn_id) < 0 {
		return ''
	}
	fn_node := t.a.nodes[int(fn_id)]
	match fn_node.kind {
		.ident {
			name := fn_node.value
			if t.var_type(name).len > 0 {
				return name
			}
			// Try qualified with current module
			if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
				qname := '${t.cur_module}.${name}'
				if t.is_known_fn_name(qname) {
					return qname
				}
			}
			// Try unqualified name after current-module authority.
			if t.is_known_fn_name(name) {
				return name
			}
			return name
		}
		.selector {
			if fn_node.children_count > 0 {
				base_id := t.a.children[fn_node.children_start]
				base := t.a.nodes[int(base_id)]
				if base.kind == .ident {
					full := '${base.value}.${fn_node.value}'
					if t.is_known_fn_name(full) {
						return full
					}
				}
				method_name := t.resolve_receiver_method_name(base_id, fn_node.value)
				if method_name.len > 0 {
					return method_name
				}
				if base.kind == .ident {
					return '${base.value}.${fn_node.value}'
				}
			}
			return ''
		}
		else {
			return ''
		}
	}
}

fn (t &Transformer) local_fn_decl_return_type(name string) ?string {
	if name.len == 0 {
		return none
	}
	qname := transform_qualified_fn_name(t.cur_module, name)
	if ret := t.fn_ret_types[qname] {
		return ret
	}
	if !isnil(t.tc) {
		if ret := t.tc.fn_ret_types[qname] {
			return ret.name()
		}
	}
	return none
}

fn (t &Transformer) local_fn_value_return_type_from_type(typ string) ?string {
	if typ.len == 0 {
		return none
	}
	normalized := t.normalize_type_alias(typ)
	return fn_type_return_type_text(normalized)
}

fn fn_type_return_type_text(typ string) ?string {
	clean := typ.trim_space()
	if !(clean.starts_with('fn(') || clean.starts_with('fn (')) {
		return none
	}
	open_idx := clean.index_u8(`(`)
	if open_idx < 0 {
		return none
	}
	mut depth := 0
	for i in open_idx .. clean.len {
		if clean[i] == `(` {
			depth++
		} else if clean[i] == `)` {
			depth--
			if depth == 0 {
				ret := clean[i + 1..].trim_space()
				if ret.len == 0 {
					return 'void'
				}
				return ret
			}
		}
	}
	return none
}

// is_known_fn_name reports whether is known fn name applies in transform.
fn (t &Transformer) is_known_fn_name(name string) bool {
	if name in t.fn_ret_types {
		return true
	}
	if !isnil(t.tc) {
		return name in t.tc.fn_ret_types || name in t.tc.fn_param_types
	}
	return false
}

// resolve_receiver_method_name resolves resolve receiver method name information for transform.
fn (t &Transformer) resolve_receiver_method_name(base_id flat.NodeId, method string) string {
	if method.len == 0 {
		return ''
	}
	mut base_type := t.lvalue_type(base_id)
	if base_type.starts_with('&') {
		base_type = base_type[1..]
	}
	if base_type.len == 0 {
		return ''
	}
	if method_name := t.resolve_receiver_method_for_type(base_type, method) {
		return method_name
	}
	mut raw_var_clean := ''
	if raw_var_type := t.raw_var_type_for_expr(base_id) {
		raw_clean := if raw_var_type.starts_with('&') {
			raw_var_type[1..]
		} else {
			raw_var_type
		}
		raw_var_clean = raw_clean
		if raw_clean.len > 0 && raw_clean != base_type {
			if method_name := t.resolve_receiver_method_for_type(raw_clean, method) {
				return method_name
			}
		}
	}
	if raw_const_type := t.raw_const_type_name_for_expr(base_id) {
		raw_clean := if raw_const_type.starts_with('&') {
			raw_const_type[1..]
		} else {
			raw_const_type
		}
		if raw_clean.len > 0 && raw_clean != base_type && raw_clean != raw_var_clean {
			if method_name := t.resolve_receiver_method_for_type(raw_clean, method) {
				return method_name
			}
		}
	}
	if alias_method := t.resolve_alias_receiver_method(base_type, method) {
		return alias_method
	}
	if embedded_method := t.resolve_embedded_receiver_method(base_type, method) {
		return embedded_method
	}
	return ''
}

fn (t &Transformer) resolve_collection_receiver_method_name(base_id flat.NodeId, method string, clean_base_type string) string {
	if method.len == 0 {
		return ''
	}
	if raw_var_type := t.raw_var_type_for_expr(base_id) {
		raw_clean := if raw_var_type.starts_with('&') { raw_var_type[1..] } else { raw_var_type }
		if raw_clean.len > 0 && raw_clean != clean_base_type {
			if method_name := t.resolve_receiver_method_for_type(raw_clean, method) {
				return method_name
			}
		}
	}
	if raw_const_type := t.raw_const_type_name_for_expr(base_id) {
		raw_clean := if raw_const_type.starts_with('&') {
			raw_const_type[1..]
		} else {
			raw_const_type
		}
		if raw_clean.len > 0 && raw_clean != clean_base_type {
			if method_name := t.resolve_receiver_method_for_type(raw_clean, method) {
				return method_name
			}
		}
	}
	if method_name := t.resolve_receiver_method_for_type(clean_base_type, method) {
		return method_name
	}
	return ''
}

// resolve_receiver_method_for_type resolves resolve_receiver_method_for_type logic in transform.
fn (t &Transformer) resolve_receiver_method_for_type(receiver_type string, method string) ?string {
	mut clean_type := receiver_type
	if clean_type.starts_with('&') {
		clean_type = clean_type[1..]
	}
	if clean_type.starts_with('map[') {
		for candidate in t.map_receiver_method_candidates(clean_type, method) {
			if t.is_known_fn_name(candidate) {
				return candidate
			}
		}
	} else {
		direct := '${clean_type}.${method}'
		if t.is_known_fn_name(direct) {
			return direct
		}
	}
	if clean_type.starts_with('[]') {
		elem_type := clean_type[2..]
		short_elem := if elem_type.contains('.') { elem_type.all_after_last('.') } else { elem_type }
		short_array := '[]${short_elem}.${method}'
		if t.is_known_fn_name(short_array) {
			return short_array
		}
		if elem_type.contains('.') {
			qualified_array := '${elem_type.all_before_last('.')}.[]${short_elem}.${method}'
			if t.is_known_fn_name(qualified_array) {
				return qualified_array
			}
		} else if transform_can_prefix_collection_receiver(t.cur_module) {
			current_module_array := '${t.cur_module}.[]${short_elem}.${method}'
			if t.is_known_fn_name(current_module_array) {
				return current_module_array
			}
		}
	} else if clean_type.contains('.') {
		short_type := clean_type.all_after_last('.')
		short_method := '${short_type}.${method}'
		if t.is_known_fn_name(short_method) {
			return short_method
		}
		qualified_short_method := '${clean_type.all_before_last('.')}.${short_type}.${method}'
		if t.is_known_fn_name(qualified_short_method) {
			return qualified_short_method
		}
	}
	if !isnil(t.tc) {
		if target := t.tc.type_aliases[clean_type] {
			alias_method := '${target}.${method}'
			if t.is_known_fn_name(alias_method) {
				return alias_method
			}
		}
	}
	return none
}

// resolve_alias_receiver_method converts resolve alias receiver method data for transform.
fn (t &Transformer) resolve_alias_receiver_method(base_type string, method string) ?string {
	if isnil(t.tc) || base_type.len == 0 || method.len == 0 {
		return none
	}
	clean_base := t.normalize_type_alias(base_type)
	if alias_method := t.alias_methods['${clean_base}.${method}'] {
		return alias_method
	}
	if !t.is_integer_type_name(clean_base) {
		return none
	}
	for name, params in t.tc.fn_param_types {
		if !name.ends_with('.${method}') || params.len == 0 {
			continue
		}
		receiver_name := name.all_before_last('.')
		if receiver_name.len == 0 || receiver_name !in t.tc.type_aliases {
			continue
		}
		param_name := params[0].name()
		if t.alias_receiver_type_matches(clean_base, param_name) {
			return name
		}
	}
	return none
}

fn (t &Transformer) resolve_embedded_receiver_method(base_type string, method string) ?string {
	if base_type.len == 0 || method.len == 0 {
		return none
	}
	mut lookup_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
	if lookup_type !in t.structs && lookup_type.contains('.') {
		short_type := lookup_type.all_after_last('.')
		if short_type in t.structs {
			lookup_type = short_type
		}
	}
	info := t.lookup_struct_info(lookup_type) or { return none }
	for field in info.fields {
		if !t.is_embedded_field(field) {
			continue
		}
		field_type := if field.raw_typ.len > 0 { field.raw_typ } else { field.typ }
		clean_field := if field_type.starts_with('&') { field_type[1..] } else { field_type }
		if method_name := t.resolve_receiver_method_for_type(clean_field, method) {
			return method_name
		}
		if method_name := t.resolve_embedded_receiver_method(clean_field, method) {
			return method_name
		}
	}
	return none
}

// alias_receiver_type_matches converts alias receiver type matches data for transform.
fn (t &Transformer) alias_receiver_type_matches(base_type string, alias_type string) bool {
	if base_type.len == 0 || alias_type.len == 0 {
		return false
	}
	clean_alias := if alias_type.starts_with('&') { alias_type[1..] } else { alias_type }
	alias_target := t.normalize_type_alias(clean_alias)
	if alias_target == base_type {
		return true
	}
	if !isnil(t.tc) {
		alias_c_type := t.tc.c_type(t.tc.parse_type(alias_target))
		base_c_type := t.tc.c_type(t.tc.parse_type(base_type))
		if alias_c_type == base_c_type {
			return true
		}
	}
	return t.is_integer_type_name(alias_target) && t.is_integer_type_name(base_type)
}

// is_integer_type_name reports whether is integer type name applies in transform.
fn (t &Transformer) is_integer_type_name(typ string) bool {
	return typ in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'byte', 'u16', 'u32', 'u64', 'rune',
		'isize', 'usize']
}

// raw_var_type_for_expr supports raw var type for expr handling for Transformer.
fn (t &Transformer) raw_var_type_for_expr(id flat.NodeId) ?string {
	if int(id) < 0 {
		return none
	}
	node := t.a.nodes[int(id)]
	if node.kind == .ident {
		typ := t.var_type(node.value)
		if typ.len > 0 {
			return typ
		}
	}
	if node.typ.len > 0 {
		return node.typ
	}
	return none
}

// raw_const_type_name_for_expr supports raw const type name for expr handling for Transformer.
fn (t &Transformer) raw_const_type_name_for_expr(id flat.NodeId) ?string {
	if int(id) < 0 || isnil(t.tc) {
		return none
	}
	name := t.expr_key(id)
	if name.len == 0 {
		return none
	}
	key := t.const_type_key(name) or { return none }
	typ := t.tc.const_types[key] or { return none }
	return typ.name()
}

// resolve_method_receiver_type determines the receiver type for method calls.
// For a call where child[0] is a .selector, resolves the type of the selector's base expression.
fn (t &Transformer) resolve_method_receiver_type(call_node flat.Node) string {
	if call_node.children_count == 0 {
		return ''
	}
	fn_id := t.a.children[call_node.children_start]
	if int(fn_id) < 0 {
		return ''
	}
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return ''
	}
	base_id := t.a.children[fn_node.children_start]
	return t.resolve_expr_type(base_id)
}

// normalize_generic_call_expr transforms normalize generic call expr data for transform.
fn (mut t Transformer) normalize_generic_call_expr(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return id
	}
	fn_id := t.a.child(&node, 0)
	if int(fn_id) < 0 {
		return id
	}
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .index || fn_node.children_count < 2 || fn_node.value == 'range' {
		return id
	}
	base_id := t.a.child(&fn_node, 0)
	base := t.a.nodes[int(base_id)]
	if base.kind !in [.ident, .selector] {
		return id
	}
	type_arg := t.generic_call_type_args_name(fn_node)
	if type_arg.len == 0 {
		return id
	}
	mut children := []flat.NodeId{cap: int(node.children_count)}
	children << base_id
	for i in 1 .. node.children_count {
		children << t.a.child(&node, i)
	}
	start := t.a.children.len
	for child in children {
		t.a.children << child
	}
	return t.a.add_node(flat.Node{
		kind:           .call
		op:             node.op
		children_start: start
		children_count: flat.child_count(children.len)
		pos:            node.pos
		value:          type_arg
		typ:            node.typ
	})
}

// generic_call_type_arg_name supports generic call type arg name handling for Transformer.
fn (t &Transformer) generic_call_type_arg_name(id flat.NodeId) string {
	if int(id) < 0 {
		return ''
	}
	node := t.a.nodes[int(id)]
	match node.kind {
		.ident {
			return node.value
		}
		.selector {
			if node.children_count == 0 {
				return node.value
			}
			base := t.generic_call_type_arg_name(t.a.child(&node, 0))
			if base.len == 0 {
				return node.value
			}
			return '${base}.${node.value}'
		}
		.index {
			if node.children_count < 2 || node.value == 'range' {
				return ''
			}
			base := t.generic_call_type_arg_name(t.a.child(&node, 0))
			if base.len == 0 {
				return ''
			}
			mut args := []string{}
			for i in 1 .. node.children_count {
				arg := t.generic_call_type_arg_name(t.a.child(&node, i))
				if arg.len == 0 {
					return ''
				}
				args << arg
			}
			return '${base}[${args.join(', ')}]'
		}
		.array_init {
			if node.value.len > 0 {
				return '[]${node.value}'
			}
			return ''
		}
		.map_init {
			return node.value
		}
		.prefix {
			if node.children_count == 0 {
				return ''
			}
			child := t.generic_call_type_arg_name(t.a.child(&node, 0))
			if child.len == 0 {
				return ''
			}
			if node.op == .amp {
				return '&${child}'
			}
			return child
		}
		else {
			return ''
		}
	}
}

fn (t &Transformer) generic_call_type_args_name(index_node flat.Node) string {
	if index_node.kind != .index || index_node.children_count < 2 || index_node.value == 'range' {
		return ''
	}
	mut args := []string{}
	for i in 1 .. index_node.children_count {
		arg := t.generic_call_type_arg_name(t.a.child(&index_node, i))
		if arg.len == 0 {
			return ''
		}
		args << arg
	}
	return args.join(', ')
}

// transform_call_args transforms all children of a call expression.
// child[0] is the function expression, children[1..n] are arguments.
fn (mut t Transformer) transform_call_args(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.children_count == 0 {
		return t.a.add_node(flat.Node{
			kind:  .call
			op:    node.op
			pos:   node.pos
			value: node.value
			typ:   node.typ
		})
	}
	call_name := t.call_name_for_node(id, node)
	mut params := t.call_param_types(call_name)
	if concrete_params := t.concrete_generic_call_param_types(id, node) {
		params = concrete_params.clone()
	}
	param_offset := t.call_param_offset(call_name, node, params)
	is_variadic := t.call_is_variadic(call_name)
	variadic_idx := if is_variadic && params.len > 0 && params[params.len - 1] is types.Array {
		params.len - 1
	} else {
		-1
	}
	mut new_children := []flat.NodeId{cap: int(node.children_count)}
	saved_in_call_callee := t.in_call_callee
	t.in_call_callee = true
	new_children << t.transform_expr(t.a.children[node.children_start])
	t.in_call_callee = saved_in_call_callee
	mut i := 1
	for i < node.children_count {
		arg_idx := new_children.len - 1
		param_idx := arg_idx + param_offset
		arg_id := t.a.child(&node, i)
		arg_node := t.a.nodes[int(arg_id)]
		param_type := if param_idx < params.len { params[param_idx].name() } else { '' }
		if arg_node.kind == .field_init {
			if packed_arg := t.transform_params_struct_call_arg(node, i, param_type) {
				new_children << packed_arg
				i = t.next_non_field_init_arg(node, i)
				continue
			}
		}
		if variadic_idx >= 0 && param_idx == variadic_idx {
			variadic_type := params[variadic_idx]
			if variadic_type is types.Array {
				if arg_node.kind == .prefix && arg_node.value == '...'
					&& arg_node.children_count > 0 {
					spread_id := t.a.child(&arg_node, 0)
					new_children << t.transform_call_arg_for_param(spread_id, param_type)
					i++
					break
				}
				remaining := int(node.children_count) - i
				if remaining == 1 {
					arg_type := t.node_type(arg_id)
					if arg_type.starts_with('[]') {
						new_children << t.transform_call_arg_for_param(arg_id, param_type)
					} else {
						new_children << t.pack_variadic_args(node, i, variadic_type.elem_type)
					}
				} else {
					new_children << t.pack_variadic_args(node, i, variadic_type.elem_type)
				}
				break
			}
		}
		new_children << t.transform_call_arg_for_param(arg_id, param_type)
		i++
	}
	explicit_args := int(node.children_count) - 1
	if variadic_idx >= 0 && explicit_args == variadic_idx - param_offset {
		variadic_type := params[variadic_idx]
		if variadic_type is types.Array {
			new_children << t.pack_variadic_args(node, int(node.children_count),
				variadic_type.elem_type)
		}
	}
	t.append_missing_params_struct_args(mut new_children, params, param_offset)
	start := t.a.children.len
	for nc in new_children {
		t.a.children << nc
	}
	return t.a.add_node(flat.Node{
		kind:           .call
		op:             node.op
		children_start: start
		children_count: flat.child_count(new_children.len)
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
}

// try_lower_join_path_call supports try lower join path call handling for Transformer.
fn (mut t Transformer) try_lower_join_path_call(id flat.NodeId, node flat.Node) ?flat.NodeId {
	call_name := t.call_name_for_node(id, node)
	if call_name != 'join_path' && call_name != 'os.join_path' {
		return none
	}
	// A spread argument (`...rest`) has a runtime-determined length and cannot be
	// unrolled into nested join_path_single calls at compile time. Defer to the real
	// variadic os.join_path in that case.
	for i in 1 .. node.children_count {
		arg := t.a.child_node(&node, i)
		if arg.kind == .prefix && arg.value == '...' {
			return none
		}
	}
	if node.children_count <= 1 {
		return t.make_string_literal('')
	}
	t.mark_fn_used('os.join_path_single')
	mut result := t.transform_expr(t.a.child(&node, 1))
	for i in 2 .. node.children_count {
		arg := t.transform_expr(t.a.child(&node, i))
		result = t.make_call_typed('os.join_path_single', arr2(result, arg), 'string')
	}
	return result
}

// transform_params_struct_call_arg transforms transform params struct call arg data for transform.
fn (mut t Transformer) transform_params_struct_call_arg(node flat.Node, field_start int, param_type string) ?flat.NodeId {
	struct_type := t.params_struct_type_name(param_type) or { return none }
	mut field_ids := []flat.NodeId{}
	for i in field_start .. node.children_count {
		field_id := t.a.child(&node, i)
		field := t.a.nodes[int(field_id)]
		if field.kind != .field_init {
			break
		}
		field_ids << field_id
	}
	if field_ids.len == 0 {
		return none
	}
	start := t.a.children.len
	for field_id in field_ids {
		t.a.children << field_id
	}
	struct_id := t.a.add_node(flat.Node{
		kind:           .struct_init
		children_start: start
		children_count: flat.child_count(field_ids.len)
		value:          struct_type
		typ:            struct_type
	})
	return t.transform_struct_fields(struct_id, t.a.nodes[int(struct_id)])
}

// next_non_field_init_arg returns next non field init arg data for Transformer.
fn (t &Transformer) next_non_field_init_arg(node flat.Node, field_start int) int {
	mut i := field_start
	for i < node.children_count {
		field := t.a.child_node(&node, i)
		if field.kind != .field_init {
			break
		}
		i++
	}
	return i
}

// params_struct_type_name supports params struct type name handling for Transformer.
fn (t &Transformer) params_struct_type_name(param_type string) ?string {
	if param_type.len == 0 {
		return none
	}
	mut typ := param_type
	if typ.starts_with('&') {
		typ = typ[1..]
	}
	if info := t.lookup_struct_info(typ) {
		if info.is_params {
			return typ
		}
	}
	normalized := t.normalize_type_alias(typ)
	if normalized != typ {
		if info := t.lookup_struct_info(normalized) {
			if info.is_params {
				return normalized
			}
		}
	}
	return none
}

// call_name_for_node updates call name for node state for Transformer.
fn (t &Transformer) call_name_for_node(id flat.NodeId, node flat.Node) string {
	if !isnil(t.tc) {
		if name := t.tc.resolved_call_name(id) {
			return name
		}
	}
	return t.resolve_call_name(node)
}

// call_param_offset updates call param offset state for Transformer.
fn (t &Transformer) call_param_offset(call_name string, node flat.Node, params []types.Type) int {
	if params.len == 0 || node.children_count == 0 {
		return 0
	}
	fn_node := t.a.child_node(&node, 0)
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return 0
	}
	base_id := t.a.child(fn_node, 0)
	// `module.Type.fn(...)` / `Type.fn(...)` is a static associated function call, not a
	// method: the base names a type, not a value, so no receiver must be prepended.
	if _ := t.static_assoc_fn_name(base_id, fn_node.value) {
		return 0
	}
	method_name := t.resolve_receiver_method_name(base_id, fn_node.value)
	if method_name.len == 0 {
		return 0
	}
	if t.receiver_method_param_offset(base_id, node, params) == 1 {
		return 1
	}
	if call_name.len == 0 || call_name == method_name || call_name == c_name(method_name) {
		return 1
	}
	return 0
}

// static_assoc_fn_name returns the name of the static associated function a selector
// call resolves to, if the base names a type (`Type.fn` or `module.Type.fn`) and that
// function exists. Such calls take no receiver, so the base must not be prepended as an
// argument. Returns none for ordinary method calls (base is a value).
fn (t &Transformer) static_assoc_fn_name(base_id flat.NodeId, method string) ?string {
	if method.len == 0 {
		return none
	}
	base := t.a.nodes[int(base_id)]
	if base.kind == .ident {
		if base.value == 'C' || t.is_import_alias_ident(base_id) {
			return none
		}
		for type_name in t.static_assoc_type_candidates(base.value) {
			name := '${type_name}.${method}'
			if t.is_known_fn_name(name) {
				return name
			}
		}
	} else if base.kind == .selector && base.children_count > 0 {
		inner := t.a.child_node(&base, 0)
		if inner.kind == .ident {
			type_ident := '${inner.value}.${base.value}'
			for type_name in t.static_assoc_type_candidates(type_ident) {
				name := '${type_name}.${method}'
				if t.is_known_fn_name(name) {
					return name
				}
			}
		}
	}
	return none
}

fn (t &Transformer) is_import_alias_ident(id flat.NodeId) bool {
	if int(id) < 0 || isnil(t.tc) {
		return false
	}
	node := t.a.nodes[int(id)]
	return node.kind == .ident && node.value in t.tc.imports
}

fn (t &Transformer) static_assoc_type_candidates(type_ident string) []string {
	if type_ident.len == 0 {
		return []string{}
	}
	mut candidates := []string{}
	candidates << type_ident
	if !type_ident.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
		&& t.cur_module != 'builtin' {
		candidates << '${t.cur_module}.${type_ident}'
	}
	if !isnil(t.tc) {
		qname := t.tc.qualify_name(type_ident)
		if qname !in candidates {
			candidates << qname
		}
	}
	mut result := []string{}
	for candidate in candidates {
		if t.is_static_assoc_type_name(candidate) && candidate !in result {
			result << candidate
		}
	}
	return result
}

fn (t &Transformer) is_static_assoc_type_name(type_name string) bool {
	if type_name in t.structs || type_name in t.enum_types || type_name in t.sum_types {
		return true
	}
	if isnil(t.tc) {
		return false
	}
	return type_name in t.tc.structs || type_name in t.tc.enum_names || type_name in t.tc.sum_types
		|| type_name in t.tc.interface_names || type_name in t.tc.type_aliases
}

// try_lower_static_assoc_call lowers `Type.method(args)` to a direct call to
// `Type.method(args)` once the checker/transformer has proven that the base is a
// type, not a value receiver.
fn (mut t Transformer) try_lower_static_assoc_call(id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	fn_id := t.a.child(&node, 0)
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return none
	}
	base_id := t.a.child(&fn_node, 0)
	static_fn := t.static_assoc_fn_name(base_id, fn_node.value) or { return none }
	normalized := t.transform_call_args(id, node)
	normalized_node := t.a.nodes[int(normalized)]
	mut args := []flat.NodeId{cap: int(normalized_node.children_count) - 1}
	for i in 1 .. normalized_node.children_count {
		args << t.a.child(&normalized_node, i)
	}
	ret_type := t.receiver_method_return_type(static_fn, node.typ)
	return t.make_call_typed(static_fn, args, ret_type)
}

// call_param_types updates call param types state for Transformer.
fn (t &Transformer) call_param_types(call_name string) []types.Type {
	if call_name.len == 0 || isnil(t.tc) {
		return []types.Type{}
	}
	params := t.tc.fn_param_types[call_name] or { return []types.Type{} }
	return params
}

// call_is_variadic updates call is variadic state for Transformer.
fn (t &Transformer) call_is_variadic(call_name string) bool {
	if call_name.len == 0 || isnil(t.tc) {
		return false
	}
	if t.tc.c_variadic_fns[call_name] {
		return false
	}
	return t.tc.fn_variadic[call_name] or { false }
}

// call_param_type_name updates call param type name state for Transformer.
fn (t &Transformer) call_param_type_name(call_name string, idx int) string {
	if idx < 0 || call_name.len == 0 || isnil(t.tc) {
		return ''
	}
	params := t.tc.fn_param_types[call_name] or { return '' }
	if idx >= params.len {
		return ''
	}
	return params[idx].name()
}

// transform_call_arg_for_param transforms transform call arg for param data for transform.
fn (mut t Transformer) transform_call_arg_for_param(arg_id flat.NodeId, param_type string) flat.NodeId {
	if int(arg_id) < 0 {
		return arg_id
	}
	mut arg_node := &t.a.nodes[int(arg_id)]
	if arg_node.kind == .array_literal && arg_node.typ.len == 0 && param_type.starts_with('[]') {
		arg_node.typ = param_type
	}
	if arg_node.kind == .enum_val && param_type in t.enum_types {
		return t.transform_enum_shorthand(arg_id, *arg_node, param_type)
	}
	if param_type.starts_with('&') && arg_node.kind == .selector
		&& t.selector_chain_has_sum_variant_field(arg_id) {
		value := t.transform_expr(arg_id)
		mut value_type := t.node_type(arg_id)
		if value_type.len == 0 {
			value_type = t.node_type(value)
		}
		stable := t.stable_transformed_expr_for_reuse(value, value_type, 'addr')
		addr := t.make_prefix(.amp, stable)
		t.a.nodes[int(addr)].typ = param_type
		return addr
	}
	if param_type.starts_with('&') && t.is_sum_type_name(param_type[1..]) {
		target_sum := param_type[1..]
		arg_type := t.node_type(arg_id)
		arg_key := t.expr_key(arg_id)
		has_smartcast := t.has_smartcast(arg_key)
		if !has_smartcast
			&& t.resolve_sum_name(t.trim_pointer_type(arg_type)) == t.resolve_sum_name(target_sum) {
			return t.transform_expr(arg_id)
		}
		if arg_node.kind == .prefix && arg_node.op == .amp && arg_node.children_count > 0 {
			inner_id := t.a.child(arg_node, 0)
			inner_type := t.node_type(inner_id)
			if t.resolve_sum_name(t.trim_pointer_type(inner_type)) == t.resolve_sum_name(target_sum) {
				return t.transform_expr(arg_id)
			}
		}
		wrapped := t.wrap_sum_value(arg_id, target_sum)
		tmp_name := t.new_temp('sum_arg')
		t.pending_stmts << t.make_decl_assign_typed(tmp_name, wrapped, target_sum)
		return t.make_prefix(.amp, t.make_ident(tmp_name))
	}
	if ptr_arg := t.transform_pointer_rvalue_arg(arg_id, *arg_node, param_type) {
		return ptr_arg
	}
	if t.is_sum_type_name(param_type) {
		return t.wrap_sum_value(arg_id, param_type)
	}
	if param_type.starts_with('[]') {
		arg_type := t.node_type(arg_id)
		if t.is_fixed_array_type(arg_type) {
			return t.fixed_array_value_to_array(arg_id, arg_type, param_type)
		}
		if const_arg := t.transform_const_array_arg_for_param(arg_id, param_type) {
			return const_arg
		}
	}
	if param_type.len > 0 && t.type_text_has_generic_placeholder(param_type, t.cur_module) {
		return t.transform_expr(arg_id)
	}
	return t.transform_expr_for_type(arg_id, param_type)
}

fn (mut t Transformer) transform_pointer_rvalue_arg(arg_id flat.NodeId, arg_node flat.Node, param_type string) ?flat.NodeId {
	if !param_type.starts_with('&') {
		return none
	}
	mut value_id := arg_id
	mut value_node := arg_node
	if arg_node.kind == .prefix && arg_node.op == .amp && arg_node.children_count > 0 {
		value_id = t.a.child(&arg_node, 0)
		value_node = t.a.nodes[int(value_id)]
	}
	if !is_pointer_arg_temp_rvalue(value_node) {
		return none
	}
	value_type := param_type[1..]
	if value_type.len == 0 || value_type == 'void' || value_type == 'unknown' {
		return none
	}
	arg_type := t.node_type(value_id)
	if arg_type.len == 0 || arg_type == 'void' || arg_type == 'unknown'
		|| is_pointer_like_type_name(arg_type) {
		return none
	}
	value := t.transform_expr_for_type(value_id, value_type)
	tmp_name := t.new_temp('ptr_arg')
	t.pending_stmts << t.make_decl_assign_typed(tmp_name, value, value_type)
	addr := t.make_prefix(.amp, t.make_ident(tmp_name))
	t.a.nodes[int(addr)].typ = param_type
	return addr
}

fn is_pointer_arg_temp_rvalue(node flat.Node) bool {
	return node.kind == .call || (node.kind == .index && node.value == 'range')
}

fn is_pointer_like_type_name(typ string) bool {
	mut clean := typ
	if clean.starts_with('mut ') {
		clean = clean[4..]
	}
	return clean.starts_with('&') || clean in ['voidptr', 'byteptr', 'charptr']
}

fn (mut t Transformer) append_missing_params_struct_args(mut args []flat.NodeId, params []types.Type, param_offset int) {
	mut param_idx := param_offset
	if args.len > 0 {
		param_idx = args.len - 1 + param_offset
	}
	for param_idx < params.len {
		param_type := params[param_idx].name()
		struct_type := t.params_struct_type_name(param_type) or { break }
		args << t.zero_value_for_type(struct_type)
		param_idx++
	}
}

// is_fn_pointer_type_name reports whether is fn pointer type name applies in transform.
fn (t &Transformer) is_fn_pointer_type_name(type_name string) bool {
	if type_name.len == 0 || isnil(t.tc) {
		return false
	}
	typ := t.tc.parse_type(type_name)
	if typ is types.FnType {
		return true
	}
	if typ is types.Alias {
		return typ.base_type is types.FnType
	}
	return false
}

// is_named_fn_value_arg reports whether is named fn value arg applies in transform.
fn (t &Transformer) is_named_fn_value_arg(arg_id flat.NodeId) bool {
	if int(arg_id) < 0 || isnil(t.tc) {
		return false
	}
	node := t.a.nodes[int(arg_id)]
	if node.kind == .ident {
		if _ := t.resolve_fn_value_ident(node.value) {
			return true
		}
		return false
	}
	if node.kind == .selector && node.children_count > 0 {
		key := t.expr_key(arg_id)
		return key in t.tc.fn_ret_types || key in t.tc.fn_param_types
	}
	return false
}

// transform_const_array_arg_for_param supports transform_const_array_arg_for_param handling.
fn (mut t Transformer) transform_const_array_arg_for_param(arg_id flat.NodeId, param_type string) ?flat.NodeId {
	expr_id := t.const_expr_for_arg(arg_id) or { return none }
	expr := t.a.nodes[int(expr_id)]
	elem_type := param_type[2..]
	if expr.kind == .array_init && expr.children_count == 0 {
		return t.make_array_new_call(elem_type, t.make_int_literal(0), t.make_int_literal(0))
	}
	if expr.kind != .array_literal {
		return none
	}
	if expr.children_count == 0 {
		return t.make_array_new_call(elem_type, t.make_int_literal(0), t.make_int_literal(0))
	}
	mut values := []flat.NodeId{cap: int(expr.children_count)}
	for i in 0 .. expr.children_count {
		values << t.transform_expr(t.a.child(&expr, i))
	}
	return t.make_array_literal_typed(values, param_type)
}

// const_expr_for_arg supports const expr for arg handling for Transformer.
fn (t &Transformer) const_expr_for_arg(arg_id flat.NodeId) ?flat.NodeId {
	if isnil(t.tc) || int(arg_id) < 0 {
		return none
	}
	node := t.a.nodes[int(arg_id)]
	if node.kind == .ident {
		if t.var_type(node.value).len > 0 {
			return none
		}
		if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
			if expr_id := t.const_expr_for_name('${t.cur_module}.${node.value}') {
				return expr_id
			}
		}
		return t.const_expr_for_name(node.value)
	}
	if node.kind == .selector && node.children_count > 0 {
		base := t.a.child_node(&node, 0)
		if base.kind == .ident {
			return t.const_expr_for_name('${base.value}.${node.value}')
		}
	}
	return none
}

// const_expr_for_name supports const expr for name handling for Transformer.
fn (t &Transformer) const_expr_for_name(name string) ?flat.NodeId {
	if isnil(t.tc) || name.len == 0 {
		return none
	}
	if expr_id := t.tc.const_exprs[name] {
		return expr_id
	}
	key := t.const_type_key(name) or { return none }
	if expr_id := t.tc.const_exprs[key] {
		return expr_id
	}
	return none
}

// pack_variadic_args supports pack variadic args handling for Transformer.
fn (mut t Transformer) pack_variadic_args(node flat.Node, first_arg int, elem_type types.Type) flat.NodeId {
	expected_enum := elem_type.name()
	array_type := '[]${expected_enum}'
	if named_arg := t.transform_variadic_struct_fields(node, first_arg, elem_type) {
		if t.in_const_init {
			return t.make_array_literal_typed([named_arg], array_type)
		}
		tmp_name := t.new_temp('varargs')
		t.pending_stmts << t.make_decl_assign_typed(tmp_name, t.make_array_new_call(expected_enum,
			t.make_int_literal(0), t.make_int_literal(1)), array_type)
		value_name := t.new_temp('vararg')
		t.pending_stmts << t.make_decl_assign_typed(value_name, named_arg, expected_enum)
		t.pending_stmts << t.make_expr_stmt(t.make_call_typed('array_push', arr2(t.make_prefix(.amp,
			t.make_ident(tmp_name)), t.make_prefix(.amp, t.make_ident(value_name))), 'void'))
		t.set_var_type(tmp_name, array_type)
		return t.make_ident(tmp_name)
	}
	if t.in_const_init {
		mut values := []flat.NodeId{cap: int(node.children_count) - first_arg}
		for i in first_arg .. node.children_count {
			arg_id := t.a.child(&node, i)
			arg := t.a.nodes[int(arg_id)]
			if arg.kind == .enum_val && expected_enum in t.enum_types {
				values << t.transform_enum_shorthand(arg_id, arg, expected_enum)
			} else if t.is_sum_type_name(expected_enum) {
				values << t.wrap_sum_value(arg_id, expected_enum)
			} else {
				values << t.transform_expr(arg_id)
			}
		}
		return t.make_array_literal_typed(values, array_type)
	}
	tmp_name := t.new_temp('varargs')
	t.pending_stmts << t.make_decl_assign_typed(tmp_name, t.make_array_new_call(expected_enum,
		t.make_int_literal(0), t.make_int_literal(int(node.children_count) - first_arg)),
		array_type)
	for i in first_arg .. node.children_count {
		arg_id := t.a.child(&node, i)
		arg := t.a.nodes[int(arg_id)]
		value := if arg.kind == .enum_val && expected_enum in t.enum_types {
			t.transform_enum_shorthand(arg_id, arg, expected_enum)
		} else if t.is_sum_type_name(expected_enum) {
			t.wrap_sum_value(arg_id, expected_enum)
		} else {
			t.transform_expr(arg_id)
		}
		value_name := t.new_temp('vararg')
		t.pending_stmts << t.make_decl_assign_typed(value_name, value, expected_enum)
		t.pending_stmts << t.make_expr_stmt(t.make_call_typed('array_push', arr2(t.make_prefix(.amp,
			t.make_ident(tmp_name)), t.make_prefix(.amp, t.make_ident(value_name))), 'void'))
	}
	t.set_var_type(tmp_name, array_type)
	return t.make_ident(tmp_name)
}

fn (mut t Transformer) transform_variadic_struct_fields(node flat.Node, field_start int, elem_type types.Type) ?flat.NodeId {
	if field_start >= node.children_count {
		return none
	}
	if elem_type !is types.Struct {
		return none
	}
	first := t.a.child_node(&node, field_start)
	if first.kind != .field_init {
		return none
	}
	mut field_ids := []flat.NodeId{}
	for i in field_start .. node.children_count {
		field_id := t.a.child(&node, i)
		field := t.a.nodes[int(field_id)]
		if field.kind != .field_init {
			break
		}
		field_ids << field_id
	}
	if field_ids.len == 0 {
		return none
	}
	start := t.a.children.len
	for field_id in field_ids {
		t.a.children << field_id
	}
	struct_id := t.a.add_node(flat.Node{
		kind:           .struct_init
		children_start: start
		children_count: flat.child_count(field_ids.len)
		value:          elem_type.name()
		typ:            elem_type.name()
	})
	return t.transform_struct_fields(struct_id, t.a.nodes[int(struct_id)])
}

// make_array_literal_typed builds make array literal typed data for transform.
fn (mut t Transformer) make_array_literal_typed(values []flat.NodeId, typ string) flat.NodeId {
	start := t.a.children.len
	for value in values {
		t.a.children << value
	}
	return t.a.add_node(flat.Node{
		kind:           .array_literal
		children_start: start
		children_count: flat.child_count(values.len)
		typ:            typ
	})
}

// stringify_expr supports stringify expr handling for Transformer.
fn (mut t Transformer) stringify_expr(expr_id flat.NodeId) flat.NodeId {
	expr := t.transform_expr(expr_id)
	mut typ := t.node_type(expr)
	if typ.len == 0 {
		typ = t.node_type(expr_id)
	}
	if typ.len == 0 {
		// Structural fallback for compound arguments (infix, prefix, cast,
		// paren, ...) so e.g. `println(a + b)` for ints is stringified via
		// strconv__format_int instead of being passed to println as a raw
		// number. Mirrors the fallback already used by string interpolation.
		typ = t.reliable_stringify_type(expr)
		if typ.len == 0 {
			typ = t.reliable_stringify_type(expr_id)
		}
	}
	return t.wrap_string_conversion(expr, typ)
}

// reliable_stringify_type supports reliable stringify type handling for Transformer.
fn (t &Transformer) reliable_stringify_type(id flat.NodeId) string {
	mut typ := t.node_type(id)
	if typ.len > 0 {
		return typ
	}
	if int(id) >= 0 {
		node := t.a.nodes[int(id)]
		if node.typ.len > 0 {
			return node.typ
		}
		match node.kind {
			.int_literal {
				return 'int'
			}
			.float_literal {
				return 'f64'
			}
			.bool_literal {
				return 'bool'
			}
			.char_literal {
				return 'rune'
			}
			.string_literal, .string_interp {
				return 'string'
			}
			.infix {
				return t.reliable_infix_stringify_type(node)
			}
			.prefix {
				if node.op == .not {
					return 'bool'
				}
				if node.children_count > 0 {
					return t.reliable_stringify_type(t.a.child(&node, 0))
				}
			}
			.paren {
				if node.children_count > 0 {
					return t.reliable_stringify_type(t.a.child(&node, 0))
				}
			}
			.cast_expr {
				if node.value.len > 0 {
					return t.normalize_type_alias(node.value)
				}
				if node.children_count > 0 {
					return t.reliable_stringify_type(t.a.child(&node, 0))
				}
			}
			else {}
		}
	}
	return ''
}

// reliable_infix_stringify_type supports reliable infix stringify type handling for Transformer.
fn (t &Transformer) reliable_infix_stringify_type(node flat.Node) string {
	if node.children_count < 2 {
		return ''
	}
	lhs_type := t.reliable_stringify_type(t.a.child(&node, 0))
	rhs_type := t.reliable_stringify_type(t.a.child(&node, 1))
	if lhs_type == 'string' || rhs_type == 'string' {
		return 'string'
	}
	match node.op {
		.eq, .ne, .lt, .gt, .le, .ge, .logical_and, .logical_or {
			return 'bool'
		}
		.left_shift, .right_shift, .right_shift_unsigned {
			// shifts keep the left operand's type/width
			if lhs_type.len > 0 && t.is_numeric_stringify_type(lhs_type) {
				return lhs_type
			}
		}
		.plus, .minus, .mul, .div, .mod, .amp, .pipe, .xor {
			if lhs_type.len > 0 && rhs_type.len > 0 && t.is_numeric_stringify_type(lhs_type)
				&& t.is_numeric_stringify_type(rhs_type) {
				// Use the promoted result type, not the lhs, so e.g.
				// `1 + u64(x)` formats as unsigned rather than signed int.
				return promote_numeric_stringify_type(lhs_type, rhs_type)
			}
		}
		else {}
	}

	return ''
}

// promote_numeric_stringify_type returns the result type of a binary numeric
// operation for stringify purposes: floats dominate, the wider integer wins,
// and on equal width an explicit type beats the untyped-literal default `int`.
fn promote_numeric_stringify_type(a string, b string) string {
	if a == b {
		return a
	}
	if a == 'f64' || b == 'f64' {
		return 'f64'
	}
	if a == 'f32' || b == 'f32' {
		return 'f32'
	}
	ra := int_stringify_rank(a)
	rb := int_stringify_rank(b)
	if ra > rb {
		return a
	}
	if rb > ra {
		return b
	}
	if a == 'int' {
		return b
	}
	if b == 'int' {
		return a
	}
	return a
}

fn int_stringify_rank(typ string) int {
	return match typ {
		'i8', 'u8', 'byte' { 8 }
		'i16', 'u16' { 16 }
		'i32', 'u32', 'int', 'rune' { 32 }
		'i64', 'u64', 'isize', 'usize' { 64 }
		else { 32 }
	}
}

// is_numeric_stringify_type reports whether is numeric stringify type applies in transform.
fn (t &Transformer) is_numeric_stringify_type(typ string) bool {
	is_number := typ in ['int', 'int literal', 'i8', 'i16', 'i32', 'i64', 'isize', 'usize', 'u8',
		'byte', 'u16', 'u32', 'u64', 'f32', 'f64', 'float literal', 'rune']
	return is_number || typ in t.enum_types
}

// is_enum_stringify_type reports whether is enum stringify type applies in transform.
fn (t &Transformer) is_enum_stringify_type(typ string) bool {
	mut clean_typ := typ
	if clean_typ.starts_with('&') {
		clean_typ = clean_typ[1..]
	}
	if clean_typ.starts_with('mut ') {
		clean_typ = clean_typ[4..]
	}
	if clean_typ in t.enum_types {
		return true
	}
	mut qtyp := clean_typ
	if !qtyp.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
		&& t.cur_module != 'builtin' {
		qtyp = '${t.cur_module}.${clean_typ}'
		if qtyp in t.enum_types {
			return true
		}
	}
	if isnil(t.tc) {
		return false
	}
	if alias := t.tc.type_aliases[clean_typ] {
		return t.is_enum_stringify_type(alias)
	}
	if qtyp != clean_typ {
		if alias := t.tc.type_aliases[qtyp] {
			return t.is_enum_stringify_type(alias)
		}
	}
	parsed := t.tc.parse_type(clean_typ)
	if parsed is types.Enum {
		return true
	}
	if qtyp != clean_typ {
		qparsed := t.tc.parse_type(qtyp)
		if qparsed is types.Enum {
			return true
		}
	}
	return false
}

// enum_str_method_name supports enum str method name handling for Transformer.
fn (t &Transformer) enum_str_method_name(typ string) ?string {
	mut candidates := []string{cap: 3}
	candidates << typ
	if !typ.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
		&& t.cur_module != 'builtin' {
		candidates << '${t.cur_module}.${typ}'
	}
	if !isnil(t.tc) {
		parsed := t.tc.parse_type(typ)
		if parsed is types.Enum {
			candidates << parsed.name
		}
	}
	for candidate in candidates {
		method := '${candidate}.str'
		if t.is_known_fn_name(method) {
			return method
		}
	}
	return none
}

// enum_autostr_call builds a call to the compiler-synthesized `<Enum>__autostr` helper
// (emitted by cgen's enum_str_defs) which returns the enum field NAME. Used as the default
// `${enum}` stringification when the user has not defined a custom `.str()` — V auto-derives
// one. Mirrors the struct-str qualification so the C name matches cgen's enum_decls naming.
fn (mut t Transformer) enum_autostr_call(expr flat.NodeId, typ string) flat.NodeId {
	mut qualified := typ
	if qualified.starts_with('main.') {
		qualified = qualified[5..]
	} else if !typ.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
		&& t.cur_module != 'builtin' {
		q := '${t.cur_module}.${typ}'
		if q in t.enum_types {
			qualified = q
		}
	}
	return t.make_call_typed('${c_name(qualified)}__autostr', arr1(expr), 'string')
}

// wrap_string_conversion transforms wrap string conversion data for transform.
fn (mut t Transformer) wrap_string_conversion(expr flat.NodeId, typ string) flat.NodeId {
	mut clean_typ := typ
	is_ref := clean_typ.starts_with('&')
	if clean_typ.starts_with('&') {
		clean_typ = clean_typ[1..]
	}
	if clean_typ.starts_with('builtin.') {
		clean_typ = clean_typ.all_after_last('.')
	}
	if t.is_optional_type_name(clean_typ) {
		return t.wrap_optional_string_conversion(expr, clean_typ)
	}
	if clean_typ.len == 0 || clean_typ == 'unknown' {
		inferred := t.resolve_expr_type(expr)
		if inferred.len > 0 && inferred != clean_typ {
			return t.wrap_string_conversion(expr, inferred)
		}
	}
	if !isnil(t.tc) {
		if alias := t.tc.type_aliases[clean_typ] {
			return t.wrap_string_conversion(expr, alias)
		}
		mut qtyp := clean_typ
		if !qtyp.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
			&& t.cur_module != 'builtin' {
			qtyp = '${t.cur_module}.${clean_typ}'
		}
		if alias := t.tc.type_aliases[qtyp] {
			return t.wrap_string_conversion(expr, alias)
		}
		if !clean_typ.contains('.') {
			for aname, target in t.tc.type_aliases {
				if aname.all_after_last('.') == clean_typ {
					return t.wrap_string_conversion(expr, target)
				}
			}
		}
		parsed := t.tc.parse_type(clean_typ)
		if parsed is types.Enum {
			if method := t.enum_str_method_name(clean_typ) {
				return t.make_call_typed(method, arr1(expr), 'string')
			}
			return t.enum_autostr_call(expr, clean_typ)
		}
		if qtyp != clean_typ {
			qparsed := t.tc.parse_type(qtyp)
			if qparsed is types.Enum {
				if method := t.enum_str_method_name(qtyp) {
					return t.make_call_typed(method, arr1(expr), 'string')
				}
				return t.enum_autostr_call(expr, qtyp)
			}
		}
	}
	if clean_typ == 'string' {
		return expr
	}
	if is_ref || clean_typ in ['voidptr', 'byteptr', 'charptr'] {
		return t.make_call_typed('ptr_str', arr1(expr), 'string')
	}
	if clean_typ == 'IError' || clean_typ == 'builtin.IError' {
		return t.make_call_typed('IError.str', arr1(expr), 'string')
	}
	match clean_typ {
		'bool' {
			return t.make_call_typed('bool.str', arr1(expr), 'string')
		}
		'u8', 'byte', 'u16', 'u32', 'usize' {
			return t.make_call_typed('strconv__format_uint', arr2(expr, t.make_int_literal(10)),
				'string')
		}
		'u64' {
			return t.make_call_typed('u64.str', arr1(expr), 'string')
		}
		'int', 'int literal' {
			return t.make_call_typed('int.str', arr1(expr), 'string')
		}
		'i8' {
			return t.make_call_typed('i8.str', arr1(expr), 'string')
		}
		'i16' {
			return t.make_call_typed('i16.str', arr1(expr), 'string')
		}
		'i32' {
			return t.make_call_typed('i32.str', arr1(expr), 'string')
		}
		'i64' {
			return t.make_call_typed('i64.str', arr1(expr), 'string')
		}
		'isize' {
			return t.make_call_typed('strconv__format_int', arr2(expr, t.make_int_literal(10)),
				'string')
		}
		'f32' {
			return t.make_call_typed('strconv__f32_to_str_l', arr1(expr), 'string')
		}
		'f64', 'float literal' {
			return t.make_call_typed('strconv__f64_to_str_l', arr1(expr), 'string')
		}
		else {
			if clean_typ in t.enum_types {
				if method := t.enum_str_method_name(clean_typ) {
					return t.make_call_typed(method, arr1(expr), 'string')
				}
				return t.enum_autostr_call(expr, clean_typ)
			}
			mut qenum := clean_typ
			if !clean_typ.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
				&& t.cur_module != 'builtin' {
				qenum = '${t.cur_module}.${clean_typ}'
			}
			if qenum in t.enum_types {
				if method := t.enum_str_method_name(qenum) {
					return t.make_call_typed(method, arr1(expr), 'string')
				}
				return t.enum_autostr_call(expr, qenum)
			}
			if clean_typ in t.structs || clean_typ in t.sum_types {
				mut qualified := clean_typ
				if !clean_typ.contains('.') && t.cur_module.len > 0 && t.cur_module != 'main'
					&& t.cur_module != 'builtin' {
					q := '${t.cur_module}.${clean_typ}'
					if q in t.structs || q in t.sum_types {
						qualified = q
					}
				}
				str_fn := '${c_name(qualified)}__str'
				known_str := str_fn in t.fn_ret_types
					|| (!isnil(t.tc) && str_fn in t.tc.fn_ret_types)
				if known_str {
					return t.make_call_typed(str_fn, arr1(expr), 'string')
				}
				return t.make_string_literal('${qualified}{}')
			} else if t.is_fixed_array_type(clean_typ) {
				elem_type := fixed_array_elem_type(clean_typ)
				arr := t.fixed_array_value_to_array(expr, clean_typ, '[]${elem_type}')
				return t.wrap_string_conversion(arr, '[]${elem_type}')
			} else if clean_typ.len > 0 && clean_typ.starts_with('[]') {
				return t.lower_array_str(expr, clean_typ)
			} else if clean_typ.len > 0 && clean_typ.starts_with('map[') {
				return t.lower_map_str(expr, clean_typ)
			} else if clean_typ == 'rune' {
				return t.make_call_typed('rune.str', arr1(expr), 'string')
			} else {
				return expr
			}
		}
	}
}

fn (mut t Transformer) wrap_formatted_string_conversion(expr flat.NodeId, typ string, format string) flat.NodeId {
	if format.len == 0 {
		return t.wrap_string_conversion(expr, typ)
	}
	mut clean_typ := typ
	if clean_typ.starts_with('&') {
		clean_typ = clean_typ[1..]
	}
	if clean_typ.starts_with('builtin.') {
		clean_typ = clean_typ.all_after_last('.')
	}
	if precision := fixed_decimal_precision(format) {
		if clean_typ in ['f32', 'f64', 'float_literal'] {
			arg := if clean_typ == 'f64' {
				expr
			} else {
				t.make_cast('f64', expr, 'f64')
			}
			return t.make_call_typed('v3_f64_fixed', arr2(arg, t.make_int_literal(precision)),
				'string')
		}
	}
	if format == 'c' {
		if clean_typ in ['u8', 'byte', 'char', 'rune', 'int'] {
			arg := if clean_typ == 'int' {
				expr
			} else {
				t.make_cast('int', expr, 'int')
			}
			return t.make_call_typed('v3_char_string', arr1(arg), 'string')
		}
	}
	if base := integer_format_base(format) {
		if clean_typ in ['u8', 'byte', 'u16', 'u32', 'u64', 'usize'] {
			return t.make_call_typed('strconv__format_uint', arr2(expr, t.make_int_literal(base)),
				'string')
		}
		if clean_typ in ['int', 'i8', 'i16', 'i32', 'i64', 'isize'] {
			return t.make_call_typed('strconv__format_int', arr2(expr, t.make_int_literal(base)),
				'string')
		}
	}
	if width := zero_padded_decimal_width(format) {
		if clean_typ in ['int', 'i8', 'i16', 'i32', 'i64', 'isize', 'usize', 'u8', 'byte', 'u16',
			'u32', 'u64'] {
			if clean_typ in ['u64', 'usize', 'u32', 'u16', 'u8', 'byte'] {
				arg := if clean_typ == 'u64' {
					expr
				} else {
					t.make_cast('u64', expr, 'u64')
				}
				return t.make_call_typed('v3_u64_zpad', arr2(arg, t.make_int_literal(width)),
					'string')
			}
			if clean_typ in ['i64', 'isize', 'i32', 'i16', 'i8'] {
				arg := if clean_typ == 'i64' {
					expr
				} else {
					t.make_cast('i64', expr, 'i64')
				}
				return t.make_call_typed('v3_i64_zpad', arr2(arg, t.make_int_literal(width)),
					'string')
			}
			return t.make_call_typed('v3_int_zpad', arr2(expr, t.make_int_literal(width)), 'string')
		}
	}
	return t.wrap_string_conversion(expr, typ)
}

fn fixed_decimal_precision(format string) ?int {
	if format.len < 3 || format[0] != `.` || format[format.len - 1] != `f` {
		return none
	}
	mut n := 0
	for i in 1 .. format.len - 1 {
		ch := format[i]
		if ch < `0` || ch > `9` {
			return none
		}
		n = n * 10 + int(ch - `0`)
	}
	return n
}

fn integer_format_base(format string) ?int {
	match format {
		'x' {
			return 16
		}
		'o' {
			return 8
		}
		else {}
	}

	return none
}

fn zero_padded_decimal_width(format string) ?int {
	if format.len < 2 || format[0] != `0` {
		return none
	}
	mut end := format.len
	if format[end - 1] == `d` {
		end--
	}
	if end >= 3 && format[end - 2] == `.` && format[end - 1] == `0` {
		end -= 2
	}
	if end <= 1 {
		return none
	}
	mut width := 0
	for i in 1 .. end {
		ch := format[i]
		if ch < `0` || ch > `9` {
			return none
		}
		width = width * 10 + int(ch - `0`)
	}
	if width <= 0 {
		return none
	}
	return width
}

// append_string builds `result = result + piece` using the runtime string concat helper.
// Using string__plus directly (instead of `+=`) keeps the synthesized node independent of
// type resolution for the freshly-introduced temp.
fn (mut t Transformer) append_string(result_name string, piece flat.NodeId) flat.NodeId {
	concat := t.make_call_typed('string__plus', arr2(t.make_ident(result_name), piece), 'string')
	return t.make_assign(t.make_ident(result_name), concat)
}

// lower_array_str expands `${arr}` for a `[]T` into a runtime loop that formats each element
// via wrap_string_conversion, so nested arrays, structs with `str`, enums, etc. all recurse
// correctly. Produces `[e0, e1, ...]`; string elements are wrapped in single quotes to match V.
fn (mut t Transformer) lower_array_str(arr_expr flat.NodeId, base_type string) flat.NodeId {
	src := t.a.nodes[int(arr_expr)]
	elem_type := base_type[2..]
	base := t.stable_expr_for_reuse(arr_expr)
	mut prefix := []flat.NodeId{}
	t.drain_pending(mut prefix)
	result_name := t.new_temp('arr_str')
	idx_name := t.new_temp('arr_str_idx')
	prefix << t.make_decl_assign_typed(result_name, t.make_string_literal('['), 'string')
	init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
	cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(base, 'len', 'int'))
	post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
	elem_name := t.new_temp('arr_str_it')
	elem_expr := t.array_get_value(base, t.make_ident(idx_name), elem_type)
	elem_decl := t.make_decl_assign_typed(elem_name, elem_expr, elem_type)
	mut loop_body := []flat.NodeId{}
	loop_body << elem_decl
	// `if idx > 0 { result = result + ', ' }`
	sep_cond := t.make_infix(.gt, t.make_ident(idx_name), t.make_int_literal(0))
	sep_stmt := t.append_string(result_name, t.make_string_literal(', '))
	loop_body << t.make_if(sep_cond, t.make_block(arr1(sep_stmt)), t.make_empty())
	// element text (recurses; may push its own statements for nested arrays/optionals)
	t.set_var_type(elem_name, elem_type)
	elem_str := t.wrap_string_conversion(t.make_ident(elem_name), elem_type)
	t.unset_var_type(elem_name)
	t.drain_pending(mut loop_body)
	if elem_type == 'string' {
		loop_body << t.append_string(result_name, t.make_string_literal("'"))
		loop_body << t.append_string(result_name, elem_str)
		loop_body << t.append_string(result_name, t.make_string_literal("'"))
	} else {
		loop_body << t.append_string(result_name, elem_str)
	}
	prefix << t.make_for_stmt(init, cond, post, loop_body, src)
	prefix << t.append_string(result_name, t.make_string_literal(']'))
	for stmt in prefix {
		t.pending_stmts << stmt
	}
	return t.make_ident(result_name)
}

fn (mut t Transformer) lower_map_str(map_expr flat.NodeId, map_type string) flat.NodeId {
	key_type, value_type := t.map_type_parts(map_type)
	if key_type.len == 0 || value_type.len == 0 {
		return map_expr
	}
	lowered := t.transform_expr_for_type(map_expr, map_type)
	return t.make_call_typed('v3_map_str', arr4(lowered,
		t.make_int_literal(t.map_str_kind_for_type(key_type)),
		t.make_int_literal(t.map_str_kind_for_type(value_type)),
		t.make_int_literal(t.map_str_fixed_len_for_type(value_type))), 'string')
}

fn (t &Transformer) map_str_kind_for_type(typ string) int {
	mut clean := t.normalize_type_alias(typ).trim_space()
	if clean.starts_with('builtin.') {
		clean = clean.all_after_last('.')
	}
	match clean {
		'string' {
			return 1
		}
		'rune' {
			return 4
		}
		'isize', 'char', 'i8', 'i16', 'i32', 'i64', 'int' {
			return 2
		}
		'usize', 'u8', 'byte', 'u16', 'u32', 'u64' {
			return 3
		}
		'f32', 'f64' {
			return 5
		}
		'bool' {
			return 7
		}
		else {
			if clean.starts_with('[]') && clean[2..] in ['f32', 'f64'] {
				return 6
			}
			if transform_type_text_is_fixed_array(clean) {
				elem := t.normalize_type_alias(fixed_array_elem_type(clean))
				if elem == 'f32' {
					return 9
				}
				if elem == 'f64' {
					return 6
				}
			}
			return 0
		}
	}
}

fn (t &Transformer) map_str_fixed_len_for_type(typ string) int {
	clean := t.normalize_type_alias(typ).trim_space()
	if transform_type_text_is_fixed_array(clean) {
		return fixed_array_len(clean)
	}
	return 0
}

// wrap_optional_string_conversion transforms wrap optional string conversion data for transform.
fn (mut t Transformer) wrap_optional_string_conversion(expr flat.NodeId, typ string) flat.NodeId {
	opt_type := t.qualify_optional_type(typ)
	mut value_type := t.optional_base_type(opt_type)
	if value_type.len == 0 || value_type == 'void' {
		value_type = 'int'
	}
	opt_name := t.new_temp('opt_str')
	res_name := t.new_temp('opt_str_text')
	t.pending_stmts << t.make_decl_assign_typed(opt_name, expr, opt_type)
	t.pending_stmts << t.make_decl_assign_typed(res_name, t.make_string_literal('Option(none)'),
		'string')
	value := t.make_selector(t.make_ident(opt_name), 'value', value_type)
	mut value_str := t.wrap_string_conversion(value, value_type)
	if value_type == 'string' {
		value_str = t.string_plus(t.string_plus(t.make_string_literal("'"), value_str),
			t.make_string_literal("'"))
	}
	some_str := t.string_plus(t.string_plus(t.make_string_literal('Option('), value_str),
		t.make_string_literal(')'))
	assign_some := t.make_assign(t.make_ident(res_name), some_str)
	t.pending_stmts << t.make_if(t.make_selector(t.make_ident(opt_name), 'ok', 'bool'),
		t.make_block(arr1(assign_some)), t.make_empty())
	return t.make_ident(res_name)
}

// string_plus supports string plus handling for Transformer.
fn (mut t Transformer) string_plus(left flat.NodeId, right flat.NodeId) flat.NodeId {
	return t.make_call_typed('string__plus', arr2(left, right), 'string')
}

// is_flag_enum_type reports whether is flag enum type applies in transform.
fn (t &Transformer) is_flag_enum_type(typ string) bool {
	mut clean := typ
	if clean.starts_with('&') {
		clean = clean[1..]
	}
	if clean.len == 0 {
		return false
	}
	if !isnil(t.tc) {
		parsed := t.tc.parse_type(clean)
		if parsed is types.Enum {
			return parsed.is_flag
		}
	}
	return false
}

// is_runtime_array_flags_selector reports is_runtime_array_flags_selector logic in transform.
fn (t &Transformer) is_runtime_array_flags_selector(id flat.NodeId) bool {
	if int(id) < 0 {
		return false
	}
	node := t.a.nodes[int(id)]
	if node.kind != .selector || node.value != 'flags' || node.children_count == 0 {
		return false
	}
	owner_id := t.a.child(&node, 0)
	owner_type := t.node_type(owner_id).trim_left('&')
	return owner_type.starts_with('[]') || owner_type == 'strings.Builder'
}

// try_lower_flag_enum_stmt supports try lower flag enum stmt handling for Transformer.
fn (mut t Transformer) try_lower_flag_enum_stmt(call_id flat.NodeId) ?flat.NodeId {
	if int(call_id) < 0 {
		return none
	}
	call := t.a.nodes[int(call_id)]
	if call.kind != .call || call.children_count < 2 {
		return none
	}
	fn_id := t.a.children[call.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0
		|| fn_node.value !in ['set', 'clear'] {
		return none
	}
	base_id := t.a.children[fn_node.children_start]
	if t.is_runtime_array_flags_selector(base_id) {
		return none
	}
	base_type := t.node_type(base_id)
	if !t.is_flag_enum_type(base_type) {
		return none
	}
	base := t.transform_expr(base_id)
	arg := t.transform_expr(t.a.children[call.children_start + 1])
	if fn_node.value == 'set' {
		return t.make_assign_op(base, arg, .pipe_assign)
	}
	return t.make_assign_op(base, t.make_prefix(.bit_not, arg), .amp_assign)
}

// try_lower_flag_enum_call supports try lower flag enum call handling for Transformer.
fn (mut t Transformer) try_lower_flag_enum_call(node flat.Node) ?flat.NodeId {
	if node.children_count == 1 {
		fn_id := t.a.children[node.children_start]
		fn_node := t.a.nodes[int(fn_id)]
		if fn_node.kind != .selector || fn_node.children_count == 0 || fn_node.value != 'zero' {
			return none
		}
		base_id := t.a.children[fn_node.children_start]
		base_node := t.a.nodes[int(base_id)]
		if base_node.kind != .ident || !t.is_flag_enum_type(base_node.value) {
			return none
		}
		return t.make_cast(base_node.value, t.make_int_literal(0), base_node.value)
	}
	if node.children_count < 2 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 || fn_node.value !in ['has', 'all'] {
		return none
	}
	base_id := t.a.children[fn_node.children_start]
	if t.is_runtime_array_flags_selector(base_id) {
		return none
	}
	mut base_type := t.node_type(base_id)
	if base_type.len == 0 {
		base_type = t.lvalue_type(base_id)
	}
	if !t.is_flag_enum_type(base_type) {
		return none
	}
	base := t.transform_expr(base_id)
	arg_id := t.a.children[node.children_start + 1]
	arg := t.transform_expr(arg_id)
	masked := t.make_infix(.amp, base, arg)
	if fn_node.value == 'has' {
		return t.make_infix(.ne, masked, t.make_int_literal(0))
	}
	arg_copy := t.transform_expr(arg_id)
	return t.make_infix(.eq, masked, arg_copy)
}

// try_lower_array_method_call supports try lower array method call handling for Transformer.
fn (mut t Transformer) try_lower_array_method_call(call_id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return none
	}
	array_builtin_method := t.array_builtin_method_name(fn_node.value) or { '' }
	if fn_node.value !in ['clone', 'reverse', 'contains', 'index', 'last_index', 'join', 'any',
		'all', 'count', 'equals', 'prepend', 'insert', 'push_many', 'str'] {
		if fn_node.value !in ['filter', 'map', 'sort', 'sorted', 'sort_with_compare', 'sorted_with_compare']
			&& array_builtin_method.len == 0 {
			return none
		}
	}
	base_id := t.a.children[fn_node.children_start]
	mut base_type := t.node_type(base_id)
	base_node := t.a.nodes[int(base_id)]
	if (array_type_has_generic_placeholder(base_type) || base_type.contains('unknown'))
		&& base_node.kind == .call {
		concrete_base_type := t.concrete_generic_call_return_type(base_id, base_node)
		if concrete_base_type.starts_with('[]') {
			base_type = concrete_base_type
		}
	}
	if (!base_type.starts_with('[]') && !t.is_fixed_array_type(base_type)) || base_type == 'array' {
		lvalue_base_type := t.lvalue_type(base_id)
		if lvalue_base_type.starts_with('[]') || t.is_fixed_array_type(lvalue_base_type) {
			base_type = lvalue_base_type
		}
	}
	if !base_type.starts_with('[]') && !t.is_fixed_array_type(base_type) {
		if base_node.kind in [.call, .selector, .as_expr] {
			new_base := t.transform_expr(base_id)
			new_base_type := t.node_type(new_base)
			if new_base_type.starts_with('[]') || t.is_fixed_array_type(new_base_type) {
				selector := t.make_selector(new_base, fn_node.value, '')
				mut children := []flat.NodeId{cap: int(node.children_count)}
				children << selector
				for i in 1 .. node.children_count {
					children << t.a.child(&node, i)
				}
				start := t.a.children.len
				for child in children {
					t.a.children << child
				}
				new_node := flat.Node{
					kind:           .call
					children_start: start
					children_count: node.children_count
					pos:            node.pos
					typ:            node.typ
				}
				return t.try_lower_array_method_call(call_id, new_node)
			}
		}
	}
	if fn_node.value == 'str' && base_node.kind == .call {
		new_base := t.transform_expr(base_id)
		new_base_type := t.node_type(new_base)
		if new_base_type.starts_with('[]') {
			return t.lower_array_str(new_base, new_base_type)
		}
		if new_base_type.starts_with('map[') {
			return t.lower_map_str(new_base, new_base_type)
		}
	}
	clean_base_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
	if fn_node.value == 'str' && t.is_builder_receiver(base_id, base_type) {
		return none
	}
	if t.is_fixed_array_type(clean_base_type) && fn_node.value == 'pointers'
		&& array_builtin_method.len > 0 {
		method_name := t.resolve_receiver_method_name(base_id, fn_node.value)
		if method_name.len > 0 && method_name != array_builtin_method
			&& t.call_resolved_to_method(call_id, method_name) {
			args := t.transform_receiver_method_args(node, base_id, method_name)
			ret_type := t.receiver_method_return_type(method_name, node.typ)
			t.mark_fn_used(method_name)
			return t.make_call_typed(method_name, args, ret_type)
		}
		if dynamic_method := t.resolve_fixed_array_dynamic_receiver_method(clean_base_type,
			fn_node.value)
		{
			return t.lower_fixed_array_dynamic_receiver_method_call(node, base_id, clean_base_type,
				dynamic_method)
		}
		args := t.transform_receiver_method_args(node, base_id, array_builtin_method)
		ret_type := t.receiver_method_return_type(array_builtin_method, node.typ)
		return t.make_call_typed(array_builtin_method, args, ret_type)
	}
	if t.is_fixed_array_type(clean_base_type) {
		elem_type := fixed_array_elem_type(clean_base_type)
		array_type := '[]${elem_type}'
		tmp_name := t.new_temp('fixed_arr')
		t.pending_stmts << t.make_decl_assign_typed(tmp_name, t.fixed_array_value_to_array(base_id,
			clean_base_type, array_type), array_type)
		selector := t.make_selector(t.make_ident(tmp_name), fn_node.value, '')
		mut children := []flat.NodeId{cap: int(node.children_count)}
		children << selector
		for i in 1 .. node.children_count {
			children << t.a.child(&node, i)
		}
		start := t.a.children.len
		for child in children {
			t.a.children << child
		}
		new_node := flat.Node{
			kind:           .call
			children_start: start
			children_count: node.children_count
			pos:            node.pos
			typ:            node.typ
		}
		return t.try_lower_array_method_call(call_id, new_node)
	}
	if !clean_base_type.starts_with('[]') {
		return none
	}
	if exact_call := t.lower_checker_selected_receiver_method(call_id, node, base_id,
		array_builtin_method)
	{
		return exact_call
	}
	elem_type := clean_base_type[2..]
	if fn_node.value == 'prepend' {
		return t.lower_array_prepend_call(node, fn_node, base_type, elem_type)
	}
	if fn_node.value == 'insert' {
		return t.lower_array_insert_call(node, fn_node, base_type, elem_type)
	}
	if fn_node.value == 'push_many' {
		return t.lower_array_push_many_call(node, fn_node, base_type, elem_type)
	}
	if fn_node.value == 'contains' {
		method_name := t.resolve_receiver_method_name(base_id, fn_node.value)
		if method_name.len > 0 && t.call_resolved_to_method(call_id, method_name) {
			args := t.transform_receiver_method_args(node, base_id, method_name)
			ret_type := t.receiver_method_return_type(method_name, node.typ)
			t.mark_fn_used(method_name)
			return t.make_call_typed(method_name, args, ret_type)
		}
	}
	match fn_node.value {
		'filter' {
			return t.lower_array_filter_call(node, fn_node, clean_base_type)
		}
		'map' {
			return t.lower_array_map_call(node, fn_node, clean_base_type)
		}
		'sort' {
			return t.lower_array_sort_call(node, fn_node, base_type)
		}
		'sorted' {
			return t.lower_array_sorted_call(node, fn_node, clean_base_type)
		}
		'sort_with_compare' {
			return t.lower_array_sort_with_compare_call(node, fn_node, base_type)
		}
		'sorted_with_compare' {
			return t.lower_array_sorted_with_compare_call(node, fn_node, clean_base_type)
		}
		'any', 'all' {
			return t.lower_array_any_all_call(node, fn_node, clean_base_type, fn_node.value)
		}
		'count' {
			return t.lower_array_count_call(node, fn_node, clean_base_type)
		}
		'str' {
			return t.wrap_string_conversion(t.transform_expr(base_id), clean_base_type)
		}
		'equals' {
			if node.children_count < 2 {
				return none
			}
			method_name := t.resolve_receiver_method_name(base_id, 'equals')
			if method_name.len > 0 && t.call_resolved_to_method(call_id, method_name) {
				args := t.transform_receiver_method_args(node, base_id, method_name)
				t.mark_fn_used(method_name)
				return t.make_call_typed(method_name, args, 'bool')
			}
			receiver := t.transform_expr(base_id)
			arg := t.transform_expr(t.a.children[node.children_start + 1])
			if t.array_elem_needs_element_eq(elem_type) {
				return t.make_array_elementwise_eq_call(receiver, arg, elem_type, clean_base_type,
					clean_base_type, node)
			}
			if elem_type.starts_with('[]') {
				return t.make_call_typed('array_eq_array', arr3(receiver, arg,
					t.make_int_literal(array_nested_eq_depth(clean_base_type))), 'bool')
			}
			if elem_type == 'string' {
				return t.make_call_typed('array_eq_string', arr2(receiver, arg), 'bool')
			}
			return t.make_call_typed('array_eq_raw', arr3(receiver, arg,
				t.make_sizeof_type(elem_type)), 'bool')
		}
		else {}
	}

	match fn_node.value {
		'clone' {
			method_name := t.resolve_collection_receiver_method_name(base_id, fn_node.value,
				clean_base_type)
			if method_name.len > 0 && t.call_resolved_to_method(call_id, method_name) {
				args := t.transform_receiver_method_args(node, base_id, method_name)
				ret_type := t.receiver_method_return_type(method_name, node.typ)
				t.mark_fn_used(method_name)
				return t.make_call_typed(method_name, args, ret_type)
			}
			return t.make_array_clone_call(base_id, base_type)
		}
		'reverse' {
			mut receiver := t.transform_expr(base_id)
			if base_type.starts_with('&') {
				receiver = t.make_prefix(.mul, receiver)
				t.a.nodes[int(receiver)].typ = clean_base_type
			}
			return t.make_call_typed('array__reverse', arr1(receiver), clean_base_type)
		}
		'contains' {
			if node.children_count < 2 {
				return none
			}
			arg_id := t.a.children[node.children_start + 1]
			if lowered := t.lower_array_membership_expr(base_id, arg_id, base_type, true, node) {
				return lowered
			}
			receiver := t.transform_expr(base_id)
			arg := t.transform_expr(arg_id)
			fn_name := if elem_type == 'string' {
				'array_contains_string'
			} else {
				'array_contains_int'
			}
			return t.make_call_typed(fn_name, arr2(receiver, arg), 'bool')
		}
		'index' {
			if node.children_count < 2 {
				return none
			}
			arg_id := t.a.children[node.children_start + 1]
			if lowered := t.lower_array_index_expr(base_id, arg_id, base_type, true, node) {
				return lowered
			}
			receiver := t.transform_expr(base_id)
			arg := t.transform_expr(arg_id)
			fn_name := if elem_type == 'string' { 'array_index_string' } else { 'array_index_int' }
			return t.make_call_typed(fn_name, arr2(receiver, arg), 'int')
		}
		'last_index' {
			if node.children_count < 2 {
				return none
			}
			arg_id := t.a.children[node.children_start + 1]
			if lowered := t.lower_array_last_index_expr(base_id, arg_id, base_type, true, node) {
				return lowered
			}
			return none
		}
		'join' {
			if node.children_count < 2 {
				return none
			}
			receiver := t.transform_expr(base_id)
			arg := t.transform_expr(t.a.children[node.children_start + 1])
			return t.make_call_typed('Array_string__join', arr2(receiver, arg), 'string')
		}
		else {
			if array_method_stays_in_cgen(fn_node.value) {
				method_name := t.resolve_collection_receiver_method_name(base_id, fn_node.value,
					clean_base_type)
				if method_name.len > 0 && method_name != array_builtin_method
					&& t.call_resolved_to_method(call_id, method_name) {
					args := t.transform_receiver_method_args(node, base_id, method_name)
					ret_type := t.receiver_method_return_type(method_name, node.typ)
					t.mark_fn_used(method_name)
					return t.make_call_typed(method_name, args, ret_type)
				}
				if fn_node.value in ['pop', 'clear', 'trim'] {
					t.mark_fn_used('array__${fn_node.value}')
				}
				return none
			}
			if array_builtin_method.len > 0 {
				method_name := t.resolve_collection_receiver_method_name(base_id, fn_node.value,
					clean_base_type)
				if method_name.len > 0 && method_name != array_builtin_method {
					args := t.transform_receiver_method_args(node, base_id, method_name)
					ret_type := t.receiver_method_return_type(method_name, node.typ)
					t.mark_fn_used(method_name)
					return t.make_call_typed(method_name, args, ret_type)
				}
				args := t.transform_receiver_method_args(node, base_id, array_builtin_method)
				ret_type := t.receiver_method_return_type(array_builtin_method, node.typ)
				return t.make_call_typed(array_builtin_method, args, ret_type)
			}
			return none
		}
	}
}

fn (t &Transformer) array_builtin_method_name(method string) ?string {
	method_name := 'array.${method}'
	if t.is_known_fn_name(method_name) {
		return method_name
	}
	return none
}

fn array_method_stays_in_cgen(method string) bool {
	return method in ['last', 'first', 'delete_last', 'pop', 'pop_left', 'clear', 'repeat',
		'repeat_to_depth', 'trim', 'ensure_cap', 'delete', 'free', 'str', 'bytestr', 'wait']
}

// try_lower_map_method_call supports try lower map method call handling for Transformer.
fn (mut t Transformer) try_lower_map_method_call(call_id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0
		|| fn_node.value !in ['keys', 'values', 'delete', 'clear', 'free', 'move', 'reserve'] {
		return none
	}
	base_id := t.a.children[fn_node.children_start]
	mut base_type := t.node_type(base_id)
	if base_type.len == 0 {
		base_type = t.checker_node_type(base_id)
	}
	clean_type := t.clean_map_type(base_type)
	if !clean_type.starts_with('map[') {
		return none
	}
	builtin_method := 'map.${fn_node.value}'
	if exact_call := t.lower_checker_selected_receiver_method(call_id, node, base_id,
		builtin_method)
	{
		return exact_call
	}
	method_name := t.resolve_receiver_method_name(base_id, fn_node.value)
	if method_name.len > 0 && method_name != builtin_method
		&& t.call_resolved_to_method(call_id, method_name) {
		args := t.transform_receiver_method_args(node, base_id, method_name)
		ret_type := t.receiver_method_return_type(method_name, node.typ)
		t.mark_fn_used(method_name)
		return t.make_call_typed(method_name, args, ret_type)
	}
	base := t.transform_expr(base_id)
	if fn_node.value in ['clear', 'free'] {
		t.mark_fn_used('map__${fn_node.value}')
		return t.make_call_typed('map__${fn_node.value}', arr1(t.runtime_addr(base, base_type)),
			'void')
	}
	if fn_node.value == 'move' {
		t.mark_fn_used('map__move')
		return t.make_call_typed('map__move', arr1(t.runtime_addr(base, base_type)), clean_type)
	}
	if fn_node.value == 'reserve' {
		if node.children_count < 2 {
			return none
		}
		t.mark_fn_used('map__reserve')
		capacity := t.transform_expr_for_type(t.a.child(&node, 1), 'u32')
		return t.make_call_typed('map__reserve', arr2(t.runtime_addr(base, base_type), capacity),
			'void')
	}
	if fn_node.value == 'delete' {
		if node.children_count < 2 {
			return none
		}
		key_type := t.map_key_type(clean_type)
		if key_type.len == 0 {
			return none
		}
		t.mark_fn_used('map__delete')
		key_name := t.new_temp('map_key')
		t.pending_stmts << t.make_decl_assign_typed(key_name, t.transform_expr_for_type(t.a.child(&node, 1),
			key_type), key_type)
		return t.make_call_typed('map__delete', arr2(t.runtime_addr(base, base_type), t.make_prefix(.amp,
			t.make_ident(key_name))), 'void')
	}
	elem_type := if fn_node.value == 'keys' {
		t.map_key_type(clean_type)
	} else {
		t.map_value_type(clean_type)
	}
	if elem_type.len == 0 {
		return none
	}
	t.mark_fn_used('map__${fn_node.value}')
	return t.make_call_typed('map__${fn_node.value}', arr1(t.runtime_addr(base, base_type)),
		'[]${elem_type}')
}

// try_lower_channel_method_call lowers channel source methods to runtime calls before
// backend selection.
fn (mut t Transformer) try_lower_channel_method_call(call_id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 || fn_node.value != 'close' {
		return none
	}
	base_id := t.a.child(&fn_node, 0)
	if exact_call := t.lower_checker_selected_receiver_method(call_id, node, base_id, 'chan.close') {
		return exact_call
	}
	mut base_type := t.node_type(base_id)
	if base_type.len == 0 {
		base_type = t.lvalue_type(base_id)
	}
	mut clean_type := base_type
	mut ptr_depth := 0
	for clean_type.starts_with('&') {
		ptr_depth++
		clean_type = clean_type[1..].trim_space()
	}
	if !clean_type.starts_with('chan ') {
		return none
	}
	t.mark_fn_used('sync__Channel__close')
	errs := t.make_array_new_call('IError', t.make_int_literal(0), t.make_int_literal(0))
	fn_expr := t.make_selector(t.make_ident('C'), 'sync__Channel__close', '')
	mut receiver := t.transform_expr(base_id)
	for _ in 0 .. ptr_depth {
		receiver = t.make_prefix(.mul, receiver)
	}
	return t.make_call_expr_typed(fn_expr, arr2(receiver, errs), 'void')
}

// try_lower_move_method_call supports try lower move method call handling for Transformer.
fn (mut t Transformer) try_lower_move_method_call(call_id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count != 1 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 || fn_node.value != 'move' {
		return none
	}
	base_id := t.a.child(&fn_node, 0)
	base_type := t.node_type(base_id)
	clean_array_type := t.membership_container_type(base_type)
	if clean_array_type.starts_with('[]') {
		if !isnil(t.tc) {
			if resolved := t.tc.resolved_call_name(call_id) {
				if !is_builtin_collection_resolved_call(resolved) && t.is_known_fn_name(resolved) {
					return none
				}
			}
		}
		return t.transform_expr(base_id)
	}
	return none
}

// lift_fn_literal supports lift fn literal handling for Transformer.
fn (mut t Transformer) lift_fn_literal(_id flat.NodeId, node flat.Node) flat.NodeId {
	name := t.new_temp('anon_fn')
	mut param_types := []types.Type{}
	mut param_ids := []flat.NodeId{}
	mut param_names := []string{}
	mut capture_names := []string{}
	mut capture_types := map[string]string{}
	mut capture_globals := map[string]string{}
	mut body_ids := []flat.NodeId{}
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		child := t.a.nodes[int(child_id)]
		if child.kind == .param {
			param_ids << child_id
			if child.value.len > 0 {
				param_names << child.value
			}
			if !isnil(t.tc) {
				param_types << t.tc.parse_type(child.typ)
			}
		} else if child.kind == .ident {
			if child.value.len > 0 && child.value !in capture_names {
				mut capture_type := t.var_type(child.value)
				if capture_type.len == 0 {
					capture_type = t.node_type(child_id)
				}
				if capture_type.len == 0 && !isnil(t.tc) {
					if typ := t.tc.expr_type(child_id) {
						capture_type = typ.name()
					}
				}
				if capture_type.len == 0 || capture_type == 'unknown' {
					capture_type = 'int'
				}
				capture_names << child.value
				capture_types[child.value] = capture_type
				capture_globals[child.value] = '${name}_${child.value}'
			}
		} else {
			body_ids << child_id
		}
	}
	ret_type := if node.typ.len > 0 { node.typ } else { 'void' }
	saved_fn_name := t.cur_fn_name
	saved_ret_type := t.cur_fn_ret_type
	saved_vars := t.var_types.clone()
	t.cur_fn_name = name
	t.cur_fn_ret_type = ret_type
	t.reset_var_types()
	for param_id in param_ids {
		param := t.a.nodes[int(param_id)]
		if param.value.len > 0 && param.typ.len > 0 {
			t.set_var_type(param.value, param.typ)
		}
	}
	mut lifted_body := []flat.NodeId{cap: capture_names.len + body_ids.len}
	for capture_name in capture_names {
		if capture_name in param_names {
			continue
		}
		capture_type := capture_types[capture_name] or { continue }
		capture_global := capture_globals[capture_name] or { continue }
		t.add_fn_literal_capture_global(capture_global, capture_type)
		t.pending_stmts << t.make_assign(t.make_ident(capture_global), t.make_ident(capture_name))
		t.set_var_type(capture_name, capture_type)
		lifted_body << t.make_decl_assign_typed(capture_name, t.make_ident(capture_global),
			capture_type)
	}
	for body_id in body_ids {
		lifted_body << body_id
	}
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	new_body := t.transform_stmts(lifted_body)
	t.pending_stmts = outer_pending
	t.var_types = saved_vars
	t.cur_fn_name = saved_fn_name
	t.cur_fn_ret_type = saved_ret_type
	mut all_ids := []flat.NodeId{cap: param_ids.len + new_body.len}
	for param_id in param_ids {
		all_ids << param_id
	}
	for body_id in new_body {
		all_ids << body_id
	}
	if t.cur_module.len > 0 {
		t.a.add_node(flat.Node{
			kind:  .module_decl
			value: t.cur_module
		})
	}
	start := t.a.children.len
	for child_id in all_ids {
		t.a.children << child_id
	}
	t.a.add_node(flat.Node{
		kind:           .fn_decl
		value:          name
		typ:            ret_type
		children_start: start
		children_count: flat.child_count(all_ids.len)
	})
	if !isnil(t.tc) {
		ret := t.tc.parse_type(ret_type)
		t.tc.fn_ret_types[name] = ret
		t.tc.fn_param_types[name] = param_types.clone()
		t.tc.fn_variadic[name] = false
		if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
			qname := '${t.cur_module}.${name}'
			t.tc.fn_ret_types[qname] = ret
			t.tc.fn_param_types[qname] = param_types.clone()
			t.tc.fn_variadic[qname] = false
		}
	}
	if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		return t.make_ident('${t.cur_module}.${name}')
	}
	return t.make_ident(name)
}

fn (mut t Transformer) add_fn_literal_capture_global(name string, typ string) {
	if typ.len == 0 {
		return
	}
	if t.cur_module.len > 0 {
		t.a.add_node(flat.Node{
			kind:  .module_decl
			value: t.cur_module
		})
	}
	field := t.a.add_node(flat.Node{
		kind:  .field_decl
		value: name
		typ:   typ
	})
	start := t.a.children.len
	t.a.children << field
	t.a.add_node(flat.Node{
		kind:           .global_decl
		children_start: start
		children_count: 1
	})
	t.globals[name] = typ
	if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		t.globals['${t.cur_module}.${name}'] = typ
	}
}

// try_lower_builtin_call checks if a call is to a builtin that needs special lowering.
// Returns none for most calls so the caller falls through to generic call transform.
fn (mut t Transformer) try_lower_builtin_call(_id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	if cast_call := t.try_lower_primitive_cast_call(node) {
		return cast_call
	}
	if flag_call := t.try_lower_flag_enum_call(node) {
		return flag_call
	}
	if flag_default := t.try_lower_flag_default_value_call(node) {
		return flag_default
	}
	if pool_call := t.try_lower_pool_generic_method_call(node) {
		return pool_call
	}
	if static_call := t.try_lower_static_assoc_call(_id, node) {
		return static_call
	}
	if move_call := t.try_lower_move_method_call(_id, node) {
		return move_call
	}
	if channel_call := t.try_lower_channel_method_call(_id, node) {
		return channel_call
	}
	if map_call := t.try_lower_map_method_call(_id, node) {
		return map_call
	}
	if array_call := t.try_lower_array_method_call(_id, node) {
		return array_call
	}
	if type_name_call := t.try_lower_sum_type_name_method_call(node) {
		return type_name_call
	}
	if receiver_call := t.try_lower_receiver_method_call(_id, node) {
		return receiver_call
	}
	if string_call := t.try_lower_string_method_call(node) {
		return string_call
	}
	fn_id := t.a.children[node.children_start]
	if int(fn_id) < 0 {
		return none
	}
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .ident {
		return none
	}
	name := fn_node.value
	if name in ['maxof', 'minof'] && node.value.len > 0 && node.children_count == 1
		&& t.is_std_minmaxof_call(_id, name) {
		if value := t.try_lower_minmaxof_call(name, node.value) {
			return value
		}
	}
	match name {
		'copy' {
			return t.try_lower_copy_call(node)
		}
		'println', 'eprintln', 'print', 'eprint' {
			if node.children_count < 2 {
				return t.transform_call_args(_id, node)
			}
			arg := t.stringify_expr(t.a.child(&node, 1))
			return t.make_call(name, arr1(arg))
		}
		'panic' {
			if node.children_count == 2 {
				arg_id := t.a.child(&node, 1)
				arg_type := t.node_type(arg_id)
				if arg_type == 'IError' {
					arg := t.transform_expr(arg_id)
					return t.make_call('panic',
						arr1(t.make_method_call(arg, 'str', []flat.NodeId{})))
				}
			}
			return none
		}
		'sizeof' {
			return none
		}
		'typeof' {
			return none
		}
		else {
			return none
		}
	}
}

fn (t &Transformer) is_std_minmaxof_call(id flat.NodeId, name string) bool {
	if isnil(t.tc) {
		return false
	}
	resolved := t.tc.resolved_call_name(id) or { return false }
	return resolved == 'math.${name}'
}

fn (mut t Transformer) try_lower_minmaxof_call(name string, raw_type string) ?flat.NodeId {
	mut typ := raw_type
	if !isnil(t.tc) {
		typ = t.normalize_type_in_module(raw_type, t.cur_module)
	}
	if typ.starts_with('builtin.') {
		typ = typ.all_after_last('.')
	}
	value := if name == 'maxof' {
		match typ {
			'i8' { '127' }
			'i16' { '32767' }
			'int', 'i32' { '2147483647' }
			'i64' { '9223372036854775807' }
			'u8' { '255' }
			'u16' { '65535' }
			'u32' { '4294967295' }
			'u64' { '18446744073709551615' }
			'f32' { '3.40282346638528859811704183484516925440e+38' }
			'f64' { '1.797693134862315708145274237317043567981e+308' }
			else { return none }
		}
	} else {
		match typ {
			'i8' { '-128' }
			'i16' { '-32768' }
			'int', 'i32' { '(-2147483647 - 1)' }
			'i64' { '(-9223372036854775807 - 1)' }
			'u8', 'u16', 'u32', 'u64' { '0' }
			'f32' { '-3.40282346638528859811704183484516925440e+38' }
			'f64' { '-1.797693134862315708145274237317043567981e+308' }
			else { return none }
		}
	}
	if typ in ['f32', 'f64'] {
		return t.make_float_literal_typed(value, typ)
	}
	return t.make_int_literal_typed(value, typ)
}

fn (mut t Transformer) try_lower_copy_call(node flat.Node) ?flat.NodeId {
	if node.children_count != 3 {
		return none
	}
	dst_arg_id := t.a.child(&node, 1)
	src_arg_id := t.a.child(&node, 2)
	dst_id := t.copy_mut_arg_value(dst_arg_id)
	src := t.transform_expr_for_type(src_arg_id, '[]u8')
	if t.copy_destination_is_range(dst_id) {
		slice := t.transform_expr(dst_id)
		tmp_name := t.new_temp('copy_dst')
		t.pending_stmts << t.make_decl_assign_typed(tmp_name, slice, '[]u8')
		return t.make_call_typed('copy', arr2(t.make_prefix(.amp, t.make_ident(tmp_name)), src),
			'int')
	}
	dst := t.make_prefix(.amp, t.transform_expr(dst_id))
	return t.make_call_typed('copy', arr2(dst, src), 'int')
}

fn (t &Transformer) copy_mut_arg_value(id flat.NodeId) flat.NodeId {
	if int(id) < 0 {
		return id
	}
	node := t.a.nodes[int(id)]
	if node.kind == .paren && node.children_count > 0 {
		return t.copy_mut_arg_value(t.a.child(&node, 0))
	}
	if node.kind == .prefix && node.op == .amp && node.children_count > 0 {
		return t.copy_mut_arg_value(t.a.child(&node, 0))
	}
	return id
}

fn (t &Transformer) copy_destination_is_range(id flat.NodeId) bool {
	if int(id) < 0 {
		return false
	}
	node := t.a.nodes[int(id)]
	if node.kind != .index {
		return false
	}
	if node.value == 'range' {
		return true
	}
	if node.children_count > 1 {
		index := t.a.child_node(&node, 1)
		return index.kind == .range
	}
	return false
}

const primitive_cast_type_names = ['bool', 'int', 'i8', 'i16', 'i32', 'i64', 'isize', 'u8', 'byte',
	'u16', 'u32', 'u64', 'usize', 'f32', 'f64', 'rune', 'char']

// try_lower_primitive_cast_call supports try lower primitive cast call handling for Transformer.
fn (mut t Transformer) try_lower_primitive_cast_call(node flat.Node) ?flat.NodeId {
	if node.children_count != 2 {
		return none
	}
	fn_id := t.a.child(&node, 0)
	if int(fn_id) < 0 {
		return none
	}
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .ident || fn_node.value !in primitive_cast_type_names {
		return none
	}
	arg_id := t.a.child(&node, 1)
	return t.make_cast(fn_node.value, t.transform_expr(arg_id), fn_node.value)
}

// try_lower_flag_default_value_call
// supports helper handling in transform.
fn (mut t Transformer) try_lower_flag_default_value_call(node flat.Node) ?flat.NodeId {
	if node.children_count != 2 {
		return none
	}
	fn_id := t.a.child(&node, 0)
	fn_node := t.a.nodes[int(fn_id)]
	mut name := ''
	if fn_node.kind == .ident {
		name = fn_node.value
	} else if fn_node.kind == .selector {
		name = fn_node.value
	}
	if name != 'flag_default_value' {
		return none
	}
	arg_id := t.a.child(&node, 1)
	arg := t.transform_expr(arg_id)
	mut arg_type := t.resolve_expr_type(arg_id)
	if arg_type.len == 0 {
		arg_type = t.reliable_stringify_type(arg_id)
	}
	if arg_type.len == 0 {
		arg_type = t.node_type(arg)
	}
	if t.normalize_type_alias(arg_type) == 'string' {
		escaped := t.make_call_typed('escape_default_string', arr1(arg), 'string')
		return t.string_plus(t.string_plus(t.make_string_literal('"'), escaped),
			t.make_string_literal('"'))
	}
	return t.wrap_string_conversion(arg, arg_type)
}

// try_lower_sum_type_name_method_call supports try_lower_sum_type_name_method_call handling.
fn (mut t Transformer) try_lower_sum_type_name_method_call(node flat.Node) ?flat.NodeId {
	if node.children_count != 1 {
		return none
	}
	fn_id := t.a.child(&node, 0)
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.value != 'type_name' || fn_node.children_count == 0 {
		return none
	}
	base_id := t.a.child(&fn_node, 0)
	mut base_type := t.node_type(base_id)
	if base_type.len == 0 {
		base_type = t.lvalue_type(base_id)
	}
	clean_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
	resolved_sum := t.resolve_sum_name(clean_type)
	variants := t.sum_types[resolved_sum] or { return none }
	base := t.stable_transformed_expr_for_reuse(t.transform_expr(base_id), base_type, 'sum_type')
	tag := t.make_selector_op(base, 'typ', 'int', if base_type.starts_with('&') {
		.arrow
	} else {
		.dot
	})
	return t.build_sum_type_name_chain(tag, resolved_sum, variants, 0)
}

// build_sum_type_name_chain builds sum type name chain data for transform.
fn (mut t Transformer) build_sum_type_name_chain(tag flat.NodeId, sum_name string, variants []string, idx int) flat.NodeId {
	if idx >= variants.len {
		return t.make_string_literal('')
	}
	variant := variants[idx]
	display := if variant.contains('.') { variant.all_after_last('.') } else { variant }
	cond := t.make_infix(.eq, tag, t.make_int_literal(t.sum_type_index(sum_name, variant)))
	then_block := t.make_block(arr1(t.make_expr_stmt(t.make_string_literal(display))))
	else_expr := t.build_sum_type_name_chain(tag, sum_name, variants, idx + 1)
	else_block := t.make_block(arr1(t.make_expr_stmt(else_expr)))
	start := t.a.children.len
	t.a.children << cond
	t.a.children << then_block
	t.a.children << else_block
	return t.a.add_node(flat.Node{
		kind:           .if_expr
		children_start: start
		children_count: 3
		typ:            'string'
	})
}

// try_lower_pool_generic_method_call
// supports helper handling in transform.
fn (mut t Transformer) try_lower_pool_generic_method_call(node flat.Node) ?flat.NodeId {
	if node.children_count == 0 || node.value.len == 0 {
		return none
	}
	fn_id := t.a.child(&node, 0)
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return none
	}
	method := fn_node.value
	if method !in ['get_item', 'get_results', 'get_results_ref'] {
		return none
	}
	base_id := t.a.child(&fn_node, 0)
	base_type := t.lvalue_type(base_id)
	if !is_pool_processor_type(base_type) {
		return none
	}
	elem_type := node.value
	base := t.stable_expr_for_reuse(base_id)
	mut prefix := []flat.NodeId{}
	t.drain_pending(mut prefix)
	if method == 'get_item' {
		if node.children_count < 2 {
			return none
		}
		idx := t.transform_expr(t.a.child(&node, 1))
		t.drain_pending(mut prefix)
		items := t.pool_processor_field(base, base_type, 'items', '[]voidptr')
		item := t.make_index(items, idx, 'voidptr')
		cast := t.make_cast('&${elem_type}', item, '&${elem_type}')
		value := t.make_prefix(.mul, cast)
		t.a.nodes[int(value)].typ = elem_type
		for stmt in prefix {
			t.pending_stmts << stmt
		}
		return value
	}
	result_name := t.new_temp('pool_results')
	idx_name := t.new_temp('pool_idx')
	results := t.pool_processor_field(base, base_type, 'results', '[]voidptr')
	results_len := t.make_selector(results, 'len', 'int')
	is_ref_results := method == 'get_results_ref'
	out_elem_type := if is_ref_results { '&${elem_type}' } else { elem_type }
	out_type := '[]${out_elem_type}'
	prefix << t.make_decl_assign_typed(result_name, t.make_array_new_call(out_elem_type,
		t.make_int_literal(0), results_len), out_type)
	init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
	cond_results := t.pool_processor_field(base, base_type, 'results', '[]voidptr')
	cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(cond_results, 'len', 'int'))
	post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
	body_results := t.pool_processor_field(base, base_type, 'results', '[]voidptr')
	item := t.make_index(body_results, t.make_ident(idx_name), 'voidptr')
	value := if is_ref_results {
		t.make_cast('&${elem_type}', item, '&${elem_type}')
	} else {
		t.make_prefix(.mul, t.make_cast('&${elem_type}', item, '&${elem_type}'))
	}
	t.a.nodes[int(value)].typ = out_elem_type
	value_name := t.new_temp('pool_result')
	value_decl := t.make_decl_assign_typed(value_name, value, out_elem_type)
	push_call := t.make_call_typed('array_push', arr2(t.make_prefix(.amp, t.make_ident(result_name)), t.make_prefix(.amp,
		t.make_ident(value_name))), 'void')
	loop_body := [value_decl, t.make_expr_stmt(push_call)]
	prefix << t.make_for_stmt(init, cond, post, loop_body, node)
	for stmt in prefix {
		t.pending_stmts << stmt
	}
	return t.make_ident(result_name)
}

// is_pool_processor_type reports whether is pool processor type applies in transform.
fn is_pool_processor_type(typ string) bool {
	mut clean := typ
	if clean.starts_with('&') {
		clean = clean[1..]
	}
	if clean.starts_with('mut ') {
		clean = clean[4..]
	}
	return clean == 'PoolProcessor' || clean.ends_with('.PoolProcessor')
}

// pool_processor_field supports pool processor field handling for Transformer.
fn (mut t Transformer) pool_processor_field(base flat.NodeId, base_type string, field string, typ string) flat.NodeId {
	op := if base_type.starts_with('&') { flat.Op.arrow } else { flat.Op.dot }
	return t.make_selector_op(base, field, typ, op)
}

// try_lower_receiver_method_call supports try lower receiver method call handling for Transformer.
fn (mut t Transformer) try_lower_receiver_method_call(id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return none
	}
	method := fn_node.value
	base_id := t.a.child(&fn_node, 0)
	base_node := t.a.nodes[int(base_id)]
	if t.is_import_alias_ident(base_id) {
		return none
	}
	// `Type.fn(...)` / `module.Type.fn(...)` is a static associated function, not a method:
	// the base names a type, so it must not be lowered into `fn(receiver, ...)`.
	if _ := t.static_assoc_fn_name(base_id, method) {
		return none
	}
	mut base_type := if base_node.kind in [.selector, .index] {
		t.lvalue_type(base_id)
	} else {
		t.node_type(base_id)
	}
	if base_type.len == 0 {
		base_type = t.lvalue_type(base_id)
	}
	base_is_pointer := base_type.starts_with('&')
	if base_type.starts_with('&') {
		base_type = base_type[1..]
	}
	if base_type.len == 0 {
		return none
	}
	mut builtin_base_type := t.normalize_type_alias(base_type)
	if builtin_base_type == 'byte' {
		builtin_base_type = 'u8'
	}
	if base_type == '[]rune' && method == 'string' {
		return t.make_call_typed('Array_rune__string', arr1(t.transform_expr(base_id)), 'string')
	}
	if method == 'str' && t.is_array_transform_call(base_id) {
		base := t.transform_expr(base_id)
		transformed_type := t.node_type(base)
		if transformed_type.starts_with('[]') {
			return t.wrap_string_conversion(base, transformed_type)
		}
	}
	if method == 'str' && t.is_builder_receiver(base_id, base_type) {
		method_name := 'strings.Builder.str'
		args := t.transform_receiver_method_args(node, base_id, method_name)
		return t.make_call_typed(method_name, args, 'string')
	}
	if base_type.starts_with('[]') && method == 'str' {
		return t.wrap_string_conversion(t.transform_expr(base_id), base_type)
	}
	if method == 'str' {
		if t.is_enum_stringify_type(base_type) {
			return none
		}
		return t.wrap_string_conversion(t.transform_expr(base_id), base_type)
	}
	if builtin_base_type == 'string' && method == 'hex' && !base_is_pointer {
		return t.make_call_typed('string.hex', arr1(t.transform_expr(base_id)), 'string')
	}
	if base_type == '[]u8' || base_type == '[]byte' {
		if method == 'bytestr' {
			return t.make_call_typed('Array_u8__bytestr', arr1(t.transform_expr(base_id)), 'string')
		}
		if method == 'hex' && !base_is_pointer {
			return t.make_call_typed('Array_u8__hex', arr1(t.transform_expr(base_id)), 'string')
		}
	}
	if t.is_builder_receiver(base_id, base_type) {
		for method_name in ['strings.Builder.${method}', 'Builder.${method}'] {
			if t.is_known_fn_name(method_name) {
				args := t.transform_receiver_method_args(node, base_id, method_name)
				ret_type := t.receiver_method_return_type(method_name, node.typ)
				return t.make_call_typed(method_name, args, ret_type)
			}
		}
	}
	if builtin_base_type == 'u8' && method in ['is_space', 'is_digit', 'is_hex_digit', 'is_letter'] {
		return t.make_call_typed('u8__${method}', arr1(t.transform_expr(base_id)), 'bool')
	}
	if !base_is_pointer
		&& builtin_base_type in ['u8', 'i8', 'u16', 'i16', 'u32', 'int', 'u64', 'i64', 'rune']
		&& method in ['hex', 'hex_full'] {
		return t.make_call_typed('${builtin_base_type}__${method}',
			arr1(t.transform_expr(base_id)), 'string')
	}
	if base_type.starts_with('[]') || base_type.starts_with('map[') {
		if base_type.starts_with('[]') {
			return none
		}
	}
	method_name := t.resolve_receiver_method_name(base_id, method)
	if method_name.len > 0 {
		args := t.transform_receiver_method_args(node, base_id, method_name)
		ret_type := t.receiver_method_return_type(method_name, node.typ)
		return t.make_call_typed(method_name, args, ret_type)
	}
	if !isnil(t.tc) {
		if resolved_method := t.tc.resolved_call_name(id) {
			if t.is_known_fn_name(resolved_method) {
				params := t.call_param_types(resolved_method)
				if !t.resolved_call_uses_receiver_type(base_id, base_type, params) {
					return none
				}
				args := t.transform_receiver_method_args_with_base(node, t.receiver_base_for_resolved_method(base_id,
					resolved_method), resolved_method)
				ret_type := t.receiver_method_return_type(resolved_method, node.typ)
				return t.make_call_typed(resolved_method, args, ret_type)
			}
		}
	}
	if sum_method := t.resolve_smartcast_sum_receiver_method(base_id, method) {
		args := t.transform_receiver_method_args_with_base(node, t.receiver_base_for_resolved_method(base_id,
			sum_method), sum_method)
		ret_type := t.receiver_method_return_type(sum_method, node.typ)
		return t.make_call_typed(sum_method, args, ret_type)
	}
	return none
}

// is_builder_receiver reports whether is builder receiver applies in transform.
fn (t &Transformer) is_builder_receiver(base_id flat.NodeId, base_type string) bool {
	if is_builder_type_name(base_type) {
		return true
	}
	if raw_type := t.raw_var_type_for_expr(base_id) {
		return is_builder_type_name(raw_type)
	}
	if raw_field_type := t.raw_selector_field_type(base_id) {
		return is_builder_type_name(raw_field_type)
	}
	return false
}

// raw_selector_field_type supports raw selector field type handling for Transformer.
fn (t &Transformer) raw_selector_field_type(id flat.NodeId) ?string {
	if int(id) < 0 {
		return none
	}
	node := t.a.nodes[int(id)]
	if node.kind != .selector || node.children_count == 0 {
		return none
	}
	base_id := t.a.child(&node, 0)
	mut base_type := t.original_expr_type(base_id)
	if base_type.len == 0 {
		base_type = t.node_type(base_id)
	}
	if base_type.starts_with('&') {
		base_type = base_type[1..]
	}
	return t.lookup_struct_field_raw_type(base_type, node.value)
}

// is_builder_type_name reports whether is builder type name applies in transform.
fn is_builder_type_name(typ string) bool {
	mut clean := typ
	if clean.starts_with('&') {
		clean = clean[1..]
	}
	return clean == 'strings.Builder' || clean == 'Builder'
}

// resolved_call_uses_receiver_type
// supports helper handling in transform.
fn (t &Transformer) resolved_call_uses_receiver_type(base_id flat.NodeId, receiver_type string, params []types.Type) bool {
	if params.len == 0 {
		return false
	}
	mut param_type := params[0].name()
	if param_type.starts_with('&') {
		param_type = param_type[1..]
	}
	if sc := t.find_smartcast(t.expr_key(base_id)) {
		sc_type := t.trim_pointer_type(t.smartcast_target_type(sc))
		if sc_type.len > 0 && t.normalize_type_alias(sc_type) == t.normalize_type_alias(param_type) {
			return true
		}
		sc_sum := t.trim_pointer_type(t.resolve_sum_name(sc.sum_type_name))
		if sc_sum.len > 0 && t.normalize_type_alias(sc_sum) == t.normalize_type_alias(param_type) {
			return true
		}
		if t.is_sum_type_name(param_type) {
			for parent in t.sum_type_parents_for_variant(sc.variant_name) {
				if t.normalize_type_alias(parent) == t.normalize_type_alias(param_type) {
					return true
				}
			}
		}
	}
	mut base_type := receiver_type
	if base_type.starts_with('&') {
		base_type = base_type[1..]
	}
	if base_type.len == 0 {
		return true
	}
	if t.normalize_type_alias(base_type) == t.normalize_type_alias(param_type) {
		return true
	}
	if _ := t.embedded_receiver_path(base_type, param_type) {
		return true
	}
	return false
}

// receiver_base_for_resolved_method
// supports helper handling in transform.
fn (mut t Transformer) receiver_base_for_resolved_method(base_id flat.NodeId, method_name string) flat.NodeId {
	if embedded_base := t.embedded_receiver_base(base_id, method_name) {
		return embedded_base
	}
	key := t.expr_key(base_id)
	sc := t.find_smartcast(key) or { return t.transform_expr(base_id) }
	params := t.call_param_types(method_name)
	if params.len == 0 {
		return t.transform_expr(base_id)
	}
	mut param_type := params[0].name()
	if param_type.starts_with('&') {
		param_type = param_type[1..]
	}
	target_type := t.trim_pointer_type(t.smartcast_target_type(sc))
	if target_type.len > 0
		&& t.normalize_type_alias(param_type) == t.normalize_type_alias(target_type) {
		return t.apply_smartcast_contexts(t.make_plain_expr_for_smartcast(base_id),
			t.original_expr_type(base_id), t.smartcasts_for(key))
	}
	method_receiver := method_name.all_before_last('.')
	if method_receiver.len > 0 && t.is_sum_type_name(method_receiver)
		&& t.normalize_type_alias(param_type) == t.normalize_type_alias(method_receiver) {
		return t.make_plain_expr_for_smartcast(base_id)
	}
	mut sum_type := t.resolve_sum_name(sc.sum_type_name)
	if sum_type.starts_with('&') {
		sum_type = sum_type[1..]
	}
	if sum_type.len > 0 && t.normalize_type_alias(param_type) == t.normalize_type_alias(sum_type) {
		return t.make_plain_expr_for_smartcast(base_id)
	}
	original_type := t.trim_pointer_type(t.original_expr_type(base_id))
	if original_type.len > 0
		&& t.normalize_type_alias(param_type) == t.normalize_type_alias(original_type) {
		return t.make_plain_expr_for_smartcast(base_id)
	}
	return t.transform_expr(base_id)
}

fn (mut t Transformer) embedded_receiver_base(base_id flat.NodeId, method_name string) ?flat.NodeId {
	params := t.call_param_types(method_name)
	if params.len == 0 {
		return none
	}
	mut param_type := params[0].name()
	if param_type.starts_with('&') {
		param_type = param_type[1..]
	}
	mut base_type := t.node_type(base_id)
	if base_type.len == 0 {
		base_type = t.lvalue_type(base_id)
	}
	mut is_ptr := false
	if base_type.starts_with('&') {
		is_ptr = true
		base_type = base_type[1..]
	}
	path := t.embedded_receiver_path(base_type, param_type) or { return none }
	mut base := t.transform_expr(base_id)
	mut current_is_ptr := is_ptr
	for field in path {
		op := if current_is_ptr { flat.Op.arrow } else { flat.Op.dot }
		field_type := if field.raw_typ.len > 0 { field.raw_typ } else { field.typ }
		base = t.make_selector_op(base, field.name, field_type, op)
		current_is_ptr = field_type.starts_with('&')
	}
	return base
}

fn (t &Transformer) embedded_receiver_field(base_type string, receiver_type string) ?FieldInfo {
	path := t.embedded_receiver_path(base_type, receiver_type) or { return none }
	if path.len == 0 {
		return none
	}
	return path[0]
}

fn (t &Transformer) embedded_receiver_path(base_type string, receiver_type string) ?[]FieldInfo {
	if base_type.len == 0 || receiver_type.len == 0 {
		return none
	}
	mut lookup_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
	if lookup_type !in t.structs && lookup_type.contains('.') {
		short_type := lookup_type.all_after_last('.')
		if short_type in t.structs {
			lookup_type = short_type
		}
	}
	info := t.structs[lookup_type] or { return none }
	clean_receiver := t.normalize_type_alias(receiver_type)
	for field in info.fields {
		if !t.is_embedded_field(field) {
			continue
		}
		field_type := if field.raw_typ.len > 0 { field.raw_typ } else { field.typ }
		clean_field := t.normalize_type_alias(field_type.trim_left('&'))
		short_field := if clean_field.contains('.') {
			clean_field.all_after_last('.')
		} else {
			clean_field
		}
		if (field.name == clean_field || field.name == short_field) && clean_field == clean_receiver {
			return [field]
		}
		if sub_path := t.embedded_receiver_path(clean_field, receiver_type) {
			mut path := []FieldInfo{}
			path << field
			path << sub_path
			return path
		}
	}
	return none
}

// receiver_method_return_type supports receiver method return type handling for Transformer.
fn (t &Transformer) receiver_method_return_type(method_name string, fallback string) string {
	if !isnil(t.tc) {
		if typ := t.tc.fn_ret_types[method_name] {
			return t.normalize_type_alias(typ.name())
		}
	}
	if ret := t.fn_ret_types[method_name] {
		return ret
	}
	return fallback
}

fn (t &Transformer) call_resolved_to_method(call_id flat.NodeId, method_name string) bool {
	if isnil(t.tc) {
		return true
	}
	if resolved := t.tc.resolved_call_name(call_id) {
		return resolved == method_name
	}
	return false
}

fn (mut t Transformer) lower_checker_selected_receiver_method(call_id flat.NodeId, node flat.Node, base_id flat.NodeId, builtin_name string) ?flat.NodeId {
	if isnil(t.tc) {
		return none
	}
	resolved := t.tc.resolved_call_name(call_id) or { return none }
	if resolved == builtin_name || is_builtin_collection_resolved_call(resolved)
		|| !t.is_known_fn_name(resolved) {
		return none
	}
	args := t.transform_receiver_method_args(node, base_id, resolved)
	ret_type := t.receiver_method_return_type(resolved, node.typ)
	t.mark_fn_used(resolved)
	return t.make_call_typed(resolved, args, ret_type)
}

fn is_builtin_collection_resolved_call(name string) bool {
	return name.len == 0 || is_raw_collection_method_name(name, 'array.') || name == 'array_clone'
		|| is_runtime_collection_helper_name(name) || is_raw_collection_method_name(name, 'map.')
}

fn is_raw_collection_method_name(name string, prefix string) bool {
	if !name.starts_with(prefix) {
		return false
	}
	rest := name[prefix.len..]
	return rest.len > 0 && !rest.contains('.')
}

fn is_runtime_collection_helper_name(name string) bool {
	return name in ['array__clone', 'array__reverse', 'array__prepend', 'array__insert',
		'array__push_many', 'array__needs_unique_shift', 'map__delete', 'map__move', 'map__reserve',
		'map__keys', 'map__values', 'map__clear', 'map__free', 'map__get', 'map__get_check',
		'map__exists', 'map__set']
}

// resolve_smartcast_sum_receiver_method supports resolve_smartcast_sum_receiver_method handling.
fn (t &Transformer) resolve_smartcast_sum_receiver_method(base_id flat.NodeId, method string) ?string {
	key := t.expr_key(base_id)
	sc := t.find_smartcast(key) or { return none }
	variant := t.resolve_variant(sc.sum_type_name, sc.variant_name)
	mut receiver_types := []string{}
	receiver_types << variant
	original_type := t.trim_pointer_type(t.original_expr_type(base_id))
	if original_type.len > 0 && original_type !in receiver_types {
		receiver_types << original_type
	}
	if sc.sum_type_name.len > 0 && sc.sum_type_name !in receiver_types {
		receiver_types << sc.sum_type_name
	}
	sum_type := t.resolve_sum_name(sc.sum_type_name)
	if sum_type.len > 0 && sum_type !in receiver_types {
		receiver_types << sum_type
	}
	for parent in t.sum_type_parents_for_variant(sc.variant_name) {
		if parent !in receiver_types {
			receiver_types << parent
		}
	}
	for receiver_type in receiver_types {
		for candidate in t.receiver_method_candidates(receiver_type, method) {
			if t.is_known_fn_name(candidate) {
				return candidate
			}
		}
	}
	return none
}

// sum_type_parents_for_variant supports sum type parents for variant handling for Transformer.
fn (t &Transformer) sum_type_parents_for_variant(variant string) []string {
	if parents := t.sum_variant_parents[variant] {
		return parents.clone()
	}
	short := t.variant_short_name(variant)
	if short != variant {
		if parents := t.sum_variant_parents[short] {
			return parents.clone()
		}
	}
	mut result := []string{}
	for sum_name, variants in t.sum_types {
		for v in variants {
			short_v := t.variant_short_name(v)
			if v == variant || short_v == short {
				result << sum_name
				break
			}
		}
	}
	if !isnil(t.tc) {
		for sum_name, variants in t.tc.sum_types {
			if sum_name in result {
				continue
			}
			for v in variants {
				short_v := t.variant_short_name(v)
				if v == variant || short_v == short {
					result << sum_name
					break
				}
			}
		}
	}
	return result
}

// receiver_method_candidates supports receiver method candidates handling for Transformer.
fn (t &Transformer) receiver_method_candidates(receiver_type string, method string) []string {
	mut clean_type := receiver_type
	if clean_type.starts_with('&') {
		clean_type = clean_type[1..]
	}
	if clean_type.starts_with('map[') {
		return t.map_receiver_method_candidates(clean_type, method)
	}
	mut candidates := []string{}
	candidates << '${clean_type}.${method}'
	if clean_type.starts_with('[]') {
		elem_type := clean_type[2..]
		short_elem := if elem_type.contains('.') { elem_type.all_after_last('.') } else { elem_type }
		candidates << '[]${short_elem}.${method}'
		if elem_type.contains('.') {
			candidates << '${elem_type.all_before_last('.')}.[]${short_elem}.${method}'
		} else if transform_can_prefix_collection_receiver(t.cur_module) {
			candidates << '${t.cur_module}.[]${short_elem}.${method}'
		}
	} else if clean_type.contains('.') {
		short_type := clean_type.all_after_last('.')
		candidates << '${short_type}.${method}'
	} else if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		candidates << '${t.cur_module}.${clean_type}.${method}'
	}
	return candidates
}

fn (t &Transformer) resolve_fixed_array_dynamic_receiver_method(fixed_type string, method string) ?string {
	elem_type := fixed_array_outer_elem_type(fixed_type)
	if elem_type.len == 0 {
		return none
	}
	return t.resolve_receiver_method_for_type('[]${elem_type}', method)
}

fn (mut t Transformer) lower_fixed_array_dynamic_receiver_method_call(node flat.Node, base_id flat.NodeId, fixed_type string, method_name string) flat.NodeId {
	elem_type := fixed_array_outer_elem_type(fixed_type)
	array_type := '[]${elem_type}'
	tmp_name := t.new_temp('fixed_arr')
	t.pending_stmts << t.make_decl_assign_typed(tmp_name, t.fixed_array_value_to_array(base_id,
		fixed_type, array_type), array_type)
	args := t.transform_receiver_method_args_with_base(node, t.make_ident(tmp_name), method_name)
	ret_type := t.receiver_method_return_type(method_name, node.typ)
	t.mark_fn_used(method_name)
	return t.make_call_typed(method_name, args, ret_type)
}

fn fixed_array_outer_elem_type(type_text string) string {
	clean := type_text.trim_space()
	if clean.len == 0 {
		return ''
	}
	if clean.starts_with('[') {
		bracket_end := generic_matching_bracket(clean, 0)
		if bracket_end < clean.len {
			return clean[bracket_end + 1..]
		}
		return ''
	}
	elem, dims := transform_postfix_fixed_array_parts(clean)
	if elem.len == 0 || dims.len == 0 {
		return fixed_array_elem_type(clean)
	}
	mut out := elem
	for i := dims.len - 1; i > 0; i-- {
		out += '[${dims[i]}]'
	}
	return out
}

fn transform_push_receiver_candidate(mut candidates []string, candidate string) {
	if candidate.len > 0 && candidate !in candidates {
		candidates << candidate
	}
}

fn transform_can_prefix_collection_receiver(module_name string) bool {
	return module_name.len > 0 && module_name != 'main' && module_name != 'builtin'
}

fn (t &Transformer) receiver_type_text_variants(type_text string) []string {
	clean := type_text.trim_space()
	mut names := []string{}
	transform_push_receiver_candidate(mut names, clean)
	transform_push_receiver_candidate(mut names, receiver_type_text_short_spelling(clean))
	if t.is_fixed_array_type(clean) {
		source := t.receiver_type_text_source_fixed_spelling(clean)
		transform_push_receiver_candidate(mut names, source)
		transform_push_receiver_candidate(mut names, receiver_type_text_short_spelling(source))
	}
	return names
}

fn (t &Transformer) receiver_type_text_source_fixed_spelling(type_text string) string {
	clean := type_text.trim_space()
	if clean.len == 0 || clean.starts_with('[') || !t.is_fixed_array_type(clean) {
		return clean
	}
	elem, dims := transform_postfix_fixed_array_parts(clean)
	if elem.len == 0 || dims.len == 0 {
		return clean
	}
	mut source := elem
	for i := dims.len; i > 0; i-- {
		source = '[${dims[i - 1]}]${source}'
	}
	return source
}

fn transform_postfix_fixed_array_parts(type_text string) (string, []string) {
	clean := type_text.trim_space()
	mut end := clean.len
	mut dims := []string{}
	for end > 0 && clean[end - 1] == `]` {
		start := transform_trailing_matching_bracket_start(clean, end)
		if start < 0 {
			break
		}
		dims << clean[start + 1..end - 1].trim_space()
		end = start
	}
	return clean[..end], dims
}

fn transform_trailing_matching_bracket_start(s string, end int) int {
	mut depth := 0
	for i := end - 1; i >= 0; i-- {
		if s[i] == `]` {
			depth++
		} else if s[i] == `[` {
			depth--
			if depth == 0 {
				return i
			}
		}
	}
	return -1
}

fn receiver_type_text_short_spelling(type_text string) string {
	clean := type_text.trim_space()
	if clean.starts_with('[]') {
		return '[]' + receiver_type_text_short_spelling(clean[2..])
	}
	if clean.starts_with('[') {
		bracket_end := generic_matching_bracket(clean, 0)
		if bracket_end < clean.len {
			return clean[..bracket_end + 1] + receiver_type_text_short_spelling(clean[bracket_end +
				1..])
		}
	}
	if clean.starts_with('map[') {
		bracket_end := generic_matching_bracket(clean, 3)
		if bracket_end < clean.len {
			key := receiver_type_text_short_spelling(clean[4..bracket_end])
			value := receiver_type_text_short_spelling(clean[bracket_end + 1..])
			return 'map[${key}]${value}'
		}
	}
	if clean.contains('.') {
		return clean.all_after_last('.')
	}
	return clean
}

fn (t &Transformer) receiver_type_text_module_names(type_text string) []string {
	clean := type_text.trim_space()
	mut names := []string{}
	if clean.starts_with('[]') {
		return t.receiver_type_text_module_names(clean[2..])
	}
	if clean.starts_with('[') {
		bracket_end := generic_matching_bracket(clean, 0)
		if bracket_end < clean.len {
			return t.receiver_type_text_module_names(clean[bracket_end + 1..])
		}
	}
	if clean.starts_with('map[') {
		key_type := t.map_key_type(clean)
		value_type := t.map_value_type(clean)
		for name in t.receiver_type_text_module_names(key_type) {
			transform_push_receiver_candidate(mut names, name)
		}
		for name in t.receiver_type_text_module_names(value_type) {
			transform_push_receiver_candidate(mut names, name)
		}
		return names
	}
	if t.is_fixed_array_type(clean) {
		return t.receiver_type_text_module_names(fixed_array_elem_type(clean))
	}
	if clean.contains('.') {
		transform_push_receiver_candidate(mut names, clean.all_before_last('.'))
	}
	return names
}

// map_receiver_method_candidates supports map receiver method candidates handling for Transformer.
fn (t &Transformer) map_receiver_method_candidates(receiver_type string, method string) []string {
	clean_type := t.clean_map_type(receiver_type)
	key_type := t.map_key_type(clean_type)
	value_type := t.map_value_type(clean_type)
	mut candidates := []string{}
	if key_type.len == 0 || value_type.len == 0 {
		transform_push_receiver_candidate(mut candidates, '${clean_type}.${method}')
		return candidates
	}
	key_types := t.receiver_type_text_variants(key_type)
	value_types := t.receiver_type_text_variants(value_type)
	mut map_types := []string{}
	for key in key_types {
		for value in value_types {
			transform_push_receiver_candidate(mut map_types, 'map[${key}]${value}')
		}
	}
	for map_type in map_types {
		transform_push_receiver_candidate(mut candidates, '${map_type}.${method}')
	}
	mut module_names := []string{}
	if transform_can_prefix_collection_receiver(t.cur_module) {
		transform_push_receiver_candidate(mut module_names, t.cur_module)
	}
	for mod_name in t.receiver_type_text_module_names(key_type) {
		transform_push_receiver_candidate(mut module_names, mod_name)
	}
	for mod_name in t.receiver_type_text_module_names(value_type) {
		transform_push_receiver_candidate(mut module_names, mod_name)
	}
	for mod_name in module_names {
		for map_type in map_types {
			transform_push_receiver_candidate(mut candidates, '${mod_name}.${map_type}.${method}')
		}
	}
	return candidates
}

// transform_receiver_method_args transforms transform receiver method args data for transform.
fn (mut t Transformer) transform_receiver_method_args(node flat.Node, base_id flat.NodeId, method_name string) []flat.NodeId {
	return t.transform_receiver_method_args_with_base(node, t.receiver_base_for_resolved_method(base_id,
		method_name), method_name)
}

// transform_receiver_method_args_with_base
// transforms helper data for transform.
fn (mut t Transformer) transform_receiver_method_args_with_base(node flat.Node, base flat.NodeId, method_name string) []flat.NodeId {
	mut args := []flat.NodeId{cap: int(node.children_count)}
	args << base
	params := t.call_param_types(method_name)
	param_offset := t.receiver_method_param_offset(base, node, params)
	explicit_args := int(node.children_count) - 1
	expected_explicit := params.len - param_offset
	is_variadic := t.call_is_variadic(method_name) || (params.len > 0
		&& params[params.len - 1] is types.Array && explicit_args > expected_explicit)
	variadic_idx := if is_variadic && params.len > 0 && params[params.len - 1] is types.Array {
		params.len - 1
	} else {
		-1
	}
	mut i := 1
	for i < node.children_count {
		param_idx := (args.len - 1) + param_offset
		arg_id := t.a.child(&node, i)
		arg_node := t.a.nodes[int(arg_id)]
		param_type := if param_idx < params.len { params[param_idx].name() } else { '' }
		if arg_node.kind == .field_init {
			if packed_arg := t.transform_params_struct_call_arg(node, i, param_type) {
				args << packed_arg
				i = t.next_non_field_init_arg(node, i)
				continue
			}
		}
		if variadic_idx >= 0 && param_idx == variadic_idx {
			variadic_type := params[variadic_idx]
			if variadic_type is types.Array {
				if arg_node.kind == .prefix && arg_node.value == '...'
					&& arg_node.children_count > 0 {
					spread_id := t.a.child(&arg_node, 0)
					args << t.transform_call_arg_for_param(spread_id, param_type)
					i++
					break
				}
				remaining := int(node.children_count) - i
				if remaining == 1 {
					arg_type := t.node_type(arg_id)
					if arg_type.starts_with('[]') {
						args << t.transform_call_arg_for_param(arg_id, param_type)
					} else {
						args << t.pack_variadic_args(node, i, variadic_type.elem_type)
					}
				} else {
					args << t.pack_variadic_args(node, i, variadic_type.elem_type)
				}
				break
			}
		}
		args << t.transform_call_arg_for_param(arg_id, param_type)
		i++
	}
	if variadic_idx >= 0 && explicit_args == variadic_idx - param_offset {
		variadic_type := params[variadic_idx]
		if variadic_type is types.Array {
			args << t.pack_variadic_args(node, int(node.children_count), variadic_type.elem_type)
		}
	}
	t.append_missing_params_struct_args(mut args, params, param_offset)
	return args
}

// receiver_method_param_offset supports receiver method param offset handling for Transformer.
fn (t &Transformer) receiver_method_param_offset(base_id flat.NodeId, node flat.Node, params []types.Type) int {
	if params.len == 0 {
		return 0
	}
	base_type := t.node_type(base_id)
	first_type := t.normalize_type_alias(params[0].name())
	clean_first := if first_type.starts_with('&') { first_type[1..] } else { first_type }
	clean_base := if base_type.starts_with('&') { base_type[1..] } else { base_type }
	if clean_first == clean_base
		|| t.normalize_type_alias(clean_first) == t.normalize_type_alias(clean_base)
		|| clean_first.all_after_last('.') == clean_base.all_after_last('.') {
		return 1
	}
	if params.len >= int(node.children_count) {
		return 1
	}
	return 0
}

// try_lower_string_method_call supports try lower string method call handling for Transformer.
fn (mut t Transformer) try_lower_string_method_call(node flat.Node) ?flat.NodeId {
	if node.children_count == 0 {
		return none
	}
	fn_id := t.a.children[node.children_start]
	fn_node := t.a.nodes[int(fn_id)]
	if fn_node.kind != .selector || fn_node.children_count == 0 {
		return none
	}
	method := fn_node.value
	if method == 'count' && node.children_count == 2 && t.expr_uses_ident(t.a.child(&node, 1), 'it') {
		return t.lower_string_count_call(node, fn_node)
	}
	if method !in ['replace', 'replace_once', 'trim', 'trim_left', 'trim_right', 'all_before',
		'all_after', 'all_before_last', 'all_after_last', 'contains', 'starts_with', 'ends_with',
		'bytes', 'substr', 'substr_unsafe', 'repeat', 'plus_two'] {
		return none
	}
	base_id := t.a.child(&fn_node, 0)
	base_type := t.node_type(base_id)
	if base_type != 'string' {
		return none
	}
	mut args := []flat.NodeId{cap: int(node.children_count)}
	args << t.transform_expr(base_id)
	for i in 1 .. node.children_count {
		args << t.transform_expr(t.a.child(&node, i))
	}
	ret_type := match method {
		'contains', 'starts_with', 'ends_with' { 'bool' }
		'bytes' { '[]u8' }
		else { 'string' }
	}

	return t.make_call_typed('string__${method}', args, ret_type)
}

// lower_string_count_call builds lower string count call data for transform.
fn (mut t Transformer) lower_string_count_call(node flat.Node, fn_node flat.Node) ?flat.NodeId {
	base_id := t.a.child(&fn_node, 0)
	base_type := t.node_type(base_id)
	if base_type != 'string' {
		return none
	}
	base := t.stable_expr_for_reuse(base_id)
	mut prefix := []flat.NodeId{}
	t.drain_pending(mut prefix)
	result_name := t.new_temp('count')
	idx_name := t.new_temp('count_idx')
	prefix << t.make_decl_assign_typed(result_name, t.make_int_literal(0), 'int')
	init := t.make_decl_assign_typed(idx_name, t.make_int_literal(0), 'int')
	cond := t.make_infix(.lt, t.make_ident(idx_name), t.make_selector(base, 'len', 'int'))
	post := t.make_expr_stmt(t.make_postfix(t.make_ident(idx_name), .inc))
	elem_expr := t.make_index(base, t.make_ident(idx_name), 'u8')
	elem_decl := t.make_decl_assign_typed('it', elem_expr, 'u8')
	predicate_id := t.a.child(&node, 1)
	old_it := t.var_type('it')
	t.set_var_type('it', 'u8')
	predicate := t.transform_expr(predicate_id)
	if old_it.len > 0 {
		t.set_var_type('it', old_it)
	} else {
		t.unset_var_type('it')
	}
	mut loop_body := []flat.NodeId{}
	loop_body << elem_decl
	t.drain_pending(mut loop_body)
	inc := t.make_assign_op(t.make_ident(result_name), t.make_int_literal(1), .plus_assign)
	loop_body << t.make_if(predicate, t.make_block(arr1(inc)), t.make_empty())
	prefix << t.make_for_stmt(init, cond, post, loop_body, node)
	for stmt in prefix {
		t.pending_stmts << stmt
	}
	return t.make_ident(result_name)
}

// expr_uses_ident supports expr uses ident handling for Transformer.
fn (t &Transformer) expr_uses_ident(id flat.NodeId, name string) bool {
	if int(id) < 0 {
		return false
	}
	node := t.a.nodes[int(id)]
	if node.kind == .ident && node.value == name {
		return true
	}
	for i in 0 .. node.children_count {
		if t.expr_uses_ident(t.a.child(&node, i), name) {
			return true
		}
	}
	return false
}

// is_method_call checks if a .call node is a method call (child[0] is .selector).
// Returns true for `obj.method(args)` patterns.
fn (mut t Transformer) is_method_call(node flat.Node) bool {
	if node.children_count == 0 {
		return false
	}
	fn_id := t.a.children[node.children_start]
	if int(fn_id) < 0 {
		return false
	}
	fn_node := t.a.nodes[int(fn_id)]
	return fn_node.kind == .selector
}

// get_call_return_type looks up the return type for a resolved call.
// Handles both checker-resolved calls and transform-time name resolution.
fn (t &Transformer) get_call_return_type(id flat.NodeId, node flat.Node) string {
	if t.is_local_fn_value_call(node) {
		return ''
	}
	if ret := t.checker_resolved_non_builtin_return_type(id, node) {
		return ret
	}
	if node.children_count > 0 {
		fn_node := t.a.child_node(&node, 0)
		if fn_node.kind == .ident {
			local_type := t.var_type(fn_node.value)
			if local_type.len > 0 {
				if ret := t.local_fn_value_return_type_from_type(local_type) {
					return t.call_return_type_name(ret, node)
				}
			} else {
				if ret := t.local_fn_decl_return_type(fn_node.value) {
					return t.call_return_type_name(ret, node)
				}
			}
		}
		if fn_node.kind == .selector
			&& fn_node.value in ['clone', 'reverse', 'repeat', 'repeat_to_depth']
			&& fn_node.children_count > 0 {
			base_id := t.a.child(fn_node, 0)
			base_type := t.node_type(base_id)
			clean_type := if base_type.starts_with('&') { base_type[1..] } else { base_type }
			if clean_type.starts_with('[]') {
				return clean_type
			}
		}
		if fn_node.kind == .selector && fn_node.value == 'wait' && fn_node.children_count > 0 {
			base_id := t.a.child(fn_node, 0)
			base_type := t.node_type(base_id)
			clean_type := t.membership_container_type(base_type)
			if clean_type.starts_with('[]') {
				elem_type := clean_type[2..]
				if elem_type == 'thread' {
					return 'void'
				}
				if elem_type.starts_with('thread ') {
					return '[]${elem_type[7..]}'
				}
			}
		}
		if fn_node.kind == .selector && fn_node.value in ['keys', 'values']
			&& fn_node.children_count > 0 {
			base_id := t.a.child(fn_node, 0)
			mut base_type := t.node_type(base_id)
			if base_type.len == 0 {
				base_type = t.checker_node_type(base_id)
			}
			clean_type := t.clean_map_type(base_type)
			if clean_type.starts_with('map[') {
				elem_type := if fn_node.value == 'keys' {
					t.map_key_type(clean_type)
				} else {
					t.map_value_type(clean_type)
				}
				if elem_type.len > 0 {
					return '[]${elem_type}'
				}
			}
		}
		// A method on a concrete generic instance (`Box[int].clone`) is registered under
		// the open form (`Box[T].clone`), whose stored return type collapsed `Box[T]` to
		// the bare base. Resolve it through the checker, which re-substitutes the concrete
		// arguments from the signature text, so the inferred decl type is `Box[int]`.
		if !isnil(t.tc) && fn_node.kind == .selector && fn_node.children_count > 0 {
			base_type := t.node_type(t.a.child(fn_node, 0))
			clean_base := if base_type.starts_with('&') { base_type[1..] } else { base_type }
			if clean_base.contains('[') && clean_base.ends_with(']') {
				if ci := t.tc.resolve_generic_struct_method(clean_base, fn_node.value) {
					rn := ci.return_type.name()
					if rn.len > 0 && rn != 'void' && rn != 'unknown' {
						return t.normalize_type_alias(rn)
					}
				}
			}
		}
	}
	if !isnil(t.tc) {
		if name := t.tc.resolved_call_name(id) {
			if ret := t.tc.fn_ret_types[name] {
				return t.call_return_type_name(ret.name(), node)
			}
		}
	}
	name := t.resolve_call_name(node)
	if name.len == 0 {
		return ''
	}
	if !isnil(t.tc) {
		if ret := t.tc.fn_ret_types[name] {
			return t.call_return_type_name(ret.name(), node)
		}
		if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
			qname := '${t.cur_module}.${name}'
			if ret := t.tc.fn_ret_types[qname] {
				return t.call_return_type_name(ret.name(), node)
			}
		}
	}
	// Try exact name first
	if ret := t.fn_ret_types[name] {
		return t.call_return_type_name(ret, node)
	}
	// Try qualified with current module
	if t.cur_module.len > 0 && t.cur_module != 'main' && t.cur_module != 'builtin' {
		qname := '${t.cur_module}.${name}'
		if ret := t.fn_ret_types[qname] {
			return t.call_return_type_name(ret, node)
		}
	}
	return ''
}

fn (t &Transformer) checker_resolved_non_builtin_return_type(id flat.NodeId, node flat.Node) ?string {
	if isnil(t.tc) {
		return none
	}
	name := t.tc.resolved_call_name(id) or { return none }
	if is_builtin_collection_resolved_call(name) {
		return none
	}
	ret := t.tc.fn_ret_types[name] or { return none }
	return t.call_return_type_name(ret.name(), node)
}

// call_return_type_name updates call return type name state for Transformer.
fn (t &Transformer) call_return_type_name(ret_name string, node flat.Node) string {
	mut typ := ret_name
	if node.value.len > 0 {
		generic_arg := t.normalize_type_in_module(node.value, t.cur_module)
		if generic_arg.len > 0 {
			typ = t.specialize_generic_type_name(typ, generic_arg)
		}
	}
	if t.is_optional_type_name(typ) {
		return typ
	}
	return t.normalize_type_alias(typ)
}

// specialize_generic_type_name supports specialize generic type name handling for Transformer.
fn (t &Transformer) specialize_generic_type_name(typ string, generic_arg string) string {
	clean := typ.trim_space()
	if clean.len == 0 || generic_arg.len == 0 {
		return typ
	}
	if clean == 'T' {
		return generic_arg
	}
	if clean.starts_with('&') {
		return '&' + t.specialize_generic_type_name(clean[1..], generic_arg)
	}
	if clean.starts_with('[]') {
		return '[]' + t.specialize_generic_type_name(clean[2..], generic_arg)
	}
	if clean.starts_with('?') {
		return '?' + t.specialize_generic_type_name(clean[1..], generic_arg)
	}
	if clean.starts_with('!') {
		return '!' + t.specialize_generic_type_name(clean[1..], generic_arg)
	}
	if clean.starts_with('...') {
		return '...' + t.specialize_generic_type_name(clean[3..], generic_arg)
	}
	if clean.starts_with('map[') {
		bracket_end := clean.index(']') or { return typ }
		key_type := t.specialize_generic_type_name(clean[4..bracket_end], generic_arg)
		value_type := t.specialize_generic_type_name(clean[bracket_end + 1..], generic_arg)
		return 'map[${key_type}]${value_type}'
	}
	if clean.starts_with('[') {
		bracket_end := clean.index(']') or { return typ }
		return clean[..bracket_end + 1] + t.specialize_generic_type_name(clean[bracket_end +
			1..], generic_arg)
	}
	return typ
}