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

fn (mut t Transformer) register_if_guard_lhs_payload_type(lhs []ast.Expr, payload_type types.Type) {
	for expr in lhs {
		match expr {
			ast.Ident {
				if expr.name != '_' {
					t.remember_local_decl_type(expr.name, payload_type)
					t.register_local_var_type(expr.name, payload_type)
					if expr.pos.is_valid() {
						t.register_synth_type(expr.pos, payload_type)
					}
				}
			}
			ast.ModifierExpr {
				if expr.expr is ast.Ident {
					ident := expr.expr as ast.Ident
					if ident.name != '_' {
						t.remember_local_decl_type(ident.name, payload_type)
						t.register_local_var_type(ident.name, payload_type)
						if ident.pos.is_valid() {
							t.register_synth_type(ident.pos, payload_type)
						}
					}
				}
			}
			else {}
		}
	}
}

// try_expand_if_guard_assign_stmts expands an if-guard assignment to multiple statements.
// Transforms: x := if r := map[key] { r } else { default }
// Into (for maps):
//   x := if key in map { map[key] } else { default }
// Into (for other cases):
//   r := expr
//   x := if r { r } else { default }
fn (mut t Transformer) try_expand_if_guard_assign_stmts(stmt ast.AssignStmt) ?[]ast.Stmt {
	// Check for single assignment with IfExpr RHS
	if stmt.rhs.len != 1 || stmt.lhs.len != 1 {
		return none
	}
	rhs_expr := stmt.rhs[0]
	// Check if RHS is an IfExpr with IfGuardExpr condition
	if rhs_expr !is ast.IfExpr {
		return none
	}
	if_expr := rhs_expr as ast.IfExpr
	if if_expr.cond !is ast.IfGuardExpr {
		return none
	}
	guard := if_expr.cond as ast.IfGuardExpr

	// Extract guard variable name from LHS of the guard assignment
	mut guard_var_name := ''
	for lhs_expr in guard.stmt.lhs {
		if lhs_expr is ast.Ident {
			guard_var_name = lhs_expr.name
			break
		} else if lhs_expr is ast.ModifierExpr {
			if lhs_expr.expr is ast.Ident {
				guard_var_name = lhs_expr.expr.name
				break
			}
		}
	}
	if guard_var_name == '' || guard.stmt.rhs.len == 0 {
		return none
	}

	guard_rhs := guard.stmt.rhs[0]
	if t.expr_wrapper_type_for_or(guard_rhs) != none || t.expr_returns_result(guard_rhs)
		|| t.expr_returns_option(guard_rhs) {
		return none
	}
	synth_pos := t.next_synth_pos()

	// Check if RHS is a map index expression - use "key in map" condition
	if guard_rhs is ast.IndexExpr {
		if _ := t.get_map_type_for_expr(guard_rhs.lhs) {
			// This is a map access - transform using "key in map" check
			// x := if key in map { map[key] } else { default }
			key_in_map := t.make_infix_expr_at(.key_in, guard_rhs.expr, guard_rhs.lhs,
				guard_rhs.pos)

			// Build new stmts for the then-branch: guard_var := map[key]; <original stmts>
			mut new_then_stmts := []ast.Stmt{cap: if_expr.stmts.len + 1}
			new_then_stmts << ast.AssignStmt{
				op:  .decl_assign
				lhs: guard.stmt.lhs
				rhs: guard.stmt.rhs
				pos: guard.stmt.pos
			}
			for s in if_expr.stmts {
				new_then_stmts << s
			}

			modified_if := ast.IfExpr{
				cond:      key_in_map
				stmts:     new_then_stmts
				else_expr: if_expr.else_expr
				pos:       synth_pos
			}
			// Propagate the original IfExpr type to the synthesized node
			if orig_type := t.get_expr_type(ast.Expr(if_expr)) {
				t.register_synth_type(synth_pos, orig_type)
			}

			return [
				ast.Stmt(ast.AssignStmt{
					op:  stmt.op
					lhs: stmt.lhs
					rhs: [ast.Expr(modified_if)]
					pos: stmt.pos
				}),
			]
		}
	}

	// Non-map case: use original approach
	mut stmts := []ast.Stmt{}

	// 1. Guard variable declaration: r := expr
	stmts << ast.AssignStmt{
		op:  .decl_assign
		lhs: guard.stmt.lhs
		rhs: guard.stmt.rhs
		pos: guard.stmt.pos
	}

	// 2. Modified if expression with guard variable as condition
	//    x := if r { r } else { default }
	// Use synthesized position to avoid inheriting wrong type from original IfGuardExpr
	guard_ident := ast.Ident{
		name: guard_var_name
		pos:  synth_pos
	}
	modified_if := ast.IfExpr{
		cond:      guard_ident
		stmts:     if_expr.stmts
		else_expr: if_expr.else_expr
		pos:       synth_pos
	}
	// Propagate the original IfExpr type to the synthesized node
	if orig_type := t.get_expr_type(ast.Expr(if_expr)) {
		t.register_synth_type(synth_pos, orig_type)
	}
	stmts << ast.AssignStmt{
		op:  stmt.op
		lhs: stmt.lhs
		rhs: [ast.Expr(modified_if)]
		pos: stmt.pos
	}

	return stmts
}

// try_expand_if_guard_stmt expands a statement-level if-guard.
// Transforms: if attr := table[name] { use(attr) }
// Into: if (table[name]) { attr := table[name]; use(attr) }
// For Result types: if attr := fn_call() { use(attr) }
// Into: { _tmp := fn_call(); if (!_tmp.is_error) { attr := *(_tmp.data); use(attr) } else { else_body } }
fn (mut t Transformer) if_guard_else_expr_with_err(else_expr ast.Expr, temp_ident ast.Ident) ast.Expr {
	if else_expr is ast.IfExpr {
		else_if := else_expr as ast.IfExpr
		if else_if.cond is ast.EmptyExpr {
			mut else_stmts := []ast.Stmt{}
			else_stmts << ast.AssignStmt{
				op:  .decl_assign
				lhs: [ast.Expr(ast.Ident{
					name: 'err'
				})]
				rhs: [
					t.synth_selector(temp_ident, 'err', types.Type(types.Struct{
						name: 'IError'
					})),
				]
			}
			else_stmts << else_if.stmts
			return ast.IfExpr{
				cond:      else_if.cond
				stmts:     t.transform_stmts(else_stmts)
				else_expr: t.transform_expr(else_if.else_expr)
				pos:       else_if.pos
			}
		}
	}
	return t.transform_expr(else_expr)
}

