// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.

module transformer

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

fn (t &Transformer) active_local_decl_type_for_expr(expr ast.Expr) ?types.Type {
	match expr {
		ast.Ident {
			return t.lookup_local_decl_type(expr.name)
		}
		ast.ParenExpr {
			return t.active_local_decl_type_for_expr(expr.expr)
		}
		ast.ModifierExpr {
			return t.active_local_decl_type_for_expr(expr.expr)
		}
		ast.ComptimeExpr {
			return t.active_local_decl_type_for_expr(expr.expr)
		}
		else {}
	}

	return none
}

fn (mut t Transformer) transform_expr(expr ast.Expr) ast.Expr {
	// Guard against corrupt Expr with NULL data pointer (ARM64 backend issue).
	// Default-initialized sum types have data_ptr=0, which crashes on field access.
	if !expr_has_valid_data(expr) {
		return expr
	}
	return match expr {
		ast.CallExpr {
			t.transform_call_expr(expr)
		}
		ast.CallOrCastExpr {
			t.transform_call_or_cast_expr(expr)
		}
		ast.IfExpr {
			t.transform_if_expr(expr)
		}
		ast.InfixExpr {
			t.transform_infix_expr(expr)
		}
		ast.ParenExpr {
			ast.Expr(ast.ParenExpr{
				expr: t.transform_expr(expr.expr)
				pos:  expr.pos
			})
		}
		ast.PrefixExpr {
			if expr.op == .amp {
				if pointer_cast := t.amp_type_cast_expr(expr.expr) {
					return t.transform_expr(pointer_cast)
				}
			}
			// Lower `&{base | field: val}` (AssocExpr) in the transformer so backends do not
			// need to deal with address-of rvalue compound expressions.
			if expr.op == .amp {
				if assoc := t.unwrap_assoc_expr(expr.expr) {
					return t.lower_assoc_expr(assoc, true)
				}
			}
			if expr.op == .arrow && expr.expr is ast.OrExpr {
				or_expr := expr.expr as ast.OrExpr
				return t.transform_expr(ast.Expr(ast.OrExpr{
					expr:  ast.Expr(ast.PrefixExpr{
						op:   .arrow
						expr: or_expr.expr
						pos:  expr.pos
					})
					stmts: or_expr.stmts
					pos:   or_expr.pos
				}))
			}
			ast.Expr(ast.PrefixExpr{
				op:   expr.op
				expr: t.transform_expr(expr.expr)
				pos:  expr.pos
			})
		}
		ast.PostfixExpr {
			if expr.op in [.not, .question] {
				mut inner := t.transform_expr(expr.expr)
				// For string range with `!` propagation, use checked version
				if expr.expr is ast.IndexExpr && expr.expr.expr is ast.RangeExpr
					&& t.is_string_expr(expr.expr.lhs) {
					inner = t.rename_substr_to_checked(inner)
				}
				is_native_backend := t.pref != unsafe { nil } && t.is_native_be
				if is_native_backend {
					return ast.Expr(ast.PostfixExpr{
						op:   expr.op
						expr: inner
						pos:  expr.pos
					})
				}
				// Non-SSA backends still lower `expr!`/`expr?` in the transformer.
				// Keep codegen valid by converting them to a cast of the underlying
				// result/option expression to the checker-inferred value type.
				mut type_name := ''
				if inner_type := t.get_expr_type(expr.expr) {
					match inner_type {
						types.ResultType {
							type_name = t.type_to_c_name(inner_type.base_type)
						}
						types.OptionType {
							type_name = t.type_to_c_name(inner_type.base_type)
						}
						else {}
					}
				}
				if type_name == '' {
					if typ := t.get_expr_type(expr) {
						type_name = t.type_to_c_name(typ)
					}
				}
				if type_name != '' {
					return ast.CastExpr{
						typ:  ast.Expr(ast.Ident{
							name: type_name
						})
						expr: inner
					}
				}
				inner
			} else {
				ast.Expr(ast.PostfixExpr{
					op:   expr.op
					expr: t.transform_expr(expr.expr)
					pos:  expr.pos
				})
			}
		}
		ast.CastExpr {
			// Casts to sum types must be lowered to explicit sum type initialization,
			// since C does not allow casting a variant struct to the sum type struct.
			sumtype_name := t.type_expr_name_full(expr.typ)
			if sumtype_name != '' && t.is_sum_type(sumtype_name) {
				if wrapped := t.wrap_sumtype_value(expr.expr, sumtype_name) {
					return wrapped
				}
			}
			ast.Expr(ast.CastExpr{
				typ:  expr.typ
				expr: t.transform_expr(expr.expr)
				pos:  expr.pos
			})
		}
		ast.IndexExpr {
			t.transform_index_expr(expr)
		}
		ast.ArrayInitExpr {
			t.transform_array_init_expr(expr)
		}
		ast.MapInitExpr {
			t.transform_map_init_expr(expr)
		}
		ast.SqlExpr {
			t.transform_sql_expr(expr)
		}
		ast.MatchExpr {
			t.transform_match_expr(expr)
		}
		ast.ComptimeExpr {
			t.transform_comptime_expr(expr)
		}
		ast.InitExpr {
			t.transform_init_expr(expr)
		}
		ast.UnsafeExpr {
			// Normalize `unsafe { nil }` to plain `nil`.
			// This keeps pointer-null semantics and avoids backend-specific null lowering bugs.
			if t.is_unsafe_nil_expr(expr) {
				ast.Expr(ast.Ident{
					name: 'nil'
					pos:  expr.pos
				})
			} else {
				ast.Expr(ast.UnsafeExpr{
					stmts: t.transform_stmts(expr.stmts)
				})
			}
		}
		ast.LockExpr {
			// Lower to mutex lock/unlock calls wrapped in UnsafeExpr (compound expression)
			mut stmts := t.expand_lock_expr(expr)
			// When used as a value expression (GCC compound expr), the last statement's
			// value is returned. But the unlock calls come after the body, making the
			// compound expr return void. Fix: duplicate the value-producing statement
			// (last body stmt) after the unlock calls so it becomes the final expression.
			n_unlocks := expr.lock_exprs.len + expr.rlock_exprs.len
			if n_unlocks > 0 && stmts.len > n_unlocks {
				body_end := stmts.len - n_unlocks
				stmts << stmts[body_end - 1]
			}
			ast.Expr(ast.UnsafeExpr{
				stmts: stmts
			})
		}
		ast.AssocExpr {
			t.lower_assoc_expr(expr, false)
		}
		ast.FieldInit {
			// Transform the value inside field initializations (e.g., fn(name: expr))
			ast.Expr(ast.FieldInit{
				name:  expr.name
				value: t.transform_expr(expr.value)
			})
		}
		ast.SelectorExpr {
			t.transform_selector_expr(expr)
		}
		ast.Ident {
			if expr.name == '@VMODROOT' {
				return ast.Expr(t.vmodroot_string_literal(expr.pos))
			}
			// Check for smart cast on simple identifiers (e.g., if x is Type { x })
			if ctx := t.find_smartcast_for_expr(expr.name) {
				return t.apply_smartcast_direct_ctx(expr, ctx)
			}
			ast.Expr(expr)
		}
		ast.StringInterLiteral {
			// Transform interpolations, applying smart cast if needed
			t.transform_string_inter_literal(expr)
		}
		ast.AsCastExpr {
			// Keep explicit `as` casts as casts. A same-expression smartcast can
			// otherwise rewrite the operand into a direct sum payload access and hide
			// the original storage type from the backend, which is wrong for nested
			// sum types like Expr(Type(ArrayFixedType)).
			expr_key := t.expr_to_string(expr.expr)
			saved_smartcast_stack := t.smartcast_stack.clone()
			saved_smartcast_expr_counts := t.smartcast_expr_counts.clone()
			for _ in 0 .. smartcast_search_limit {
				if _ := t.remove_smartcast_for_expr(expr_key) {
					continue
				}
				break
			}
			transformed_inner := t.transform_expr(expr.expr)
			t.smartcast_stack = saved_smartcast_stack.clone()
			t.smartcast_expr_counts = saved_smartcast_expr_counts.clone()
			ast.Expr(ast.AsCastExpr{
				expr: transformed_inner
				typ:  expr.typ
				pos:  expr.pos
			})
		}
		ast.OrExpr {
			// OrExpr in expression context (e.g., nested, in return, in for-loop condition)
			mut prefix_stmts := []ast.Stmt{}
			result_expr := t.expand_single_or_expr(expr, mut prefix_stmts)
			if prefix_stmts.len > 0 {
				// Wrap in UnsafeExpr — cleanc emits as GCC compound expression ({ ... })
				prefix_stmts << ast.ExprStmt{
					expr: result_expr
				}
				ast.Expr(ast.UnsafeExpr{
					stmts: prefix_stmts
				})
			} else {
				result_expr
			}
		}
		ast.IfGuardExpr {
			// IfGuardExpr should only appear as IfExpr condition, handled by transform_if_expr.
			// If it somehow reaches here standalone, just evaluate the RHS.
			if expr.stmt.rhs.len > 0 {
				return t.transform_expr(expr.stmt.rhs[0])
			}
			expr
		}
		ast.GenericArgs {
			// typeof[T] — keep as-is so typeof[T]().name can be resolved later
			if t.is_typeof_generic_args(expr) {
				return expr
			}
			// Disambiguate `x[y]` parsed as GenericArgs: if lhs is not callable and there
			// is a single argument, this is an index expression.
			if expr.args.len == 1 {
				if lhs_type := t.get_expr_type(expr.lhs) {
					if !t.is_callable_type(lhs_type) {
						return t.transform_index_expr(ast.IndexExpr{
							lhs:      expr.lhs
							expr:     expr.args[0]
							is_gated: false
							pos:      expr.pos
						})
					}
				}
			}
			// Keep selectors as selectors so module and method calls still lower
			// through the normal call paths after specialization.
			t.specialize_generic_callable_expr(expr.lhs, expr.args, expr.pos)
		}
		ast.GenericArgOrIndexExpr {
			// Disambiguate parser ambiguity `x[y]`:
			// - callable lhs => generic arg specialization token (`x_T`)
			// - otherwise => normal index expression
			if lhs_type := t.get_expr_type(expr.lhs) {
				if t.is_callable_type(lhs_type) {
					return t.specialize_generic_callable_expr(expr.lhs, [expr.expr], expr.pos)
				}
			}
			return t.transform_index_expr(ast.IndexExpr{
				lhs:      expr.lhs
				expr:     expr.expr
				is_gated: false
				pos:      expr.pos
			})
		}
		ast.ModifierExpr {
			ast.Expr(ast.ModifierExpr{
				kind: expr.kind
				expr: t.transform_expr(expr.expr)
				pos:  expr.pos
			})
		}
		ast.FnLiteral {
			ast.Expr(ast.FnLiteral{
				typ:           expr.typ
				captured_vars: expr.captured_vars
				stmts:         t.transform_stmts(expr.stmts)
				pos:           expr.pos
			})
		}
		ast.LambdaExpr {
			ast.Expr(ast.LambdaExpr{
				args: expr.args
				expr: t.transform_expr(expr.expr)
				pos:  expr.pos
			})
		}
		ast.KeywordOperator {
			if expr.op == .key_typeof && expr.exprs.len > 0 {
				type_name := t.resolve_typeof_expr(expr.exprs[0])
				if type_name != '' {
					return ast.StringLiteral{
						kind:  .v
						value: quote_v_string_literal(type_name)
						pos:   expr.pos
					}
				}
			}
			if expr.op == .key_go && expr.exprs.len > 0 {
				return t.lower_go_call(expr)
			}
			ast.Expr(expr)
		}
		else {
			expr
		}
	}
}

fn (t &Transformer) amp_type_cast_expr(expr ast.Expr) ?ast.Expr {
	match expr {
		ast.IndexExpr {
			if expr.lhs !is ast.CallOrCastExpr {
				return none
			}
			cast_lhs := expr.lhs as ast.CallOrCastExpr
			if !t.call_or_cast_lhs_is_type(cast_lhs.lhs) {
				return none
			}
			return ast.IndexExpr{
				lhs:      ast.CastExpr{
					typ:  ast.PrefixExpr{
						op:   .amp
						expr: cast_lhs.lhs
						pos:  cast_lhs.pos
					}
					expr: cast_lhs.expr
					pos:  cast_lhs.pos
				}
				expr:     expr.expr
				is_gated: expr.is_gated
				pos:      expr.pos
			}
		}
		ast.SelectorExpr {
			if expr.lhs !is ast.CallOrCastExpr {
				return none
			}
			cast_lhs := expr.lhs as ast.CallOrCastExpr
			if !t.call_or_cast_lhs_is_type(cast_lhs.lhs) {
				return none
			}
			return ast.SelectorExpr{
				lhs: ast.CastExpr{
					typ:  ast.PrefixExpr{
						op:   .amp
						expr: cast_lhs.lhs
						pos:  cast_lhs.pos
					}
					expr: cast_lhs.expr
					pos:  cast_lhs.pos
				}
				rhs: expr.rhs
				pos: expr.pos
			}
		}
		else {
			return none
		}
	}
}

// is_typeof_generic_args checks if a GenericArgs node is typeof[T]
// without using an `is` check that would trigger smartcast narrowing.
fn (t &Transformer) is_typeof_generic_args(ga ast.GenericArgs) bool {
	return ga.lhs.name() == 'typeof'
}

fn (t &Transformer) resolve_typeof_generic_arg_type_name(arg ast.Expr) string {
	type_name_from_expr := t.resolve_typeof_expr(arg)
	if type_name_from_expr != '' {
		return type_name_from_expr
	}
	type_name := t.expr_to_type_name(arg)
	if type_name == '' {
		return ''
	}
	return c_name_to_v_name(type_name)
}

fn (t &Transformer) resolve_specialized_typeof_call_type_name(call_name string) string {
	marker := 'typeof_T_'
	idx := call_name.index(marker) or { return '' }
	type_name := call_name[idx + marker.len..]
	if type_name == '' {
		return ''
	}
	return c_name_to_v_name(type_name)
}

fn (t &Transformer) resolve_typeof_call_lhs_type_name(lhs ast.Expr) string {
	if lhs is ast.GenericArgs {
		if t.is_typeof_generic_args(lhs) && lhs.args.len > 0 {
			return t.resolve_typeof_generic_arg_type_name(lhs.args[0])
		}
	}
	if lhs is ast.GenericArgOrIndexExpr {
		if lhs.lhs.name() == 'typeof' {
			return t.resolve_typeof_generic_arg_type_name(lhs.expr)
		}
	}
	if lhs is ast.Ident {
		return t.resolve_specialized_typeof_call_type_name(lhs.name)
	}
	return ''
}

fn typeof_selector_result(type_name string, selector string, pos token.Pos) ?ast.Expr {
	if type_name == '' {
		return none
	}
	if selector == 'idx' {
		return ast.Expr(typeof_idx_literal(type_name, pos))
	}
	if selector == 'name' {
		return ast.Expr(ast.StringLiteral{
			kind:  .v
			value: quote_v_string_literal(type_name)
			pos:   pos
		})
	}
	return none
}

