module transform

import v3.flat

// try_expand_if_guard detects an if-guard pattern where the condition is a
// decl_assign whose RHS is a call returning an optional (?T) or result (!T).
// When detected it expands:
//   if val := maybe_call() { body }
// into:
//   __or_tmp_N := maybe_call()
//   if !__or_tmp_N.is_error { val := __or_tmp_N.data; body... }
//
fn (mut t Transformer) try_expand_if_guard(_id flat.NodeId, node flat.Node) ?[]flat.NodeId {
	if node.kind != .if_expr || node.children_count < 2 {
		return none
	}
	cond_id := t.a.child(&node, 0)
	cond := t.a.nodes[int(cond_id)]
	if cond.kind != .decl_assign || cond.children_count < 2 {
		return none
	}
	lhs_id := t.a.child(&cond, 0)
	rhs_id := t.a.child(&cond, 1)
	lhs := t.a.nodes[int(lhs_id)]
	if lhs.kind != .ident || lhs.value.len == 0 {
		return none
	}
	lhs_ids := t.multi_assign_lhs_ids(cond)
	if lhs_ids.len == 1 {
		if info := t.map_index_info(rhs_id) {
			return t.expand_map_index_if_guard(node, lhs.value, info)
		}
		if info := t.array_index_info(rhs_id) {
			return t.expand_array_index_if_guard(node, lhs.value, info)
		}
	}
	mut rhs_type := t.optional_result_expr_type_name(rhs_id)
	if !t.is_optional_type_name(rhs_type) {
		return none
	}
	rhs_type = t.qualify_optional_type(rhs_type)
	value_type := t.optional_base_type(rhs_type)
	tmp_name := t.new_temp('if_guard')
	rhs_expr := t.transform_expr(rhs_id)
	mut prelude := []flat.NodeId{}
	t.drain_pending(mut prelude)
	tmp_decl := t.make_decl_assign_typed(tmp_name, rhs_expr, rhs_type)
	ok_cond := t.make_selector(t.make_ident(tmp_name), 'ok', 'bool')
	mut value_decls := []flat.NodeId{}
	if lhs_ids.len > 1 {
		if rhs_types := t.multi_return_types_for_expr(rhs_id, lhs_ids.len) {
			for i, lhs_item_id in lhs_ids {
				lhs_item := t.a.nodes[int(lhs_item_id)]
				if lhs_item.kind != .ident || lhs_item.value == '_' {
					continue
				}
				field_type := rhs_types[i].name()
				payload := t.make_selector(t.make_ident(tmp_name), 'value', value_type)
				field := t.make_selector(payload, 'arg${i}', field_type)
				value_decls << t.make_decl_assign_typed(lhs_item.value, field, field_type)
			}
		}
	}
	if value_decls.len == 0 && lhs.value != '_' && value_type != 'void' {
		value_decls << t.make_decl_assign_typed(lhs.value, t.make_selector(t.make_ident(tmp_name),
			'value', value_type), value_type)
	}

	then_id := t.a.child(&node, 1)
	then_node := t.a.nodes[int(then_id)]
	if lhs_ids.len > 1 {
		if rhs_types := t.multi_return_types_for_expr(rhs_id, lhs_ids.len) {
			for i, lhs_item_id in lhs_ids {
				lhs_item := t.a.nodes[int(lhs_item_id)]
				if lhs_item.kind == .ident && lhs_item.value.len > 0 && lhs_item.value != '_' {
					t.set_var_type(lhs_item.value, rhs_types[i].name())
				}
			}
		}
	} else {
		if lhs.value != '_' && value_type != 'void' {
			t.set_var_type(lhs.value, value_type)
		}
	}
	mut then_children := []flat.NodeId{}
	for value_decl in value_decls {
		then_children << value_decl
	}
	if then_node.kind == .block {
		then_children << t.transform_stmts(t.a.children_of(&then_node))
	} else {
		then_children << t.transform_stmt(then_id)
	}
	then_block := t.make_block(then_children)

	mut else_block := flat.empty_node
	if node.children_count >= 3 {
		else_id := t.a.child(&node, 2)
		else_node := t.a.nodes[int(else_id)]
		else_block = t.transform_if_guard_else_block(else_id, else_node, tmp_name)
	}
	mut expanded := []flat.NodeId{cap: prelude.len + 2}
	for stmt in prelude {
		expanded << stmt
	}
	expanded << tmp_decl
	expanded << t.make_if(ok_cond, then_block, else_block)
	return expanded
}

// optional_result_expr_type_name supports optional result expr type name handling for Transformer.
fn (mut t Transformer) optional_result_expr_type_name(id flat.NodeId) string {
	if int(id) < 0 {
		return ''
	}
	if !isnil(t.tc) {
		node := t.a.nodes[int(id)]
		if node.kind == .call {
			concrete_ret := t.concrete_generic_call_return_type(id, node)
			if t.is_optional_type_name(concrete_ret) {
				return concrete_ret
			}
			if name := t.tc.resolved_call_name(id) {
				if ret := t.tc.fn_ret_types[name] {
					ret_name := ret.name()
					if t.is_optional_type_name(ret_name) {
						return ret_name
					}
				}
			}
			ret_name := t.get_call_return_type(id, node)
			if t.is_optional_type_name(ret_name) {
				return ret_name
			}
		}
		if typ := t.tc.expr_type(id) {
			typ_name := typ.name()
			if t.is_optional_type_name(typ_name) {
				return typ_name
			}
		}
	}
	return t.node_type(id)
}

// transform_if_guard_else_block transforms transform if guard else block data for transform.
fn (mut t Transformer) transform_if_guard_else_block(else_id flat.NodeId, else_node flat.Node, err_source string) flat.NodeId {
	saved_var_types := t.var_types.clone()
	t.set_var_type('err', 'IError')
	mut children := []flat.NodeId{}
	err_value := if err_source.len > 0 {
		t.make_selector(t.make_ident(err_source), 'err', 'IError')
	} else {
		t.make_struct_init('IError')
	}
	children << t.make_decl_assign_typed('err', err_value, 'IError')
	if else_node.kind == .block {
		children << t.transform_stmts(t.a.children_of(&else_node))
	} else if else_node.kind == .if_expr {
		children << t.transform_else_if_expr(else_id, else_node)
	} else {
		children << t.transform_stmt(else_id)
	}
	t.var_types = saved_var_types
	return t.make_block(children)
}