fn (mut t Transformer) try_expand_if_guard_stmt(stmt ast.ExprStmt) ?[]ast.Stmt {
	// Check if this is an IfExpr with IfGuardExpr condition
	if stmt.expr !is ast.IfExpr {
		return none
	}
	if_expr := stmt.expr as ast.IfExpr
	if if_expr.cond !is ast.IfGuardExpr {
		return none
	}
	guard := if_expr.cond as ast.IfGuardExpr

	// The entire if-guard expansion is at statement position. Suppress value-
	// position IfExpr hoisting (`_if_t<N> := if ...`) for nested else-if chains
	// so they don't generate mistyped temps for what is really a statement.
	saved_skip := t.skip_if_value_lowering
	t.skip_if_value_lowering = true
	defer {
		t.skip_if_value_lowering = saved_skip
	}

	if guard.stmt.rhs.len == 0 {
		return none
	}

	mut rhs := guard.stmt.rhs[0]
	mut guard_prefix_stmts := []ast.Stmt{}
	if t.expr_has_or_expr(rhs) {
		rhs = t.extract_or_expr(rhs, mut guard_prefix_stmts)
	}
	synth_pos := t.next_synth_pos()

	// Check if RHS is a call that returns Result/Option
	// First try expression-based lookup (works for both function and method calls)
	mut is_result := t.expr_returns_result(rhs)
	mut is_option := t.expr_returns_option(rhs)

	// Fallback to function name lookup for simple function calls
	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 || is_option {
		// Handle Result/Option if-guard
		// Generate: { _tmp := call(); if (!_tmp.is_error) { attr := extractValue(_tmp); body } else { else } }
		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 stmts := []ast.Stmt{}
		mut data_type := types.Type(types.voidptr_)
		for prefix_stmt in guard_prefix_stmts {
			stmts << prefix_stmt
		}

		// Register temp variable type so cleanc can look up its type for .data unwrapping
		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
				is_result = true
				is_option = false
			} else if wrapper_type is types.OptionType {
				data_type = wrapper_type.base_type
				is_result = false
				is_option = true
			}
		} 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 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.ResultType {
				data_type = wrapper_type.base_type
			} else if wrapper_type is types.OptionType {
				data_type = wrapper_type.base_type
			}
		}

		// 1. _tmp := call()
		transformed_rhs := t.transform_expr(rhs)
		if t.pending_stmts.len > 0 {
			for ps in t.pending_stmts {
				stmts << ps
			}
			t.pending_stmts.clear()
		}
		stmts << ast.AssignStmt{
			op:  .decl_assign
			lhs: [ast.Expr(temp_ident)]
			rhs: [transformed_rhs]
			pos: temp_pos
		}

		// 2. Build condition: !_tmp.is_error (for Result) or _tmp.state == 0 (for Option)
		success_cond := if is_result {
			ast.Expr(ast.PrefixExpr{
				op:   .not
				expr: t.synth_selector(temp_ident, 'is_error', types.Type(types.bool_))
			})
		} else {
			t.make_infix_expr(.eq, t.synth_selector(temp_ident, 'state', types.Type(types.int_)),
				t.make_number_expr('0'))
		}

		// 3. Build if-body: attr := _tmp.data; original_body
		// cleanc handles the cast and dereference when it sees .data on Result type
		mut if_stmts := []ast.Stmt{}
		data_access := t.synth_selector(temp_ident, 'data', data_type)
		t.register_if_guard_lhs_payload_type(guard.stmt.lhs, data_type)
		if_stmts << ast.AssignStmt{
			op:  .decl_assign
			lhs: guard.stmt.lhs
			rhs: [data_access]
			pos: guard.stmt.pos
		}
		for s in if_expr.stmts {
			if_stmts << s
		}

		// 4. Build the if expression
		transformed_if_stmts := t.transform_stmts(if_stmts)
		modified_if := ast.IfExpr{
			cond:      success_cond
			stmts:     transformed_if_stmts
			else_expr: t.if_guard_else_expr_with_err(if_expr.else_expr, temp_ident)
			pos:       if_pos
		}
		// Propagate the original IfExpr type to the synthesized node
		if orig_type := t.get_expr_type(ast.Expr(if_expr)) {
			t.register_synth_type(if_pos, orig_type)
		}
		stmts << ast.ExprStmt{
			expr: modified_if
		}

		return stmts
	}

	// Non-Result/Option if-guard
	// Check if RHS is an index expression (map or array lookup)
	// For map lookups: if x := map[key] { use(x) }
	// Transform to: { _tmp := map__get_check(&map, &key); if (_tmp != nil) { x := *_tmp; use(x) } }
	// For array lookups: if x := arr[i] { use(x) }
	// Transform to: if (i < arr.len) { x := arr[i]; use(x) }
	if rhs is ast.IndexExpr {
		if map_expr_typ := t.get_expr_type(rhs.lhs) {
			if map_type := t.unwrap_map_type(map_expr_typ) {
				// This is a map lookup - use map__get_check pattern
				temp_pos := synth_pos
				if_pos := t.next_synth_pos()
				temp_name := t.gen_temp_name()
				temp_ident := ast.Ident{
					name: temp_name
					pos:  temp_pos
				}

				// Register temp variable type: map__get_check returns pointer to value type
				pointer_type := types.Type(types.Pointer{
					base_type: map_type.value_type
				})
				t.register_temp_var(temp_name, pointer_type)
				t.register_synth_type(temp_pos, pointer_type)

				mut prefix_stmts := []ast.Stmt{}
				map_arg := if t.is_pointer_type(map_expr_typ) {
					t.transform_expr(rhs.lhs)
				} else {
					t.addr_of_with_prefix_temp(rhs.lhs, map_expr_typ, mut prefix_stmts)
				}
				key_arg := t.addr_of_with_prefix_temp(rhs.expr, map_type.key_type, mut prefix_stmts)

				get_check_call := ast.CallExpr{
					lhs:  ast.Ident{
						name: 'map__get_check'
					}
					args: [
						map_arg,
						t.voidptr_cast(key_arg),
					]
				}
				temp_assign := ast.AssignStmt{
					op:  .decl_assign
					lhs: [ast.Expr(temp_ident)]
					rhs: [ast.Expr(get_check_call)]
					pos: synth_pos
				}

				// Build if body: guard_var := *_tmp; original_body
				// Use typed_deref to cast voidptr to correct pointer type
				// before dereference (map__get_check returns voidptr)
				mut if_stmts := []ast.Stmt{}
				deref_tmp := t.typed_deref(temp_ident, map_type.value_type)
				if_stmts << ast.AssignStmt{
					op:  .decl_assign
					lhs: guard.stmt.lhs
					rhs: [deref_tmp]
					pos: guard.stmt.pos
				}
				for s in if_expr.stmts {
					if_stmts << s
				}

				// Build condition: _tmp != nil
				null_check := t.make_infix_expr(.ne, ast.Expr(temp_ident), ast.Expr(ast.Ident{
					name: 'nil'
				}))

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

				prefix_stmts << ast.Stmt(temp_assign)
				prefix_stmts << ast.Stmt(ast.ExprStmt{
					expr: modified_if
				})
				return prefix_stmts
			}
		}

		// This is an array lookup - generate bounds check: index < array.len
		bounds_check := t.make_infix_expr_at(.lt, t.transform_expr(rhs.expr), t.synth_selector(t.transform_expr(rhs.lhs),
			'len', types.Type(types.int_)), rhs.pos)

		// Build if body: guard_var := arr[i]; original_body
		mut if_stmts := []ast.Stmt{}
		if_stmts << ast.AssignStmt{
			op:  .decl_assign
			lhs: guard.stmt.lhs
			rhs: guard.stmt.rhs
			pos: guard.stmt.pos
		}
		for s in if_expr.stmts {
			if_stmts << s
		}

		// Build the if expression
		modified_if := ast.IfExpr{
			cond:      bounds_check
			stmts:     t.transform_stmts(if_stmts)
			else_expr: t.transform_expr(if_expr.else_expr)
			pos:       synth_pos
		}
		// Propagate the original IfExpr type to the synthesized node
		if orig_type := t.get_expr_type(ast.Expr(if_expr)) {
			t.register_synth_type(synth_pos, orig_type)
		}

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

	rhs_expr := t.transform_expr(rhs)

	// For map lookups returning arrays, generate:
	// { arr := map[key]; if (arr.data != nil) { ... } }
	// This handles the case where "key exists" = "non-nil data"
	map_returns_array := t.is_map_lookup_returning_array(rhs)

	// Prepend guard variable assignment to stmts (inside the if body)
	guard_assign := ast.AssignStmt{
		op:  .decl_assign
		lhs: guard.stmt.lhs
		rhs: guard.stmt.rhs
		pos: guard.stmt.pos
	}
	mut new_stmts := []ast.Stmt{cap: if_expr.stmts.len + 1}
	new_stmts << guard_assign
	for s in if_expr.stmts {
		new_stmts << s
	}

	// Determine the condition to use
	mut cond_expr := ast.Expr(rhs_expr)
	if map_returns_array {
		// For arrays, check .data != nil (indicates key existed in map)
		// Extract guard variable name
		mut guard_var_name := ''
		for lhs_expr in guard.stmt.lhs {
			if lhs_expr is ast.Ident {
				guard_var_name = lhs_expr.name
				break
			}
		}
		// Check if it's a blank identifier - if so, use a temp variable
		is_blank := guard_var_name == '_'
		if is_blank {
			guard_var_name = t.gen_temp_name()
		}
		if guard_var_name != '' {
			// Generate: guard_var.data != nil
			// But we need to declare the variable first, so we generate:
			// { arr := map[key]; if (arr.data) { ... } }
			// Put assignment before the if, then use arr.data as condition
			// When blank, use temp variable instead of _
			temp_lhs := if is_blank {
				[
					ast.Expr(ast.Ident{
						name: guard_var_name
						pos:  synth_pos
					}),
				]
			} else {
				guard.stmt.lhs
			}
			temp_assign := ast.AssignStmt{
				op:  .decl_assign
				lhs: temp_lhs
				rhs: guard.stmt.rhs
				pos: guard.stmt.pos
			}
			// Remove the guard_assign from new_stmts since we're putting it before the if
			new_stmts = []ast.Stmt{cap: if_expr.stmts.len}
			for s in if_expr.stmts {
				new_stmts << s
			}
			// Use arr.data as condition
			cond_expr = t.synth_selector(ast.Ident{
				name: guard_var_name
				pos:  synth_pos
			}, 'data', types.Type(types.voidptr_))
			modified_if := ast.IfExpr{
				cond:      cond_expr
				stmts:     t.transform_stmts(new_stmts)
				else_expr: t.transform_expr(if_expr.else_expr)
				pos:       synth_pos
			}
			// Propagate the original IfExpr type to the synthesized node
			if orig_type := t.get_expr_type(ast.Expr(if_expr)) {
				t.register_synth_type(synth_pos, orig_type)
			}
			return [
				ast.Stmt(temp_assign),
				ast.Stmt(ast.ExprStmt{
					expr: modified_if
				}),
			]
		}
	}

	modified_if := ast.IfExpr{
		cond:      cond_expr
		stmts:     t.transform_stmts(new_stmts)
		else_expr: t.transform_expr(if_expr.else_expr)
		pos:       synth_pos
	}
	// Propagate the original IfExpr type to the synthesized node
	if orig_type := t.get_expr_type(ast.Expr(if_expr)) {
		t.register_synth_type(synth_pos, orig_type)
	}

	return [ast.Stmt(ast.ExprStmt{
		expr: modified_if
	})]
}