fn (mut t Transformer) transform_index_expr(expr ast.IndexExpr) ast.Expr {
	// Lower slices in transformer so backends do not need slice-specific type logic.
	if expr.expr is ast.RangeExpr {
		lhs := t.transform_expr(expr.lhs)
		return t.transform_slice_index_expr(lhs, expr.lhs, expr.expr, expr.is_gated)
	}

	// Keep gated indexing as-is (`arr#[i]`).
	if expr.is_gated {
		return ast.IndexExpr{
			lhs:      t.transform_expr(expr.lhs)
			expr:     t.transform_expr(expr.expr)
			is_gated: expr.is_gated
			pos:      expr.pos
		}
	}

	// Lower map reads `m[key]` to `map__get(&m, &key, &zero)` in transformer so backends
	// do not need map-specific IndexExpr logic.
	mut map_expr_type_opt := t.map_index_lhs_type(expr.lhs)
	if map_expr_type_opt == none && expr.lhs is ast.Ident {
		map_expr_type_opt = t.lookup_var_type((expr.lhs as ast.Ident).name)
	}
	if map_expr_typ := map_expr_type_opt {
		if map_type := t.unwrap_map_type(map_expr_typ) {
			if t.is_eval_backend() {
				return ast.IndexExpr{
					lhs:      t.transform_expr(expr.lhs)
					expr:     t.transform_expr(expr.expr)
					is_gated: expr.is_gated
					pos:      expr.pos
				}
			}
			mut stmts := []ast.Stmt{}

			// Map arg: map__get expects a pointer to the map.
			map_arg := t.map_expr_to_runtime_ptr(expr.lhs, map_expr_typ, map_type)

			// Key temp (so we can take its address safely for the duration of the whole expression).
			key_tmp := t.gen_temp_name()
			key_ident := t.typed_temp_ident(key_tmp, map_type.key_type)
			mut key_lhs := []ast.Expr{cap: 1}
			key_lhs << ast.Expr(key_ident)
			mut key_rhs := []ast.Expr{cap: 1}
			key_rhs << t.transform_expr(expr.expr)
			stmts << ast.Stmt(ast.AssignStmt{
				op:  .decl_assign
				lhs: key_lhs
				rhs: key_rhs
				pos: key_ident.pos
			})

			// Zero/default temp.
			zero_tmp := t.gen_temp_name()
			zero_ident := t.typed_temp_ident(zero_tmp, map_type.value_type)
			mut zero_lhs := []ast.Expr{cap: 1}
			zero_lhs << ast.Expr(zero_ident)
			mut zero_rhs := []ast.Expr{cap: 1}
			zero_rhs << t.zero_value_expr_for_type(map_type.value_type)
			stmts << ast.Stmt(ast.AssignStmt{
				op:  .decl_assign
				lhs: zero_lhs
				rhs: zero_rhs
				pos: zero_ident.pos
			})

			get_call := ast.CallExpr{
				lhs:  ast.Ident{
					name: 'map__get'
				}
				args: [
					map_arg,
					t.voidptr_cast(ast.Expr(ast.PrefixExpr{
						op:   .amp
						expr: key_ident
					})),
					t.voidptr_cast(ast.Expr(ast.PrefixExpr{
						op:   .amp
						expr: zero_ident
					})),
				]
			}
			cast_ptr_type := ast.Expr(ast.PrefixExpr{
				op:   .amp
				expr: t.type_to_ast_type_expr(map_type.value_type)
			})
			deref_pos := t.next_synth_pos()
			t.register_synth_type(deref_pos, map_type.value_type)
			typed_ptr := ast.Expr(ast.CastExpr{
				typ:  cast_ptr_type
				expr: get_call
			})
			deref_expr := ast.Expr(ast.PrefixExpr{
				op:   .mul
				expr: typed_ptr
				pos:  deref_pos
			})
			stmts << ast.Stmt(ast.ExprStmt{
				expr: ast.Expr(ast.ParenExpr{
					expr: deref_expr
					pos:  deref_pos
				})
			})

			return ast.Expr(ast.UnsafeExpr{
				stmts: stmts
				pos:   deref_pos
			})
		}
	}

	return ast.IndexExpr{
		lhs:      t.transform_expr(expr.lhs)
		expr:     t.transform_expr(expr.expr)
		is_gated: expr.is_gated
		pos:      expr.pos
	}
}

// is_simple_slice_bound reports whether a slice bound expression is free of
// side effects and cheap enough to reference more than once (so a fixed-array
// slice can inline it instead of binding it to a temp).
fn is_simple_slice_bound(e ast.Expr) bool {
	return match e {
		ast.BasicLiteral { true }
		ast.Ident { true }
		ast.SelectorExpr { is_simple_slice_bound(e.lhs) }
		ast.ParenExpr { is_simple_slice_bound(e.expr) }
		else { false }
	}
}

fn (mut t Transformer) transform_slice_index_expr(lhs ast.Expr, orig_lhs ast.Expr, range ast.RangeExpr, _is_gated bool) ast.Expr {
	start_expr := if range.start is ast.EmptyExpr {
		ast.Expr(ast.BasicLiteral{
			kind:  .number
			value: '0'
		})
	} else {
		t.transform_expr(range.start)
	}

	// Build end expression for lowering target calls:
	// `a..b` -> b, `a...b` -> b + 1, `a..` -> lhs.len.
	mut end_expr := ast.Expr(ast.empty_expr)
	if range.end is ast.EmptyExpr {
		end_expr = t.synth_selector(lhs, 'len', types.Type(types.int_))
	} else {
		end_expr = t.transform_expr(range.end)
		if range.op == .ellipsis {
			end_expr = ast.Expr(ast.InfixExpr{
				op:  .plus
				lhs: end_expr
				rhs: ast.BasicLiteral{
					kind:  .number
					value: '1'
				}
			})
		}
	}
	string_end_expr := if range.end is ast.EmptyExpr {
		ast.Expr(ast.BasicLiteral{
			kind:  .number
			value: '2147483647'
		})
	} else {
		end_expr
	}
	array_slice_fn_name := if range.end is ast.EmptyExpr {
		'array__slice_ni'
	} else {
		'array__slice'
	}

	// Prefer semantic string detection over position-based type tags.
	// Expression positions are often shared with parent index/slice nodes,
	// which can incorrectly stamp the source as array-like.
	if t.is_string_expr(orig_lhs) || t.is_string_expr(lhs) {
		return ast.CallExpr{
			lhs:  ast.Ident{
				name: 'string__substr'
			}
			args: [lhs, start_expr, string_end_expr]
		}
	}

	if lhs_type := t.get_expr_type(orig_lhs) {
		match lhs_type {
			types.String {
				return ast.CallExpr{
					lhs:  ast.Ident{
						name: 'string__substr'
					}
					args: [lhs, start_expr, string_end_expr]
				}
			}
			types.Alias {
				if lhs_type.name == 'string' || lhs_type.base_type is types.String {
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: 'string__substr'
						}
						args: [lhs, start_expr, string_end_expr]
					}
				}
			}
			types.Array {
				return ast.CallExpr{
					lhs:  ast.Ident{
						name: array_slice_fn_name
					}
					args: [lhs, start_expr, end_expr]
				}
			}
			types.ArrayFixed {
				elem_c_name := lhs_type.elem_type.name()
				// For a fixed array the default high bound (`a[..]`) is the
				// compile-time length, not a runtime `.len` selector. Emitting
				// the selector (`u.b.len`) leaves cleanc unable to type the
				// bound temp and it falls back to the fixed-array type, which
				// then breaks the `new_array_from_c_array` pointer arithmetic.
				fixed_end_expr := if range.end is ast.EmptyExpr {
					ast.Expr(ast.BasicLiteral{
						kind:  .number
						value: lhs_type.len.str()
					})
				} else {
					end_expr
				}
				sizeof_expr := ast.Expr(ast.KeywordOperator{
					op:    .key_sizeof
					exprs: [
						ast.Expr(ast.Ident{
							name: elem_c_name
						}),
					]
				})
				// When both bounds are side-effect free we can reference them
				// directly: `new_array_from_c_array(end - start, end - start,
				// sizeof(T), &a[start])`. This avoids emitting bound temps,
				// which the cleanc backend can mis-type as the fixed-array type
				// (turning `end - start` into pointer arithmetic on a struct).
				if is_simple_slice_bound(start_expr) && is_simple_slice_bound(fixed_end_expr) {
					len_expr := ast.Expr(ast.InfixExpr{
						op:  .minus
						lhs: fixed_end_expr
						rhs: start_expr
					})
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: 'new_array_from_c_array'
						}
						args: [
							len_expr,
							len_expr,
							sizeof_expr,
							ast.Expr(ast.PrefixExpr{
								op:   .amp
								expr: ast.IndexExpr{
									lhs:  lhs
									expr: start_expr
								}
							}),
						]
					}
				}
				// Complex bounds (calls, arithmetic, ...) must be evaluated once,
				// so bind them to typed temps before the slice call.
				start_ident := t.gen_typed_temp_ident(types.Type(types.int_))
				end_ident := t.gen_typed_temp_ident(types.Type(types.int_))
				len_expr := ast.Expr(ast.InfixExpr{
					op:  .minus
					lhs: ast.Expr(end_ident)
					rhs: ast.Expr(start_ident)
				})
				slice_call := ast.Expr(ast.CallExpr{
					lhs:  ast.Ident{
						name: 'new_array_from_c_array'
					}
					args: [
						len_expr,
						len_expr,
						sizeof_expr,
						ast.Expr(ast.PrefixExpr{
							op:   .amp
							expr: ast.IndexExpr{
								lhs:  lhs
								expr: ast.Expr(start_ident)
							}
						}),
					]
				})
				return ast.UnsafeExpr{
					stmts: [
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [ast.Expr(start_ident)]
							rhs: [start_expr]
							pos: start_ident.pos
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [ast.Expr(end_ident)]
							rhs: [fixed_end_expr]
							pos: end_ident.pos
						}),
						ast.Stmt(ast.ExprStmt{
							expr: slice_call
						}),
					]
				}
			}
			types.Pointer {
				if lhs_type.base_type is types.Array {
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: array_slice_fn_name
						}
						args: [
							ast.Expr(ast.PrefixExpr{
								op:   .mul
								expr: lhs
							}),
							start_expr,
							end_expr,
						]
					}
				}
			}
			else {}
		}
	}
	// Fallback when env type lookup misses selector/if-guard positions.
	if t.infer_expr_type(orig_lhs) == 'string' {
		return ast.CallExpr{
			lhs:  ast.Ident{
				name: 'string__substr'
			}
			args: [lhs, start_expr, string_end_expr]
		}
	}

	// Type lookup failed; default to array__slice (most common case).
	return ast.CallExpr{
		lhs:  ast.Ident{
			name: array_slice_fn_name
		}
		args: [lhs, start_expr, end_expr]
	}
}

// transform_selector_expr transforms a selector expression, applying smart cast if applicable
fn (mut t Transformer) transform_selector_expr(expr ast.SelectorExpr) ast.Expr {
	// typeof(x).name -> string literal with V type name
	if expr.lhs is ast.KeywordOperator && expr.lhs.op == .key_typeof
		&& expr.rhs.name in ['name', 'idx'] {
		if expr.lhs.exprs.len > 0 {
			type_name := t.resolve_typeof_expr(expr.lhs.exprs[0])
			if result := typeof_selector_result(type_name, expr.rhs.name, expr.pos) {
				return result
			}
		}
	}
	// typeof[T]().name -> string literal with V type name
	// Parser creates: SelectorExpr{lhs: CallExpr{lhs: GenericArgs{lhs: Ident{"typeof"}, args: [T]}}, rhs: "name"}
	if expr.rhs.name in ['name', 'idx'] && expr.lhs is ast.CallExpr {
		call := expr.lhs as ast.CallExpr
		type_name := t.resolve_typeof_call_lhs_type_name(call.lhs)
		if result := typeof_selector_result(type_name, expr.rhs.name, expr.pos) {
			return result
		}
	}
	if expr.rhs.name in ['name', 'idx'] && expr.lhs is ast.CallOrCastExpr {
		call := expr.lhs as ast.CallOrCastExpr
		if call.expr is ast.EmptyExpr {
			type_name := t.resolve_typeof_call_lhs_type_name(call.lhs)
			if result := typeof_selector_result(type_name, expr.rhs.name, expr.pos) {
				return result
			}
		}
	}
	// Generated sumtype representation fields already have their base expression
	// lowered. Do not apply smartcasts to them again on a later transform pass.
	if expr.rhs.name in ['_tag', '_data'] || (expr.rhs.name.starts_with('_')
		&& expr.lhs is ast.SelectorExpr && (expr.lhs as ast.SelectorExpr).rhs.name == '_data') {
		return ast.Expr(expr)
	}
	// Check for smart cast field access: check ALL contexts in the stack
	if t.has_active_smartcast() {
		full_str := t.expr_to_string(expr)
		// First check if the ENTIRE selector matches a direct smartcast context
		// This handles cases like `sel := rhs_expr.lhs` inside `if rhs_expr.lhs is SelectorExpr`
		if direct_ctx := t.find_smartcast_for_expr(full_str) {
			// Direct access to smartcast variable - apply direct smartcast
			return t.apply_smartcast_direct_ctx(expr, direct_ctx)
		}
		// Check if LHS matches any smartcast context for field access
		lhs_str := t.expr_to_string(expr.lhs)
		if ctx := t.find_smartcast_for_expr(lhs_str) {
			// This is a field access on the smartcast variable
			// e.g., w.valera.len when w.valera is smartcast to string
			return t.apply_smartcast_field_access_ctx(expr.lhs, expr.rhs.name, ctx)
		}
	}
	if expr.lhs is ast.Ident && expr.lhs.name == 'os' && expr.rhs.name == 'args' {
		return ast.CallExpr{
			lhs: ast.Ident{
				name: 'arguments'
				pos:  expr.pos
			}
			pos: expr.pos
		}
	}
	// Handle module-qualified enum value access: module.EnumType.value -> module__EnumType__value
	// Also handle nested module references: rand.seed.time_seed_array -> seed__time_seed_array
	if expr.lhs is ast.SelectorExpr {
		lhs_sel := expr.lhs as ast.SelectorExpr
		if lhs_sel.lhs is ast.Ident {
			module_name := lhs_sel.lhs.name
			type_name := lhs_sel.rhs.name
			qualified := '${module_name}__${type_name}'
			if typ := t.lookup_type(qualified) {
				if typ is types.Enum {
					t.register_synth_type(expr.pos, typ)
					return ast.Ident{
						name: t.enum_member_ident_for_lookup(qualified, typ, expr.rhs.name)
						pos:  expr.pos
					}
				}
			}
			// Nested module reference: rand.seed.time_seed_array -> seed__time_seed_array
			// Only resolve when both the outer ident is a module AND the inner name
			// is also a sub-module (not a variable like os.args.len).
			if t.is_module_ident(module_name) {
				sub_mod := lhs_sel.rhs.name
				fn_name := expr.rhs.name
				// Check if sub_mod is actually a module scope
				if t.get_module_scope(sub_mod) != none {
					return ast.Ident{
						name: '${sub_mod}__${fn_name}'
						pos:  expr.pos
					}
				}
				// Try full qualified name (module__sub_mod as scope key)
				full_mod := '${module_name}__${sub_mod}'
				if t.get_module_scope(full_mod) != none {
					return ast.Ident{
						name: '${full_mod}__${fn_name}'
						pos:  expr.pos
					}
				}
			}
		}
	}
	// Handle same-module enum access: Op.identify -> discord__Op__identify
	if expr.lhs is ast.Ident {
		lhs_name := expr.lhs.name
		// Check if LHS is an enum type in the current module
		qualified := if t.cur_module != '' && t.cur_module != 'main' && t.cur_module != 'builtin'
			&& !lhs_name.contains('__') {
			'${t.cur_module}__${lhs_name}'
		} else {
			lhs_name
		}
		if typ := t.lookup_type(qualified) {
			if typ is types.Enum {
				t.register_synth_type(expr.pos, typ)
				return ast.Ident{
					name: t.enum_member_ident_for_lookup(qualified, typ, expr.rhs.name)
					pos:  expr.pos
				}
			}
		}
	}
	// Default transformation
	return ast.SelectorExpr{
		lhs: t.transform_expr(expr.lhs)
		rhs: expr.rhs
		pos: expr.pos
	}
}

// transform_string_inter_literal transforms string interpolations, applying smart cast where needed
fn (mut t Transformer) transform_match_expr(expr ast.MatchExpr) ast.Expr {
	match_expr, branches := t.transform_match_expr_parts(expr)
	return t.lower_match_expr_to_if(match_expr, branches)
}

fn sumtype_match_variant_base_name(name string) string {
	c_name := name.replace('.', '__')
	if bracket_idx := c_name.index('[') {
		return c_name[..bracket_idx]
	}
	return c_name
}

fn sumtype_match_generic_base_is_unique(sumtype_name string, variants []string, base_variant string) bool {
	mut matches := 0
	for variant in variants {
		if sum_type_variant_matches_for_sumtype(sumtype_name,
			sumtype_match_variant_base_name(variant), base_variant)
		{
			matches++
			if matches > 1 {
				return false
			}
		}
	}
	return matches == 1
}

fn (t &Transformer) generic_match_branch_variant_info(lhs ast.Expr, args []ast.Expr) (string, string, string, bool) {
	base_name := t.type_expr_name(lhs)
	if base_name == '' {
		return '', '', '', false
	}
	base_full := t.type_expr_name_full(lhs)
	suffix := t.generic_specialization_suffix(args)
	variant_full := if base_full != '' && suffix != '' { base_full + suffix } else { base_full }
	variant_module := if base_full.contains('__') {
		base_full.all_before_last('__')
	} else {
		''
	}
	return base_name, variant_full, variant_module, true
}

fn (t &Transformer) match_branch_variant_info(c ast.Expr) (string, string, string, bool, bool) {
	if c is ast.Ident {
		c_variant_name := c.name
		c_variant_name_full := if t.cur_module != '' && t.cur_module != 'main'
			&& t.cur_module != 'builtin'
			&& c.name !in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'byte', 'rune', 'f32', 'f64', 'usize', 'isize', 'bool', 'string', 'voidptr', 'charptr', 'byteptr'] {
			'${t.cur_module}__${c.name}'
		} else {
			c.name
		}
		return c_variant_name, c_variant_name_full, '', false, c_variant_name != ''
	}
	if c is ast.SelectorExpr {
		c_variant_name := c.rhs.name
		c_variant_name_full := t.type_expr_name_full(c)
		c_variant_module := if c_variant_name_full.contains('__') {
			c_variant_name_full.all_before_last('__')
		} else {
			''
		}
		return c_variant_name, c_variant_name_full, c_variant_module, false, c_variant_name != ''
	}
	if c is ast.Type {
		if c is ast.GenericType {
			c_variant_name, c_variant_name_full, c_variant_module, _ := t.generic_match_branch_variant_info(c.name,
				c.params)
			return c_variant_name, c_variant_name_full, c_variant_module, true, c_variant_name != ''
		}
		c_variant_name := t.type_variant_name(c)
		return c_variant_name, t.type_variant_name_full(c), '', false, c_variant_name != ''
	}
	if c is ast.GenericArgs {
		c_variant_name, c_variant_name_full, c_variant_module, _ := t.generic_match_branch_variant_info(c.lhs,
			c.args)
		return c_variant_name, c_variant_name_full, c_variant_module, true, c_variant_name != ''
	}
	if c is ast.GenericArgOrIndexExpr {
		c_variant_name, c_variant_name_full, c_variant_module, _ := t.generic_match_branch_variant_info(c.lhs, [
			c.expr,
		])
		return c_variant_name, c_variant_name_full, c_variant_module, true, c_variant_name != ''
	}
	return '', '', '', false, false
}