// transform_else_if_expr transforms transform else if expr data for transform.
fn (mut t Transformer) transform_else_if_expr(else_id flat.NodeId, else_node flat.Node) flat.NodeId {
	if expanded := t.try_expand_if_guard(else_id, else_node) {
		return t.make_block(expanded)
	}
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	new_if := t.transform_if_branches_with_smartcast(else_id, else_node)
	mut local_pending := t.pending_stmts.clone()
	t.pending_stmts = outer_pending
	if local_pending.len == 0 {
		return new_if
	}
	local_pending << new_if
	return t.make_block(local_pending)
}

// expand_map_index_if_guard builds expand map index if guard data for transform.
fn (mut t Transformer) expand_map_index_if_guard(node flat.Node, lhs_name string, info MapIndexInfo) ?[]flat.NodeId {
	map_expr := t.stable_expr_for_reuse(info.base_id)
	key_name := t.new_temp('map_key')
	ptr_name := t.new_temp('map_ptr')
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	key_expr := t.transform_expr(info.key_id)
	mut prelude := []flat.NodeId{}
	t.drain_pending(mut prelude)
	prelude << t.make_decl_assign_typed(key_name, key_expr, info.key_type)
	prelude << t.make_decl_assign_typed(ptr_name, t.make_map_get_check_expr(map_expr,
		info.base_type, key_name), 'voidptr')

	ptr_ident := t.make_ident(ptr_name)
	found_cond := t.make_infix(.ne, ptr_ident, t.a.add(.nil_literal))
	ptr_value := t.make_prefix(.mul, t.make_cast('&${info.value_type}', t.make_ident(ptr_name),
		'&${info.value_type}'))
	value_decl := t.make_decl_assign_typed(lhs_name, ptr_value, info.value_type)

	then_id := t.a.child(&node, 1)
	then_node := t.a.nodes[int(then_id)]
	t.set_var_type(lhs_name, info.value_type)
	mut then_children := []flat.NodeId{}
	then_children << value_decl
	if then_node.kind == .block {
		then_children << t.transform_stmts(t.a.children_of(&then_node))
	} else {
		then_children << t.transform_stmt(then_id)
	}
	then_block := t.make_block(then_children)

	mut else_block := flat.empty_node
	if node.children_count >= 3 {
		else_id := t.a.child(&node, 2)
		else_node := t.a.nodes[int(else_id)]
		else_block = if else_node.kind == .block {
			t.make_block(t.transform_stmts(t.a.children_of(&else_node)))
		} else if else_node.kind == .if_expr {
			t.transform_else_if_expr(else_id, else_node)
		} else {
			t.make_block(t.transform_stmt(else_id))
		}
	}
	t.pending_stmts = outer_pending
	mut expanded := []flat.NodeId{cap: prelude.len + 1}
	for stmt in prelude {
		expanded << stmt
	}
	expanded << t.make_if(found_cond, then_block, else_block)
	return expanded
}

// expand_array_index_if_guard builds expand array index if guard data for transform.
fn (mut t Transformer) expand_array_index_if_guard(node flat.Node, lhs_name string, info ArrayIndexInfo) ?[]flat.NodeId {
	array_expr := t.stable_expr_for_reuse(info.base_id)
	index_name := t.new_temp('arr_idx')
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	index_expr := t.transform_expr(info.index_id)
	mut prelude := []flat.NodeId{}
	t.drain_pending(mut prelude)
	prelude << t.make_decl_assign_typed(index_name, index_expr, 'int')

	idx_ident := t.make_ident(index_name)
	lower_ok := t.make_infix(.ge, idx_ident, t.make_int_literal(0))
	upper_ok := t.make_infix(.lt, t.make_ident(index_name), t.make_selector(array_expr, 'len',
		'int'))
	found_cond := t.make_infix(.logical_and, lower_ok, upper_ok)

	then_id := t.a.child(&node, 1)
	then_node := t.a.nodes[int(then_id)]
	saved_var_types := t.var_types.clone()
	mut then_children := []flat.NodeId{}
	mut guard_value_type := info.value_type
	mut value_expr := t.make_index(array_expr, t.make_ident(index_name), info.value_type)
	if t.is_optional_type_name(info.value_type) {
		guard_value_type = t.optional_base_type(t.qualify_optional_type(info.value_type))
		opt_name := t.new_temp('arr_opt')
		value_expr = t.make_selector(t.make_ident(opt_name), 'value', guard_value_type)
		then_children << t.make_decl_assign_typed(opt_name, t.make_index(array_expr,
			t.make_ident(index_name), info.value_type), info.value_type)
	}
	then_children << t.make_decl_assign_typed(lhs_name, value_expr, guard_value_type)
	t.set_var_type(lhs_name, guard_value_type)
	if then_node.kind == .block {
		then_children << t.transform_stmts(t.a.children_of(&then_node))
	} else {
		then_children << t.transform_stmt(then_id)
	}
	t.var_types = saved_var_types
	then_block := t.make_block(then_children)

	mut else_block := flat.empty_node
	if node.children_count >= 3 {
		else_id := t.a.child(&node, 2)
		else_node := t.a.nodes[int(else_id)]
		else_block = if else_node.kind == .block {
			t.make_block(t.transform_stmts(t.a.children_of(&else_node)))
		} else if else_node.kind == .if_expr {
			t.transform_else_if_expr(else_id, else_node)
		} else {
			t.make_block(t.transform_stmt(else_id))
		}
	}
	mut selected_block := then_block
	if t.is_optional_type_name(info.value_type) && then_children.len > 0 {
		opt_decl := then_children[0]
		opt_name := t.a.nodes[int(t.a.child(&t.a.nodes[int(opt_decl)], 0))].value
		ok_cond := t.make_selector(t.make_ident(opt_name), 'ok', 'bool')
		mut inner_children := []flat.NodeId{}
		for i in 1 .. then_children.len {
			inner_children << then_children[i]
		}
		inner_if := t.make_if(ok_cond, t.make_block(inner_children), else_block)
		selected_block = t.make_block([opt_decl, inner_if])
	}
	t.pending_stmts = outer_pending
	mut expanded := []flat.NodeId{cap: prelude.len + 1}
	for stmt in prelude {
		expanded << stmt
	}
	expanded << t.make_if(found_cond, selected_block, else_block)
	return expanded
}