// try_expand_return_if_expr handles IfExpr in return statements
// Transforms: return if cond { a } else { b }
// Into: if cond { return a } else { return b }
fn (mut t Transformer) try_expand_return_if_expr(stmt ast.ReturnStmt) ?[]ast.Stmt {
	// Only handle single-expression returns with IfExpr
	if stmt.exprs.len != 1 {
		return none
	}
	if_expr := stmt.exprs[0]
	if if_expr !is ast.IfExpr {
		return none
	}
	ie := if_expr as ast.IfExpr
	// Must have an else branch to be a valid expression form
	if ie.else_expr is ast.EmptyExpr {
		return none
	}
	// Transform into if-statement with return in each branch
	return t.expand_return_if_expr(ie)
}

// try_expand_return_match_expr handles MatchExpr in return statements.
// It first lowers the match to an if-expression, then emits branch-local returns so
// optional/result and aggregate return ABI handling is applied independently per branch.
fn (mut t Transformer) try_expand_return_match_expr(stmt ast.ReturnStmt) ?[]ast.Stmt {
	if stmt.exprs.len != 1 {
		return none
	}
	match_expr := stmt.exprs[0]
	if match_expr !is ast.MatchExpr {
		return none
	}
	match_expr_ast := match_expr as ast.MatchExpr
	return_sumtype_info := t.current_return_sumtype_wrap_info() or { ConcreteSumtypeWrapInfo{} }
	should_wrap_return_sumtype := return_sumtype_info.name != ''
	skip_return_sumtype_wrap := (t.cur_fn_returns_option || t.cur_fn_returns_result)
		&& t.return_expr_should_skip_sumtype_wrap(match_expr)
	old_wrap := t.sumtype_return_wrap
	if should_wrap_return_sumtype && !skip_return_sumtype_wrap {
		t.sumtype_return_wrap = return_sumtype_info.name
	}
	old_preserve_match_branch_value := t.preserve_match_branch_value
	t.preserve_match_branch_value = true
	transformed := t.transform_match_expr(match_expr_ast)
	t.preserve_match_branch_value = old_preserve_match_branch_value
	t.sumtype_return_wrap = old_wrap
	if transformed is ast.IfExpr {
		ie := transformed as ast.IfExpr
		return t.expand_return_match_if_expr(ie)
	}
	return none
}