// transform_match_expr_parts returns the two inputs to `lower_match_expr_to_if`
// — the transformed match expression (either `_tag` access for sumtype matches
// or the plain transformed `expr.expr` for non-sumtype matches) and the
// transformed branch list. The flat-write arm calls this directly + then
// invokes `lower_match_expr_to_if_flat` to skip every nested IfExpr wrapper-
// struct allocation in the lowered chain. The legacy `transform_match_expr`
// above wraps it for non-flat callers via `lower_match_expr_to_if`. Same
// `_parts` extraction template as `transform_return_stmt_parts` (session 59)
// and `transform_assign_stmt_parts` (session 60).
fn (mut t Transformer) transform_match_expr_parts(expr ast.MatchExpr) (ast.Expr, []ast.MatchBranch) {
	// Check if matching on a sum type
	mut sumtype_name := t.get_sumtype_name_for_expr(expr.expr)
	smartcast_expr := t.expr_to_string(expr.expr)

	// Verify that it's actually a sum type match by checking branch conditions.
	// If conditions are string/number literals, it's NOT a sum type match even if
	// the expression type looks like a sum type.
	if sumtype_name != '' && expr.branches.len > 0 {
		first_branch := expr.branches[0]
		if first_branch.cond.len > 0 {
			first_cond := first_branch.cond[0]
			if first_cond is ast.BasicLiteral || first_cond is ast.StringLiteral
				|| first_cond is ast.StringInterLiteral {
				sumtype_name = ''
			}
		}
	}

	if sumtype_name != '' {
		// Sum type match - set up smartcast context for each branch
		variants := t.get_sum_type_variants(sumtype_name)

		mut branches := []ast.MatchBranch{cap: expr.branches.len}
		for branch in expr.branches {
			if branch.cond.len > 0 {
				mut cond_tags := []int{cap: branch.cond.len}
				mut cond_variants := []string{cap: branch.cond.len}
				mut cond_variants_full := []string{cap: branch.cond.len}
				mut can_split_branch := true

				for c in branch.cond {
					c_variant_name, c_variant_name_full, c_variant_module, c_variant_is_generic, ok :=
						t.match_branch_variant_info(c)
					if !ok {
						can_split_branch = false
						break
					}

					qualified_variant := if c_variant_module != ''
						&& !c_variant_name.starts_with('Array_')
						&& !c_variant_name.starts_with('Map_') {
						'${c_variant_module}__${c_variant_name}'
					} else {
						c_variant_name
					}
					qualified_variant_full := if c_variant_name_full != ''
						&& c_variant_name_full != c_variant_name {
						c_variant_name_full
					} else if c_variant_module != '' {
						'${c_variant_module}__${c_variant_name}'
					} else {
						c_variant_name
					}

					mut c_tag := -1
					for i, v in variants {
						if c_variant_is_generic
							&& sum_type_variant_matches_for_sumtype(sumtype_name, v, qualified_variant_full) {
							c_tag = i
							break
						}
						if sum_type_variant_matches_for_sumtype(sumtype_name, v, qualified_variant) {
							c_tag = i
							break
						}
						if c_variant_is_generic
							&& sumtype_match_generic_base_is_unique(sumtype_name, variants, qualified_variant)
							&& sum_type_variant_matches_for_sumtype(sumtype_name, sumtype_match_variant_base_name(v), qualified_variant) {
							c_tag = i
							break
						}
						// Handle array variant matching:
						// c_variant_name is 'Array_Attribute' or 'Array_ast__Attribute' (C format)
						// v is '[]Attribute' or '[]ast__Attribute' (V format from types.Array.name())
						if c_variant_name.starts_with('Array_') && v.starts_with('[]') {
							c_elem := c_variant_name[6..] // Strip 'Array_'
							v_elem := v[2..] // Strip '[]'
							c_elem_short := if c_elem.contains('__') {
								c_elem.all_after_last('__')
							} else {
								c_elem
							}
							v_elem_short := if v_elem.contains('__') {
								v_elem.all_after_last('__')
							} else {
								v_elem
							}
							if c_elem == v_elem || c_elem_short == v_elem_short {
								c_tag = i
								break
							}
						}
						// Handle fixed array variant matching
						if c_variant_name.starts_with('Array_fixed_') && v.starts_with('[') {
							// TODO: implement fixed array matching if needed
						}
						// Handle map variant matching
						if c_variant_name.starts_with('Map_') && v.starts_with('map[') {
							// TODO: implement map matching if needed
						}
					}

					if c_tag < 0 {
						can_split_branch = false
						break
					}
					cond_tags << c_tag
					cond_variants << if c_variant_is_generic && qualified_variant_full != '' {
						qualified_variant_full
					} else {
						qualified_variant
					}
					cond_variants_full << qualified_variant_full
				}

				if can_split_branch && cond_tags.len > 0 {
					// When a branch has multiple sum variants, each condition needs its own
					// smartcast context. Splitting preserves correct dispatch in branch bodies.
					for i, c_tag in cond_tags {
						smartcast_stack_before := t.smartcast_stack.clone()
						smartcast_counts_before := t.smartcast_expr_counts.clone()
						t.push_smartcast_full(smartcast_expr, cond_variants[i],
							cond_variants_full[i], sumtype_name)
						mut transformed_stmts := t.transform_match_branch_stmts(branch.stmts)
						if t.sumtype_return_wrap != '' {
							transformed_stmts = t.wrap_sumtype_return_branch_tail_stmts(transformed_stmts,
								t.sumtype_return_wrap)
						}
						t.smartcast_stack = smartcast_stack_before.clone()
						t.smartcast_expr_counts = smartcast_counts_before.clone()

						branches << ast.MatchBranch{
							cond:  [
								ast.Expr(ast.BasicLiteral{
									kind:  token.Token.number
									value: '${c_tag}'
								}),
							]
							stmts: transformed_stmts
							pos:   branch.pos
						}
					}
				} else {
					// No variant name found, just transform normally
					mut fallback_stmts := t.transform_match_branch_stmts(branch.stmts)
					if t.sumtype_return_wrap != '' {
						fallback_stmts = t.wrap_sumtype_return_branch_tail_stmts(fallback_stmts,
							t.sumtype_return_wrap)
					}
					branches << ast.MatchBranch{
						cond:  branch.cond
						stmts: fallback_stmts
						pos:   branch.pos
					}
				}
			} else {
				// else branch - no smartcast context
				mut else_stmts := t.transform_match_branch_stmts(branch.stmts)
				if t.sumtype_return_wrap != '' {
					else_stmts = t.wrap_sumtype_return_branch_tail_stmts(else_stmts,
						t.sumtype_return_wrap)
				}
				branches << ast.MatchBranch{
					cond:  branch.cond
					stmts: else_stmts
					pos:   branch.pos
				}
			}
		}

		// Transform match expression to use _tag field.
		// For nested sum type matches (e.g., match o { Inner { match o { Small { ... } } } }),
		// the expression is already smartcasted to the inner sum type. We must keep the
		// smartcast so we access the INNER type's _tag, not the outer one.
		// Only remove smartcast contexts when this is NOT a nested sum type match.
		mut is_nested_sumtype_match := false
		if ctx := t.find_smartcast_for_expr(smartcast_expr) {
			if t.is_sum_type(ctx.variant) || t.is_sum_type(if ctx.variant.contains('__') {
				ctx.variant.all_after_last('__')
			} else {
				ctx.variant
			}) {
				is_nested_sumtype_match = true
			}
		}
		transformed_match_expr := if !is_nested_sumtype_match && expr.expr is ast.Ident {
			ast.Expr(expr.expr)
		} else {
			t.transform_expr(expr.expr)
		}
		tag_access := t.synth_selector(transformed_match_expr, '_tag', types.Type(types.int_))

		return tag_access, branches
	}

	// Non-sum type match - simple transformation
	// Determine if match expression is an enum type so we can resolve shorthands (.red → Color__red)
	mut enum_type_name := ''
	if typ := t.get_expr_type(expr.expr) {
		c_name := t.type_to_c_name(typ)
		if c_name != '' {
			if resolved := t.lookup_type(c_name) {
				if resolved is types.Enum {
					enum_type_name = c_name
				}
			}
		}
	}
	mut branches := []ast.MatchBranch{cap: expr.branches.len}
	for branch in expr.branches {
		mut conds := branch.cond.clone()
		if enum_type_name != '' {
			conds = []ast.Expr{cap: branch.cond.len}
			for c in branch.cond {
				conds << t.resolve_enum_shorthand(c, enum_type_name)
			}
		}
		branches << ast.MatchBranch{
			cond:  conds
			stmts: t.transform_match_branch_stmts(branch.stmts)
			pos:   branch.pos
		}
	}
	return t.transform_expr(expr.expr), branches
}

fn (mut t Transformer) transform_match_branch_stmts(stmts []ast.Stmt) []ast.Stmt {
	if stmts.len == 0 {
		return []ast.Stmt{}
	}
	if !t.preserve_match_branch_value {
		return t.transform_stmts(stmts)
	}
	last := stmts[stmts.len - 1]
	if last is ast.ExprStmt {
		mut out := []ast.Stmt{}
		if stmts.len > 1 {
			out << t.transform_stmts(stmts[..stmts.len - 1])
		}
		saved_pending := t.pending_stmts
		t.pending_stmts = []ast.Stmt{}
		saved_skip_if_value_lowering := t.skip_if_value_lowering
		if last.expr is ast.IfExpr {
			t.skip_if_value_lowering = true
		}
		mut branch_expr := last.expr
		if t.cur_fn_ret_type_name != '' {
			if ret_type := t.lookup_type(t.cur_fn_ret_type_name) {
				if ret_type is types.Enum {
					branch_expr = t.resolve_expr_with_expected_type(branch_expr, ret_type)
				}
			}
		}
		transformed_expr := t.transform_expr(branch_expr)
		t.skip_if_value_lowering = saved_skip_if_value_lowering
		final_pending := t.pending_stmts
		t.pending_stmts = saved_pending
		for stmt in final_pending {
			out << stmt
		}
		out << ast.Stmt(ast.ExprStmt{
			expr: transformed_expr
		})
		return out
	}
	return t.transform_stmts(stmts)
}

fn (mut t Transformer) wrap_sumtype_return_branch_tail_stmts(stmts []ast.Stmt, sumtype_name string) []ast.Stmt {
	if stmts.len == 0 {
		return stmts
	}
	last_idx := stmts.len - 1
	last_stmt := stmts[last_idx]
	if last_stmt !is ast.ExprStmt {
		return stmts
	}
	mut out := stmts.clone()
	out[last_idx] = ast.Stmt(ast.ExprStmt{
		expr: t.wrap_sumtype_return_branch_tail_expr((last_stmt as ast.ExprStmt).expr,
			sumtype_name, stmts[..last_idx])
	})
	return out
}

fn (mut t Transformer) wrap_sumtype_return_branch_tail_expr(expr ast.Expr, sumtype_name string, prefix []ast.Stmt) ast.Expr {
	if expr is ast.IfExpr {
		return ast.Expr(ast.IfExpr{
			cond:      expr.cond
			stmts:     t.wrap_sumtype_return_branch_tail_stmts(expr.stmts, sumtype_name)
			else_expr: t.wrap_sumtype_return_branch_tail_expr(expr.else_expr, sumtype_name,
				[]ast.Stmt{})
			pos:       expr.pos
		})
	}
	info := t.sumtype_wrap_info_for_name(sumtype_name) or { return expr }
	return t.wrap_sumtype_return_tail_leaf_expr(expr, info, prefix)
}

fn (mut t Transformer) wrap_sumtype_return_tail_leaf_expr(expr ast.Expr, info ConcreteSumtypeWrapInfo, prefix []ast.Stmt) ast.Expr {
	if wrapped := t.wrap_sumtype_value_transformed_with_variants(expr, info.name, info.variants) {
		return wrapped
	}
	if expr is ast.Ident {
		if typ := t.lookup_var_type(expr.name) {
			type_name := t.type_to_c_name(typ)
			if type_name != '' && type_name != 'void'
				&& !t.is_same_sumtype_name(type_name, info.name) {
				if variant_name := t.match_variant(type_name, info.variants) {
					return t.build_sumtype_init_with_variants(expr, variant_name, info.name,
						info.variants) or { expr }
				}
			}
		}
		if variant_name := t.sumtype_return_variant_for_tail_ident(expr.name, info, prefix) {
			return t.build_sumtype_init_with_variants(expr, variant_name, info.name, info.variants) or {
				expr
			}
		}
	}
	return expr
}

fn (mut t Transformer) sumtype_return_variant_for_tail_ident(name string, info ConcreteSumtypeWrapInfo, prefix []ast.Stmt) ?string {
	if name == '' || prefix.len == 0 {
		return none
	}
	for i := prefix.len - 1; i >= 0; i-- {
		stmt := prefix[i]
		if stmt !is ast.AssignStmt {
			continue
		}
		assign := stmt as ast.AssignStmt
		if assign.lhs.len != 1 || assign.rhs.len != 1 {
			continue
		}
		lhs := assign.lhs[0]
		if lhs !is ast.Ident || (lhs as ast.Ident).name != name {
			continue
		}
		if typ := t.get_expr_type(lhs) {
			if variant_name := t.sumtype_return_variant_from_type(typ, info) {
				return variant_name
			}
		}
		if variant_name := t.sumtype_return_variant_from_expr(assign.rhs[0], info) {
			return variant_name
		}
	}
	return none
}

fn (mut t Transformer) sumtype_return_variant_from_expr(expr ast.Expr, info ConcreteSumtypeWrapInfo) ?string {
	if typ := t.get_expr_type(expr) {
		if variant_name := t.sumtype_return_variant_from_type(typ, info) {
			return variant_name
		}
	}
	if expr is ast.InitExpr {
		init_variant_name := t.init_expr_sumtype_variant_name(expr, info.variants, info.name)
		if init_variant_name != '' {
			return init_variant_name
		}
	}
	if expr is ast.CastExpr {
		return t.sumtype_return_variant_from_type_expr(expr.typ, info)
	}
	if expr is ast.ParenExpr {
		return t.sumtype_return_variant_from_expr(expr.expr, info)
	}
	if expr is ast.ModifierExpr {
		return t.sumtype_return_variant_from_expr(expr.expr, info)
	}
	return none
}

fn (mut t Transformer) sumtype_return_variant_from_type_expr(typ_expr ast.Expr, info ConcreteSumtypeWrapInfo) ?string {
	concrete_typ_expr := if t.cur_monomorphized_fn_bindings.len > 0 {
		t.substitute_type_in_expr(typ_expr, t.cur_monomorphized_fn_bindings)
	} else {
		typ_expr
	}
	if typ := t.type_from_init_expr(ast.InitExpr{
		typ: concrete_typ_expr
	})
	{
		if variant_name := t.sumtype_return_variant_from_type(typ, info) {
			return variant_name
		}
	}
	type_name := t.get_init_expr_type_name(concrete_typ_expr)
	if type_name == '' || t.is_same_sumtype_name(type_name, info.name) {
		return none
	}
	return t.match_variant(type_name, info.variants)
}

fn (t &Transformer) sumtype_return_variant_from_type(typ types.Type, info ConcreteSumtypeWrapInfo) ?string {
	mut type_name := t.type_to_c_name(typ)
	if type_name == '' {
		type_name = typ.name()
	}
	if type_name == '' || type_name == 'void' || t.is_same_sumtype_name(type_name, info.name) {
		return none
	}
	return t.match_variant(type_name, info.variants)
}

// lower_match_expr_to_if converts a transformed match expression into a nested IfExpr chain.
// Backends only need to support IfExpr after this lowering.
fn (mut t Transformer) lower_match_expr_to_if(match_expr ast.Expr, branches []ast.MatchBranch) ast.Expr {
	is_match_true := match_expr is ast.BasicLiteral && match_expr.kind == .key_true
	is_match_false := match_expr is ast.BasicLiteral && match_expr.kind == .key_false

	mut current := ast.Expr(ast.empty_expr)
	for i := branches.len - 1; i >= 0; i-- {
		branch := branches[i]
		if branch.cond.len == 0 {
			current = ast.Expr(ast.IfExpr{
				cond:      ast.empty_expr
				stmts:     branch.stmts
				else_expr: current
			})
			continue
		}

		branch_cond := t.build_match_branch_cond(match_expr, branch.cond, is_match_true,
			is_match_false)
		current = ast.Expr(ast.IfExpr{
			cond:      branch_cond
			stmts:     branch.stmts
			else_expr: current
		})
	}
	return current
}

