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

import v2.ast
import v2.types

fn (mut g Gen) set_file_module(file ast.File) {
	g.cur_file_name = file.name
	g.cur_import_modules.clear()
	for imp in file.imports {
		mod_name := if imp.name.contains('.') { imp.name.all_after_last('.') } else { imp.name }
		if imp.alias != '' {
			g.cur_import_modules[imp.alias] = mod_name
		}
		if !imp.is_aliased && mod_name != '' {
			g.cur_import_modules[mod_name] = mod_name
		}
	}
	g.is_module_ident_cache.clear()
	g.resolved_module_names.clear()
	for stmt in file.stmts {
		if stmt is ast.ModuleStmt {
			g.cur_module = stmt.name.replace('.', '_')
			return
		}
	}
	g.cur_module = if file.mod != '' { file.mod.replace('.', '_') } else { 'main' }
}

fn (mut g Gen) set_file_cursor_module(fc ast.FileCursor) {
	g.cur_file_name = fc.name()
	g.cur_import_modules.clear()
	imports := fc.imports()
	for i in 0 .. imports.len() {
		stmt := imports.at(i)
		if stmt.kind() != .stmt_import {
			continue
		}
		imp := stmt.import_stmt()
		mod_name := if imp.name.contains('.') { imp.name.all_after_last('.') } else { imp.name }
		if imp.alias != '' {
			g.cur_import_modules[imp.alias] = mod_name
		}
		if !imp.is_aliased && mod_name != '' {
			g.cur_import_modules[mod_name] = mod_name
		}
	}
	g.cur_module = flat_file_module_name(fc)
	g.is_module_ident_cache.clear()
	g.resolved_module_names.clear()
}

fn (mut g Gen) restore_file_module_context(file_name string, module_name string, import_modules map[string]string) {
	g.cur_file_name = file_name
	g.cur_module = module_name
	g.cur_import_modules = import_modules.clone()
	g.is_module_ident_cache.clear()
	g.resolved_module_names.clear()
}

fn (mut g Gen) gen_stmts(stmts []ast.Stmt) {
	saved_file_name := g.cur_file_name
	saved_module := g.cur_module
	mut saved_import_modules := g.cur_import_modules.clone()
	for i in 0 .. stmts.len {
		g.gen_stmt(stmts[i])
		// A ModuleStmt (or a spliced generated-fn body) can switch the module
		// context mid-list; restore the source context so the following
		// statements resolve against the original module. The cheap dirty
		// check keeps the hot path free of per-statement map clones.
		if g.cur_module != saved_module || g.cur_file_name != saved_file_name
			|| g.cur_import_modules.len != saved_import_modules.len {
			g.cur_file_name = saved_file_name
			g.cur_module = saved_module
			g.cur_import_modules = saved_import_modules.clone()
			g.is_module_ident_cache.clear()
			g.resolved_module_names.clear()
		}
	}
	g.cur_file_name = saved_file_name
	g.cur_module = saved_module
	g.cur_import_modules = saved_import_modules.move()
	g.is_module_ident_cache.clear()
	g.resolved_module_names.clear()
}

fn (mut g Gen) gen_scoped_stmts(stmts []ast.Stmt) {
	mut saved_runtime_local_types := g.runtime_local_types.clone()
	mut saved_runtime_decl_types := g.runtime_decl_types.clone()
	mut saved_not_local_var_cache := g.not_local_var_cache.clone()
	g.gen_stmts(stmts)
	g.runtime_local_types = saved_runtime_local_types.move()
	g.runtime_decl_types = saved_runtime_decl_types.move()
	g.not_local_var_cache = saved_not_local_var_cache.move()
}

fn (mut g Gen) gen_scoped_expr_stmts(expr ast.Expr) {
	mut saved_runtime_local_types := g.runtime_local_types.clone()
	mut saved_runtime_decl_types := g.runtime_decl_types.clone()
	mut saved_not_local_var_cache := g.not_local_var_cache.clone()
	g.gen_stmts_from_expr(expr)
	g.runtime_local_types = saved_runtime_local_types.move()
	g.runtime_decl_types = saved_runtime_decl_types.move()
	g.not_local_var_cache = saved_not_local_var_cache.move()
}

fn tuple_field_types_need_stmt_expr(field_types []string) bool {
	for field_type in field_types {
		if field_type.starts_with('Array_fixed_') && !field_type.ends_with('*') {
			return true
		}
	}
	return false
}

fn (mut g Gen) gen_tuple_field_expr_value(field_type string, expr ast.Expr) {
	if g.is_interface_type(field_type) {
		expr_type := g.get_expr_type(expr).trim_right('*')
		if expr_type != '' && expr_type != field_type && !g.is_interface_type(expr_type) {
			if g.gen_interface_cast(field_type, expr) {
				return
			}
		}
	}
	g.expr(expr)
}