// expand_return_if_expr recursively expands an if-expression into if-statements with returns
fn (mut t Transformer) expand_return_if_expr(ie ast.IfExpr) []ast.Stmt {
	return t.expand_return_if_expr_with_options(ie, false)
}

fn (mut t Transformer) expand_return_match_if_expr(ie ast.IfExpr) []ast.Stmt {
	return t.expand_return_if_expr_with_options(ie, true)
}

fn (mut t Transformer) return_stmts_for_branch_expr(expr ast.Expr, allow_empty_else bool) []ast.Stmt {
	if expr is ast.IfExpr {
		return t.expand_return_if_expr_with_options(expr, allow_empty_else)
	}
	if t.is_void_call_expr(expr) {
		return [
			ast.Stmt(ast.ExprStmt{
				expr: expr
			}),
		]
	}
	if expr is ast.UnsafeExpr && expr.stmts.len > 0 {
		last := expr.stmts[expr.stmts.len - 1]
		if last is ast.ExprStmt && last.expr is ast.IfExpr {
			mut stmts := []ast.Stmt{cap: expr.stmts.len}
			if expr.stmts.len > 1 {
				for stmt in expr.stmts[..expr.stmts.len - 1] {
					stmts << stmt
				}
			}
			stmts << t.expand_return_if_expr_with_options(last.expr, allow_empty_else)
			return stmts
		}
	}
	return_expr := if info := t.current_return_sumtype_wrap_info() {
		t.wrap_sumtype_value_transformed_with_variants(expr, info.name, info.variants) or { expr }
	} else {
		expr
	}
	return [
		ast.Stmt(ast.ReturnStmt{
			exprs: [return_expr]
		}),
	]
}

fn (mut t Transformer) expand_return_if_expr_with_options(ie ast.IfExpr, allow_empty_else bool) []ast.Stmt {
	// Build the then-branch statements with return
	mut then_stmts := []ast.Stmt{}
	for i, s in ie.stmts {
		if i == ie.stmts.len - 1 {
			// Last statement - wrap in return if it's an expression
			if s is ast.ExprStmt {
				then_stmts << t.return_stmts_for_branch_expr(s.expr, allow_empty_else)
			} else {
				then_stmts << s
			}
		} else {
			then_stmts << s
		}
	}

	// Build the else-branch
	mut else_expr := ast.empty_expr
	if ie.else_expr is ast.IfExpr {
		else_ie := ie.else_expr as ast.IfExpr
		// Check if this is a pure else block (no condition)
		if else_ie.cond is ast.EmptyExpr {
			// Pure else - create an if block with just the else stmts that include return
			mut else_stmts := []ast.Stmt{}
			for i, s in else_ie.stmts {
				if i == else_ie.stmts.len - 1 {
					if s is ast.ExprStmt {
						else_stmts << t.return_stmts_for_branch_expr(s.expr, allow_empty_else)
					} else {
						else_stmts << s
					}
				} else {
					else_stmts << s
				}
			}
			else_expr = ast.Expr(ast.IfExpr{
				cond:      ast.empty_expr
				stmts:     else_stmts
				else_expr: ast.empty_expr
			})
		} else {
			// else-if chain - recursively expand
			expanded_else := t.expand_return_if_expr_with_options(else_ie, allow_empty_else)
			// The expanded result should be an ExprStmt containing an IfExpr
			if expanded_else.len > 0 && expanded_else[0] is ast.ExprStmt {
				expr_stmt := expanded_else[0] as ast.ExprStmt
				else_expr = expr_stmt.expr
			} else {
				// Fallback: wrap in else block
				else_expr = ast.Expr(ast.IfExpr{
					cond:      ast.empty_expr
					stmts:     expanded_else
					else_expr: ast.empty_expr
				})
			}
		}
	} else if ie.else_expr is ast.EmptyExpr && allow_empty_else {
		else_expr = ast.empty_expr
	} else {
		// Simple else - wrap the expression in return
		else_expr = ast.Expr(ast.IfExpr{
			cond:      ast.empty_expr
			stmts:     t.return_stmts_for_branch_expr(ie.else_expr, allow_empty_else)
			else_expr: ast.empty_expr
		})
	}

	// Create the transformed if expression (used as statement)
	transformed_if := ast.IfExpr{
		cond:      ie.cond
		stmts:     then_stmts
		else_expr: else_expr
	}
	// Wrap in ExprStmt to make it a valid statement
	return [ast.Stmt(ast.ExprStmt{
		expr: transformed_if
	})]
}

// try_expand_if_expr_assign_stmts handles assignment with IfExpr RHS.
// Transforms: lhs = if cond { a } else { b }
// Into: if cond { lhs = a } else { lhs = b }
fn (mut t Transformer) try_expand_if_expr_assign_stmts(stmt ast.AssignStmt) ?[]ast.Stmt {
	// Only handle simple assignment for now.
	if stmt.op != .assign || stmt.lhs.len != 1 || stmt.rhs.len != 1 {
		return none
	}
	rhs := stmt.rhs[0]
	if rhs !is ast.IfExpr {
		return none
	}
	ie := rhs as ast.IfExpr
	// Expression-form if must have else branch.
	if ie.else_expr is ast.EmptyExpr {
		return none
	}
	return t.expand_assign_if_expr(stmt.lhs[0], ie)
}