// lower_match_expr_to_if_flat is the direct-emit mirror of
// `lower_match_expr_to_if`. Emits the nested IfExpr chain straight into the
// flat builder via `emit_if_expr_by_ids`, skipping the `ast.IfExpr` wrapper-
// struct allocation per branch (the legacy helper allocates one IfExpr struct
// per branch — N-branch matches allocate N structs that the leaf `emit_expr`
// walk would still have to traverse). Children are already-transformed by
// `transform_match_expr_parts`, so leaf-encode via `out.emit_expr` /
// `out.emit_stmt` (mirrors `add_expr(IfExpr)`'s `push_expr`/`push_stmt`
// walk). The flat MatchExpr arm calls this after `_parts`.
fn (mut t Transformer) lower_match_expr_to_if_flat(match_expr ast.Expr, branches []ast.MatchBranch, mut out ast.FlatBuilder) ast.FlatNodeId {
	is_match_true := match_expr is ast.BasicLiteral && match_expr.kind == .key_true
	is_match_false := match_expr is ast.BasicLiteral && match_expr.kind == .key_false

	mut current := out.emit_expr(ast.empty_expr)
	for i := branches.len - 1; i >= 0; i-- {
		branch := branches[i]
		mut stmt_ids := []ast.FlatNodeId{cap: branch.stmts.len}
		for s in branch.stmts {
			stmt_ids << out.emit_stmt(s)
		}
		if branch.cond.len == 0 {
			cond_id := out.emit_expr(ast.empty_expr)
			current = out.emit_if_expr_by_ids(cond_id, current, stmt_ids, token.Pos{})
			continue
		}
		branch_cond := t.build_match_branch_cond(match_expr, branch.cond, is_match_true,
			is_match_false)
		cond_id := out.emit_expr(branch_cond)
		current = out.emit_if_expr_by_ids(cond_id, current, stmt_ids, token.Pos{})
	}
	return current
}

fn transformer_stmts_contain_label_stmt(stmts []ast.Stmt) bool {
	for stmt in stmts {
		if transformer_stmt_contains_label_stmt(stmt) {
			return true
		}
	}
	return false
}

fn transformer_stmt_contains_label_stmt(stmt ast.Stmt) bool {
	if !stmt_has_valid_data(stmt) {
		return false
	}
	match stmt {
		ast.BlockStmt {
			return transformer_stmts_contain_label_stmt(stmt.stmts)
		}
		ast.ComptimeStmt {
			return transformer_stmt_contains_label_stmt(stmt.stmt)
		}
		ast.DeferStmt {
			return transformer_stmts_contain_label_stmt(stmt.stmts)
		}
		ast.ExprStmt {
			return transformer_expr_contains_label_stmt(stmt.expr)
		}
		ast.ForStmt {
			return transformer_stmt_contains_label_stmt(stmt.init)
				|| transformer_stmt_contains_label_stmt(stmt.post)
				|| transformer_expr_contains_label_stmt(stmt.cond)
				|| transformer_stmts_contain_label_stmt(stmt.stmts)
		}
		ast.LabelStmt {
			return true
		}
		ast.ReturnStmt {
			for return_expr in stmt.exprs {
				if transformer_expr_contains_label_stmt(return_expr) {
					return true
				}
			}
			return false
		}
		else {
			return false
		}
	}
}

fn transformer_expr_contains_label_stmt(expr ast.Expr) bool {
	if !expr_has_valid_data(expr) {
		return false
	}
	match expr {
		ast.IfExpr {
			return transformer_expr_contains_label_stmt(expr.cond)
				|| transformer_stmts_contain_label_stmt(expr.stmts)
				|| transformer_expr_contains_label_stmt(expr.else_expr)
		}
		ast.MatchExpr {
			for branch in expr.branches {
				if transformer_stmts_contain_label_stmt(branch.stmts) {
					return true
				}
			}
			return false
		}
		ast.SelectExpr {
			return transformer_stmts_contain_label_stmt(expr.stmts)
				|| transformer_expr_contains_label_stmt(expr.next)
		}
		ast.UnsafeExpr {
			return transformer_stmts_contain_label_stmt(expr.stmts)
		}
		else {
			return false
		}
	}
}