fn (mut g Gen) gen_tuple_field_stmt_expr_assign(tuple_name string, idx int, field_type string, expr ast.Expr) {
	field_name := '${tuple_name}.arg${idx}'
	if field_type.starts_with('Array_fixed_') && !field_type.ends_with('*') {
		if expr is ast.CallExpr {
			if call_ret := g.get_call_return_type(expr.lhs, expr.args) {
				if call_ret == field_type {
					wrapper_type := g.c_fn_return_type_from_v(field_type)
					tmp_name := '_tuple_arr_${g.tmp_counter}'
					g.tmp_counter++
					g.sb.write_string('{ ${wrapper_type} ${tmp_name} = ')
					g.expr(expr)
					g.sb.write_string('; memcpy(${field_name}, ${tmp_name}.ret_arr, sizeof(${field_type})); } ')
					return
				}
			}
		}
		if expr is ast.IfExpr {
			g.gen_decl_if_expr(field_name, field_type, &expr)
			return
		}
		g.sb.write_string('memcpy(${field_name}, ')
		if expr is ast.ArrayInitExpr {
			g.sb.write_string('((${field_type})')
			g.expr(expr)
			g.sb.write_string(')')
		} else {
			g.expr(expr)
		}
		g.sb.write_string(', sizeof(${field_type})); ')
		return
	}
	g.sb.write_string('${field_name} = ')
	g.gen_tuple_field_expr_value(field_type, expr)
	g.sb.write_string('; ')
}

fn (mut g Gen) gen_tuple_value_stmt_expr(tuple_type string, tuple_exprs []ast.Expr, field_types []string) {
	tmp_name := '_tuple_ret_${g.tmp_counter}'
	g.tmp_counter++
	g.sb.write_string('({ ${tuple_type} ${tmp_name} = (${tuple_type}){0}; ')
	for i, field_type in field_types {
		if i < tuple_exprs.len {
			g.gen_tuple_field_stmt_expr_assign(tmp_name, i, field_type, tuple_exprs[i])
		} else if field_type.starts_with('Array_fixed_') && !field_type.ends_with('*') {
			g.sb.write_string('memset(${tmp_name}.arg${i}, 0, sizeof(${field_type})); ')
		} else {
			g.sb.write_string('${tmp_name}.arg${i} = ${zero_value_for_type(field_type)}; ')
		}
	}
	g.sb.write_string('${tmp_name}; })')
}