// expand_assign_if_expr recursively expands an if-expression into if-statements
// that perform assignment in each branch.
fn (mut t Transformer) expand_assign_if_expr(lhs ast.Expr, ie ast.IfExpr) []ast.Stmt {
	mut then_stmts := []ast.Stmt{}
	for i, s in ie.stmts {
		if i == ie.stmts.len - 1 && s is ast.ExprStmt {
			then_stmts << ast.AssignStmt{
				op:  .assign
				lhs: [lhs]
				rhs: [s.expr]
			}
		} else {
			then_stmts << s
		}
	}

	mut else_expr := ast.empty_expr
	if ie.else_expr is ast.IfExpr {
		else_ie := ie.else_expr as ast.IfExpr
		// else { ... }
		if else_ie.cond is ast.EmptyExpr {
			mut else_stmts := []ast.Stmt{}
			for i, s in else_ie.stmts {
				if i == else_ie.stmts.len - 1 && s is ast.ExprStmt {
					else_stmts << ast.AssignStmt{
						op:  .assign
						lhs: [lhs]
						rhs: [s.expr]
					}
				} else {
					else_stmts << s
				}
			}
			else_expr = ast.Expr(ast.IfExpr{
				cond:      ast.empty_expr
				stmts:     else_stmts
				else_expr: ast.empty_expr
			})
		} else {
			expanded_else := t.expand_assign_if_expr(lhs, else_ie)
			if expanded_else.len > 0 {
				first_else_stmt := expanded_else[0]
				if first_else_stmt is ast.ExprStmt {
					else_expr = (first_else_stmt as ast.ExprStmt).expr
				} else {
					else_expr = ast.Expr(ast.IfExpr{
						cond:      ast.empty_expr
						stmts:     expanded_else
						else_expr: ast.empty_expr
					})
				}
			} else {
				else_expr = ast.Expr(ast.IfExpr{
					cond:      ast.empty_expr
					stmts:     expanded_else
					else_expr: ast.empty_expr
				})
			}
		}
	} else {
		else_expr = ast.Expr(ast.IfExpr{
			cond:      ast.empty_expr
			stmts:     [
				ast.Stmt(ast.AssignStmt{
					op:  .assign
					lhs: [lhs]
					rhs: [ie.else_expr]
				}),
			]
			else_expr: ast.empty_expr
		})
	}

	transformed_if := ast.IfExpr{
		cond:      ie.cond
		stmts:     then_stmts
		else_expr: else_expr
	}
	return [ast.Stmt(ast.ExprStmt{
		expr: transformed_if
	})]
}

// if_expr_is_value returns true if the IfExpr produces a value (i.e., the body's
// last statement is an ExprStmt whose expression has a non-void type).
// This distinguishes value-position ifs from statement-position ifs that happen
// to have an else branch.
fn (t &Transformer) if_expr_is_value(ie ast.IfExpr) bool {
	if ie.stmts.len == 0 {
		return false
	}
	last := ie.stmts[ie.stmts.len - 1]
	if last !is ast.ExprStmt {
		return false
	}
	// Check that the expression actually produces a non-void value.
	// Statement-form ifs may end with void function calls or postfix ops
	// used for side effects (i++, println(...), etc).
	last_expr := (last as ast.ExprStmt).expr
	if typ := t.get_expr_type(last_expr) {
		type_name := t.type_to_c_name(typ)
		if type_name == '' || type_name == 'void' {
			return false
		}
	}
	return true
}

// try_expand_tuple_if_assign_stmts expands `x, y, w, h := if cond { a, b, c, d } else { e, f, g, h }`
// into individual declarations + if-statement with assignments:
//   x := 0; y := 0; w := 0; h := 0;
//   if cond { x = a; y = b; w = c; h = d } else { x = e; y = f; w = g; h = h2 }
fn (mut t Transformer) try_expand_tuple_if_assign_stmts(stmt ast.AssignStmt) ?[]ast.Stmt {
	if stmt.op != .decl_assign {
		return none
	}
	// Must have tuple LHS
	is_tuple_lhs := stmt.lhs.len > 1 || (stmt.lhs.len == 1 && stmt.lhs[0] is ast.Tuple)
	if !is_tuple_lhs {
		return none
	}
	// Must have single IfExpr RHS
	if stmt.rhs.len != 1 {
		return none
	}
	if stmt.rhs[0] !is ast.IfExpr {
		// Check if RHS might be Tuple containing an IfExpr
		return none
	}
	tuple_lhs := if stmt.lhs.len > 1 {
		stmt.lhs
	} else if stmt.lhs[0] is ast.Tuple {
		(stmt.lhs[0] as ast.Tuple).exprs
	} else {
		stmt.lhs
	}
	n := tuple_lhs.len
	if n == 0 {
		return none
	}
	if_expr := stmt.rhs[0] as ast.IfExpr
	// Extract tuple values from then branch
	then_stmts := t.build_tuple_branch_assigns(if_expr.stmts, tuple_lhs, n, stmt.pos) or {
		return none
	}
	// Process else branch
	mut else_expr := ast.Expr(ast.empty_expr)
	if if_expr.else_expr is ast.IfExpr {
		else_if := if_expr.else_expr as ast.IfExpr
		if else_if.cond is ast.EmptyExpr {
			// Plain else block
			else_stmts := t.build_tuple_branch_assigns(else_if.stmts, tuple_lhs, n, stmt.pos) or {
				return none
			}
			else_expr = ast.IfExpr{
				stmts: else_stmts
				pos:   else_if.pos
			}
		} else {
			// else-if chain
			else_if_stmts := t.build_tuple_branch_assigns(else_if.stmts, tuple_lhs, n, stmt.pos) or {
				return none
			}
			else_expr = ast.IfExpr{
				cond:      else_if.cond
				stmts:     else_if_stmts
				else_expr: else_if.else_expr
				pos:       else_if.pos
			}
		}
	}
	// Build result: declarations for each variable, then the if-statement
	mut result := []ast.Stmt{cap: n + 1}
	for lhs_expr in tuple_lhs {
		result << ast.Stmt(ast.AssignStmt{
			op:  .decl_assign
			lhs: [lhs_expr]
			rhs: [ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '0'
			})]
			pos: stmt.pos
		})
	}
	result << ast.Stmt(ast.ExprStmt{
		expr: ast.IfExpr{
			cond:      if_expr.cond
			stmts:     then_stmts
			else_expr: else_expr
			pos:       if_expr.pos
		}
	})
	return result
}