fn (mut t Transformer) transform_if_expr(expr ast.IfExpr) ast.Expr {
	has_labeled_else_branch := transformer_expr_contains_label_stmt(expr.else_expr)
	// Normalize long && chains containing `is` checks so smartcast lowering can
	// apply to patterns like `a && x is T && b`.
	if !has_labeled_else_branch && expr.cond is ast.InfixExpr && expr.cond.op == token.Token.and {
		terms := t.flatten_and_terms(expr.cond)
		if terms.len > 2 {
			mut is_idx := -1
			for i, term in terms {
				if term is ast.InfixExpr && term.op in [.key_is, .eq]
					&& t.smartcast_context_from_is_check(term) != none {
					is_idx = i
					break
				}
			}
			if is_idx >= 0 {
				pre_terms := if is_idx > 0 { terms[..is_idx] } else { []ast.Expr{} }
				post_terms := if is_idx + 1 < terms.len { terms[is_idx + 1..] } else { []ast.Expr{} }
				mut inner_cond := terms[is_idx]
				if post_terms.len > 0 {
					post_cond := if post_terms.len == 1 {
						post_terms[0]
					} else {
						ast.Expr(ast.ParenExpr{
							expr: t.join_and_terms(post_terms)
							pos:  post_terms[0].pos()
						})
					}
					inner_cond = ast.Expr(ast.InfixExpr{
						op:  token.Token.and
						lhs: inner_cond
						rhs: post_cond
					})
				}
				inner_if := ast.IfExpr{
					cond:      inner_cond
					stmts:     expr.stmts
					else_expr: expr.else_expr
					pos:       expr.pos
				}
				if pre_terms.len > 0 {
					outer_if := ast.IfExpr{
						cond:      t.join_and_terms(pre_terms)
						stmts:     [ast.Stmt(ast.ExprStmt{
							expr: inner_if
						})]
						else_expr: expr.else_expr
						pos:       expr.pos
					}
					return t.transform_if_expr(outer_if)
				}
				return t.transform_if_expr(inner_if)
			}
		}
	}

	// Check for compound && condition with is check: if x is Type && cond { ... }
	// Transform to nested ifs: if x is Type { if cond { ... } }
	// This allows the smart cast context to be active for the inner condition
	if !has_labeled_else_branch && expr.cond is ast.InfixExpr {
		cond := expr.cond as ast.InfixExpr
		if cond.op == .and {
			// Check if LHS is an is-check
			if cond.lhs is ast.InfixExpr {
				lhs_infix := cond.lhs as ast.InfixExpr
				if lhs_infix.op in [.key_is, .eq]
					&& t.smartcast_context_from_is_check(lhs_infix) != none {
					// Transform: if x is Type && rest { body } else { else_body }
					// Handle directly to ensure else_body is transformed WITHOUT smartcast
					// Get variant info from lhs_infix (the is-check)
					mut variant_name := ''
					mut variant_module := ''
					if lhs_infix.rhs is ast.Ident {
						variant_name = (lhs_infix.rhs as ast.Ident).name
					} else if lhs_infix.rhs is ast.SelectorExpr {
						sel := lhs_infix.rhs as ast.SelectorExpr
						variant_name = sel.rhs.name
						if sel.lhs is ast.Ident {
							variant_module = (sel.lhs as ast.Ident).name
						}
					}
					if variant_name != '' {
						variant_lookup_name := sum_type_variant_name_with_module(variant_module,
							variant_name)
						mut sumtype_name := t.get_sumtype_name_for_expr(lhs_infix.lhs)
						if sumtype_name == '' {
							sumtype_name = t.find_sumtype_for_variant(variant_lookup_name)
						}
						if sumtype_name != '' {
							variants := t.get_sum_type_variants(sumtype_name)
							mut tag_value := -1
							for i, v in variants {
								if sum_type_variant_matches_for_sumtype(sumtype_name, v,
									variant_lookup_name)
								{
									tag_value = i
									break
								}
							}
							if tag_value >= 0 {
								smartcast_expr := t.expr_to_string(lhs_infix.lhs)
								qualified_variant := if variant_module != '' {
									'${variant_module}__${variant_name}'
								} else {
									variant_name
								}
								// For full variant name (type casts), always include module prefix
								qualified_variant_full := if variant_module != '' {
									'${variant_module}__${variant_name}'
								} else if t.cur_module != '' && t.cur_module != 'main'
									&& t.cur_module != 'builtin' {
									'${t.cur_module}__${variant_name}'
								} else {
									variant_name
								}
								transformed_lhs := t.transform_tag_check_lhs_for_sumtype(lhs_infix.lhs,
									sumtype_name)
								// Push smartcast for body and inner condition
								smartcast_stack_before := t.smartcast_stack.clone()
								smartcast_counts_before := t.smartcast_expr_counts.clone()
								t.push_smartcast_full(smartcast_expr, qualified_variant,
									qualified_variant_full, sumtype_name)
								condition_smartcast_stack := t.smartcast_stack.clone()
								condition_smartcast_counts := t.smartcast_expr_counts.clone()
								// Check if inner condition (rest) is also an is-check
								mut inner_cond_lowered := false
								mut inner_tag_check := ast.Expr(ast.BasicLiteral{
									kind:  token.Token.number
									value: '0'
								})
								inner_rhs_expr := smartcast_lhs_expr(cond.rhs)
								if inner_rhs_expr is ast.InfixExpr
									&& (inner_rhs_expr as ast.InfixExpr).op in [.key_is, .eq] {
									orig_inner := inner_rhs_expr as ast.InfixExpr
									mut inner_smartcast_pushed := false
									if inner_ctx := t.smartcast_context_from_is_check(orig_inner) {
										t.push_smartcast_ctx(inner_ctx)
										inner_smartcast_pushed = true
									}
									mut inner_vname := ''
									mut inner_vmodule := ''
									if orig_inner.rhs is ast.Ident {
										inner_vname = (orig_inner.rhs as ast.Ident).name
									} else if orig_inner.rhs is ast.SelectorExpr {
										inner_sel := orig_inner.rhs as ast.SelectorExpr
										inner_vname = inner_sel.rhs.name
										if inner_sel.lhs is ast.Ident {
											inner_vmodule = (inner_sel.lhs as ast.Ident).name
										}
									}
									if inner_vname != '' {
										inner_lookup_name := sum_type_variant_name_with_module(inner_vmodule,
											inner_vname)
										// Get sum type from ORIGINAL expression (before smartcast)
										mut inner_stype :=
											t.get_sumtype_name_for_expr(orig_inner.lhs)
										if inner_stype == '' {
											inner_stype =
												t.find_sumtype_for_variant(inner_lookup_name)
										}
										if inner_stype != '' {
											inner_variants := t.get_sum_type_variants(inner_stype)
											mut inner_tag := -1
											for iv, iv_name in inner_variants {
												if sum_type_variant_matches_for_sumtype(inner_stype,
													iv_name, inner_lookup_name)
												{
													inner_tag = iv
													break
												}
											}
											if inner_tag >= 0 && !inner_smartcast_pushed {
												// Push inner smartcast for body
												inner_qv := if inner_vmodule != '' {
													'${inner_vmodule}__${inner_vname}'
												} else {
													inner_vname
												}
												inner_qvf := if inner_vmodule != '' {
													'${inner_vmodule}__${inner_vname}'
												} else if t.cur_module != ''
													&& t.cur_module != 'main'
													&& t.cur_module != 'builtin' {
													'${t.cur_module}__${inner_vname}'
												} else {
													inner_vname
												}
												inner_se := t.expr_to_string(orig_inner.lhs)
												t.push_smartcast_full(inner_se, inner_qv,
													inner_qvf, inner_stype)
												inner_smartcast_pushed = true
											}
										}
									}
								}
								active_smartcast_stack := t.smartcast_stack.clone()
								active_smartcast_counts := t.smartcast_expr_counts.clone()
								// Transform inner condition with smartcast (if not already lowered).
								// Expression expansions from the condition must run before the
								// nested if, while the outer smartcast is active.
								saved_rest_pending := t.pending_stmts
								t.pending_stmts = []ast.Stmt{}
								t.smartcast_stack = condition_smartcast_stack.clone()
								t.smartcast_expr_counts = condition_smartcast_counts.clone()
								transformed_rest := if inner_cond_lowered {
									inner_tag_check
								} else {
									t.transform_expr(cond.rhs)
								}
								rest_pending := t.pending_stmts
								t.pending_stmts = saved_rest_pending
								t.smartcast_stack = active_smartcast_stack.clone()
								t.smartcast_expr_counts = active_smartcast_counts.clone()
								mut seen_body_smartcasts := map[string]bool{}
								for sc in t.smartcast_stack {
									seen_body_smartcasts['${sc.expr}|${sc.variant}|${sc.variant_full}|${sc.sumtype}'] = true
								}
								for term in t.flatten_and_terms_unwrapped(cond.rhs) {
									if term is ast.InfixExpr {
										if body_ctx := t.smartcast_context_from_condition_term(term) {
											key := '${body_ctx.expr}|${body_ctx.variant}|${body_ctx.variant_full}|${body_ctx.sumtype}'
											if key !in seen_body_smartcasts {
												t.push_smartcast_ctx(body_ctx)
												seen_body_smartcasts[key] = true
											}
										}
									}
								}
								// Transform body with smartcast(s)
								transformed_body := t.transform_stmts(expr.stmts)
								// Restore the surrounding context before transforming else.
								t.smartcast_stack = smartcast_stack_before.clone()
								t.smartcast_expr_counts = smartcast_counts_before.clone()
								// Transform else WITHOUT smartcast
								transformed_else := t.transform_expr(expr.else_expr)
								// Build tag check
								tag_check := ast.InfixExpr{
									op:  token.Token.eq
									lhs: t.synth_selector(transformed_lhs, '_tag',
										types.Type(types.int_))
									rhs: ast.BasicLiteral{
										kind:  token.Token.number
										value: '${tag_value}'
									}
									pos: lhs_infix.pos
								}
								// Build inner if (with already-transformed components)
								inner_if := ast.IfExpr{
									cond:      transformed_rest
									stmts:     transformed_body
									else_expr: transformed_else
									pos:       expr.pos
								}
								mut outer_stmts := []ast.Stmt{cap: rest_pending.len + 1}
								for pending_stmt in rest_pending {
									outer_stmts << pending_stmt
								}
								outer_stmts << ast.Stmt(ast.ExprStmt{
									expr: inner_if
								})
								// Build outer if
								return ast.IfExpr{
									cond:      tag_check
									stmts:     outer_stmts
									else_expr: transformed_else
									pos:       expr.pos
								}
							}
						}
					}
					// Fallback: use smartcast_context_from_is_check to get the proper
					// context (interface-aware with __iface__ prefix, or plain).
					if iface_ctx := t.smartcast_context_from_is_check(lhs_infix) {
						// Transform else_expr FIRST without smartcast
						transformed_else_fallback := t.transform_expr(expr.else_expr)
						// Push interface-aware smartcast context
						t.push_smartcast_ctx(iface_ctx)
						// Transform inner condition and body with smartcast
						saved_rest_pending := t.pending_stmts
						t.pending_stmts = []ast.Stmt{}
						transformed_rest_fallback := t.transform_expr(cond.rhs)
						rest_pending := t.pending_stmts
						t.pending_stmts = saved_rest_pending
						transformed_body_fallback := t.transform_stmts(expr.stmts)
						// Pop smartcast
						t.pop_smartcast()
						inner_if := ast.IfExpr{
							cond:      transformed_rest_fallback
							stmts:     transformed_body_fallback
							else_expr: transformed_else_fallback
							pos:       expr.pos
						}
						mut outer_stmts := []ast.Stmt{cap: rest_pending.len + 1}
						for pending_stmt in rest_pending {
							outer_stmts << pending_stmt
						}
						outer_stmts << ast.Stmt(ast.ExprStmt{
							expr: inner_if
						})
						// Keep original is-check condition (let cleanc handle it)
						return ast.IfExpr{
							cond:      t.transform_expr(ast.Expr(lhs_infix))
							stmts:     outer_stmts
							else_expr: transformed_else_fallback
							pos:       expr.pos
						}
					}
				}
			}
			// Check if RHS is an is-check: if cond && x is Type { ... }
			// Transform to: if cond { if x is Type { ... } else { else_body } } else { else_body }
			if cond.rhs is ast.InfixExpr {
				rhs_infix := cond.rhs as ast.InfixExpr
				if rhs_infix.op in [.key_is, .eq]
					&& t.smartcast_context_from_is_check(rhs_infix) != none {
					// Transform: if cond && x is Type { body } else { else_body }
					// To: if cond { if x is Type { body } else { else_body } } else { else_body }
					inner_if := ast.IfExpr{
						cond:      ast.Expr(cond.rhs)
						stmts:     expr.stmts
						else_expr: expr.else_expr
						pos:       expr.pos
					}
					outer_if := ast.IfExpr{
						cond:      cond.lhs
						stmts:     [ast.Stmt(ast.ExprStmt{
							expr: inner_if
						})]
						else_expr: expr.else_expr
						pos:       expr.pos
					}
					// Recursively transform - inner will handle smartcast
					return t.transform_if_expr(outer_if)
				}
			}
		}
	}

	// Check for sum type smart cast: if x is Type { ... }
	if expr.cond is ast.InfixExpr {
		cond := expr.cond as ast.InfixExpr
		if cond.op in [.key_is, .eq] && t.smartcast_context_from_is_check(cond) != none {
			if ctx := t.smartcast_context_from_is_check(cond) {
				if tag_value := t.smartcast_context_tag_value(ctx) {
					transformed_lhs := t.transform_tag_check_lhs_for_sumtype(cond.lhs, ctx.sumtype)

					t.push_smartcast_ctx(ctx)
					transformed_stmts := t.transform_stmts(expr.stmts)
					t.pop_smartcast()

					tag_check := ast.InfixExpr{
						op:  token.Token.eq
						lhs: t.synth_selector(transformed_lhs, '_tag', types.Type(types.int_))
						rhs: ast.BasicLiteral{
							kind:  token.Token.number
							value: '${tag_value}'
						}
						pos: cond.pos
					}
					return ast.IfExpr{
						cond:      tag_check
						stmts:     transformed_stmts
						else_expr: t.transform_expr(expr.else_expr)
						pos:       expr.pos
					}
				}
			}
			// Get the variant type name from RHS
			// Also extract module for qualified types like types.Type
			mut variant_name := ''
			mut variant_module := ''
			if cond.rhs is ast.Ident {
				variant_name = (cond.rhs as ast.Ident).name
			} else if cond.rhs is ast.SelectorExpr {
				// Handle module-qualified types like types.Type
				sel := cond.rhs as ast.SelectorExpr
				variant_name = sel.rhs.name
				// Extract module name (e.g., from types.Type, extract "types")
				if sel.lhs is ast.Ident {
					variant_module = (sel.lhs as ast.Ident).name
				}
			}
			if variant_name != '' {
				variant_lookup_name := sum_type_variant_name_with_module(variant_module,
					variant_name)
				// Get the sum type name from LHS type
				// First try normal lookup, then fall back to finding sumtype by variant
				mut sumtype_name := t.get_sumtype_name_for_expr(cond.lhs)

				// If that failed or returned wrong sumtype, try finding by variant
				if sumtype_name == '' {
					sumtype_name = t.find_sumtype_for_variant(variant_lookup_name)
				}

				// Cross-check: if the variant has an explicit module prefix (e.g. types.FnType)
				// but the resolved sumtype is from a different module (e.g. ast__Type),
				// the resolution picked the wrong homonymous sum type. Re-resolve using the
				// variant's module to find the correct sum type.
				if variant_module != '' && sumtype_name.contains('__') {
					st_mod := sumtype_name.all_before_last('__')
					if st_mod != variant_module {
						st_short := sumtype_name.all_after_last('__')
						candidate := '${variant_module}__${st_short}'
						if t.is_sum_type(candidate) {
							sumtype_name = candidate
						}
					}
				}

				if sumtype_name != '' {
					// Find the tag value for this variant
					variants := t.get_sum_type_variants(sumtype_name)
					mut tag_value := -1
					for i, v in variants {
						if sum_type_variant_matches_for_sumtype(sumtype_name, v,
							variant_lookup_name)
						{
							tag_value = i
							break
						}
					}

					if tag_value >= 0 {
						// Get the string representation of the LHS expression
						smartcast_expr := t.expr_to_string(cond.lhs)

						// Create fully qualified variant name if module is specified
						// e.g., types.Type -> types__Type
						qualified_variant := if variant_module != '' {
							'${variant_module}__${variant_name}'
						} else {
							variant_name
						}
						// For full variant name (type casts), always include module prefix
						qualified_variant_full := if variant_module != '' {
							'${variant_module}__${variant_name}'
						} else if t.cur_module != '' && t.cur_module != 'main'
							&& t.cur_module != 'builtin' {
							'${t.cur_module}__${variant_name}'
						} else {
							variant_name
						}

						transformed_lhs := t.transform_tag_check_lhs_for_sumtype(cond.lhs,
							sumtype_name)

						// Push smart cast context for transforming body (supports nested smartcasts)
						t.push_smartcast_full(smartcast_expr, qualified_variant,
							qualified_variant_full, sumtype_name)

						// Transform body with smart cast context
						transformed_stmts := t.transform_stmts(expr.stmts)

						// Pop context
						t.pop_smartcast()

						// Transform condition: v is Type -> v._tag == TAG_VALUE
						// This prevents cleanc from also applying smart cast
						// Use transformed_lhs to apply outer smartcasts to the tag check
						tag_check := ast.InfixExpr{
							op:  token.Token.eq
							lhs: t.synth_selector(transformed_lhs, '_tag', types.Type(types.int_))
							rhs: ast.BasicLiteral{
								kind:  token.Token.number
								value: '${tag_value}'
							}
							pos: cond.pos
						}

						// Transform else_expr (may have its own smart cast context)
						return ast.IfExpr{
							cond:      tag_check
							stmts:     transformed_stmts
							else_expr: t.transform_expr(expr.else_expr)
							pos:       expr.pos
						}
					}
				}
				// Interface smartcast: if iface_var is ConcreteType { ... }
				// The condition is left as-is (cleanc handles _type_id comparison).
				// We only need to push the smartcast context so field accesses in
				// the body are lowered to ((ConcreteType*)(iface._object))->field.
				if iface_ctx := t.smartcast_context_from_is_check(cond) {
					t.push_smartcast_ctx(iface_ctx)
					transformed_stmts := t.transform_stmts(expr.stmts)
					t.pop_smartcast()
					return ast.IfExpr{
						cond:      t.transform_expr(expr.cond)
						stmts:     transformed_stmts
						else_expr: t.transform_expr(expr.else_expr)
						pos:       expr.pos
					}
				}
			}
		}
	}

	// Handle if-guard expression in condition (for nested/expression-level if-guards)
	// For Option-returning expressions in if-guards, we need to expand them with temp variables.
	// Transform: if r := opt_func() { body } else { else_body }
	// To: { _tmp := opt_func(); if _tmp.state == 0 { r := _tmp.data; body } else { else_body } }
	if expr.cond is ast.IfGuardExpr {
		guard := expr.cond as ast.IfGuardExpr
		if guard.stmt.rhs.len > 0 {
			synth_pos := t.next_synth_pos()
			rhs := guard.stmt.rhs[0]

			// Check if RHS returns Result or Option type
			mut is_result := t.expr_returns_result(rhs)
			mut is_option := t.expr_returns_option(rhs)
			if !is_result && !is_option {
				fn_name := t.get_call_fn_name(rhs)
				is_result = fn_name != '' && t.fn_returns_result(fn_name)
				is_option = fn_name != '' && t.fn_returns_option(fn_name)
			}
			if !is_result && !is_option {
				if ret_type := t.fn_pointer_call_return_type(rhs) {
					is_result = ret_type is types.ResultType || ret_type.name().starts_with('!')
					is_option = ret_type is types.OptionType || ret_type.name().starts_with('?')
				}
			}
			if is_result {
				// Handle Result if-guard using temp variable pattern
				// Transform: if var := result_call() { body } else { else_body }
				// To: { _tmp := result_call(); if !_tmp.is_error { var := _tmp.data; body } else { else_body } }
				temp_name := t.gen_temp_name()
				temp_pos := synth_pos
				if_pos := t.next_synth_pos()
				temp_ident := ast.Ident{
					name: temp_name
					pos:  temp_pos
				}

				mut is_blank := false
				if guard.stmt.lhs.len == 1 {
					lhs0 := guard.stmt.lhs[0]
					if lhs0 is ast.Ident {
						if lhs0.name == '_' {
							is_blank = true
						}
					}
				}
				mut data_type := types.Type(types.voidptr_)
				if wrapper_type := t.expr_wrapper_type_for_or(rhs) {
					t.register_temp_var(temp_name, wrapper_type)
					t.register_synth_type(temp_pos, wrapper_type)
					if wrapper_type is types.ResultType {
						data_type = wrapper_type.base_type
					}
				} else if wrapper_type := t.get_expr_type(rhs) {
					t.register_temp_var(temp_name, wrapper_type)
					t.register_synth_type(temp_pos, wrapper_type)
					if wrapper_type is types.ResultType {
						data_type = wrapper_type.base_type
					}
				} else if wrapper_type := t.fn_pointer_call_return_type(rhs) {
					t.register_temp_var(temp_name, wrapper_type)
					t.register_synth_type(temp_pos, wrapper_type)
					if wrapper_type is types.ResultType {
						data_type = wrapper_type.base_type
					}
				}

				// 1. _tmp := result_call()
				temp_assign := ast.AssignStmt{
					op:  .decl_assign
					lhs: [ast.Expr(temp_ident)]
					rhs: [t.transform_expr(rhs)]
					pos: temp_pos
				}

				// 2. Condition: !_tmp.is_error
				success_cond := ast.PrefixExpr{
					op:   .not
					expr: t.synth_selector(temp_ident, 'is_error', types.Type(types.bool_))
				}

				// 3. Body: var := _tmp.data; original_body
				mut body_stmts := []ast.Stmt{}
				if !is_blank {
					data_access := t.synth_selector(temp_ident, 'data', data_type)
					t.register_if_guard_lhs_payload_type(guard.stmt.lhs, data_type)
					body_stmts << ast.AssignStmt{
						op:  .decl_assign
						lhs: guard.stmt.lhs
						rhs: [data_access]
						pos: guard.stmt.pos
					}
				}
				for s in expr.stmts {
					body_stmts << s
				}

				modified_if := ast.IfExpr{
					cond:      success_cond
					stmts:     t.transform_stmts(body_stmts)
					else_expr: t.transform_expr(expr.else_expr)
					pos:       if_pos
				}
				// Propagate the original IfExpr type to the synthesized node
				if orig_type := t.get_expr_type(ast.Expr(expr)) {
					t.register_synth_type(if_pos, orig_type)
				}

				// Wrap temp assignment + if in UnsafeExpr (compound expression)
				return ast.UnsafeExpr{
					stmts: [ast.Stmt(temp_assign), ast.ExprStmt{
						expr: modified_if
					}]
				}
			}

			if is_option {
				// Handle Option if-guard using a temp variable to avoid taking
				// addresses of rvalue wrappers when extracting `.data`.
				// Transform: if var := opt_call() { body } else { else_body }
				// To: { _tmp := opt_call(); if _tmp.state == 0 { var := _tmp.data; body } else { else_body } }
				temp_name := t.gen_temp_name()
				temp_pos := synth_pos
				if_pos := t.next_synth_pos()
				temp_ident := ast.Ident{
					name: temp_name
					pos:  temp_pos
				}
				mut data_type := types.Type(types.voidptr_)
				if wrapper_type := t.expr_wrapper_type_for_or(rhs) {
					t.register_temp_var(temp_name, wrapper_type)
					t.register_synth_type(temp_pos, wrapper_type)
					if wrapper_type is types.OptionType {
						data_type = wrapper_type.base_type
					}
				} else if wrapper_type := t.get_expr_type(rhs) {
					t.register_temp_var(temp_name, wrapper_type)
					t.register_synth_type(temp_pos, wrapper_type)
					if wrapper_type is types.OptionType {
						data_type = wrapper_type.base_type
					}
				} else if wrapper_type := t.fn_pointer_call_return_type(rhs) {
					t.register_temp_var(temp_name, wrapper_type)
					t.register_synth_type(temp_pos, wrapper_type)
					if wrapper_type is types.OptionType {
						data_type = wrapper_type.base_type
					}
				}
				mut is_blank := false
				if guard.stmt.lhs.len == 1 {
					lhs0 := guard.stmt.lhs[0]
					if lhs0 is ast.Ident {
						if lhs0.name == '_' {
							is_blank = true
						}
					}
				}

				temp_assign := ast.AssignStmt{
					op:  .decl_assign
					lhs: [ast.Expr(temp_ident)]
					rhs: [t.transform_expr(rhs)]
					pos: temp_pos
				}

				opt_success_cond := ast.InfixExpr{
					op:  .eq
					lhs: t.synth_selector(temp_ident, 'state', types.Type(types.int_))
					rhs: ast.BasicLiteral{
						kind:  .number
						value: '0'
					}
				}

				mut body_stmts := []ast.Stmt{}
				if !is_blank {
					data_access := t.synth_selector(temp_ident, 'data', data_type)
					t.register_if_guard_lhs_payload_type(guard.stmt.lhs, data_type)
					body_stmts << ast.AssignStmt{
						op:  .decl_assign
						lhs: guard.stmt.lhs
						rhs: [data_access]
						pos: guard.stmt.pos
					}
				}
				for s in expr.stmts {
					body_stmts << s
				}

				modified_if := ast.IfExpr{
					cond:      opt_success_cond
					stmts:     t.transform_stmts(body_stmts)
					else_expr: t.transform_expr(expr.else_expr)
					pos:       if_pos
				}
				// Propagate the original IfExpr type to the synthesized node
				if orig_type := t.get_expr_type(ast.Expr(expr)) {
					t.register_synth_type(if_pos, orig_type)
				}

				return ast.UnsafeExpr{
					stmts: [ast.Stmt(temp_assign), ast.ExprStmt{
						expr: modified_if
					}]
				}
			}

			// Non-option case: use simple transformation
			// For map if-guards: if r := map[key] { body } else { else_body }
			// Transform to: if (key in map) { r := map[key]; body } else { else_body }
			// For other cases: if (rhs) { r := rhs; body } else { else_body }
			mut is_blank := false
			if guard.stmt.lhs.len == 1 {
				lhs0 := guard.stmt.lhs[0]
				if lhs0 is ast.Ident {
					if lhs0.name == '_' {
						is_blank = true
					}
				}
			}

			// Check if RHS is a map or array index expression
			mut cond_expr := ast.Expr(t.transform_expr(rhs))
			if rhs is ast.IndexExpr {
				// Try to see if this is a map index
				if _ := t.get_map_type_for_expr(rhs.lhs) {
					// This is a map access - generate "key in map" check
					cond_expr = ast.Expr(ast.InfixExpr{
						op:  .key_in
						lhs: rhs.expr // the key expression
						rhs: rhs.lhs  // the map expression
						pos: rhs.pos
					})
				} else {
					// This is an array access - generate bounds check: index < array.len
					cond_expr = ast.Expr(ast.InfixExpr{
						op:  .lt
						lhs: t.transform_expr(rhs.expr) // the index expression
						rhs: t.synth_selector(t.transform_expr(rhs.lhs), 'len',
							types.Type(types.int_))
						pos: rhs.pos
					})
				}
			}

			mut new_stmts := []ast.Stmt{cap: expr.stmts.len + 1}
			if !is_blank {
				guard_assign := ast.AssignStmt{
					op:  .decl_assign
					lhs: guard.stmt.lhs
					rhs: guard.stmt.rhs
					pos: guard.stmt.pos
				}
				new_stmts << guard_assign
			}
			for s in expr.stmts {
				new_stmts << s
			}
			saved_p := t.pending_stmts
			t.pending_stmts = []ast.Stmt{}
			t_stmts := t.transform_stmts(new_stmts)
			inner_p := t.pending_stmts
			t.pending_stmts = saved_p
			for ip in inner_p {
				t.pending_stmts << ip
			}
			saved_p2 := t.pending_stmts
			t.pending_stmts = []ast.Stmt{}
			t_else := t.transform_expr(expr.else_expr)
			inner_p2 := t.pending_stmts
			t.pending_stmts = saved_p2
			for ip in inner_p2 {
				t.pending_stmts << ip
			}
			result_if := ast.IfExpr{
				cond:      t.transform_expr(cond_expr)
				stmts:     t_stmts
				else_expr: t_else
				pos:       synth_pos
			}
			// Propagate the original IfExpr type to the synthesized node
			if orig_type := t.get_expr_type(ast.Expr(expr)) {
				t.register_synth_type(synth_pos, orig_type)
			}
			return result_if
		}
	}

	// Default transformation
	mut body_smartcasts := []SmartcastContext{}
	mut seen_smartcasts := map[string]bool{}
	for term in t.flatten_and_terms_unwrapped(expr.cond) {
		if term is ast.InfixExpr {
			if ctx := t.smartcast_context_from_condition_term(term) {
				key := '${ctx.expr}|${ctx.variant}|${ctx.variant_full}'
				if key !in seen_smartcasts {
					seen_smartcasts[key] = true
					body_smartcasts << ctx
				}
			}
		}
	}
	outer_smartcast_stack := t.smartcast_stack.clone()
	outer_smartcast_counts := t.smartcast_expr_counts.clone()
	for ctx in body_smartcasts {
		t.push_smartcast_full(ctx.expr, ctx.variant, ctx.variant_full, ctx.sumtype)
	}
	// Save and restore pending_stmts around branch transformation to prevent
	// outer pending_stmts (e.g., from earlier RHS if-expr lowering) from being
	// flushed into the inner branch's transform_stmts.
	saved_pending := t.pending_stmts
	t.pending_stmts = []ast.Stmt{}
	transformed_stmts := t.transform_stmts(expr.stmts)
	// Merge any pending_stmts generated by the then-branch transform back into the outer context.
	inner_pending_then := t.pending_stmts
	t.pending_stmts = saved_pending
	for ip in inner_pending_then {
		t.pending_stmts << ip
	}
	t.smartcast_stack = outer_smartcast_stack.clone()
	t.smartcast_expr_counts = outer_smartcast_counts.clone()
	saved_pending2 := t.pending_stmts
	t.pending_stmts = []ast.Stmt{}
	transformed_else := t.transform_expr(expr.else_expr)
	// Merge any pending_stmts generated by the else-expr transform back into the outer context.
	inner_pending := t.pending_stmts
	t.pending_stmts = saved_pending2
	for ip in inner_pending {
		t.pending_stmts << ip
	}
	t.smartcast_stack = outer_smartcast_stack.clone()
	t.smartcast_expr_counts = outer_smartcast_counts.clone()
	transformed_if := ast.IfExpr{
		cond:      t.transform_expr(expr.cond)
		stmts:     transformed_stmts
		else_expr: transformed_else
		pos:       expr.pos
	}
	t.smartcast_stack = outer_smartcast_stack.clone()
	t.smartcast_expr_counts = outer_smartcast_counts.clone()
	// Lower value-position IfExpr: hoist to a temp variable assignment.
	// This eliminates expression-valued IfExpr so backends don't need statement-expressions.
	// A value-position if has an else branch and its body ends with an ExprStmt (producing a value).
	// Skip lowering when:
	// - The IfExpr is directly inside an ExprStmt (statement position, not value)
	// - The IfExpr is already the RHS of a decl_assign (cleanc handles this efficiently)
	if !t.skip_if_value_lowering && transformed_if.else_expr !is ast.EmptyExpr
		&& t.if_expr_is_value(transformed_if) {
		return t.lower_if_expr_value(transformed_if)
	}
	return transformed_if
}