// try_expand_if_expr_value detects an if-expression used as a value and
// lowers it to a mutable temporary so that the C backend sees a simple
// variable instead of a gcc statement-expression.
//
//   x := if cond { a } else { b }
// becomes:
//   mut __if_tmp_N := zero_value
//   if cond { __if_tmp_N = a } else { __if_tmp_N = b }
//   x := __if_tmp_N
fn (mut t Transformer) try_expand_if_expr_value(id flat.NodeId, node flat.Node) ?flat.NodeId {
	if node.kind != .if_expr {
		return none
	}
	// An if-expression used as a value must have both then and else branches.
	if node.children_count < 3 {
		return none
	}
	mut result_type := t.if_expr_result_type(id, node)
	if result_type.len == 0 || result_type == 'void' {
		return none
	}
	return t.try_expand_if_expr_value_for_type(id, node, result_type)
}

// try_expand_if_expr_value_for_type
// supports helper handling in transform.
fn (mut t Transformer) try_expand_if_expr_value_for_type(id flat.NodeId, node flat.Node, result_type string) ?flat.NodeId {
	if node.kind != .if_expr || node.children_count < 3 || result_type.len == 0
		|| result_type == 'void' {
		return none
	}
	mut actual_result_type := result_type
	branch_type := t.if_expr_branch_result_type(node)
	if t.if_expr_branch_overrides_sum_target(branch_type, result_type) {
		actual_result_type = branch_type
	}
	tmp_name := t.new_temp('if_val')
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()

	mut prelude := []flat.NodeId{}
	prelude << t.make_decl_assign_typed(tmp_name, t.zero_value_for_type(actual_result_type),
		actual_result_type)
	for stmt in t.build_if_value_chain(id, tmp_name, actual_result_type) {
		prelude << stmt
	}

	t.pending_stmts = outer_pending
	for stmt in prelude {
		t.pending_stmts << stmt
	}
	tmp := t.make_ident(tmp_name)
	t.a.nodes[int(tmp)].typ = actual_result_type
	return tmp
}

// if_expr_branch_overrides_sum_target supports if_expr_branch_overrides_sum_target handling.
fn (t &Transformer) if_expr_branch_overrides_sum_target(branch_type string, target_type string) bool {
	if branch_type.len == 0 || target_type.len == 0 {
		return false
	}
	if branch_type.starts_with('[]') {
		branch_elem := branch_type[2..]
		target_short := if target_type.contains('.') {
			target_type.all_after_last('.')
		} else {
			target_type
		}
		branch_short := if branch_elem.contains('.') {
			branch_elem.all_after_last('.')
		} else {
			branch_elem
		}
		if target_short == branch_short {
			return true
		}
	}
	resolved_target := t.resolve_sum_name(target_type)
	if resolved_target.len == 0 || resolved_target !in t.sum_types {
		return false
	}
	clean_branch := t.trim_pointer_type(branch_type)
	branch_sum := t.resolve_sum_name(clean_branch)
	variant_sum := t.resolve_sum_name(t.find_sum_type_for_variant(clean_branch))
	return branch_sum != resolved_target && variant_sum != resolved_target
}

// if_expr_result_type supports if expr result type handling for Transformer.
fn (t &Transformer) if_expr_result_type(id flat.NodeId, node flat.Node) string {
	mut node_typ := ''
	if node.typ.len > 0 {
		typ := t.normalize_type_alias(node.typ)
		if typ !in ['array', 'map'] {
			node_typ = typ
		}
	}
	mut checked_typ := ''
	if !isnil(t.tc) {
		if typ := t.tc.expr_type(id) {
			name := typ.name()
			if name.len > 0 {
				checked_typ = t.normalize_type_alias(name)
			}
		}
	}
	branch_typ := t.if_expr_branch_result_type(node)
	if branch_typ.starts_with('[]') && t.is_fixed_array_type(checked_typ)
		&& fixed_array_elem_type(checked_typ) == branch_typ[2..] {
		return branch_typ
	}
	if branch_typ.starts_with('[]') && t.is_fixed_array_type(node_typ)
		&& fixed_array_elem_type(node_typ) == branch_typ[2..] {
		return branch_typ
	}
	if branch_typ.starts_with('[]') && !checked_typ.starts_with('[]') && !node_typ.starts_with('[]') {
		return branch_typ
	}
	if t.if_expr_branch_type_overrides(branch_typ, checked_typ) {
		return branch_typ
	}
	if t.if_expr_branch_type_overrides(branch_typ, node_typ) {
		return branch_typ
	}
	if checked_typ.len > 0 && checked_typ !in ['array', 'map'] {
		return checked_typ
	}
	if node_typ.len > 0 {
		return node_typ
	}
	if branch_typ.len > 0 {
		return branch_typ
	}
	return ''
}

// if_expr_branch_type_overrides supports if expr branch type overrides handling for Transformer.
fn (t &Transformer) if_expr_branch_type_overrides(branch_typ string, stale_typ string) bool {
	if branch_typ.len == 0 || stale_typ.len == 0 || branch_typ == stale_typ {
		return false
	}
	if stale_typ in ['array', 'map', 'unknown'] {
		return true
	}
	if stale_typ in t.enum_types && branch_typ == 'int' {
		return false
	}
	if stale_typ.starts_with('&') && branch_typ.starts_with('&') {
		stale_inner := stale_typ[1..]
		branch_inner := branch_typ[1..]
		if stale_inner in ['int', 'void', 'unknown'] && branch_inner !in ['int', 'void', 'unknown'] {
			return true
		}
	}
	if stale_typ.starts_with('[]') || t.is_fixed_array_type(stale_typ) {
		return !branch_typ.starts_with('[]') && !t.is_fixed_array_type(branch_typ)
	}
	if stale_typ.starts_with('map[') {
		return !branch_typ.starts_with('map[')
	}
	return false
}