// extract_branch_tuple_values extracts N values from a branch's last statement.
// The last statement should be an ExprStmt containing either a Tuple or a single expression.
fn (t &Transformer) extract_branch_tuple_values(stmts []ast.Stmt, n int) ?[]ast.Expr {
	if stmts.len == 0 {
		return none
	}
	// Find last non-empty statement (skip trailing EmptyStmt)
	mut last_idx := stmts.len - 1
	for last_idx >= 0 && stmts[last_idx] is ast.EmptyStmt {
		last_idx--
	}
	if last_idx < 0 {
		return none
	}
	last := stmts[last_idx]
	if last !is ast.ExprStmt {
		return none
	}
	last_expr := (last as ast.ExprStmt).expr
	if last_expr is ast.Tuple {
		if last_expr.exprs.len == n {
			return last_expr.exprs
		}
		return none
	}
	// Single expression, only valid for n == 1
	if n == 1 {
		return [last_expr]
	}
	return none
}

// build_tuple_branch_assigns builds assignment statements for a tuple if-expression branch.
// If the branch ends with a Tuple literal (a, b, c), it assigns each element directly.
// If the branch ends with a single call expression returning a tuple, it assigns the call
// to a temp variable and extracts .arg0, .arg1, etc.
fn (mut t Transformer) build_tuple_branch_assigns(stmts []ast.Stmt, tuple_lhs []ast.Expr, n int, pos token.Pos) ?[]ast.Stmt {
	if tuple_values := t.extract_branch_tuple_values(stmts, n) {
		// Branch has explicit tuple values — assign each one directly
		mut result := []ast.Stmt{cap: n}
		for i in 0 .. n {
			result << ast.Stmt(ast.AssignStmt{
				op:  .assign
				lhs: [tuple_lhs[i]]
				rhs: [tuple_values[i]]
				pos: pos
			})
		}
		return result
	}
	// Branch has a single non-tuple expression (e.g. a function call returning a tuple).
	// Extract it and assign via temp: _tuple_tN = call(); x = _tuple_tN.arg0; y = _tuple_tN.arg1
	if stmts.len == 0 {
		return none
	}
	mut last_idx := stmts.len - 1
	for last_idx >= 0 && stmts[last_idx] is ast.EmptyStmt {
		last_idx--
	}
	if last_idx < 0 {
		return none
	}
	last := stmts[last_idx]
	if last !is ast.ExprStmt {
		return none
	}
	last_expr := (last as ast.ExprStmt).expr
	if last_expr is ast.Tuple {
		return none // Tuple case was already handled above
	}
	// Single expression returning a tuple (e.g. function call)
	t.temp_counter++
	tmp_name := '_tuple_t${t.temp_counter}'
	tmp_ident := ast.Ident{
		name: tmp_name
	}
	mut result := []ast.Stmt{cap: n + 1}
	// Include any preceding statements from the branch
	for i in 0 .. last_idx {
		if stmts[i] !is ast.EmptyStmt {
			result << stmts[i]
		}
	}
	// Assign call result to temp
	result << ast.Stmt(ast.AssignStmt{
		op:  .decl_assign
		lhs: [ast.Expr(tmp_ident)]
		rhs: [last_expr]
		pos: pos
	})
	// Extract .arg0, .arg1, etc.
	for i in 0 .. n {
		result << ast.Stmt(ast.AssignStmt{
			op:  .assign
			lhs: [tuple_lhs[i]]
			rhs: [
				ast.Expr(ast.SelectorExpr{
					lhs: tmp_ident
					rhs: ast.Ident{
						name: 'arg${i}'
					}
				}),
			]
			pos: pos
		})
	}
	return result
}

// lower_if_expr_value lowers a value-position IfExpr into a temp variable + statement-form if.
// Generates: _if_t<N> := if cond { a } else { b }
// Hoists the decl_assign via pending_stmts and returns the temp ident as replacement.
fn (mut t Transformer) lower_if_expr_value(ie ast.IfExpr) ast.Expr {
	t.temp_counter++
	tmp_name := '_if_t${t.temp_counter}'
	tmp_ident := ast.Ident{
		name: tmp_name
	}
	// Register temp variable type so cleanc can resolve it from scope
	if typ := t.get_expr_type(ast.Expr(ie)) {
		t.register_temp_var(tmp_name, typ)
	}
	// Hoist the decl_assign with the IfExpr as RHS.
	// cleanc's gen_assign_stmt already handles decl_assign + IfExpr RHS
	// by emitting: Type tmp; if (cond) { tmp = a; } else { tmp = b; }
	t.pending_stmts << ast.Stmt(ast.AssignStmt{
		op:  .decl_assign
		lhs: [ast.Expr(tmp_ident)]
		rhs: [ast.Expr(ie)]
		pos: ie.pos
	})
	return ast.Expr(tmp_ident)
}

fn (mut t Transformer) collect_defers_in_if(node ast.IfExpr, mut defer_bodies [][]ast.Stmt) ast.Expr {
	new_else := t.collect_defers_in_else(node.else_expr, mut defer_bodies)
	return ast.IfExpr{
		cond:      node.cond
		stmts:     t.collect_and_remove_defers(node.stmts, mut defer_bodies)
		else_expr: new_else
	}
}

fn (mut t Transformer) collect_defers_in_else(else_expr ast.Expr, mut defer_bodies [][]ast.Stmt) ast.Expr {
	if else_expr is ast.IfExpr {
		return t.collect_defers_in_if(else_expr, mut defer_bodies)
	}
	return else_expr
}