// get_sumtype_name_for_expr returns the sum type name for an expression, or empty string if not a sum type
// This function is smartcast-aware: if the expression is already smartcasted to a variant that is
// itself a sum type, it returns that sum type name.
fn (mut t Transformer) transform_infix_expr(expr ast.InfixExpr) ast.Expr {
	// Preserve short-circuit semantics while making smartcasts available to all
	// following terms in `&&` chains (including multiple `is` checks).
	if expr.op == .and {
		terms := t.flatten_and_terms_unwrapped(expr)
		if terms.len > 1 {
			mut transformed_terms := []ast.Expr{cap: terms.len}
			mut pushed := 0
			mut changed := false
			for term in terms {
				if term is ast.InfixExpr {
					if ctx := t.smartcast_context_from_condition_term(term) {
						transformed_terms << t.transform_expr(term)
						t.push_smartcast_full(ctx.expr, ctx.variant, ctx.variant_full, ctx.sumtype)
						pushed++
						changed = true
						continue
					}
				}
				transformed_terms << t.transform_expr(term)
			}
			for _ in 0 .. pushed {
				t.pop_smartcast()
			}
			if changed {
				return t.join_and_terms(transformed_terms)
			}
		}
	}

	// Lower sum type checks/comparisons to tag comparisons.
	// This also handles parser/checker-lowered `!is` that appears as `!=` with type RHS.
	if expr.op in [.key_is, .not_is, .eq, .ne] {
		mut variant_name := ''
		mut variant_module := ''
		if expr.rhs is ast.Ident {
			variant_name = (expr.rhs as ast.Ident).name
		} else if expr.rhs is ast.SelectorExpr {
			sel := expr.rhs as ast.SelectorExpr
			variant_name = sel.rhs.name
			if sel.lhs is ast.Ident {
				variant_module = (sel.lhs as ast.Ident).name
			}
		} else if expr.rhs is ast.Type {
			// Handle complex type expressions like []Any, map[string]Any
			variant_name = t.type_expr_to_variant_name(expr.rhs)
		}
		if variant_name != '' {
			variant_lookup_name := sum_type_variant_name_with_module(variant_module, variant_name)
			mut sumtype_name := t.get_sumtype_name_for_expr(expr.lhs)
			mut lhs_is_enum := t.get_enum_type_name(expr.lhs) != ''
			if lhs_type := t.get_expr_type(expr.lhs) {
				lhs_base := t.unwrap_alias_and_pointer_type(lhs_type)
				lhs_is_enum = lhs_is_enum || lhs_base is types.Enum
			}
			rhs_is_enum_shorthand := expr.rhs is ast.SelectorExpr
				&& (expr.rhs as ast.SelectorExpr).lhs is ast.EmptyExpr
			rhs_is_type_like := variant_name.len > 0 && variant_name[0] >= `A`
				&& variant_name[0] <= `Z`
			can_find_sumtype_fallback := expr.op in [.key_is, .not_is] || rhs_is_type_like
			if sumtype_name == '' && !lhs_is_enum && !rhs_is_enum_shorthand
				&& can_find_sumtype_fallback {
				sumtype_name = t.find_sumtype_for_variant(variant_lookup_name)
			}
			if sumtype_name != '' {
				variants := t.get_sum_type_variants(sumtype_name)
				mut tag_value := -1
				for i, v in variants {
					if sum_type_variant_matches_for_sumtype(sumtype_name, v, variant_lookup_name) {
						tag_value = i
						break
					}
				}
				if tag_value >= 0 {
					transformed_lhs := t.transform_tag_check_lhs_for_sumtype(expr.lhs, sumtype_name)
					cmp_op := if expr.op in [.key_is, .eq] {
						token.Token.eq
					} else {
						token.Token.ne
					}
					return t.make_infix_expr_at(cmp_op, t.synth_selector(transformed_lhs, '_tag',
						types.Type(types.int_)), ast.Expr(ast.BasicLiteral{
						kind:  token.Token.number
						value: '${tag_value}'
						pos:   expr.pos
					}), expr.pos)
				}
			}
			// Interface self-type check: `iface_var is InterfaceType` where the variable
			// is already of that interface type. This checks non-nil (type_id != 0).
			if sumtype_name == '' {
				if lhs_type := t.get_expr_type(expr.lhs) {
					lhs_base := t.unwrap_alias_and_pointer_type(lhs_type)
					if lhs_base is types.Interface {
						is_self_check := lhs_base.name.ends_with(variant_name)
							|| lhs_base.name == variant_name
						if is_self_check {
							transformed_lhs := t.transform_expr(expr.lhs)
							cmp_op := if expr.op in [.key_is, .eq] {
								token.Token.ne
							} else {
								token.Token.eq
							}
							return t.make_infix_expr_at(cmp_op, t.synth_selector(transformed_lhs,
								'_type_id', types.Type(types.int_)), ast.Expr(ast.BasicLiteral{
								kind:  token.Token.number
								value: '0'
								pos:   expr.pos
							}), expr.pos)
						}
					}
				}
			}
		}
	}

	// Check for string concatenation: string + string
	if expr.op == .plus {
		if literal := folded_string_literal_concat(expr) {
			return ast.Expr(ast.StringLiteral{
				kind:  .v
				value: literal
				pos:   expr.pos
			})
		}
		lhs_is_str := t.is_string_expr(expr.lhs)
		rhs_is_str := t.is_string_expr(expr.rhs)

		// Check if either side is a string literal
		lhs_is_str_literal := if expr.lhs is ast.StringLiteral {
			true
		} else if expr.lhs is ast.BasicLiteral {
			expr.lhs.kind == .string
		} else {
			false
		}
		rhs_is_str_literal := if expr.rhs is ast.StringLiteral {
			true
		} else if expr.rhs is ast.BasicLiteral {
			expr.rhs.kind == .string
		} else {
			false
		}

		// Also check if either side is a string__* call (already transformed)
		lhs_is_str_call := if expr.lhs is ast.CallExpr {
			if expr.lhs.lhs is ast.Ident {
				(expr.lhs.lhs as ast.Ident).name.starts_with('string__')
			} else {
				false
			}
		} else {
			false
		}
		rhs_is_str_call := if expr.rhs is ast.CallExpr {
			if expr.rhs.lhs is ast.Ident {
				(expr.rhs.lhs as ast.Ident).name.starts_with('string__')
			} else {
				false
			}
		} else {
			false
		}

		// Also check for string InfixExpr (chained concatenation like s1 + s2 + s3)
		lhs_is_str_infix := expr.lhs is ast.InfixExpr
			&& (expr.lhs as ast.InfixExpr).op == .plus && lhs_is_str
		rhs_is_str_infix := expr.rhs is ast.InfixExpr
			&& (expr.rhs as ast.InfixExpr).op == .plus && rhs_is_str
		// Determine if this is a string concatenation using multiple signals
		should_transform := (lhs_is_str && rhs_is_str) || (lhs_is_str_literal && (rhs_is_str || expr.rhs is ast.Ident || rhs_is_str_call)) || (rhs_is_str_literal && (lhs_is_str || expr.lhs is ast.Ident || lhs_is_str_call)) || (lhs_is_str_call && (rhs_is_str || expr.rhs is ast.Ident)) || (rhs_is_str_call && (lhs_is_str || expr.lhs is ast.Ident)) || (lhs_is_str_infix && expr.rhs is ast.Ident) // Chained: (s1 + s2) + ident
		 || (rhs_is_str_infix && expr.lhs is ast.Ident) // Chained: ident + (s1 + s2)

		// Check for chained concatenation: (s1 + s2) + s3 -> string__plus_two(s1, s2, s3)
		if expr.lhs is ast.InfixExpr && should_transform {
			lhs_infix := expr.lhs as ast.InfixExpr
			if lhs_infix.op == .plus && t.is_string_expr(lhs_infix.lhs)
				&& t.is_string_expr(lhs_infix.rhs) {
				// Transform to string__plus_two(s1, s2, s3)
				return ast.CallExpr{
					lhs:  ast.Ident{
						name: 'string__plus_two'
					}
					args: [
						t.transform_expr(lhs_infix.lhs),
						t.transform_expr(lhs_infix.rhs),
						t.transform_expr(expr.rhs),
					]
					pos:  expr.pos
				}
			}
		}
		// Check for simple concatenation: s1 + s2 -> string__plus(s1, s2)
		if should_transform {
			return ast.CallExpr{
				lhs:  ast.Ident{
					name: 'string__plus'
				}
				args: [t.transform_expr(expr.lhs), t.transform_expr(expr.rhs)]
				pos:  expr.pos
			}
		}
	}
	// Check for 'in' operator with arrays: elem in arr => Array_T_contains(arr, elem)
	if expr.op in [.key_in, .not_in] {
		// Range membership: x in a..b -> x >= a && x < b
		if expr.rhs is ast.RangeExpr {
			range := expr.rhs as ast.RangeExpr
			lhs_trans := t.transform_expr(expr.lhs)
			lower_bound := ast.Expr(ast.InfixExpr{
				op:  .ge
				lhs: lhs_trans
				rhs: t.transform_expr(range.start)
				pos: expr.pos
			})
			mut range_check := lower_bound
			if range.end !is ast.EmptyExpr {
				upper_op := if range.op == .dotdot {
					token.Token.lt
				} else {
					token.Token.le
				}
				upper_bound := ast.Expr(ast.InfixExpr{
					op:  upper_op
					lhs: lhs_trans
					rhs: t.transform_expr(range.end)
					pos: expr.pos
				})
				range_check = ast.Expr(ast.InfixExpr{
					op:  .and
					lhs: lower_bound
					rhs: upper_bound
					pos: expr.pos
				})
			}
			if expr.op == .not_in {
				return ast.PrefixExpr{
					op:   .not
					expr: range_check
					pos:  expr.pos
				}
			}
			return range_check
		}
		// Map membership: key in map -> map__exists(&map, &key)
		if rhs_type := t.map_index_lhs_type(expr.rhs) {
			if map_typ := t.unwrap_map_type(rhs_type) {
				if t.is_eval_backend() {
					return ast.InfixExpr{
						op:  expr.op
						lhs: t.transform_expr(expr.lhs)
						rhs: t.transform_expr(expr.rhs)
						pos: expr.pos
					}
				}
				map_ptr := t.map_expr_to_runtime_ptr(expr.rhs, rhs_type, map_typ)
				// For the key, declare a temp variable in the same scope as the
				// map__exists call so the pointer stays valid during the call.
				// Using addr_of_expr_with_temp would nest the temp inside a
				// statement expression whose scope ends before map__exists reads it.
				lhs_trans := t.transform_expr(expr.lhs)
				mut key_ptr := ast.Expr(ast.empty_expr)
				mut key_stmts := []ast.Stmt{}
				if t.can_take_address_expr(lhs_trans)
					&& !t.is_enum_rvalue(lhs_trans, map_typ.key_type) {
					key_ptr = ast.PrefixExpr{
						op:   .amp
						expr: lhs_trans
					}
				} else {
					key_tmp := t.gen_temp_name()
					key_ident := t.typed_temp_ident(key_tmp, map_typ.key_type)
					key_stmts << ast.Stmt(ast.AssignStmt{
						op:  .decl_assign
						lhs: [ast.Expr(key_ident)]
						rhs: [lhs_trans]
						pos: key_ident.pos
					})
					key_ptr = ast.PrefixExpr{
						op:   .amp
						expr: key_ident
					}
				}
				exists_call := ast.Expr(ast.CallExpr{
					lhs:  ast.Ident{
						name: 'map__exists'
					}
					args: [map_ptr, key_ptr]
					pos:  expr.pos
				})
				mut result_expr := exists_call
				if expr.op == .not_in {
					result_expr = ast.PrefixExpr{
						op:   .not
						expr: exists_call
						pos:  expr.pos
					}
				}
				if key_stmts.len > 0 {
					// Wrap in UnsafeExpr so the temp key variable is in scope
					// for the entire map__exists call.
					key_stmts << ast.Stmt(ast.ExprStmt{
						expr: result_expr
					})
					return ast.UnsafeExpr{
						stmts: key_stmts
					}
				}
				return result_expr
			}
		}
		// For inline array literals, expand to a chain of equality checks
		// instead of a contains() call — simpler and works for all backends.
		if expr.rhs is ast.ArrayInitExpr {
			arr := expr.rhs as ast.ArrayInitExpr
			if arr.exprs.len > 0 {
				lhs_trans := t.transform_expr(expr.lhs)
				// Get enum type from LHS for resolving shorthand in array elements
				enum_type := t.get_enum_type_name(expr.lhs)
				// Build: lhs == arr[0] || lhs == arr[1] || ...
				first_elem := if enum_type != '' {
					t.resolve_enum_shorthand(t.transform_expr(arr.exprs[0]), enum_type)
				} else {
					t.transform_expr(arr.exprs[0])
				}
				mut chain := t.make_infix_expr_at(.eq, lhs_trans, first_elem, expr.pos)
				for i := 1; i < arr.exprs.len; i++ {
					elem := if enum_type != '' {
						t.resolve_enum_shorthand(t.transform_expr(arr.exprs[i]), enum_type)
					} else {
						t.transform_expr(arr.exprs[i])
					}
					elem_cmp := t.make_infix_expr_at(.eq, lhs_trans, elem, expr.pos)
					chain = t.make_infix_expr_at(.logical_or, chain, elem_cmp, expr.pos)
				}
				if expr.op == .not_in {
					return ast.PrefixExpr{
						op:   .not
						expr: chain
						pos:  expr.pos
					}
				}
				return chain
			}
		}
		// Array membership: elem in arr -> Array_T_contains(arr, elem)
		if arr_info := t.get_array_method_info(expr.rhs) {
			// Get enum type from LHS for resolving shorthand in array
			enum_type := t.get_enum_type_name(expr.lhs)
			// If array contains enum shorthand but we can't resolve the type,
			// skip transformation and let cleanc handle it
			mut has_unresolved_shorthand := false
			if enum_type == '' && expr.rhs is ast.ArrayInitExpr {
				arr := expr.rhs as ast.ArrayInitExpr
				if arr.exprs.len > 0 {
					first := arr.exprs[0]
					// Check for enum shorthand (.value with empty LHS)
					if first is ast.SelectorExpr {
						sel := first as ast.SelectorExpr
						// Check for enum shorthand: EmptyExpr or empty Ident as LHS
						is_shorthand := if sel.lhs is ast.EmptyExpr {
							true
						} else if sel.lhs is ast.Ident {
							// Also check for empty ident name
							(sel.lhs as ast.Ident).name == ''
						} else {
							false
						}
						if is_shorthand {
							has_unresolved_shorthand = true
						}
					}
				}
			}
			// Check if this is a sum type variant check: sumtype_var in [TypeA, TypeB]
			// If LHS is a sum type and RHS contains variant type names, let cleanc handle it
			mut is_sumtype_variant_check := false
			if expr.rhs is ast.ArrayInitExpr {
				// Get LHS sum type name (if it is a sum type)
				lhs_sumtype := t.get_sumtype_name_for_expr(expr.lhs)
				if lhs_sumtype != '' {
					// Check if the array elements are variant type names (Idents)
					arr := expr.rhs as ast.ArrayInitExpr
					if arr.exprs.len > 0 && arr.exprs[0] is ast.Ident {
						// This looks like a sum type variant check
						// Verify that the ident names are actually variants
						variants := t.get_sum_type_variants(lhs_sumtype)
						first_ident := arr.exprs[0] as ast.Ident
						// Extract module prefix from sum type name (e.g., "ast__Expr" -> "ast__")
						mod_prefix := if lhs_sumtype.contains('__') {
							lhs_sumtype.all_before_last('__') + '__'
						} else {
							''
						}
						// Check both with and without module prefix
						variant_name := first_ident.name
						variant_mangled := mod_prefix + variant_name
						if variant_name in variants || variant_mangled in variants {
							is_sumtype_variant_check = true
						}
					}
				}
			}
			// If this is a sum type variant check, skip transformation entirely
			// and return the original expression (cleanc will handle tag checks)
			if is_sumtype_variant_check {
				// Return unchanged - cleanc will generate the tag check
				return t.make_infix_expr_at(expr.op, t.transform_expr(expr.lhs), expr.rhs, expr.pos)
			}
			if !has_unresolved_shorthand {
				mut method_info := arr_info
				if enum_type != '' && !arr_info.is_fixed {
					enum_c_name := t.v_type_name_to_c_name(enum_type)
					if enum_c_name != '' {
						method_info = ArrayMethodInfo{
							array_type: 'Array_${enum_c_name}'
							elem_type:  enum_c_name
							is_fixed:   false
						}
					}
				}
				contains_fn_name := t.register_needed_array_method(method_info, 'contains')
				// Transform array with enum context if needed
				transformed_rhs := if enum_type != '' && expr.rhs is ast.ArrayInitExpr {
					t.transform_array_with_enum_context(expr.rhs as ast.ArrayInitExpr, enum_type)
				} else {
					t.transform_expr(expr.rhs)
				}
				contains_call := ast.CallExpr{
					lhs:  ast.Ident{
						name: contains_fn_name
					}
					args: [transformed_rhs, t.transform_expr(expr.lhs)]
					pos:  expr.pos
				}
				if expr.op == .not_in {
					// !in => !Array_T_contains(arr, elem)
					return ast.PrefixExpr{
						op:   .not
						expr: contains_call
						pos:  expr.pos
					}
				}
				return contains_call
			} else {
				// Unresolved shorthand - return as-is for cleanc to handle expansion
				return t.make_infix_expr_at(expr.op, t.transform_expr(expr.lhs), expr.rhs, expr.pos)
			}
		}
	}
	// Check for array append: arr << elem => builtin__array_push_noscan((array*)&arr, _MOV((T[]){ elem }))
	// If RHS is also an array, use push_many instead
	// Note: map[key] << value is handled at the statement level
	// by try_transform_map_index_push in transform_stmts.
	if expr.op in [.amp, .pipe, .xor] && expr.lhs is ast.InfixExpr {
		left := expr.lhs as ast.InfixExpr
		if left.op == .left_shift {
			if _ := t.get_array_elem_type_str(left.lhs) {
				combined_rhs := ast.InfixExpr{
					lhs: left.rhs
					op:  expr.op
					rhs: expr.rhs
					pos: expr.pos
				}
				return t.transform_expr(ast.InfixExpr{
					lhs: left.lhs
					op:  .left_shift
					rhs: combined_rhs
					pos: left.pos
				})
			}
		}
	}
	if expr.op == .left_shift {
		if elem_type_name := t.get_array_elem_type_str(expr.lhs) {
			if t.is_eval_backend() {
				return ast.InfixExpr{
					op:  expr.op
					lhs: t.transform_expr(expr.lhs)
					rhs: t.transform_expr(expr.rhs)
					pos: expr.pos
				}
			}
			// Use push_many only when RHS element type matches the LHS element type.
			// This avoids mis-lowering [][]T << []T, which must stay a single push.
			mut rhs_is_array := false
			// Enum shorthand (.member) is never an array value, even if the checker
			// annotated it with the LHS array type instead of the element enum type.
			rhs_is_enum_shorthand := expr.rhs is ast.SelectorExpr
				&& (expr.rhs as ast.SelectorExpr).lhs is ast.EmptyExpr
			rhs_is_bitwise_expr := expr.rhs is ast.InfixExpr
				&& (expr.rhs as ast.InfixExpr).op in [.amp, .pipe, .xor, .left_shift, .right_shift]
			if !rhs_is_enum_shorthand && !rhs_is_bitwise_expr {
				rhs_is_array = t.append_rhs_is_array_value_compatible(elem_type_name, expr.rhs)
			}
			// Or-data-extract: _or_tN.data where the temp var holds a Result/Option of array.
			// extract_or_expr replaces `call()!` with `_or_tN.data`, losing the PostfixExpr
			// that array_value_elem_type would have recognized. Check the temp var's type.
			if !rhs_is_array && expr.rhs is ast.SelectorExpr {
				rhs_sel := expr.rhs as ast.SelectorExpr
				if rhs_sel.rhs.name == 'data' && rhs_sel.lhs is ast.Ident {
					or_ident := rhs_sel.lhs as ast.Ident
					if or_ident.name.starts_with('_or_t') {
						if or_type := t.lookup_var_type(or_ident.name) {
							unwrapped := if or_type is types.ResultType {
								or_type.base_type
							} else if or_type is types.OptionType {
								or_type.base_type
							} else {
								or_type
							}
							if unwrapped is types.Array {
								rhs_is_array = true
							}
						}
					}
				}
			}

			lhs_is_ptr := t.is_pointer_type_expr(expr.lhs)
				&& !t.array_append_lhs_uses_local_array_storage(expr.lhs)

			// Create (array*)&arr or (array*)arr expression depending on whether LHS is already a pointer
			arr_ptr_expr := if lhs_is_ptr {
				// Already a pointer, just cast
				ast.Expr(ast.CastExpr{
					typ:  ast.Ident{
						name: 'array*'
					}
					expr: t.transform_expr(expr.lhs)
				})
			} else {
				// Take address then cast
				ast.Expr(ast.CastExpr{
					typ:  ast.Ident{
						name: 'array*'
					}
					expr: ast.PrefixExpr{
						op:   .amp
						expr: t.transform_expr(expr.lhs)
						pos:  expr.pos
					}
				})
			}

			if rhs_is_array {
				// RHS is an array - use array__push_many(array*, val.data, val.len)
				rhs_transformed := t.transform_expr(expr.rhs)
				// Materialize RHS values that should not be selected twice as rvalues.
				// The VarDecl is hoisted via pending_stmts before the current statement.
				if t.contains_call_expr(expr.rhs) || expr.rhs is ast.ArrayInitExpr {
					t.temp_counter++
					tmp_name := '_pm_t${t.temp_counter}'
					tmp_ident := ast.Ident{
						name: tmp_name
					}
					if rhs_type := t.get_expr_type(expr.rhs) {
						t.register_temp_var(tmp_name, rhs_type)
					}
					t.pending_stmts << ast.Stmt(ast.AssignStmt{
						op:  .decl_assign
						lhs: [ast.Expr(tmp_ident)]
						rhs: [rhs_transformed]
					})
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: 'array__push_many'
						}
						args: [
							arr_ptr_expr,
							t.synth_selector(ast.Expr(tmp_ident), 'data',
								types.Type(types.voidptr_)),
							t.synth_selector(ast.Expr(tmp_ident), 'len', types.Type(types.int_)),
						]
						pos:  expr.pos
					}
				}
				// Wrap PrefixExpr in parens to fix operator precedence (*other.data -> (*other).data)
				rhs_for_selector := if expr.rhs is ast.PrefixExpr {
					ast.Expr(ast.ParenExpr{
						expr: rhs_transformed
					})
				} else {
					rhs_transformed
				}
				return ast.CallExpr{
					lhs:  ast.Ident{
						name: 'array__push_many'
					}
					args: [
						arr_ptr_expr,
						t.synth_selector(rhs_for_selector, 'data', types.Type(types.voidptr_)),
						t.synth_selector(rhs_for_selector, 'len', types.Type(types.int_)),
					]
					pos:  expr.pos
				}
			}

			// Create (T[]){ elem } expression for single element push
			// Note: cleanc will add _MOV wrapper when generating ArrayInitExpr
			push_rhs := t.single_nested_array_append_value(expr.rhs, elem_type_name) or { expr.rhs }
			mut transformed_rhs := t.transform_expr(push_rhs)
			rhs_is_nested_array_literal := push_rhs is ast.ArrayInitExpr
				&& (elem_type_name.starts_with('Array_')
				|| elem_type_name.starts_with('Array_fixed_'))
			if t.contains_call_expr(push_rhs) || rhs_is_nested_array_literal {
				t.temp_counter++
				tmp_name := '_ap_t${t.temp_counter}'
				tmp_ident := ast.Ident{
					name: tmp_name
				}
				if rhs_type := t.get_expr_type(push_rhs) {
					t.register_temp_var(tmp_name, rhs_type)
				}
				t.pending_stmts << ast.Stmt(ast.AssignStmt{
					op:  .decl_assign
					lhs: [ast.Expr(tmp_ident)]
					rhs: [transformed_rhs]
				})
				transformed_rhs = ast.Expr(tmp_ident)
			}
			// Clone strings when pushing to arrays to prevent use-after-free
			// (V1 does: array_push(&arr, _MOV((string[]){ string_clone(s) })))
			cloned_rhs := if elem_type_name == 'string' {
				ast.Expr(ast.CallExpr{
					lhs:  ast.Ident{
						name: 'string__clone'
					}
					args: [transformed_rhs]
				})
			} else {
				transformed_rhs
			}
			push_elem := t.wrap_array_push_elem_value(cloned_rhs, elem_type_name)
			arr_literal := ast.ArrayInitExpr{
				typ:   ast.Expr(ast.Type(ast.ArrayType{
					elem_type: ast.Ident{
						name: elem_type_name
					}
				}))
				exprs: [push_elem]
			}
			return ast.CallExpr{
				lhs:  ast.Ident{
					name: 'builtin__array_push_noscan'
				}
				args: [
					arr_ptr_expr,
					ast.Expr(arr_literal),
				]
				pos:  expr.pos
			}
		}
	}
	// Check for enum shorthand in comparisons: x.op == .amp -> x.op == Token.amp
	if expr.op in [.eq, .ne] {
		// Check if RHS is enum shorthand (.member with empty LHS)
		if expr.rhs is ast.SelectorExpr {
			rhs_sel := expr.rhs as ast.SelectorExpr
			if rhs_sel.lhs is ast.EmptyExpr {
				// RHS is enum shorthand - resolve using LHS type
				enum_type := t.get_enum_type_name(expr.lhs)
				if enum_type != '' {
					resolved_rhs := t.resolve_enum_shorthand(expr.rhs, enum_type)
					return t.make_infix_expr_at(expr.op, t.transform_expr(expr.lhs),
						t.transform_expr(resolved_rhs), expr.pos)
				}
			}
		}
		// Check if LHS is enum shorthand (.member with empty LHS)
		if expr.lhs is ast.SelectorExpr {
			lhs_sel := expr.lhs as ast.SelectorExpr
			if lhs_sel.lhs is ast.EmptyExpr {
				// LHS is enum shorthand - resolve using RHS type
				enum_type := t.get_enum_type_name(expr.rhs)
				if enum_type != '' {
					resolved_lhs := t.resolve_enum_shorthand(expr.lhs, enum_type)
					return t.make_infix_expr_at(expr.op, t.transform_expr(resolved_lhs),
						t.transform_expr(expr.rhs), expr.pos)
				}
			}
		}
	}
	// Check for string comparisons: s1 == s2, s1 < s2, etc.
	// Skip if either side is nil — that's a pointer comparison, not a string comparison.
	if expr.op in [.eq, .ne, .lt, .gt, .le, .ge] && !t.is_nil_expr(expr.lhs)
		&& !t.is_nil_expr(expr.rhs) {
		mut lhs_has_active_type := false
		mut lhs_is_str := false
		if lhs_active_type := t.active_local_decl_type_for_expr(expr.lhs) {
			lhs_has_active_type = true
			lhs_is_str = t.type_is_string(lhs_active_type)
		} else {
			lhs_is_str = t.is_string_expr(expr.lhs)
		}
		mut rhs_has_active_type := false
		mut rhs_is_str := false
		if rhs_active_type := t.active_local_decl_type_for_expr(expr.rhs) {
			rhs_has_active_type = true
			rhs_is_str = t.type_is_string(rhs_active_type)
		} else {
			rhs_is_str = t.is_string_expr(expr.rhs)
		}
		// Also check type environment for expression types if is_string_expr didn't find it,
		// unless an active local declaration already resolved the operand type.
		if !lhs_is_str && !lhs_has_active_type {
			if expr_type := t.get_expr_type(expr.lhs) {
				lhs_is_str = t.type_is_string(expr_type)
			}
		}
		if !rhs_is_str && !rhs_has_active_type {
			if expr_type := t.get_expr_type(expr.rhs) {
				rhs_is_str = t.type_is_string(expr_type)
			}
		}
		// If one side is a string literal and the other is unknown (but likely a string),
		// treat as string comparison. Only do this for string literals, not other string expressions.
		lhs_is_str_literal := if expr.lhs is ast.StringLiteral {
			true
		} else if expr.lhs is ast.BasicLiteral {
			expr.lhs.kind == .string
		} else {
			false
		}
		rhs_is_str_literal := if expr.rhs is ast.StringLiteral {
			true
		} else if expr.rhs is ast.BasicLiteral {
			expr.rhs.kind == .string
		} else {
			false
		}
		// Only infer string comparison if at least one side is a string literal AND
		// the other is identified as string OR is an ident (could be loop variable)
		// Also transform if both are Ident and at least one is known to be string
		// (the other is likely also string in a comparison context)
		// Also transform if one side is a SelectorExpr and the other is a string literal
		// (field access compared with string literal is almost always string comparison)
		// If either side is known to be a string, the other must also be string
		// (V is type-checked). This handles cases where is_string_expr fails on
		// complex expressions like Result data access selectors.
		uses_generic_type := t.expr_uses_current_generic_type(expr.lhs)
			|| t.expr_uses_current_generic_type(expr.rhs)
		active_non_string_type := (lhs_has_active_type && !lhs_is_str)
			|| (rhs_has_active_type && !rhs_is_str)
		should_transform := !uses_generic_type && !active_non_string_type && (lhs_is_str
			|| rhs_is_str || (lhs_is_str_literal && (expr.rhs is ast.Ident
			|| expr.rhs is ast.SelectorExpr))
			|| (rhs_is_str_literal && (expr.lhs is ast.Ident || expr.lhs is ast.SelectorExpr)))
		if should_transform {
			// Transform string comparisons to function calls
			match expr.op {
				.eq {
					// s1 == s2 -> string__eq(s1, s2)
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: 'string__eq'
						}
						args: [t.transform_expr(expr.lhs), t.transform_expr(expr.rhs)]
						pos:  expr.pos
					}
				}
				.ne {
					// s1 != s2 -> !string__eq(s1, s2)
					return ast.PrefixExpr{
						op:   .not
						expr: ast.CallExpr{
							lhs:  ast.Ident{
								name: 'string__eq'
							}
							args: [t.transform_expr(expr.lhs),
								t.transform_expr(expr.rhs)]
							pos:  expr.pos
						}
						pos:  expr.pos
					}
				}
				.lt {
					// s1 < s2 -> string__lt(s1, s2)
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: 'string__lt'
						}
						args: [t.transform_expr(expr.lhs), t.transform_expr(expr.rhs)]
						pos:  expr.pos
					}
				}
				.gt {
					// s1 > s2 -> string__lt(s2, s1)
					return ast.CallExpr{
						lhs:  ast.Ident{
							name: 'string__lt'
						}
						args: [t.transform_expr(expr.rhs), t.transform_expr(expr.lhs)]
						pos:  expr.pos
					}
				}
				.le {
					// s1 <= s2 -> !string__lt(s2, s1)
					return ast.PrefixExpr{
						op:   .not
						expr: ast.CallExpr{
							lhs:  ast.Ident{
								name: 'string__lt'
							}
							args: [t.transform_expr(expr.rhs),
								t.transform_expr(expr.lhs)]
							pos:  expr.pos
						}
						pos:  expr.pos
					}
				}
				.ge {
					// s1 >= s2 -> !string__lt(s1, s2)
					return ast.PrefixExpr{
						op:   .not
						expr: ast.CallExpr{
							lhs:  ast.Ident{
								name: 'string__lt'
							}
							args: [t.transform_expr(expr.lhs),
								t.transform_expr(expr.rhs)]
							pos:  expr.pos
						}
						pos:  expr.pos
					}
				}
				else {}
			}
		}
		// Check for array comparisons: arr1 == arr2 or arr1 != arr2
		lhs_arr_type := t.get_array_type_str(expr.lhs)
		rhs_arr_type := t.get_array_type_str(expr.rhs)
		// For native backends, fixed arrays use memcmp, not array__eq.
		// get_array_type_str returns 'Array_fixed_...' for fixed arrays.
		mut is_fixed_array := false
		if lhs_str := lhs_arr_type {
			if lhs_str.starts_with('Array_fixed_') {
				is_fixed_array = true
			}
		}
		if lhs_arr_type != none && rhs_arr_type != none && !is_fixed_array {
			// Use type-specific equality for arrays of structs/maps (memcmp won't work)
			mut eq_fn_name := 'array__eq'
			if t.pref.backend != .arm64 && t.pref.backend != .x64 {
				if t.array_elem_needs_deep_eq(expr.lhs) || t.array_elem_needs_deep_eq(expr.rhs) {
					eq_fn_name = '${lhs_arr_type}__eq'
				}
			}
			// Transform array comparisons to function calls
			eq_call := ast.CallExpr{
				lhs:  ast.Ident{
					name: eq_fn_name
				}
				args: [t.transform_expr(expr.lhs), t.transform_expr(expr.rhs)]
				pos:  expr.pos
			}
			if expr.op == .ne {
				// arr1 != arr2 -> !array__eq(arr1, arr2)
				return ast.PrefixExpr{
					op:   .not
					expr: eq_call
					pos:  expr.pos
				}
			}
			// arr1 == arr2 -> array__eq(arr1, arr2)
			return eq_call
		}
		// Check for fixed array comparisons: [N]T == [N]T
		// For native backends, lower to C.memcmp(&a, &b, N * sizeof(T)) == 0
		// Only for memcmp-safe element types (primitives, fixed arrays of primitives).
		// Dynamic arrays, strings, maps, and structs contain heap pointers.
		if t.is_native_be && expr.op in [.eq, .ne] {
			if lhs_type := t.get_expr_type(expr.lhs) {
				lhs_base := t.unwrap_alias_and_pointer_type(lhs_type)
				if lhs_base is types.ArrayFixed {
					if t.is_memcmp_safe_type(lhs_base.elem_type) {
						// Primitives/fixed arrays of primitives: use memcmp
						elem_size := t.type_sizeof(lhs_base.elem_type)
						total_size := lhs_base.len * elem_size
						memcmp_call := ast.CallExpr{
							lhs:  ast.Ident{
								name: 'C__memcmp'
							}
							args: [
								ast.Expr(ast.PrefixExpr{
									op:   .amp
									expr: t.transform_expr(expr.lhs)
									pos:  expr.pos
								}),
								ast.Expr(ast.PrefixExpr{
									op:   .amp
									expr: t.transform_expr(expr.rhs)
									pos:  expr.pos
								}),
								ast.Expr(ast.BasicLiteral{
									kind:  .number
									value: total_size.str()
								}),
							]
							pos:  expr.pos
						}
						zero_lit := ast.BasicLiteral{
							kind:  .number
							value: '0'
						}
						return t.make_infix_expr_at(expr.op, memcmp_call, ast.Expr(zero_lit),
							expr.pos)
					}
					// Non-memcmp-safe elements (dynamic arrays, strings, maps):
					// Generate element-by-element comparison using the appropriate
					// equality function, since synthesized AST nodes lack type info.
					elem_base := t.unwrap_alias_and_pointer_type(lhs_base.elem_type)
					eq_fn := if elem_base is types.Array {
						'array__eq'
					} else if t.type_to_c_name(elem_base) == 'string' {
						'string__=='
					} else if elem_base is types.Map {
						'map_map_eq'
					} else {
						'' // unsupported element type
					}
					if eq_fn != '' {
						lhs_trans := t.transform_expr(expr.lhs)
						rhs_trans := t.transform_expr(expr.rhs)
						mut chain := ast.Expr(ast.CallExpr{
							lhs:  ast.Ident{
								name: eq_fn
							}
							args: [
								ast.Expr(ast.IndexExpr{
									lhs:  lhs_trans
									expr: ast.BasicLiteral{
										kind:  .number
										value: '0'
									}
								}),
								ast.Expr(ast.IndexExpr{
									lhs:  rhs_trans
									expr: ast.BasicLiteral{
										kind:  .number
										value: '0'
									}
								}),
							]
							pos:  expr.pos
						})
						for i := 1; i < lhs_base.len; i++ {
							elem_cmp := ast.CallExpr{
								lhs:  ast.Ident{
									name: eq_fn
								}
								args: [
									ast.Expr(ast.IndexExpr{
										lhs:  lhs_trans
										expr: ast.BasicLiteral{
											kind:  .number
											value: i.str()
										}
									}),
									ast.Expr(ast.IndexExpr{
										lhs:  rhs_trans
										expr: ast.BasicLiteral{
											kind:  .number
											value: i.str()
										}
									}),
								]
								pos:  expr.pos
							}
							chain = t.make_infix_expr_at(.and, chain, elem_cmp, expr.pos)
						}
						if expr.op == .ne {
							return ast.PrefixExpr{
								op:   .not
								expr: chain
								pos:  expr.pos
							}
						}
						return chain
					}
				}
			}
		}
		// Check for map comparisons: map1 == map2 or map1 != map2
		// Exclude pointer-to-map types (those should be pointer comparisons)
		if expr.op in [.eq, .ne] {
			mut is_lhs_ptr_map := false
			if lhs_type := t.get_expr_type(expr.lhs) {
				if lhs_type is types.Pointer {
					is_lhs_ptr_map = true
				}
			}
			mut is_rhs_ptr_map := false
			if rhs_type := t.get_expr_type(expr.rhs) {
				if rhs_type is types.Pointer {
					is_rhs_ptr_map = true
				}
			}
			if !is_lhs_ptr_map && !is_rhs_ptr_map {
				lhs_map_type := t.get_map_type_for_expr(expr.lhs)
				rhs_map_type := t.get_map_type_for_expr(expr.rhs)
				if lhs_map_type != none || rhs_map_type != none {
					if t.is_eval_backend() {
						return ast.InfixExpr{
							op:  expr.op
							lhs: t.transform_expr(expr.lhs)
							rhs: t.transform_expr(expr.rhs)
							pos: expr.pos
						}
					}
					map_type_name := lhs_map_type or { rhs_map_type or { 'map' } }
					eq_fn := if map_type_name.starts_with('Map_') {
						'${map_type_name}_map_eq'
					} else {
						'map_map_eq'
					}
					map_eq_call := ast.CallExpr{
						lhs:  ast.Ident{
							name: eq_fn
						}
						args: [t.transform_expr(expr.lhs), t.transform_expr(expr.rhs)]
						pos:  expr.pos
					}
					if expr.op == .ne {
						return ast.PrefixExpr{
							op:   .not
							expr: map_eq_call
							pos:  expr.pos
						}
					}
					return map_eq_call
				}
			}
		}
	}
	// Note: struct == / != is handled by cleanc's memcmp/field-by-field comparison.
	// Check for struct operator overloading (e.g., time.Time - time.Time)
	// This transforms t1 - t2 into time__Time__op_minus(t1, t2) for structs with operator overloading
	// Only applies to specific known struct types that define operator methods
	if expr.op in [.plus, .minus, .mul, .div, .mod] {
		if lhs_type := t.get_expr_type(expr.lhs) {
			match lhs_type {
				types.Struct {
					type_name := t.type_to_c_name(lhs_type)
					// Only transform known struct types with operator overloading
					known_struct_ops := ['time__Time']
					if type_name in known_struct_ops {
						// Determine operator method name
						op_name := match expr.op {
							.plus { '__op_plus' }
							.minus { '__op_minus' }
							.mul { '__op_mul' }
							.div { '__op_div' }
							.mod { '__op_mod' }
							else { '' }
						}

						if op_name != '' {
							// Generate function call: Type__op(lhs, rhs)
							fn_name := '${type_name}${op_name}'
							return ast.CallExpr{
								lhs:  ast.Ident{
									name: fn_name
								}
								args: [t.transform_expr(expr.lhs),
									t.transform_expr(expr.rhs)]
								pos:  expr.pos
							}
						}
					}
				}
				else {}
			}
		}
	}
	// Default: just transform children
	lhs_trans := t.transform_expr(expr.lhs)
	rhs_trans := t.transform_expr(expr.rhs)
	return t.make_infix_expr_at(expr.op, lhs_trans, rhs_trans, expr.pos)
}