// if_expr_branch_result_type supports if expr branch result type handling for Transformer.
fn (t &Transformer) if_expr_branch_result_type(node flat.Node) string {
	mut result := ''
	if node.children_count >= 2 {
		then_smartcasts :=
			t.smartcast_contexts_from_is_exprs(t.extract_all_is_exprs(t.a.child(&node, 0)))
		then_type := t.stmt_value_type_with_smartcasts(t.a.child(&node, 1), then_smartcasts)
		if then_type.len > 0 {
			result = t.merge_if_expr_types(result, t.normalize_type_alias(then_type))
		}
	}
	if node.children_count >= 3 {
		else_id := t.a.child(&node, 2)
		else_node := t.a.nodes[int(else_id)]
		else_type := if else_node.kind == .if_expr {
			t.if_expr_result_type(else_id, else_node)
		} else {
			t.stmt_value_type(else_id)
		}
		if else_type.len > 0 {
			result = t.merge_if_expr_types(result, t.normalize_type_alias(else_type))
		}
	}
	return result
}

// smartcast_contexts_from_is_exprs converts smartcast contexts from is exprs data for transform.
fn (t &Transformer) smartcast_contexts_from_is_exprs(infos []IsExprInfo) []SmartcastContext {
	mut result := []SmartcastContext{cap: infos.len}
	for info in infos {
		result << SmartcastContext{
			expr_name:     info.expr_name
			variant_name:  info.variant_name
			sum_type_name: info.sum_type_name
		}
	}
	return result
}

// stmt_value_type_with_smartcasts
// supports helper handling in transform.
fn (t &Transformer) stmt_value_type_with_smartcasts(id flat.NodeId, contexts []SmartcastContext) string {
	if int(id) < 0 {
		return ''
	}
	node := t.a.nodes[int(id)]
	match node.kind {
		.expr_stmt {
			if node.children_count > 0 {
				return t.node_type_with_smartcasts(t.a.child(&node, node.children_count - 1),
					contexts)
			}
			return ''
		}
		.block {
			for i := node.children_count - 1; i >= 0; i-- {
				typ := t.stmt_value_type_with_smartcasts(t.a.child(&node, i), contexts)
				if typ.len > 0 {
					return typ
				}
			}
			return ''
		}
		else {
			return t.node_type_with_smartcasts(id, contexts)
		}
	}
}

// node_type_with_smartcasts supports node type with smartcasts handling for Transformer.
fn (t &Transformer) node_type_with_smartcasts(id flat.NodeId, contexts []SmartcastContext) string {
	if int(id) < 0 {
		return ''
	}
	node := t.a.nodes[int(id)]
	match node.kind {
		.ident {
			if sc := t.find_smartcast_in_context(node.value, contexts) {
				return t.smartcast_target_type(sc)
			}
			return t.node_type(id)
		}
		.selector {
			if node.children_count == 0 {
				return t.node_type(id)
			}
			full_key := t.expr_key(id)
			if full_key.len > 0 {
				if sc := t.find_smartcast_in_context(full_key, contexts) {
					return t.smartcast_target_type(sc)
				}
			}
			base_id := t.a.child(&node, 0)
			base_key := t.expr_key(base_id)
			if base_key.len > 0 {
				if sc := t.find_smartcast_in_context(base_key, contexts) {
					variant_type := t.qualify_variant(sc.variant_name, sc.sum_type_name)
					if ftyp := t.lookup_struct_field_type(variant_type, node.value) {
						return ftyp
					}
					if ftyp := t.lookup_struct_field_type(sc.variant_name, node.value) {
						return ftyp
					}
				}
			}
			base_type := t.node_type_with_smartcasts(base_id, contexts)
			clean_base := if base_type.starts_with('&') { base_type[1..] } else { base_type }
			if ftyp := t.lookup_struct_field_type(clean_base, node.value) {
				return ftyp
			}
			return t.node_type(id)
		}
		.prefix {
			if node.children_count == 0 {
				return t.node_type(id)
			}
			child_type := t.node_type_with_smartcasts(t.a.child(&node, 0), contexts)
			if node.op == .amp && child_type.len > 0 {
				return '&${child_type}'
			}
			if node.op == .mul && child_type.starts_with('&') {
				return child_type[1..]
			}
			if node.op == .not {
				return 'bool'
			}
			return t.node_type(id)
		}
		.paren {
			if node.children_count > 0 {
				return t.node_type_with_smartcasts(t.a.child(&node, 0), contexts)
			}
			return t.node_type(id)
		}
		.array_literal {
			if node.typ.len > 0 {
				typ := t.normalize_type_alias(node.typ)
				if typ != 'array' {
					return typ
				}
			}
			if node.children_count > 0 {
				elem_type := t.node_type_with_smartcasts(t.a.child(&node, 0), contexts)
				if elem_type.len > 0 {
					return '[]${elem_type}'
				}
			}
			return t.node_type(id)
		}
		.index {
			base_type := if node.children_count > 0 {
				t.node_type_with_smartcasts(t.a.child(&node, 0), contexts)
			} else {
				''
			}
			if node.value == 'range' && base_type.starts_with('[]') {
				return base_type
			}
			if base_type.starts_with('[]') {
				return base_type[2..]
			}
			return t.node_type(id)
		}
		.if_expr {
			return t.if_expr_result_type(id, node)
		}
		.match_stmt {
			return t.match_expr_type(node)
		}
		else {
			return t.node_type(id)
		}
	}
}

// find_smartcast_in_context resolves find smartcast in context information for transform.
fn (t &Transformer) find_smartcast_in_context(expr_name string, contexts []SmartcastContext) ?SmartcastContext {
	mut i := contexts.len - 1
	for i >= 0 {
		if contexts[i].expr_name == expr_name {
			return contexts[i]
		}
		i--
	}
	return t.find_smartcast(expr_name)
}

// merge_if_expr_types supports merge if expr types handling for Transformer.
fn (t &Transformer) merge_if_expr_types(current string, next string) string {
	if current.len == 0 {
		return next
	}
	if next.len == 0 || current == next {
		return current
	}
	if current == 'array' && next.starts_with('[]') {
		return next
	}
	if next == 'array' && current.starts_with('[]') {
		return current
	}
	if current.starts_with('[]') && t.is_fixed_array_type(next)
		&& current[2..] == fixed_array_elem_type(next) {
		return current
	}
	if next.starts_with('[]') && t.is_fixed_array_type(current)
		&& next[2..] == fixed_array_elem_type(current) {
		return next
	}
	if current.starts_with('[]') && !next.starts_with('[]') && current[2..] == next {
		return current
	}
	if next.starts_with('[]') && !current.starts_with('[]') && next[2..] == current {
		return next
	}
	return current
}