fn (mut g Gen) gen_stmt(node ast.Stmt) {
	if !stmt_has_valid_data(node) {
		return
	}
	match node {
		ast.FnDecl {
			g.gen_fn_decl(node)
		}
		ast.AssignStmt {
			g.gen_assign_stmt(node)
		}
		ast.ExprStmt {
			if node.expr is ast.IfExpr {
				g.write_indent()
				if_expr := node.expr as ast.IfExpr
				g.gen_if_expr_stmt(&if_expr)
				return
			}
			if node.expr is ast.UnsafeExpr {
				unsafe_expr := node.expr as ast.UnsafeExpr
				if unsafe_expr.stmts.len > 1 {
					g.write_indent()
					g.sb.writeln('{')
					g.indent++
				}
				for stmt in unsafe_expr.stmts {
					g.gen_stmt(stmt)
				}
				if unsafe_expr.stmts.len > 1 {
					g.indent--
					g.write_indent()
					g.sb.writeln('}')
				}
				return
			}
			if node.expr is ast.ComptimeExpr {
				comptime_expr := node.expr as ast.ComptimeExpr
				if comptime_expr.expr is ast.IfExpr {
					g.gen_comptime_if_stmt(comptime_expr.expr as ast.IfExpr)
					return
				}
			}
			if !expr_has_valid_data(node.expr) {
				return
			}
			g.write_indent()
			g.expr(node.expr)
			g.sb.writeln(';')
		}
		ast.ReturnStmt {
			g.emit_scheduled_drops_at_return()
			g.write_indent()
			if g.is_tuple_alias(g.cur_fn_ret_type) {
				if node.exprs.len == 1 {
					expr := node.exprs[0]
					if g.get_expr_type(expr) == g.cur_fn_ret_type {
						g.sb.write_string('return ')
						g.expr(expr)
						g.sb.writeln(';')
						return
					}
				}
				mut tuple_exprs := shallow_copy_exprs(node.exprs)
				if node.exprs.len == 1 && node.exprs[0] is ast.Tuple {
					tuple_expr := node.exprs[0] as ast.Tuple
					tuple_exprs = shallow_copy_exprs(tuple_expr.exprs)
				}
				field_types := g.tuple_aliases[g.cur_fn_ret_type] or { []string{} }
				if tuple_field_types_need_stmt_expr(field_types) {
					g.sb.write_string('return ')
					g.gen_tuple_value_stmt_expr(g.cur_fn_ret_type, tuple_exprs, field_types)
					g.sb.writeln(';')
					return
				}
				g.sb.write_string('return ((${g.cur_fn_ret_type}){')
				for i, field_type in field_types {
					if i > 0 {
						g.sb.write_string(', ')
					}
					g.sb.write_string('.arg${i} = ')
					if i < tuple_exprs.len {
						g.gen_tuple_field_expr_value(field_type, tuple_exprs[i])
					} else {
						g.sb.write_string(zero_value_for_type(field_type))
					}
				}
				g.sb.writeln('});')
				return
			}
			if node.exprs.len == 1 && node.exprs[0] is ast.IfExpr {
				if_expr := node.exprs[0] as ast.IfExpr
				g.gen_return_if_expr(if_expr, false)
				return
			}
			if g.cur_fn_ret_type.starts_with('Array_fixed_') {
				if node.exprs.len == 0 {
					g.sb.writeln('return (${g.cur_fn_c_ret_type}){0};')
					return
				}
				expr := node.exprs[0]
				g.sb.write_string('return ({ ${g.cur_fn_c_ret_type} _ret = (${g.cur_fn_c_ret_type}){0}; ')
				if expr is ast.CallExpr {
					if call_ret := g.get_call_return_type(expr.lhs, expr.args) {
						if call_ret == g.cur_fn_ret_type {
							g.sb.write_string('${g.cur_fn_c_ret_type} _tmp = ')
							g.expr(expr)
							g.sb.writeln('; memcpy(_ret.ret_arr, _tmp.ret_arr, sizeof(${g.cur_fn_ret_type})); _ret; });')
							return
						}
					}
				}
				if expr is ast.Ident || expr is ast.SelectorExpr || expr is ast.IndexExpr {
					g.sb.write_string('memcpy(_ret.ret_arr, ')
					g.expr(expr)
					g.sb.writeln(', sizeof(${g.cur_fn_ret_type})); _ret; });')
					return
				}
				g.sb.write_string('${g.cur_fn_ret_type} _arr = ')
				g.expr(expr)
				g.sb.writeln('; memcpy(_ret.ret_arr, _arr, sizeof(${g.cur_fn_ret_type})); _ret; });')
				return
			}
			if g.cur_fn_ret_type.starts_with('_option_') {
				if node.exprs.len == 0 {
					g.sb.writeln('return (${g.cur_fn_ret_type}){ .state = 2 };')
					return
				}
				expr := node.exprs[0]
				if expr is ast.BasicLiteral && expr.value == '0' {
					g.sb.writeln('return (${g.cur_fn_ret_type}){ .state = 2 };')
					return
				}
				if is_none_expr(expr) || expr is ast.Type {
					g.sb.writeln('return (${g.cur_fn_ret_type}){ .state = 2 };')
					return
				}
				mut expr_type := g.get_expr_type(expr)
				if (expr_type == '' || expr_type == 'int') && expr is ast.Ident {
					expr_type = g.get_local_var_c_type(expr.name) or { expr_type }
				}
				if (expr_type == '' || expr_type == 'int') && expr is ast.CallExpr {
					expr_type = g.get_call_return_type(expr.lhs, expr.args) or { expr_type }
				}
				value_type := option_value_type(g.cur_fn_ret_type)
				if expr is ast.Ident {
					err_ident := expr as ast.Ident
					if err_ident.name == 'err' {
						err_type := g.get_local_var_c_type(err_ident.name) or { 'IError' }
						if err_type in ['IError', 'builtin__IError'] {
							g.sb.write_string('return (${g.cur_fn_ret_type}){ .is_error=true, .err=')
							g.expr(expr)
							g.sb.writeln(' };')
							return
						}
					}
				}
				if expr_type == 'IError' {
					if value_type != '' && value_type != 'void' {
						if expr is ast.CastExpr
							&& g.expr_type_to_c(expr.typ) in ['IError', 'builtin__IError'] {
							concrete_type := g.concrete_type_for_interface_value('IError',
								expr.expr)
							if concrete_type == value_type {
								g.sb.write_string('return ({ ${g.cur_fn_ret_type} _opt = (${g.cur_fn_ret_type}){ .state = 2 }; ${value_type} _val = ')
								g.expr(expr.expr)
								g.sb.writeln('; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; });')
								return
							}
						} else if expr is ast.CallOrCastExpr
							&& g.expr_type_to_c(expr.lhs) in ['IError', 'builtin__IError'] {
							concrete_type := g.concrete_type_for_interface_value('IError',
								expr.expr)
							if concrete_type == value_type {
								g.sb.write_string('return ({ ${g.cur_fn_ret_type} _opt = (${g.cur_fn_ret_type}){ .state = 2 }; ${value_type} _val = ')
								g.expr(expr.expr)
								g.sb.writeln('; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; });')
								return
							}
						}
					}
					g.sb.write_string('return (${g.cur_fn_ret_type}){ .is_error=true, .err=')
					g.expr(expr)
					g.sb.writeln(' };')
					return
				}
				if expr_type == g.cur_fn_ret_type {
					g.sb.write_string('return ')
					g.expr(expr)
					g.sb.writeln(';')
					return
				}
				if value_type == '' || value_type == 'void' {
					g.sb.writeln('return (${g.cur_fn_ret_type}){ .state = 2 };')
					return
				}
				if value_type in g.tuple_aliases {
					if node.exprs.len == 1 && expr_type == value_type && node.exprs[0] !is ast.Tuple {
						g.sb.write_string('return ({ ${g.cur_fn_ret_type} _opt = (${g.cur_fn_ret_type}){ .state = 2 }; ${value_type} _val = ')
						g.expr(expr)
						g.sb.writeln('; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; });')
						return
					}
					field_types := g.tuple_aliases[value_type]
					mut tuple_exprs := shallow_copy_exprs(node.exprs)
					if node.exprs.len == 1 && node.exprs[0] is ast.Tuple {
						tuple_expr := node.exprs[0] as ast.Tuple
						tuple_exprs = shallow_copy_exprs(tuple_expr.exprs)
					}
					if tuple_field_types_need_stmt_expr(field_types) {
						g.sb.write_string('return ({ ${g.cur_fn_ret_type} _opt = (${g.cur_fn_ret_type}){ .state = 2 }; ${value_type} _val = ')
						g.gen_tuple_value_stmt_expr(value_type, tuple_exprs, field_types)
						g.sb.writeln('; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; });')
						return
					}
					g.sb.write_string('return ({ ${g.cur_fn_ret_type} _opt = (${g.cur_fn_ret_type}){ .state = 2 }; ${value_type} _val = (${value_type}){')
					for i, field_type in field_types {
						if i > 0 {
							g.sb.write_string(', ')
						}
						g.sb.write_string('.arg${i} = ')
						if i < tuple_exprs.len {
							g.expr(tuple_exprs[i])
						} else {
							g.sb.write_string(zero_value_for_type(field_type))
						}
					}
					g.sb.writeln('}; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; });')
					return
				}
				g.sb.write_string('return ({ ${g.cur_fn_ret_type} _opt = (${g.cur_fn_ret_type}){ .state = 2 }; ${value_type} _val = ')
				if value_type in g.sum_type_variants {
					g.gen_type_cast_expr(value_type, expr)
				} else if g.gen_auto_deref_value_param_arg(value_type, expr) {
				} else {
					g.expr(expr)
				}
				g.sb.writeln('; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; });')
				return
			}
			if g.cur_fn_ret_type.starts_with('_result_') {
				if node.exprs.len == 0 {
					g.sb.writeln('return (${g.cur_fn_ret_type}){ .is_error=false };')
					return
				}
				expr := node.exprs[0]
				if g.is_error_call_expr(expr) {
					g.sb.write_string('return (${g.cur_fn_ret_type}){ .is_error=true, .err=')
					g.expr(expr)
					g.sb.writeln(' };')
					return
				}
				// `return err` propagates the error from the or-block. A user local
				// named `err` can still be a concrete error value and must be wrapped.
				if expr is ast.Ident {
					err_ident := expr as ast.Ident
					if err_ident.name == 'err' {
						err_type := g.get_local_var_c_type(err_ident.name) or { 'IError' }
						if err_type in ['IError', 'builtin__IError'] {
							g.sb.write_string('return (${g.cur_fn_ret_type}){ .is_error=true, .err=')
							g.expr(expr)
							g.sb.writeln(' };')
							return
						}
					}
				}
				value_type := g.result_value_c_type(g.cur_fn_ret_type)
				if value_type in g.tuple_aliases && node.exprs.len > 1 {
					field_types := g.tuple_aliases[value_type]
					if tuple_field_types_need_stmt_expr(field_types) {
						g.sb.write_string('return ({ ${g.cur_fn_ret_type} _res = (${g.cur_fn_ret_type}){0}; ${value_type} _val = ')
						g.gen_tuple_value_stmt_expr(value_type, node.exprs, field_types)
						g.sb.writeln('; _result_ok(&_val, (_result*)&_res, sizeof(_val)); _res; });')
						return
					}
					g.sb.write_string('return ({ ${g.cur_fn_ret_type} _res = (${g.cur_fn_ret_type}){0}; ${value_type} _val = (${value_type}){')
					for i, field_type in field_types {
						if i > 0 {
							g.sb.write_string(', ')
						}
						g.sb.write_string('.arg${i} = ')
						if i < node.exprs.len {
							g.expr(node.exprs[i])
						} else {
							g.sb.write_string(zero_value_for_type(field_type))
						}
					}
					g.sb.writeln('}; _result_ok(&_val, (_result*)&_res, sizeof(_val)); _res; });')
					return
				}
				// `return T(x)` in `!T` functions can be an unlowered propagate path where `x` is already `_result_T`.
				// In that case return `x` directly, instead of casting to `T` and re-wrapping.
				if value_type != '' && expr is ast.CastExpr
					&& g.expr_type_to_c(expr.typ) == value_type {
					inner_type := g.get_expr_type(expr.expr)
					if inner_type == g.cur_fn_ret_type {
						g.sb.write_string('return ')
						g.expr(expr.expr)
						g.sb.writeln(';')
						return
					}
				}
				mut expr_type := g.get_expr_type(expr)
				if (expr_type == '' || expr_type == 'int') && expr is ast.Ident {
					expr_type = g.get_local_var_c_type(expr.name) or { expr_type }
				}
				if expr_type == g.cur_fn_ret_type {
					g.sb.write_string('return ')
					g.expr(expr)
					g.sb.writeln(';')
					return
				}
				if is_ierror_c_type(expr_type) {
					g.sb.write_string('return (${g.cur_fn_ret_type}){ .is_error=true, .err=')
					g.expr(expr)
					g.sb.writeln(' };')
					return
				}
				if g.concrete_ierror_base_for_c_type(expr_type) != '' {
					g.sb.write_string('return (${g.cur_fn_ret_type}){ .is_error=true, .err=')
					g.gen_ierror_from_concrete_expr(expr, expr_type)
					g.sb.writeln(' };')
					return
				}
				// For CallExpr in result-returning function, check if the called
				// function also returns the same result type (passthrough).
				if expr is ast.CallExpr {
					if call_ret := g.get_call_return_type(expr.lhs, expr.args) {
						if call_ret == g.cur_fn_ret_type {
							g.sb.write_string('return ')
							g.expr(expr)
							g.sb.writeln(';')
							return
						}
					}
				}
				if value_type == '' || value_type == 'void' {
					g.sb.writeln('return (${g.cur_fn_ret_type}){ .is_error=false };')
					return
				}
				if value_type.starts_with('Array_fixed_') {
					g.sb.write_string('return ({ ${g.cur_fn_ret_type} _res = (${g.cur_fn_ret_type}){0}; ${value_type} _val = {0}; ')
					is_zero_fixed_array := expr is ast.ArrayInitExpr && expr.exprs.len == 0
						&& expr.init is ast.EmptyExpr
					if !is_zero_fixed_array {
						g.sb.write_string('memcpy(_val, ')
						g.expr(expr)
						g.sb.write_string(', sizeof(_val)); ')
					}
					g.sb.writeln('_result_ok(&_val, (_result*)&_res, sizeof(_val)); _res; });')
					return
				}
				g.sb.write_string('return ({ ${g.cur_fn_ret_type} _res = (${g.cur_fn_ret_type}){0}; ${value_type} _val = ')
				if value_type in g.sum_type_variants {
					g.gen_type_cast_expr(value_type, expr)
				} else if g.is_interface_type(value_type) {
					// Mut params are pointers — dereference when returning as value
					if expr is ast.Ident && expr.name in g.cur_fn_mut_params {
						g.sb.write_string('(*')
						g.expr(expr)
						g.sb.write_string(')')
					} else if !g.gen_interface_cast(value_type, expr) {
						g.expr(expr)
					}
				} else {
					// Dereference mut parameters when returning by value in result-wrapping
					// (mut params are pointers, but _val expects a value)
					if !g.gen_auto_deref_value_param_arg(value_type, expr) {
						g.expr(expr)
					}
				}
				g.sb.writeln('; _result_ok(&_val, (_result*)&_res, sizeof(_val)); _res; });')
				return
			}
			g.sb.write_string('return')
			if node.exprs.len > 0 {
				g.sb.write_string(' ')
				expr := node.exprs[0]
				if g.gen_return_mut_param_value(expr) {
				} else if g.cur_fn_ret_type in g.sum_type_variants {
					g.gen_type_cast_expr(g.cur_fn_ret_type, expr)
				} else if g.is_interface_type(g.cur_fn_ret_type) {
					if g.get_expr_type(expr) == g.cur_fn_ret_type {
						g.expr(expr)
					} else {
						g.gen_type_cast_expr(g.cur_fn_ret_type, expr)
					}
				} else if g.cur_fn_ret_type.ends_with('*') && expr is ast.ParenExpr
					&& expr.expr is ast.PrefixExpr && (expr.expr as ast.PrefixExpr).op == .mul {
					// Return type is a pointer but the expression dereferences a pointer
					// (e.g., interface smartcast: *(T*)(obj._object)). Strip the deref
					// to return the pointer directly.
					deref := expr.expr as ast.PrefixExpr
					g.expr(deref.expr)
				} else if vector_elem_type_for_name(g.cur_fn_ret_type) != '' && expr is ast.InitExpr
					&& g.gen_simd_vector_init_expr(g.cur_fn_ret_type, expr.fields) {
				} else if g.gen_auto_deref_value_param_arg(g.cur_fn_ret_type, expr) {
				} else {
					g.expr(expr)
				}
			} else if g.cur_fn_name == 'main' {
				g.sb.write_string(' 0')
			}
			g.sb.writeln(';')
		}
		ast.ForStmt {
			g.gen_for_stmt(node)
		}
		ast.FlowControlStmt {
			g.write_indent()
			if node.op == .key_break {
				g.sb.writeln('break;')
			} else if node.op == .key_continue {
				if g.comptime_continue_label != '' {
					g.sb.writeln('goto ${g.comptime_continue_label};')
				} else {
					g.sb.writeln('continue;')
				}
			} else if node.op == .key_goto {
				g.sb.writeln('goto ${node.label};')
			}
		}
		ast.ModuleStmt {
			g.cur_module = node.name.replace('.', '_')
		}
		ast.ImportStmt {}
		ast.ConstDecl {
			g.gen_const_decl(node)
		}
		ast.StructDecl {
			g.gen_struct_decl(node)
		}
		ast.EnumDecl {
			g.gen_enum_decl(node)
		}
		ast.TypeDecl {
			if node.variants.len > 0 {
				g.gen_sum_type_decl(node)
			} else if node.base_type !is ast.EmptyExpr {
				g.gen_type_alias(node)
			}
		}
		ast.InterfaceDecl {
			g.gen_interface_decl(node)
		}
		ast.GlobalDecl {
			g.gen_global_decl(node)
		}
		ast.Directive {
			// C directives are collected and emitted in the preamble.
			_ = node
		}
		ast.ForInStmt {
			panic('bug in v2 compiler: ForInStmt should have been lowered in v2.transformer')
		}
		ast.DeferStmt {
			panic('bug in v2 compiler: DeferStmt should have been lowered in v2.transformer (${g.cur_file_name}:${g.cur_fn_name})')
		}
		ast.AssertStmt {
			panic('bug in v2 compiler: AssertStmt should have been lowered in v2.transformer')
		}
		ast.ComptimeStmt {
			g.gen_comptime_stmt(node)
		}
		ast.BlockStmt {
			for bs in node.stmts {
				g.gen_stmt(bs)
			}
		}
		ast.LabelStmt {
			g.write_indent()
			g.sb.writeln('${node.name}:;')
			if node.stmt !is ast.EmptyStmt {
				g.gen_stmt(node.stmt)
			}
		}
		ast.AsmStmt {
			g.write_indent()
			g.sb.writeln('/* [TODO] AsmStmt */')
		}
		[]ast.Attribute {}
		ast.EmptyStmt {}
		// else {}
	}
}