fn folded_string_literal_concat(expr ast.Expr) ?string {
	match expr {
		ast.StringLiteral {
			if expr.kind != .v {
				return none
			}
			return strip_string_literal_quotes(expr.value)
		}
		ast.InfixExpr {
			if expr.op != .plus {
				return none
			}
			left := folded_string_literal_concat(expr.lhs) or { return none }
			right := folded_string_literal_concat(expr.rhs) or { return none }
			return left + right
		}
		ast.ParenExpr {
			return folded_string_literal_concat(expr.expr)
		}
		else {
			return none
		}
	}
}

fn strip_string_literal_quotes(raw string) string {
	if raw.len < 2 {
		return raw
	}
	first := raw[0]
	last := raw[raw.len - 1]
	if first == last && first in [`'`, `"`] {
		return raw[1..raw.len - 1]
	}
	return raw
}

// resolve_field_type looks up the type of a field on a variable
// e.g., for a.flags where a is Array, returns 'ArrayFlags'
fn (mut t Transformer) transform_comptime_expr(expr ast.ComptimeExpr) ast.Expr {
	// The inner expression should be an IfExpr for $if
	inner := expr.expr
	if inner is ast.IfExpr {
		return t.eval_comptime_if(inner)
	}
	if inner is ast.CallExpr {
		if inner.lhs is ast.Ident && inner.lhs.name == 'res' {
			return ast.Expr(ast.BasicLiteral{
				kind:  .key_false
				value: 'false'
				pos:   expr.pos
			})
		}
	}
	if inner is ast.CallOrCastExpr {
		if inner.lhs is ast.Ident && inner.lhs.name == 'res' {
			return ast.Expr(ast.BasicLiteral{
				kind:  .key_false
				value: 'false'
				pos:   expr.pos
			})
		}
	}
	if inner is ast.CallExpr {
		if inner.lhs is ast.Ident && inner.lhs.name == 'embed_file' {
			return t.transform_embed_file_comptime_expr(expr, inner.args)
		}
	}
	if inner is ast.CallOrCastExpr {
		if inner.lhs is ast.Ident && inner.lhs.name == 'embed_file' {
			return t.transform_embed_file_comptime_expr(expr, [inner.expr])
		}
	}
	if inner is ast.Ident {
		if inner.name in ['VMODROOT', '@VMODROOT'] {
			return ast.Expr(t.vmodroot_string_literal(expr.pos))
		}
	}
	if transformed := t.transform_embed_file_comptime_chain(inner, expr.pos) {
		return transformed
	}
	// For other comptime expressions, just return them transformed
	return ast.ComptimeExpr{
		expr: t.transform_expr(inner)
		pos:  expr.pos
	}
}