// build_if_value_chain builds if value chain data for transform.
fn (mut t Transformer) build_if_value_chain(if_id flat.NodeId, target_name string, target_type string) []flat.NodeId {
	if_node := t.a.nodes[int(if_id)]
	if if_node.kind != .if_expr || if_node.children_count < 2 {
		return []flat.NodeId{}
	}
	if guard_chain := t.build_if_value_guard_chain(if_node, target_name, target_type) {
		return guard_chain
	}
	cond_id := t.a.child(&if_node, 0)
	then_id := t.a.child(&if_node, 1)
	has_else := if_node.children_count >= 3

	all_is := t.extract_all_is_exprs(cond_id)
	new_cond := t.transform_and_chain_smartcasts(cond_id)
	mut result := []flat.NodeId{}
	t.drain_pending(mut result)

	for info in all_is {
		t.push_smartcast(info.expr_name, info.variant_name, info.sum_type_name)
	}
	then_block := t.if_value_branch_block(then_id, target_name, target_type)
	for _ in all_is {
		t.pop_smartcast()
	}

	mut else_block := flat.empty_node
	if has_else {
		else_id := t.a.child(&if_node, 2)
		else_node := t.a.nodes[int(else_id)]
		if else_node.kind == .if_expr {
			else_block = t.make_block(t.build_if_value_chain(else_id, target_name, target_type))
		} else {
			else_block = t.if_value_branch_block(else_id, target_name, target_type)
		}
	}
	result << t.make_if(new_cond, then_block, else_block)
	return result
}

// build_if_value_guard_chain builds if value guard chain data for transform.
fn (mut t Transformer) build_if_value_guard_chain(if_node flat.Node, target_name string, target_type string) ?[]flat.NodeId {
	if if_node.children_count < 3 {
		return none
	}
	cond_id := t.a.child(&if_node, 0)
	cond := t.a.nodes[int(cond_id)]
	if cond.kind != .decl_assign || cond.children_count < 2 {
		return none
	}
	lhs_id := t.a.child(&cond, 0)
	rhs_id := t.a.child(&cond, 1)
	lhs := t.a.nodes[int(lhs_id)]
	if lhs.kind != .ident || lhs.value.len == 0 {
		return none
	}
	if info := t.map_index_info(rhs_id) {
		return t.build_map_index_if_value_guard_chain(if_node, lhs.value, info, target_name,
			target_type)
	}
	if info := t.array_index_info(rhs_id) {
		return t.build_array_index_if_value_guard_chain(if_node, lhs.value, info, target_name,
			target_type)
	}
	mut rhs_type := t.optional_result_expr_type_name(rhs_id)
	if !t.is_optional_type_name(rhs_type) {
		return none
	}
	rhs_type = t.qualify_optional_type(rhs_type)
	value_type := t.optional_base_type(rhs_type)
	tmp_name := t.new_temp('if_guard')
	rhs_expr := t.transform_expr(rhs_id)
	mut result := []flat.NodeId{}
	t.drain_pending(mut result)
	result << t.make_decl_assign_typed(tmp_name, rhs_expr, rhs_type)
	ok_cond := t.make_selector(t.make_ident(tmp_name), 'ok', 'bool')
	value_decl := t.make_decl_assign_typed(lhs.value, t.make_selector(t.make_ident(tmp_name),
		'value', value_type), value_type)

	saved_var_types := t.var_types.clone()
	t.set_var_type(lhs.value, value_type)
	then_id := t.a.child(&if_node, 1)
	then_block0 := t.if_value_branch_block(then_id, target_name, target_type)
	mut then_children := []flat.NodeId{cap: int(t.a.nodes[int(then_block0)].children_count) + 1}
	then_children << value_decl
	then_children << t.a.children_of(&t.a.nodes[int(then_block0)])
	then_block := t.make_block(then_children)
	t.var_types = saved_var_types

	else_id := t.a.child(&if_node, 2)
	else_node := t.a.nodes[int(else_id)]
	else_block := if else_node.kind == .if_expr {
		t.make_block(t.build_if_value_chain(else_id, target_name, target_type))
	} else {
		t.if_value_branch_block(else_id, target_name, target_type)
	}
	result << t.make_if(ok_cond, then_block, else_block)
	return result
}

// build_map_index_if_value_guard_chain supports build_map_index_if_value_guard_chain handling.
fn (mut t Transformer) build_map_index_if_value_guard_chain(if_node flat.Node, lhs_name string, info MapIndexInfo, target_name string, target_type string) []flat.NodeId {
	map_expr := t.stable_expr_for_reuse(info.base_id)
	key_name := t.new_temp('map_key')
	ptr_name := t.new_temp('map_ptr')
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	key_expr := t.transform_expr(info.key_id)
	mut result := []flat.NodeId{}
	t.drain_pending(mut result)
	result << t.make_decl_assign_typed(key_name, key_expr, info.key_type)
	result << t.make_decl_assign_typed(ptr_name, t.make_map_get_check_expr(map_expr,
		info.base_type, key_name), 'voidptr')
	ptr_ident := t.make_ident(ptr_name)
	found_cond := t.make_infix(.ne, ptr_ident, t.a.add(.nil_literal))

	saved_var_types := t.var_types.clone()
	mut then_children := []flat.NodeId{}
	if lhs_name != '_' {
		ptr_value := t.make_prefix(.mul, t.make_cast('&${info.value_type}', t.make_ident(ptr_name),
			'&${info.value_type}'))
		then_children << t.make_decl_assign_typed(lhs_name, ptr_value, info.value_type)
		t.set_var_type(lhs_name, info.value_type)
	}
	then_id := t.a.child(&if_node, 1)
	then_block0 := t.if_value_branch_block(then_id, target_name, target_type)
	then_children << t.a.children_of(&t.a.nodes[int(then_block0)])
	then_block := t.make_block(then_children)
	t.var_types = saved_var_types

	else_id := t.a.child(&if_node, 2)
	else_node := t.a.nodes[int(else_id)]
	else_block := if else_node.kind == .if_expr {
		t.make_block(t.build_if_value_chain(else_id, target_name, target_type))
	} else {
		t.if_value_branch_block(else_id, target_name, target_type)
	}
	t.pending_stmts = outer_pending
	result << t.make_if(found_cond, then_block, else_block)
	return result
}