// inject_defer_before_returns walks the statement list and replaces return statements
// with: { defer_body; return expr; } — saving the return value in a temp var if needed.
fn (mut t Transformer) inject_defer_before_returns(stmts []ast.Stmt, defer_stmts []ast.Stmt, has_return_type bool) []ast.Stmt {
	mut result := []ast.Stmt{cap: stmts.len}
	for stmt in stmts {
		match stmt {
			ast.ReturnStmt {
				if has_return_type && stmt.exprs.len > 0 {
					// Save return value to temp, run defers, return temp
					t.temp_counter++
					temp_name := '_defer_t${t.temp_counter}'
					if expr_type := t.get_expr_type(stmt.exprs[0]) {
						t.register_temp_var(temp_name, expr_type)
					}
					ret_expr := ast.Expr(stmt.exprs[0])
					result << ast.Stmt(ast.AssignStmt{
						op:  .decl_assign
						lhs: [ast.Expr(ast.Ident{
							name: temp_name
						})]
						rhs: [ret_expr]
					})
					result << defer_stmts
					result << ast.Stmt(ast.ReturnStmt{
						exprs: [ast.Expr(ast.Ident{
							name: temp_name
						})]
					})
				} else {
					result << defer_stmts
					result << ast.Stmt(stmt)
				}
			}
			ast.ExprStmt {
				expr := stmt.expr
				if expr is ast.IfExpr {
					result << ast.Stmt(ast.ExprStmt{
						expr: t.inject_defer_in_if_expr(expr, defer_stmts, has_return_type)
					})
				} else {
					result << ast.Stmt(stmt)
				}
			}
			ast.ForStmt {
				result << ast.Stmt(ast.ForStmt{
					init:  stmt.init
					cond:  stmt.cond
					post:  stmt.post
					stmts: t.inject_defer_before_returns(stmt.stmts, defer_stmts, has_return_type)
				})
			}
			ast.BlockStmt {
				result << ast.Stmt(ast.BlockStmt{
					stmts: t.inject_defer_before_returns(stmt.stmts, defer_stmts, has_return_type)
				})
			}
			else {
				result << stmt
			}
		}
	}
	return result
}

fn (mut t Transformer) inject_defer_in_if_expr(node ast.IfExpr, defer_stmts []ast.Stmt, has_return_type bool) ast.Expr {
	new_else := t.inject_defer_in_else(node.else_expr, defer_stmts, has_return_type)
	return ast.IfExpr{
		cond:      node.cond
		stmts:     t.inject_defer_before_returns(node.stmts, defer_stmts, has_return_type)
		else_expr: new_else
	}
}

fn (mut t Transformer) inject_defer_in_else(else_expr ast.Expr, defer_stmts []ast.Stmt, has_return_type bool) ast.Expr {
	match else_expr {
		ast.IfExpr {
			// else if: recurse
			return t.inject_defer_in_if_expr(else_expr, defer_stmts, has_return_type)
		}
		ast.EmptyExpr {
			return else_expr
		}
		else {
			return else_expr
		}
	}
}

// transform_comptime_expr evaluates compile-time conditionals and returns the selected branch
fn (mut t Transformer) eval_comptime_if(node ast.IfExpr) ast.Expr {
	cond_result := t.eval_comptime_cond(node.cond)

	if cond_result {
		// Condition is true - return the then branch with transformed statements
		if node.stmts.len == 1 {
			stmt := node.stmts[0]
			if stmt is ast.ExprStmt {
				return t.transform_expr(stmt.expr)
			}
		}
		// Multi-statement branch at expression level can't be represented;
		// statement-level expansion handles these properly
		return ast.empty_expr
	} else {
		// Condition is false - evaluate else branch
		else_e := node.else_expr
		if else_e !is ast.EmptyExpr {
			if else_e is ast.IfExpr {
				if else_e.cond is ast.EmptyExpr {
					// Plain $else block
					if else_e.stmts.len == 1 {
						stmt := else_e.stmts[0]
						if stmt is ast.ExprStmt {
							return t.transform_expr(stmt.expr)
						}
					}
					// Multi-statement $else at expression level
					return ast.empty_expr
				} else {
					// $else $if - recursive evaluation
					return t.eval_comptime_if(else_e)
				}
			}
		}
	}
	// Condition is false and no else branch - return empty (comptime block is skipped)
	return ast.empty_expr
}

// resolve_comptime_if_stmts evaluates a compile-time $if condition and returns
// the selected branch's statements, fully resolving the comptime at statement level.
fn (mut t Transformer) resolve_comptime_if_stmts(node ast.IfExpr) []ast.Stmt {
	cond_result := t.eval_comptime_cond(node.cond)
	if cond_result {
		return node.stmts
	}
	// Condition is false - evaluate else branch
	else_e := node.else_expr
	if else_e is ast.IfExpr {
		if else_e.cond is ast.EmptyExpr {
			// Plain $else block
			return else_e.stmts
		}
		// $else $if - recursive evaluation
		return t.resolve_comptime_if_stmts(else_e)
	}
	return []
}

// can_eval_comptime_cond returns true if the transformer can evaluate this
// comptime condition. Returns false for conditions involving generic type
// checks (key_is/not_is) that need to be resolved by the backend.
fn (t &Transformer) can_eval_comptime_cond(cond ast.Expr) bool {
	match cond {
		ast.Ident {
			return true
		}
		ast.ComptimeExpr {
			return t.can_eval_comptime_cond(cond.expr)
		}
		ast.CallExpr {
			return transformer_pkgconfig_call_name(cond) != none
		}
		ast.CallOrCastExpr {
			return transformer_pkgconfig_call_name(cond) != none
		}
		ast.PrefixExpr {
			return t.can_eval_comptime_cond(cond.expr)
		}
		ast.InfixExpr {
			if cond.op == .key_is || cond.op == .not_is {
				return false
			}
			return t.can_eval_comptime_cond(cond.lhs) && t.can_eval_comptime_cond(cond.rhs)
		}
		ast.PostfixExpr {
			return true
		}
		ast.ParenExpr {
			return t.can_eval_comptime_cond(cond.expr)
		}
		else {
			return false
		}
	}
}

fn (t &Transformer) can_eval_comptime_cond_cursor(cond ast.Cursor) bool {
	if !cond.is_valid() {
		return false
	}
	match cond.kind() {
		.expr_ident {
			return true
		}
		.expr_comptime, .expr_paren {
			return t.can_eval_comptime_cond_cursor(cond.edge(0))
		}
		.expr_call, .expr_call_or_cast {
			return transformer_pkgconfig_call_name_cursor(cond) != none
		}
		.expr_prefix {
			return t.can_eval_comptime_cond_cursor(cond.edge(0))
		}
		.expr_infix {
			op := unsafe { token.Token(int(cond.aux())) }
			if op == .key_is || op == .not_is {
				return false
			}
			return t.can_eval_comptime_cond_cursor(cond.edge(0))
				&& t.can_eval_comptime_cond_cursor(cond.edge(1))
		}
		.expr_postfix {
			return true
		}
		else {
			return false
		}
	}
}