fn (mut t Transformer) transform_embed_file_comptime_chain(expr ast.Expr, comptime_pos token.Pos) ?ast.Expr {
	if transformed := t.transform_embed_file_chain_lhs(expr, comptime_pos) {
		return transformed
	}
	match expr {
		ast.SelectorExpr {
			if transformed_lhs := t.transform_embed_file_chain_lhs(expr.lhs, comptime_pos) {
				return ast.Expr(ast.SelectorExpr{
					lhs: transformed_lhs
					rhs: expr.rhs
					pos: expr.pos
				})
			}
		}
		ast.CallExpr {
			mut transformed_lhs := ast.empty_expr
			if expr.lhs is ast.SelectorExpr {
				if transformed_base := t.transform_embed_file_chain_lhs(expr.lhs.lhs, comptime_pos) {
					transformed_lhs = ast.Expr(ast.SelectorExpr{
						lhs: transformed_base
						rhs: expr.lhs.rhs
						pos: expr.lhs.pos
					})
				}
			}
			if transformed_lhs !is ast.EmptyExpr {
				mut args := []ast.Expr{cap: expr.args.len}
				for arg in expr.args {
					args << t.transform_expr(arg)
				}
				return ast.Expr(ast.CallExpr{
					lhs:  transformed_lhs
					args: args
					pos:  expr.pos
				})
			}
		}
		else {}
	}

	return none
}

fn (mut t Transformer) transform_embed_file_chain_lhs(expr ast.Expr, comptime_pos token.Pos) ?ast.Expr {
	match expr {
		ast.CallExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'embed_file' {
				return t.transform_embed_file_comptime_expr(ast.ComptimeExpr{
					expr: ast.Expr(expr)
					pos:  comptime_pos
				}, expr.args)
			}
			if expr.lhs is ast.SelectorExpr {
				sel := expr.lhs as ast.SelectorExpr
				if transformed_base := t.transform_embed_file_chain_lhs(sel.lhs, comptime_pos) {
					mut args := []ast.Expr{cap: expr.args.len}
					for arg in expr.args {
						args << t.transform_expr(arg)
					}
					return ast.Expr(ast.CallExpr{
						lhs:  ast.Expr(ast.SelectorExpr{
							lhs: transformed_base
							rhs: sel.rhs
							pos: sel.pos
						})
						args: args
						pos:  expr.pos
					})
				}
			}
		}
		ast.CallOrCastExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'embed_file' {
				return t.transform_embed_file_comptime_expr(ast.ComptimeExpr{
					expr: ast.Expr(expr)
					pos:  comptime_pos
				}, [expr.expr])
			}
		}
		ast.SelectorExpr {
			if transformed_lhs := t.transform_embed_file_chain_lhs(expr.lhs, comptime_pos) {
				return ast.Expr(ast.SelectorExpr{
					lhs: transformed_lhs
					rhs: expr.rhs
					pos: expr.pos
				})
			}
		}
		ast.ComptimeExpr {
			if transformed_inner := t.transform_embed_file_comptime_chain(expr.expr, expr.pos) {
				return transformed_inner
			}
		}
		else {}
	}

	return none
}

// lower_go_call transforms `go foo(a, b)` into a regular call to
// goroutines__goroutine_create, avoiding backend-specific go handling.
// For zero-arg calls: goroutines__goroutine_create(voidptr(foo), voidptr(0), 0)
// For calls with args: generates a wrapper struct + trampoline function,
// then calls goroutines__goroutine_create(trampoline, packed_args, sizeof).
fn (mut t Transformer) lower_go_call(expr ast.KeywordOperator) ast.Expr {
	call := expr.exprs[0]
	mut call_lhs := ast.empty_expr
	mut call_args := []ast.Expr{}
	if call is ast.CallExpr {
		call_lhs = call.lhs
		call_args = call.args.clone()
	} else if call is ast.CallOrCastExpr {
		call_lhs = call.lhs
		call_args = [call.expr]
	} else {
		// Not a call expression, return as-is
		return expr
	}
	// Resolve the V-level function name for the wrapper
	fn_name := t.resolve_go_fn_name(call_lhs)
	if fn_name == '' {
		// Cannot resolve — fall back to keeping the original expression
		return expr
	}
	// Transform all arguments
	mut transformed_args := []ast.Expr{cap: call_args.len}
	for arg in call_args {
		transformed_args << t.transform_expr(arg)
	}
	// Resolve argument type names for struct generation
	mut arg_type_names := []string{cap: call_args.len}
	for arg in call_args {
		if typ := t.get_expr_type(arg) {
			arg_type_names << t.type_to_c_name(typ)
		} else {
			arg_type_names << 'int'
		}
	}
	// Check for method call (receiver needs to be first arg in wrapper)
	mut is_method := false
	mut receiver_expr := ast.empty_expr
	mut receiver_type_name := ''
	if call_lhs is ast.SelectorExpr {
		sel := call_lhs as ast.SelectorExpr
		sel_lhs := sel.lhs
		if !(sel_lhs is ast.Ident && t.is_module_name((sel_lhs as ast.Ident).name)) {
			is_method = true
			receiver_expr = t.transform_expr(sel_lhs)
			if recv_type := t.get_expr_type(sel_lhs) {
				receiver_type_name = t.type_to_c_name(recv_type)
			} else {
				receiver_type_name = 'voidptr'
			}
		}
	}
	wrapper_name := '__go_wrap_${fn_name}'
	if wrapper_name !in t.needed_go_wrappers {
		mut param_names := []string{}
		mut param_types := []string{}
		if is_method {
			param_names << '_recv'
			param_types << receiver_type_name
		}
		for i, type_name in arg_type_names {
			param_names << '_a${i}'
			param_types << type_name
		}
		t.needed_go_wrappers[wrapper_name] = GoWrapperInfo{
			fn_name:      fn_name
			wrapper_name: wrapper_name
			param_names:  param_names
			param_types:  param_types
		}
	}
	// Build call args: [receiver, args...] for methods, [args...] for functions
	mut wrapper_args := []ast.Expr{}
	if is_method {
		wrapper_args << receiver_expr
	}
	for arg in transformed_args {
		wrapper_args << arg
	}
	return ast.CallExpr{
		lhs:  ast.Ident{
			name: wrapper_name
		}
		args: wrapper_args
		pos:  expr.pos
	}
}

// resolve_go_fn_name extracts the C-mangled function name from a call LHS expression.
fn (t &Transformer) resolve_go_fn_name(lhs ast.Expr) string {
	if lhs is ast.Ident {
		if t.cur_module != '' {
			return '${t.cur_module}__${lhs.name}'
		}
		return lhs.name
	}
	if lhs is ast.SelectorExpr {
		if lhs.lhs is ast.Ident {
			mod_name := lhs.lhs.name
			return '${mod_name}__${lhs.rhs.name}'
		}
	}
	return ''
}

// is_module_name checks if a name refers to a known module.
fn (t &Transformer) is_module_name(name string) bool {
	// Check if the name is a known module by looking up its scope
	return name in t.cached_scopes
}

// eval_comptime_if evaluates a compile-time $if and returns the selected branch expression