// build_array_index_if_value_guard_chain supports build_array_index_if_value_guard_chain handling.
fn (mut t Transformer) build_array_index_if_value_guard_chain(if_node flat.Node, lhs_name string, info ArrayIndexInfo, target_name string, target_type string) []flat.NodeId {
	array_expr := t.stable_expr_for_reuse(info.base_id)
	index_name := t.new_temp('arr_idx')
	outer_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	index_expr := t.transform_expr(info.index_id)
	mut result := []flat.NodeId{}
	t.drain_pending(mut result)
	result << t.make_decl_assign_typed(index_name, index_expr, 'int')
	idx_ident := t.make_ident(index_name)
	lower_ok := t.make_infix(.ge, idx_ident, t.make_int_literal(0))
	upper_ok := t.make_infix(.lt, t.make_ident(index_name), t.make_selector(array_expr, 'len',
		'int'))
	found_cond := t.make_infix(.logical_and, lower_ok, upper_ok)

	saved_var_types := t.var_types.clone()
	mut then_children := []flat.NodeId{}
	mut opt_decl := flat.empty_node
	mut opt_name := ''
	if lhs_name != '_' {
		mut value_type := info.value_type
		mut value := t.make_index(array_expr, t.make_ident(index_name), info.value_type)
		if t.is_optional_type_name(info.value_type) {
			value_type = t.optional_base_type(t.qualify_optional_type(info.value_type))
			opt_name = t.new_temp('arr_opt')
			opt_decl = t.make_decl_assign_typed(opt_name, t.make_index(array_expr,
				t.make_ident(index_name), info.value_type), info.value_type)
			value = t.make_selector(t.make_ident(opt_name), 'value', value_type)
		}
		then_children << t.make_decl_assign_typed(lhs_name, value, value_type)
		t.set_var_type(lhs_name, value_type)
	} else if t.is_optional_type_name(info.value_type) {
		opt_name = t.new_temp('arr_opt')
		opt_decl = t.make_decl_assign_typed(opt_name, t.make_index(array_expr,
			t.make_ident(index_name), info.value_type), info.value_type)
	}
	then_id := t.a.child(&if_node, 1)
	then_block0 := t.if_value_branch_block(then_id, target_name, target_type)
	then_children << t.a.children_of(&t.a.nodes[int(then_block0)])
	then_block := t.make_block(then_children)
	t.var_types = saved_var_types

	else_id := t.a.child(&if_node, 2)
	else_node := t.a.nodes[int(else_id)]
	else_block := if else_node.kind == .if_expr {
		t.make_block(t.build_if_value_chain(else_id, target_name, target_type))
	} else {
		t.if_value_branch_block(else_id, target_name, target_type)
	}
	t.pending_stmts = outer_pending
	mut selected_block := then_block
	if t.is_optional_type_name(info.value_type) && opt_name.len > 0 {
		ok_cond := t.make_selector(t.make_ident(opt_name), 'ok', 'bool')
		inner_if := t.make_if(ok_cond, then_block, else_block)
		selected_block = t.make_block([opt_decl, inner_if])
	}
	result << t.make_if(found_cond, selected_block, else_block)
	return result
}

// if_value_branch_block supports if value branch block handling for Transformer.
fn (mut t Transformer) if_value_branch_block(branch_id flat.NodeId, target_name string, target_type string) flat.NodeId {
	if int(branch_id) < 0 {
		return t.make_block([]flat.NodeId{})
	}
	branch := t.a.nodes[int(branch_id)]
	if branch.kind == .if_expr {
		return t.make_block(t.build_if_value_chain(branch_id, target_name, target_type))
	}
	if branch.kind != .block {
		mut result := []flat.NodeId{}
		value := t.transform_if_branch_value(branch_id, target_type)
		t.drain_pending(mut result)
		result << t.make_assign(t.make_ident(target_name), value)
		return t.make_block(result)
	}
	if branch.children_count == 0 {
		return t.make_block([]flat.NodeId{})
	}

	mut stmt_ids := []flat.NodeId{cap: int(branch.children_count)}
	for i in 0 .. branch.children_count {
		stmt_ids << t.a.child(&branch, i)
	}
	mut result := []flat.NodeId{}
	if stmt_ids.len > 1 {
		for stmt in t.transform_stmts(stmt_ids[..stmt_ids.len - 1]) {
			result << stmt
		}
	}

	tail_id := stmt_ids[stmt_ids.len - 1]
	tail := t.a.nodes[int(tail_id)]
	if tail.kind == .return_stmt {
		tail_stmts := t.transform_stmt(tail_id)
		t.drain_pending(mut result)
		for stmt in tail_stmts {
			result << stmt
		}
		return t.make_block(result)
	}
	if tail.kind == .expr_stmt && tail.children_count > 0 {
		inner_id := t.a.child(&tail, 0)
		inner := t.a.nodes[int(inner_id)]
		if inner.kind == .call && t.is_noreturn_call(inner) {
			tail_stmts := t.transform_stmt(tail_id)
			t.drain_pending(mut result)
			for stmt in tail_stmts {
				result << stmt
			}
			return t.make_block(result)
		}
		if t.node_type(inner_id) == 'void' {
			tail_stmts := t.transform_stmt(tail_id)
			t.drain_pending(mut result)
			for stmt in tail_stmts {
				result << stmt
			}
			return t.make_block(result)
		}
		value := t.transform_if_branch_value(inner_id, target_type)
		t.drain_pending(mut result)
		result << t.make_assign(t.make_ident(target_name), value)
		return t.make_block(result)
	}
	if tail.kind == .block && t.stmt_value_type(tail_id).len > 0 {
		value := t.transform_if_branch_value(tail_id, target_type)
		t.drain_pending(mut result)
		result << t.make_assign(t.make_ident(target_name), value)
		return t.make_block(result)
	}
	if tail.kind == .match_stmt {
		value := t.transform_if_branch_value(tail_id, target_type)
		t.drain_pending(mut result)
		result << t.make_assign(t.make_ident(target_name), value)
		return t.make_block(result)
	}
	if tail.kind == .if_expr {
		value := t.transform_if_branch_value(tail_id, target_type)
		t.drain_pending(mut result)
		result << t.make_assign(t.make_ident(target_name), value)
		return t.make_block(result)
	}
	if t.is_stmt_kind(tail.kind) {
		tail_stmts := t.transform_stmt(tail_id)
		t.drain_pending(mut result)
		for stmt in tail_stmts {
			result << stmt
		}
		return t.make_block(result)
	}
	value := t.transform_if_branch_value(tail_id, target_type)
	t.drain_pending(mut result)
	result << t.make_assign(t.make_ident(target_name), value)
	return t.make_block(result)
}