// transform_comptime_if_bodies recursively transforms the body stmts of each
// branch in a comptime $if, without evaluating the condition. This is used when
// the condition can't be evaluated at transform time (e.g., generic type checks).
fn (mut t Transformer) transform_comptime_if_bodies(node ast.IfExpr) ast.IfExpr {
	transformed_stmts := t.transform_stmts(node.stmts)
	mut transformed_else := node.else_expr
	if node.else_expr is ast.IfExpr {
		else_if := node.else_expr as ast.IfExpr
		transformed_else_if := t.transform_comptime_if_bodies(else_if)
		transformed_else = ast.Expr(transformed_else_if)
	}
	return ast.IfExpr{
		cond:      node.cond
		stmts:     transformed_stmts
		else_expr: transformed_else
	}
}

// eval_comptime_cond evaluates a compile-time condition expression
fn (t &Transformer) eval_comptime_cond(cond ast.Expr) bool {
	match cond {
		ast.Ident {
			return t.eval_comptime_flag(cond.name)
		}
		ast.ComptimeExpr {
			return t.eval_comptime_cond(cond.expr)
		}
		ast.CallExpr {
			if pkg_name := transformer_pkgconfig_call_name(cond) {
				return t.eval_pkgconfig_cond(pkg_name)
			}
		}
		ast.CallOrCastExpr {
			if pkg_name := transformer_pkgconfig_call_name(cond) {
				return t.eval_pkgconfig_cond(pkg_name)
			}
		}
		ast.PrefixExpr {
			if cond.op == .not {
				return !t.eval_comptime_cond(cond.expr)
			}
		}
		ast.InfixExpr {
			if cond.op == .and {
				return t.eval_comptime_cond(cond.lhs) && t.eval_comptime_cond(cond.rhs)
			}
			if cond.op == .logical_or {
				return t.eval_comptime_cond(cond.lhs) || t.eval_comptime_cond(cond.rhs)
			}
		}
		ast.PostfixExpr {
			// Handle optional feature check: feature?
			if cond.op == .question {
				inner := cond.expr
				if inner is ast.Ident {
					return pref.comptime_optional_flag_value(t.pref, inner.name)
				}
			}
		}
		ast.ParenExpr {
			return t.eval_comptime_cond(cond.expr)
		}
		else {}
	}

	return false
}

fn (t &Transformer) eval_comptime_cond_cursor(cond ast.Cursor) bool {
	if !cond.is_valid() {
		return false
	}
	match cond.kind() {
		.expr_ident {
			return t.eval_comptime_flag(cond.name())
		}
		.expr_comptime {
			return t.eval_comptime_cond_cursor(cond.edge(0))
		}
		.expr_call, .expr_call_or_cast {
			if pkg_name := transformer_pkgconfig_call_name_cursor(cond) {
				return t.eval_pkgconfig_cond(pkg_name)
			}
		}
		.expr_prefix {
			op := unsafe { token.Token(int(cond.aux())) }
			if op == .not {
				return !t.eval_comptime_cond_cursor(cond.edge(0))
			}
		}
		.expr_infix {
			op := unsafe { token.Token(int(cond.aux())) }
			if op == .and {
				return t.eval_comptime_cond_cursor(cond.edge(0))
					&& t.eval_comptime_cond_cursor(cond.edge(1))
			}
			if op == .logical_or {
				return t.eval_comptime_cond_cursor(cond.edge(0))
					|| t.eval_comptime_cond_cursor(cond.edge(1))
			}
		}
		.expr_postfix {
			op := unsafe { token.Token(int(cond.aux())) }
			inner := cond.edge(0)
			if op == .question && inner.is_valid() && inner.kind() == .expr_ident {
				return pref.comptime_optional_flag_value(t.pref, inner.name())
			}
		}
		.expr_paren {
			return t.eval_comptime_cond_cursor(cond.edge(0))
		}
		else {}
	}

	return false
}

fn (t &Transformer) eval_pkgconfig_cond(pkg_name string) bool {
	if t.pref.is_cross_target() {
		return false
	}
	return pref.comptime_pkgconfig_value(pkg_name)
}

fn transformer_pkgconfig_call_name(expr ast.Expr) ?string {
	match expr {
		ast.CallExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'pkgconfig' && expr.args.len == 1 {
				return transformer_string_literal_value(expr.args[0])
			}
		}
		ast.CallOrCastExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'pkgconfig' {
				return transformer_string_literal_value(expr.expr)
			}
		}
		else {}
	}

	return none
}

fn transformer_pkgconfig_call_name_cursor(expr ast.Cursor) ?string {
	match expr.kind() {
		.expr_call {
			lhs := expr.edge(0)
			if lhs.is_valid() && lhs.kind() == .expr_ident && lhs.name() == 'pkgconfig'
				&& expr.edge_count() == 2 {
				return transformer_string_literal_value_cursor(expr.edge(1))
			}
		}
		.expr_call_or_cast {
			lhs := expr.edge(0)
			if lhs.is_valid() && lhs.kind() == .expr_ident && lhs.name() == 'pkgconfig' {
				return transformer_string_literal_value_cursor(expr.edge(1))
			}
		}
		else {}
	}

	return none
}

fn transformer_string_literal_value(expr ast.Expr) ?string {
	if expr is ast.StringLiteral {
		return transformer_unquote_string_literal_value(expr.value)
	}
	return none
}

fn transformer_string_literal_value_cursor(expr ast.Cursor) ?string {
	if !expr.is_valid() || expr.kind() != .expr_string {
		return none
	}
	return transformer_unquote_string_literal_value(expr.name())
}

fn transformer_unquote_string_literal_value(value string) string {
	if value.len >= 2 && ((value[0] == `"` && value[value.len - 1] == `"`)
		|| (value[0] == `'` && value[value.len - 1] == `'`)) {
		return value[1..value.len - 1]
	}
	return value
}

// eval_comptime_flag delegates to the shared `pref.comptime_flag_value` so
// the parser and the transformer recognize exactly the same flag names.
fn (t &Transformer) eval_comptime_flag(name string) bool {
	// Fast path: the three native-backend gated flags hit the cached bool
	// rather than the helper's repeated pref/backend comparisons.
	if name == 'native' || name == 'builtin_write_buf_to_fd_should_use_c_write' || name == 'tinyc' {
		return t.is_native_be
	}
	return pref.comptime_flag_value(t.pref, name)
}