fn (mut g Gen) gen_comptime_stmt(node ast.ComptimeStmt) {
	inner := node.stmt
	if inner is ast.ForStmt {
		g.gen_comptime_for(inner)
		return
	}
	if inner is ast.ExprStmt {
		if inner.expr is ast.ComptimeExpr {
			if inner.expr.expr is ast.IfExpr {
				g.gen_comptime_if_stmt(inner.expr.expr)
				return
			}
		}
		g.write_indent()
		g.expr(inner.expr)
		g.sb.writeln(';')
		return
	}
	g.write_indent()
	g.sb.writeln('/* [TODO] ComptimeStmt */')
}

fn (mut g Gen) gen_comptime_if_stmt(node ast.IfExpr) {
	result := g.eval_comptime_cond(node.cond)
	if result {
		g.gen_stmts(node.stmts)
		return
	}
	if node.else_expr is ast.IfExpr {
		else_if := node.else_expr as ast.IfExpr
		if else_if.cond is ast.EmptyExpr {
			g.gen_stmts(else_if.stmts)
		} else {
			g.gen_comptime_if_stmt(else_if)
		}
	}
}

fn (mut g Gen) gen_comptime_for(node ast.ForStmt) {
	// Extract ForInStmt from the ForStmt's init field
	if node.init !is ast.ForInStmt {
		g.write_indent()
		g.sb.writeln('/* [TODO] ComptimeFor non-for-in */')
		return
	}
	for_in := node.init as ast.ForInStmt
	// The expression should be T.fields (a SelectorExpr)
	if for_in.expr !is ast.SelectorExpr {
		g.write_indent()
		g.sb.writeln('/* [TODO] ComptimeFor non-selector */')
		return
	}
	sel := for_in.expr as ast.SelectorExpr
	kind := sel.rhs.name
	if kind !in ['fields', 'methods'] {
		g.write_indent()
		g.sb.writeln('/* [TODO] ComptimeFor ${kind} */')
		return
	}
	type_name := sel.lhs.name()
	concrete := g.active_generic_types[type_name] or {
		c_name := g.expr_type_to_c(sel.lhs).trim_space()
		g.concrete_type_from_c_name(c_name) or {
			g.write_indent()
			g.sb.writeln('/* [TODO] ComptimeFor unknown type ${type_name} */')
			return
		}
	}
	if concrete !is types.Struct {
		g.write_indent()
		g.sb.writeln('/* ComptimeFor: ${type_name} is not a struct */')
		return
	}
	struct_type := g.comptime_for_struct_type(concrete, concrete as types.Struct)
	if kind == 'methods' {
		g.gen_comptime_for_methods(node, for_in, type_name, struct_type)
		return
	}
	field_var := for_in.value.name()
	// Save comptime state
	prev_field_var := g.comptime_field_var
	prev_field_name := g.comptime_field_name
	prev_field_type := g.comptime_field_type
	prev_field_raw_type := g.comptime_field_raw_type
	prev_field_attrs := g.comptime_field_attrs
	prev_field_idx := g.comptime_field_idx
	prev_field_is_embed := g.comptime_field_is_embed
	prev_continue_label := g.comptime_continue_label
	g.comptime_field_var = field_var
	g.write_indent()
	g.sb.writeln('{ /* comptime for ${field_var} in ${type_name}.fields */')
	g.indent++
	for i, field in struct_type.fields {
		g.comptime_field_name = field.name
		g.comptime_field_type = g.types_type_to_c(field.typ)
		g.comptime_field_raw_type = field.typ
		g.comptime_field_attrs = g.comptime_field_attribute_strings(struct_type.name, field)
		g.comptime_field_idx = i
		g.comptime_field_is_embed = g.comptime_field_is_embedded(struct_type, field)
		g.tmp_counter++
		g.comptime_continue_label = '__v_ctf_continue_${g.tmp_counter}_${i}'
		g.write_indent()
		g.sb.writeln('{ /* field ${i}: ${field.name} */')
		g.indent++
		// Use ForStmt.stmts for the loop body
		g.gen_stmts(node.stmts)
		g.write_indent()
		g.sb.writeln('${g.comptime_continue_label}:;')
		g.indent--
		g.write_indent()
		g.sb.writeln('}')
	}
	g.indent--
	g.write_indent()
	g.sb.writeln('}')
	// Restore comptime state
	g.comptime_field_var = prev_field_var
	g.comptime_field_name = prev_field_name
	g.comptime_field_type = prev_field_type
	g.comptime_field_raw_type = prev_field_raw_type
	g.comptime_field_attrs = prev_field_attrs
	g.comptime_field_idx = prev_field_idx
	g.comptime_field_is_embed = prev_field_is_embed
	g.comptime_continue_label = prev_continue_label
}