// transform_if_branch_value transforms transform if branch value data for transform.
fn (mut t Transformer) transform_if_branch_value(id flat.NodeId, target_type string) flat.NodeId {
	if t.is_sum_type_name(target_type) {
		return t.wrap_sum_value(id, target_type)
	}
	if converted := t.fixed_array_value_to_dynamic(id, target_type) {
		return converted
	}
	return t.transform_expr_for_type(id, target_type)
}

// transform_is_condition transforms an `x is Type` condition node into the
// common sum-type tag comparison used by all C emission paths.
fn (mut t Transformer) transform_is_condition(cond_id flat.NodeId) flat.NodeId {
	if int(cond_id) < 0 {
		return cond_id
	}
	cond := t.a.nodes[int(cond_id)]
	if cond.kind != .is_expr {
		return cond_id
	}
	// is_expr: child[0] is the expression being checked, value is the type name.
	if cond.children_count < 1 {
		return cond_id
	}
	variant_name := cond.value
	if variant_name.len == 0 {
		return cond_id
	}
	return t.transform_is_expr(cond_id, cond)
}

// transform_and_chain_smartcasts handles conditions like
// `x is T && x.field > 0` where the second operand should see x
// narrowed to T through a smartcast.
//
// It walks a left-associative chain of .logical_and nodes. When a
// term is an is_expr it pushes a smartcast so subsequent terms
// (and the then-branch) see the narrowed type.
//
// Currently passes through unchanged but is structured to detect
// the pattern for future expansion.
fn (mut t Transformer) transform_and_chain_smartcasts(cond_id flat.NodeId) flat.NodeId {
	if int(cond_id) < 0 {
		return cond_id
	}
	cond := t.a.nodes[int(cond_id)]
	if cond.kind == .decl_assign {
		return t.transform_if_guard_condition(cond)
	}
	if cond.kind != .infix || cond.op !in [.logical_and, .logical_or] {
		// Not an && chain -- preserve bare smartcast checks and fully transform
		// ordinary conditions.
		if cond.kind == .is_expr {
			return t.transform_is_condition(cond_id)
		}
		return t.transform_expr(cond_id)
	}
	if cond.children_count < 2 {
		return cond_id
	}
	lhs_id := t.a.child(&cond, 0)
	rhs_id := t.a.child(&cond, 1)
	lhs := t.a.nodes[int(lhs_id)]
	new_lhs := t.transform_and_chain_smartcasts(lhs_id)
	lhs_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	lhs_smartcasts := if cond.op == .logical_and {
		t.extract_all_is_exprs(lhs_id)
	} else {
		[]IsExprInfo{}
	}
	for info in lhs_smartcasts {
		t.push_smartcast(info.expr_name, info.variant_name, info.sum_type_name)
	}
	mut new_rhs := t.transform_and_chain_smartcasts(rhs_id)
	rhs_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()
	for _ in lhs_smartcasts {
		t.pop_smartcast()
	}
	// The left operand always evaluates, so its pending statements may run before
	// the `&&`/`||`. The right operand is conditional, so any statements its
	// lowering produced (e.g. an `in [...]` / `or {}` temporary) must run only when
	// the right operand is actually reached — wrap them in a `({ ...; value; })`
	// statement-expression to preserve short-circuit evaluation.
	for stmt in lhs_pending {
		t.pending_stmts << stmt
	}
	if rhs_pending.len > 0 {
		mut block_stmts := rhs_pending.clone()
		block_stmts << t.make_expr_stmt(new_rhs)
		new_rhs = t.make_block(block_stmts)
		t.a.nodes[int(new_rhs)].typ = 'bool'
	}
	if lhs.kind == .is_expr && new_lhs == lhs_id && new_rhs == rhs_id {
		return cond_id
	}
	return t.make_infix(cond.op, new_lhs, new_rhs)
}

// transform_if_guard_condition transforms transform if guard condition data for transform.
fn (mut t Transformer) transform_if_guard_condition(node flat.Node) flat.NodeId {
	if node.kind != .decl_assign || node.children_count < 2 {
		return flat.empty_node
	}
	mut new_children := []flat.NodeId{cap: int(node.children_count)}
	for i in 0 .. node.children_count {
		child_id := t.a.child(&node, i)
		if i == 1 {
			new_children << t.transform_expr(child_id)
		} else {
			new_children << t.transform_lvalue(child_id)
		}
	}
	start := t.a.children.len
	for child in new_children {
		t.a.children << child
	}
	return t.a.add_node(flat.Node{
		kind:           .decl_assign
		op:             node.op
		children_start: start
		children_count: flat.child_count(new_children.len)
		pos:            node.pos
		value:          node.value
		typ:            node.typ
	})
}

// transform_if_branches_with_smartcast is the main if-expr handler that
// integrates smartcasting. When the condition contains an is_expr, it
// pushes a smartcast for the then-branch, transforms the body under
// that context, pops the smartcast, then transforms the else-block.
fn (mut t Transformer) transform_if_branches_with_smartcast(id flat.NodeId, node flat.Node) flat.NodeId {
	if node.kind != .if_expr || node.children_count < 2 {
		return id
	}
	cond_id := t.a.child(&node, 0)
	then_id := t.a.child(&node, 1)
	has_else := node.children_count >= 3
	else_id := if has_else { t.a.child(&node, 2) } else { flat.empty_node }

	all_is := t.extract_all_is_exprs(cond_id)
	new_cond_id := t.transform_and_chain_smartcasts(cond_id)
	cond_pending := t.pending_stmts.clone()
	t.pending_stmts.clear()

	// Transform then-block children under the smartcast context.
	saved_var_types := t.var_types.clone()
	for info in all_is {
		t.push_smartcast(info.expr_name, info.variant_name, info.sum_type_name)
	}
	then_node := t.a.nodes[int(then_id)]
	mut new_then_id := then_id
	if then_node.kind == .block {
		child_ids := t.a.children_of(&then_node)
		new_children := t.transform_stmts(child_ids)
		block_start := t.a.children.len
		for c in new_children {
			t.a.children << c
		}
		new_then_id = t.a.add_node(flat.Node{
			kind:           .block
			children_start: block_start
			children_count: flat.child_count(new_children.len)
		})
	}

	for _ in all_is {
		t.pop_smartcast()
	}
	t.var_types = saved_var_types

	// Transform else-block (no smartcast -- the is_expr was false here).
	mut new_else_id := flat.empty_node
	if has_else {
		else_node := t.a.nodes[int(else_id)]
		if else_node.kind == .if_expr {
			// else-if chain: recurse.
			new_else_id = t.transform_else_if_expr(else_id, else_node)
		} else if else_node.kind == .block {
			child_ids := t.a.children_of(&else_node)
			new_children := t.transform_stmts(child_ids)
			block_start := t.a.children.len
			for c in new_children {
				t.a.children << c
			}
			new_else_id = t.a.add_node(flat.Node{
				kind:           .block
				children_start: block_start
				children_count: flat.child_count(new_children.len)
			})
		} else {
			new_else_id = else_id
		}
	}

	// Rebuild the if_expr with (possibly) new children.
	if_start := t.a.children.len
	t.a.children << new_cond_id
	t.a.children << new_then_id
	mut child_count := 2
	if has_else {
		t.a.children << new_else_id
		child_count = 3
	}
	new_if := t.a.add_node(flat.Node{
		kind:           .if_expr
		children_start: if_start
		children_count: flat.child_count(child_count)
		typ:            node.typ
		pos:            node.pos
	})
	for pending in cond_pending {
		t.pending_stmts << pending
	}
	return new_if
}

// --- helpers ---

// IsExprInfo stores is expr info metadata used by transform.
struct IsExprInfo {
	expr_name     string
	variant_name  string
	sum_type_name string
}

// extract_all_is_exprs supports extract all is exprs handling for Transformer.
fn (t &Transformer) extract_all_is_exprs(cond_id flat.NodeId) []IsExprInfo {
	mut result := []IsExprInfo{}
	t.collect_is_exprs(cond_id, mut result)
	return result
}

// collect_is_exprs updates collect is exprs state for transform.
fn (t &Transformer) collect_is_exprs(cond_id flat.NodeId, mut result []IsExprInfo) {
	if int(cond_id) < 0 {
		return
	}
	cond := t.a.nodes[int(cond_id)]
	if cond.kind == .is_expr && cond.children_count >= 1 {
		expr_id := t.a.child(&cond, 0)
		ek := t.expr_key(expr_id)
		if ek.len > 0 && cond.value.len > 0 {
			expr_type := t.original_expr_type(expr_id)
			stn := t.sum_type_for_is_expr(expr_type, cond.value)
			if stn.len > 0 {
				result << IsExprInfo{
					expr_name:     ek
					variant_name:  cond.value
					sum_type_name: stn
				}
			} else {
				if t.is_interface_type_name(expr_type) {
					result << IsExprInfo{
						expr_name:     ek
						variant_name:  cond.value
						sum_type_name: expr_type
					}
				}
			}
		}
	}
	if cond.kind == .infix && cond.op == .logical_and && cond.children_count >= 2 {
		t.collect_is_exprs(t.a.child(&cond, 0), mut result)
		t.collect_is_exprs(t.a.child(&cond, 1), mut result)
	}
}

// extract_is_expr supports extract is expr handling for Transformer.
fn (t &Transformer) extract_is_expr(cond_id flat.NodeId) IsExprInfo {
	if int(cond_id) < 0 {
		return IsExprInfo{}
	}
	cond := t.a.nodes[int(cond_id)]
	if cond.kind == .is_expr && cond.children_count >= 1 {
		expr_id := t.a.child(&cond, 0)
		ek := t.expr_key(expr_id)
		if ek.len > 0 && cond.value.len > 0 {
			expr_type := t.original_expr_type(expr_id)
			return IsExprInfo{
				expr_name:     ek
				variant_name:  cond.value
				sum_type_name: t.sum_type_for_is_expr(expr_type, cond.value)
			}
		}
	}
	if cond.kind == .infix && cond.op == .logical_and && cond.children_count >= 2 {
		// Check left side first (is_expr is typically on the left of &&).
		lhs_id := t.a.child(&cond, 0)
		info := t.extract_is_expr(lhs_id)
		if info.expr_name.len > 0 {
			return info
		}
		// Check right side as fallback.
		rhs_id := t.a.child(&cond, 1)
		return t.extract_is_expr(rhs_id)
	}
	return IsExprInfo{}
}

// sum_type_for_is_expr supports sum type for is expr handling for Transformer.
fn (t &Transformer) sum_type_for_is_expr(expr_type string, variant string) string {
	clean_expr_type := t.trim_pointer_type(expr_type)
	resolved_expr_sum := t.resolve_sum_name(clean_expr_type)
	if resolved_expr_sum in t.sum_types {
		if _ := t.sum_variant_name(resolved_expr_sum, variant) {
			return clean_expr_type
		}
	}
	return t.find_sum_type_for_variant(variant)
}

// find_sum_type_for_variant returns the sum type name that contains
// the given variant, or '' if none is found.
fn (t &Transformer) find_sum_type_for_variant(variant string) string {
	mut best := ''
	for sum_name, variants in t.sum_types {
		for v in variants {
			if t.variant_names_match(v, variant) {
				if sum_name.contains('.') {
					return sum_name
				}
				if best.len == 0 {
					best = sum_name
				}
			}
		}
	}
	return best
}