fn (g &Gen) comptime_field_is_embedded(struct_type types.Struct, field types.Field) bool {
	for embedded in struct_type.embedded {
		embedded_name := embedded.name.all_after_last('__')
		if field.name == embedded.name || field.name == embedded_name {
			return true
		}
	}
	return false
}

fn (mut g Gen) comptime_for_struct_type(concrete types.Type, fallback types.Struct) types.Struct {
	struct_c_name := g.types_type_to_c(concrete).trim_space().trim_right('*')
	if struct_c_name == '' {
		return fallback
	}
	full_struct_type := g.lookup_struct_type_by_c_name(struct_c_name)
	if full_struct_type.fields.len > 0
		&& !type_contains_generic_placeholder(types.Type(full_struct_type)) {
		return full_struct_type
	}
	return fallback
}

// gen_comptime_for_methods emits the body of `$for method in T.methods` by
// looping over the AST FnDecls whose receiver C-type matches T, setting the
// `g.comptime_method_*` state per iteration, and recursively generating the
// loop body so per-method selectors (method.name, method.attrs, etc.) and
// `app.$method(...)` dispatch can be resolved by expr.v.
fn (mut g Gen) gen_comptime_for_methods(node ast.ForStmt, for_in ast.ForInStmt, type_name string, struct_type types.Struct) {
	concrete_struct_type := types.Type(struct_type)
	struct_c_name := g.types_type_to_c(concrete_struct_type).trim_space().trim_right('*')
	method_decls := g.collect_method_fndecls(struct_type.name, struct_c_name)
	method_var := for_in.value.name()
	prev_method_var := g.comptime_method_var
	prev_method_name := g.comptime_method_name
	prev_method_attrs := g.comptime_method_attrs
	prev_method_return_type := g.comptime_method_return_type
	prev_method_args := g.comptime_method_args
	prev_method_idx := g.comptime_method_idx
	prev_method_receiver_type := g.comptime_method_receiver_type
	prev_method_struct_name := g.comptime_method_struct_name
	prev_continue_label := g.comptime_continue_label
	g.comptime_method_var = method_var
	g.comptime_method_receiver_type = struct_c_name
	g.comptime_method_struct_name = struct_type.name
	g.write_indent()
	g.sb.writeln('{ /* comptime for ${method_var} in ${type_name}.methods */')
	g.indent++
	for i, decl in method_decls {
		g.comptime_method_name = decl.name
		g.comptime_method_attrs = comptime_attribute_strings(decl.attributes)
		g.comptime_method_return_type = decl.typ.return_type
		g.comptime_method_args = decl.typ.params.clone()
		g.comptime_method_idx = i
		g.tmp_counter++
		g.comptime_continue_label = '__v_ctm_continue_${g.tmp_counter}_${i}'
		g.write_indent()
		g.sb.writeln('{ /* method ${i}: ${decl.name} */')
		g.indent++
		g.gen_stmts(node.stmts)
		g.write_indent()
		g.sb.writeln('${g.comptime_continue_label}:;')
		g.indent--
		g.write_indent()
		g.sb.writeln('}')
	}
	g.indent--
	g.write_indent()
	g.sb.writeln('}')
	g.comptime_method_var = prev_method_var
	g.comptime_method_name = prev_method_name
	g.comptime_method_attrs = prev_method_attrs
	g.comptime_method_return_type = prev_method_return_type
	g.comptime_method_args = prev_method_args
	g.comptime_method_idx = prev_method_idx
	g.comptime_method_receiver_type = prev_method_receiver_type
	g.comptime_method_struct_name = prev_method_struct_name
	g.comptime_continue_label = prev_continue_label
}

// collect_method_fndecls walks all loaded files and returns FnDecls whose
// receiver type matches either the struct V-name or its C-mangled name.
fn (mut g Gen) collect_method_fndecls(struct_v_name string, struct_c_name string) []ast.FnDecl {
	mut out := []ast.FnDecl{}
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			g.set_file_cursor_module(fc)
			stmts := fc.stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_fn_decl {
					continue
				}
				decl := stmt.fn_decl_signature()
				if !decl.is_method {
					continue
				}
				if decl.receiver.typ is ast.EmptyExpr {
					continue
				}
				receiver_v_name := decl.receiver.typ.name()
				if receiver_v_name == struct_v_name || receiver_v_name == struct_c_name
					|| short_type_name(struct_c_name) == receiver_v_name {
					out << decl
					continue
				}
				receiver_c_name := g.expr_type_to_c(decl.receiver.typ).trim_space().trim_right('*')
				if receiver_c_name == struct_c_name {
					out << decl
				}
			}
		}
		return out
	}
	for file in g.files {
		for stmt in file.stmts {
			if stmt is ast.FnDecl {
				if !stmt.is_method {
					continue
				}
				if stmt.receiver.typ is ast.EmptyExpr {
					continue
				}
				receiver_v_name := stmt.receiver.typ.name()
				if receiver_v_name == struct_v_name || receiver_v_name == struct_c_name
					|| short_type_name(struct_c_name) == receiver_v_name {
					out << stmt
					continue
				}
				// Compare resolved C name as fallback (handles module-qualified receivers).
				receiver_c_name := g.expr_type_to_c(stmt.receiver.typ).trim_space().trim_right('*')
				if receiver_c_name == struct_c_name {
					out << stmt
				}
			}
		}
	}
	return out
}

fn comptime_attribute_strings(attrs []ast.Attribute) []string {
	mut out := []string{cap: attrs.len}
	for attr in attrs {
		if attr.name != '' {
			if attr.value is ast.EmptyExpr {
				out << attr.name
			} else {
				out << '${attr.name}: ${attr.value.name().trim("'")}'
			}
		} else if attr.value !is ast.EmptyExpr {
			out << attr.value.name().trim("'")
		}
	}
	return out
}

fn (mut g Gen) gen_return_mut_param_value(expr ast.Expr) bool {
	if expr !is ast.Ident || g.cur_fn_ret_type.ends_with('*') {
		return false
	}
	ident := expr as ast.Ident
	if ident.name !in g.cur_fn_mut_params {
		return false
	}
	local_type := (g.get_local_var_c_type(ident.name) or { '' }).trim_space()
	if !local_type.ends_with('*') {
		return false
	}
	local_base := local_type.trim_right('*')
	ret_base := g.cur_fn_ret_type.trim_right('*')
	if local_base == '' || ret_base == '' {
		return false
	}
	if local_base != ret_base && short_type_name(local_base) != short_type_name(ret_base) {
		return false
	}
	g.sb.write_string('(*')
	g.expr(expr)
	g.sb.write_string(')')
	return true
}

fn (mut g Gen) comptime_field_attribute_strings(struct_name string, field types.Field) []string {
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			stmts := g.flat.file_cursor(i).stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_struct_decl {
					continue
				}
				decl := stmt.struct_decl()
				if decl.name != struct_name && !struct_name.ends_with('__${decl.name}') {
					continue
				}
				for ast_field in decl.fields {
					if ast_field.name == field.name {
						return comptime_attribute_strings(ast_field.attributes)
					}
				}
			}
		}
		return comptime_attribute_strings(field.attributes)
	}
	for file in g.files {
		for stmt in file.stmts {
			if stmt is ast.StructDecl {
				if stmt.name != struct_name && !struct_name.ends_with('__${stmt.name}') {
					continue
				}
				for ast_field in stmt.fields {
					if ast_field.name == field.name {
						return comptime_attribute_strings(ast_field.attributes)
					}
				}
			}
		}
	}
	return comptime_attribute_strings(field.attributes)
}