// 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.parser
import v2.pref as vpref
import v2.token
import v2.types
import os

const preamble_includes_freestanding = r'// Generated by V Clean C Backend
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
'

const preamble_includes_minimal = r'// Generated by V Clean C Backend
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
#include <dirent.h>
#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#endif
#include <pthread.h>
'

const preamble_includes_minimal_windows = r'// Generated by V Clean C Backend
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
#include <windows.h>
'

const preamble_includes_full = r'// Generated by V Clean C Backend
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <signal.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/wait.h>
#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <sys/syslimits.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#include <execinfo.h>
#include <mach-o/dyld.h>
#endif
#include <termios.h>
#include <sys/ioctl.h>
#include <pthread.h>
#ifndef PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
#define PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 0
#define pthread_rwlockattr_setkind_np(attr, kind) 0
#endif
#include <time.h>
#include <sys/time.h>
#include <sys/statvfs.h>
#include <utime.h>
#include <sys/utsname.h>
#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <sys/ptrace.h>
#include <libproc.h>
#endif
extern char** environ;
#define signal(v_sig, v_handler) signal((v_sig), ((void (*)(int))(v_handler)))
#define v_signal_with_handler_cast(sig, handler) signal((sig), ((void (*)(int))(handler)))
'

const preamble_includes_full_windows = r'// Generated by V Clean C Backend
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <windows.h>
#define signal(v_sig, v_handler) signal((v_sig), ((void (*)(int))(v_handler)))
#define v_signal_with_handler_cast(sig, handler) signal((sig), ((void (*)(int))(handler)))
'

const preamble_includes_minimal_cross = r'// Generated by V Clean C Backend
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
#if defined(_WIN32)
#include <windows.h>
#else
#include <dirent.h>
#include <pthread.h>
#endif
#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#endif
'

const preamble_includes_full_cross = r'// Generated by V Clean C Backend
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#ifndef __TINYC__
#include <stdatomic.h>
#endif
#include <stddef.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#if defined(_WIN32)
#include <windows.h>
#else
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/statvfs.h>
#include <utime.h>
#include <sys/utsname.h>
#ifndef PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
#define PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 0
#define pthread_rwlockattr_setkind_np(attr, kind) 0
#endif
extern char** environ;
#endif
#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <sys/syslimits.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#include <execinfo.h>
#include <mach-o/dyld.h>
#include <sys/ptrace.h>
#include <libproc.h>
#endif
#define signal(v_sig, v_handler) signal((v_sig), ((void (*)(int))(v_handler)))
#define v_signal_with_handler_cast(sig, handler) signal((sig), ((void (*)(int))(handler)))
'

const apple_minimal_includes_guarded = r'#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#endif
'

const apple_minimal_includes_plain = r'#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
'

const apple_full_includes_guarded = r'#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <sys/syslimits.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#include <execinfo.h>
#include <mach-o/dyld.h>
#endif
'

const apple_full_includes_plain = r'#include <sys/syslimits.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <mach/mach_time.h>
#include <execinfo.h>
#include <mach-o/dyld.h>
'

const apple_late_full_includes_guarded = r'#if defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
#include <sys/ptrace.h>
#include <libproc.h>
#endif
'

const apple_late_full_includes_plain = r'#include <sys/ptrace.h>
#include <libproc.h>
'

const linux_gettid_feature_define = r'#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
'

const linux_gettid_helper = r'#include <sys/syscall.h>
static inline uint32_t v_cleanc_gettid(void) {
	return (uint32_t)syscall(SYS_gettid);
}
'

const apple_macos_cross_guard = 'defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)'
const apple_ios_cross_guard = 'defined(__APPLE__) && defined(__MACH__) && defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)'
const freestanding_missing_alloc_hook_message = 'v2: freestanding target requires freestanding_alloc hook for heap allocation'
const freestanding_missing_format_hook_message = 'v2: freestanding target cannot print non-string values without formatting support'
const freestanding_missing_heap_runtime_message = 'v2: freestanding target cannot use V runtime heap helpers with --skip-builtin'
const freestanding_missing_output_hook_message = 'v2: freestanding target requires freestanding_output hook for output'
const freestanding_missing_panic_hook_message = 'v2: freestanding target requires freestanding_panic hook for panic'

fn (g &Gen) target_os_name() string {
	return normalize_c_target_os_name(g.pref.target_os_or_host())
}

fn normalize_c_target_os_name(target_os string) string {
	return match target_os.to_lower() {
		'darwin', 'mac' { 'macos' }
		else { target_os.to_lower() }
	}
}

fn (g &Gen) has_target_define(name string) bool {
	if g.pref == unsafe { nil } {
		return false
	}
	return vpref.comptime_optional_define_value(name, g.pref.user_defines,
		g.pref.explicit_user_defines)
}

fn (g &Gen) is_freestanding_target() bool {
	return g.pref != unsafe { nil } && g.pref.is_freestanding()
}

fn (g &Gen) has_freestanding_hook_capability(capability string) bool {
	if !g.is_freestanding_target() || g.pref == unsafe { nil } {
		return false
	}
	return g.pref.has_freestanding_hook(capability)
}

fn (g &Gen) has_freestanding_hooks() bool {
	return g.has_freestanding_hook_capability('output')
		|| g.has_freestanding_hook_capability('panic')
		|| g.has_freestanding_hook_capability('alloc')
}

fn (g &Gen) c_heap_malloc_call(size_expr string) string {
	if g.has_freestanding_hook_capability('alloc') {
		return 'v_platform_malloc(${size_expr})'
	}
	if g.is_freestanding_target() {
		return g.c_freestanding_missing_alloc_ptr_expr()
	}
	return 'malloc(${size_expr})'
}

fn (g &Gen) c_heap_realloc_call(ptr_expr string, size_expr string) string {
	if g.has_freestanding_hook_capability('alloc') {
		return 'v_platform_realloc(${ptr_expr}, ${size_expr})'
	}
	if g.is_freestanding_target() {
		return g.c_freestanding_missing_alloc_ptr_expr()
	}
	return 'realloc(${ptr_expr}, ${size_expr})'
}

fn (g &Gen) c_heap_free_call(ptr_expr string) string {
	if g.has_freestanding_hook_capability('alloc') {
		return 'v_platform_free(${ptr_expr})'
	}
	if g.is_freestanding_target() {
		return g.c_freestanding_missing_alloc_void_expr()
	}
	return 'free(${ptr_expr})'
}

fn (g &Gen) c_freestanding_missing_alloc_ptr_expr() string {
	return '({ _Static_assert(0, "${freestanding_missing_alloc_hook_message}"); (void*)0; })'
}

fn (g &Gen) c_freestanding_missing_alloc_void_expr() string {
	return '({ _Static_assert(0, "${freestanding_missing_alloc_hook_message}"); (void)0; })'
}

fn (g &Gen) c_freestanding_missing_format_string_expr() string {
	return '({ _Static_assert(0, "${freestanding_missing_format_hook_message}"); (string){0}; })'
}

fn is_target_os_ct_flag(name string) bool {
	return name in [
		'darwin',
		'macos',
		'mac',
		'linux',
		'windows',
		'bsd',
		'freebsd',
		'openbsd',
		'netbsd',
		'dragonfly',
		'android',
		'termux',
		'ios',
		'solaris',
		'qnx',
		'serenity',
		'plan9',
		'vinix',
	]
}

fn c_preprocessor_flag_expr_for_ct_flag(name string) ?string {
	return match name.to_lower() {
		'linux' {
			'defined(__linux__)'
		}
		'windows' {
			'defined(_WIN32)'
		}
		'darwin', 'macos', 'mac' {
			apple_macos_cross_guard
		}
		'bsd' {
			'(${apple_macos_cross_guard}) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__)'
		}
		'freebsd' {
			'defined(__FreeBSD__)'
		}
		'openbsd' {
			'defined(__OpenBSD__)'
		}
		'netbsd' {
			'defined(__NetBSD__)'
		}
		'dragonfly' {
			'defined(__DragonFly__)'
		}
		'android' {
			'defined(__ANDROID__)'
		}
		'termux' {
			'defined(__TERMUX__)'
		}
		'ios' {
			apple_ios_cross_guard
		}
		'solaris' {
			'defined(__sun)'
		}
		'qnx' {
			'defined(__QNX__)'
		}
		'serenity' {
			'defined(__serenity__)'
		}
		'plan9' {
			'defined(__plan9__)'
		}
		'vinix' {
			'defined(__vinix__)'
		}
		else {
			none
		}
	}
}

fn optional_user_ct_flag_name(cond string) ?string {
	trimmed := cond.trim_space()
	if !trimmed.ends_with('?') {
		return none
	}
	name := trimmed[..trimmed.len - 1].trim_space()
	if name == '' {
		return none
	}
	return name
}

fn (g &Gen) c_preprocessor_expr_for_ct_cond(cond string) ?string {
	trimmed := cond.trim_space()
	if trimmed == '' {
		return none
	}
	if or_idx := top_level_bool_op_index(trimmed, '||') {
		left := g.c_preprocessor_expr_for_ct_cond(trimmed[..or_idx].trim_space()) or { return none }
		right := g.c_preprocessor_expr_for_ct_cond(trimmed[or_idx + 2..].trim_space()) or {
			return none
		}
		return combine_c_preprocessor_or_expr(left, right)
	}
	if and_idx := top_level_bool_op_index(trimmed, '&&') {
		left := g.c_preprocessor_expr_for_ct_cond(trimmed[..and_idx].trim_space()) or {
			return none
		}
		right := g.c_preprocessor_expr_for_ct_cond(trimmed[and_idx + 2..].trim_space()) or {
			return none
		}
		return combine_c_preprocessor_and_expr(left, right)
	}
	if trimmed.starts_with('!') {
		inner := g.c_preprocessor_expr_for_ct_cond(trimmed[1..]) or { return none }
		return negate_c_preprocessor_expr(inner)
	}
	if stripped := strip_outer_bool_parens(trimmed) {
		return g.c_preprocessor_expr_for_ct_cond(stripped)
	}
	if optional_name := optional_user_ct_flag_name(trimmed) {
		return if g.has_target_define(optional_name) { '' } else { '0' }
	}
	lower_trimmed := trimmed.to_lower()
	if os_guard := c_preprocessor_flag_expr_for_ct_flag(lower_trimmed) {
		return os_guard
	}
	if g.directive_ct_flag_matches(lower_trimmed) {
		return ''
	}
	return '0'
}

fn combine_c_preprocessor_and_expr(left string, right string) string {
	if left == '0' || right == '0' {
		return '0'
	}
	if left == '' {
		return right
	}
	if right == '' {
		return left
	}
	return '(${left}) && (${right})'
}

fn combine_c_preprocessor_or_expr(left string, right string) string {
	if left == '' || right == '' {
		return ''
	}
	if left == '0' {
		return right
	}
	if right == '0' {
		return left
	}
	return '(${left}) || (${right})'
}

fn negate_c_preprocessor_expr(expr string) string {
	if expr == '' {
		return '0'
	}
	if expr == '0' {
		return ''
	}
	return '!(${expr})'
}

fn (g &Gen) preamble_includes(minimal_preamble bool) string {
	if g.is_freestanding_target() {
		return preamble_includes_freestanding
	}
	target_os := g.target_os_name()
	if target_os == 'cross' {
		return if minimal_preamble {
			preamble_includes_minimal_cross
		} else {
			preamble_includes_full_cross
		}
	}
	if target_os == 'windows' {
		return if minimal_preamble {
			preamble_includes_minimal_windows
		} else {
			preamble_includes_full_windows
		}
	}
	raw := if minimal_preamble {
		preamble_includes_minimal
	} else {
		preamble_includes_full
	}
	if target_os == '' {
		return raw
	}
	mut out := raw
	if g.should_emit_linux_gettid_compat() {
		out = out.replace('// Generated by V Clean C Backend\n',
			'// Generated by V Clean C Backend\n${linux_gettid_feature_define}')
	}
	if target_os == 'macos' {
		out = out.replace(apple_minimal_includes_guarded, apple_minimal_includes_plain)
		out = out.replace(apple_full_includes_guarded, apple_full_includes_plain)
		out = out.replace(apple_late_full_includes_guarded, apple_late_full_includes_plain)
	} else {
		out = out.replace(apple_minimal_includes_guarded, '')
		out = out.replace(apple_full_includes_guarded, '')
		out = out.replace(apple_late_full_includes_guarded, '')
	}
	return out
}

fn (g &Gen) should_emit_linux_gettid_compat() bool {
	return !g.is_freestanding_target() && g.target_os_name() == 'linux'
		&& !g.has_target_define('no_gettid') && !g.has_target_define('musl')
}

fn (mut g Gen) emit_linux_gettid_compat(minimal_preamble bool) {
	if !g.should_emit_linux_gettid_compat() {
		return
	}
	if minimal_preamble {
		g.sb.writeln('#include <unistd.h>')
	}
	g.sb.write_string(linux_gettid_helper)
}

fn (g &Gen) directive_ct_flag_matches(name string) bool {
	lower_name := name.to_lower()
	if g.target_os_name() == 'cross' && is_target_os_ct_flag(lower_name) {
		return true
	}
	if vpref.comptime_flag_value(g.pref, lower_name) {
		return true
	}
	target_os := g.target_os_name()
	return match lower_name {
		'mac' { target_os == 'macos' }
		'android' { target_os == 'android' }
		'ios' { target_os == 'ios' }
		'cross' { target_os == 'cross' }
		'freestanding', 'bare' { g.is_freestanding_target() }
		else { false }
	}
}

fn (g &Gen) directive_ct_cond_matches(cond string) bool {
	if cond == '' {
		return true
	}
	trimmed := cond.trim_space()
	if g.target_os_name() == 'cross' && g.c_preprocessor_expr_for_ct_cond(trimmed) != none {
		return true
	}
	if or_idx := top_level_bool_op_index(trimmed, '||') {
		left := trimmed[..or_idx].trim_space()
		right := trimmed[or_idx + 2..].trim_space()
		return g.directive_ct_cond_matches(left) || g.directive_ct_cond_matches(right)
	}
	if and_idx := top_level_bool_op_index(trimmed, '&&') {
		left := trimmed[..and_idx].trim_space()
		right := trimmed[and_idx + 2..].trim_space()
		return g.directive_ct_cond_matches(left) && g.directive_ct_cond_matches(right)
	}
	if trimmed.starts_with('!') {
		return !g.directive_ct_cond_matches(trimmed[1..])
	}
	if stripped := strip_outer_bool_parens(trimmed) {
		return g.directive_ct_cond_matches(stripped)
	}
	if optional_name := optional_user_ct_flag_name(trimmed) {
		return g.has_target_define(optional_name)
	}
	return g.directive_ct_flag_matches(trimmed)
}

fn top_level_bool_op_index(expr string, op string) ?int {
	mut depth := 0
	mut i := 0
	for i < expr.len {
		ch := expr[i]
		if ch == `(` {
			depth++
		} else if ch == `)` {
			if depth > 0 {
				depth--
			}
		} else if depth == 0 && i + op.len <= expr.len && expr[i..i + op.len] == op {
			return i
		}
		i++
	}
	return none
}

fn strip_outer_bool_parens(expr string) ?string {
	if expr.len < 2 || expr[0] != `(` || expr[expr.len - 1] != `)` {
		return none
	}
	mut depth := 0
	for i, ch in expr {
		if ch == `(` {
			depth++
		} else if ch == `)` {
			depth--
			if depth == 0 && i < expr.len - 1 {
				return none
			}
		}
	}
	if depth == 0 {
		return expr[1..expr.len - 1].trim_space()
	}
	return none
}

fn combine_ct_conditions(outer string, inner string) string {
	if outer == '' {
		return inner
	}
	if inner == '' {
		return outer
	}
	return '(${outer}) && (${inner})'
}

fn ast_ct_cond_string(expr ast.Expr) ?string {
	return match expr {
		ast.Ident {
			expr.name
		}
		ast.PrefixExpr {
			if expr.op == .not {
				inner := ast_ct_cond_string(expr.expr) or { return none }
				'!(${inner})'
			} else {
				none
			}
		}
		ast.InfixExpr {
			left := ast_ct_cond_string(expr.lhs) or { return none }
			right := ast_ct_cond_string(expr.rhs) or { return none }
			if expr.op == .and {
				'(${left}) && (${right})'
			} else if expr.op == .logical_or {
				'(${left}) || (${right})'
			} else {
				none
			}
		}
		ast.PostfixExpr {
			if expr.op == .question && expr.expr is ast.Ident {
				'${expr.expr.name}?'
			} else {
				none
			}
		}
		ast.ParenExpr {
			inner := ast_ct_cond_string(expr.expr) or { return none }
			'(${inner})'
		}
		else {
			none
		}
	}
}

fn ast_ct_cond_string_cursor(expr ast.Cursor) ?string {
	if !expr.is_valid() {
		return none
	}
	return match expr.kind() {
		.expr_ident {
			expr.name()
		}
		.expr_comptime {
			ast_ct_cond_string_cursor(expr.edge(0)) or { return none }
		}
		.expr_prefix {
			if unsafe { token.Token(int(expr.aux())) } == .not {
				inner := ast_ct_cond_string_cursor(expr.edge(0)) or { return none }
				'!(${inner})'
			} else {
				none
			}
		}
		.expr_infix {
			left := ast_ct_cond_string_cursor(expr.edge(0)) or { return none }
			right := ast_ct_cond_string_cursor(expr.edge(1)) or { return none }
			op := unsafe { token.Token(int(expr.aux())) }
			if op == .and {
				'(${left}) && (${right})'
			} else if op == .logical_or {
				'(${left}) || (${right})'
			} else {
				none
			}
		}
		.expr_postfix {
			if unsafe { token.Token(int(expr.aux())) } == .question
				&& expr.edge(0).kind() == .expr_ident {
				'${expr.edge(0).name()}?'
			} else {
				none
			}
		}
		.expr_paren {
			inner := ast_ct_cond_string_cursor(expr.edge(0)) or { return none }
			'(${inner})'
		}
		else {
			none
		}
	}
}

fn (g &Gen) cross_directive_guard(cond string) ?string {
	if g.target_os_name() != 'cross' {
		return none
	}
	return g.c_preprocessor_expr_for_ct_cond(cond)
}

fn find_vmod_root_for_file(file_path string) string {
	mut dir := os.dir(file_path)
	for _ in 0 .. 12 {
		if os.exists(os.join_path(dir, 'v.mod')) {
			return dir
		}
		parent := os.dir(dir)
		if parent == dir || parent == '' {
			break
		}
		dir = parent
	}
	return os.dir(file_path)
}

fn normalize_c_directive_value(name string, raw string, file_name string, vroot string) string {
	mut value := raw.trim_space()
	if value.ends_with(';') {
		value = value[..value.len - 1].trim_space()
	}
	if value.contains('@VMODROOT') {
		value = value.replace('@VMODROOT', find_vmod_root_for_file(file_name))
	}
	if value.contains('@VEXEROOT') {
		value = value.replace('@VEXEROOT', vroot)
	}
	if name == 'include' {
		if value == '' {
			return value
		}
		mut had_trailing_angle := false
		if value.ends_with('>') && !value.starts_with('<') && !value.starts_with('"') {
			value = value[..value.len - 1].trim_space()
			had_trailing_angle = true
		}
		if !value.starts_with('<') && !value.starts_with('"') {
			if value.starts_with('/') || value.starts_with('./') || value.starts_with('../') {
				value = '"${value}"'
			} else if had_trailing_angle {
				value = '<${value}>'
			} else if value.contains('/') {
				value = '<${value}>'
			} else if value.ends_with('.h') || value.ends_with('.hh') || value.ends_with('.hpp') {
				value = '"${value}"'
			} else if value.ends_with('>') {
				value = '<${value}'
			} else {
				value = '<${value}>'
			}
		}
	}
	return value
}

fn (mut g Gen) emit_collected_c_directives() {
	mut seen := map[string]bool{}
	mut cross_source_paths := map[string]bool{}
	if g.target_os_name() == 'cross' {
		cross_source_paths = g.collect_cross_directives_from_original_sources(mut seen)
	}
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			file_name := fc.name()
			if file_name in cross_source_paths {
				continue
			}
			g.set_file_cursor_module(fc)
			emit_implementation_directives := g.should_emit_current_file()
			g.collect_directives_from_cursor_stmts(fc.stmts(), file_name,
				emit_implementation_directives, mut seen)
		}
		return
	}
	for file in g.files {
		if file.name in cross_source_paths {
			continue
		}
		g.set_file_module(file)
		emit_implementation_directives := g.should_emit_current_file()
		g.collect_directives_from_stmts(file.stmts, file.name, emit_implementation_directives, mut
			seen)
	}
}

fn (mut g Gen) collect_cross_directives_from_original_sources(mut seen map[string]bool) map[string]bool {
	// Cross mode reparses only the files that survived normal source filtering.
	// This recovers C directives from $if OS branches before transform strips
	// them, but it does not provide a second OS-specific function-body pipeline.
	mut parsed_paths := map[string]bool{}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(g.pref)
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			source_path := fc.name()
			if source_path == '' || source_path in parsed_paths || !os.exists(source_path) {
				continue
			}
			parsed_paths[source_path] = true
			source_files := par.parse_files([source_path], mut file_set)
			for source_file in source_files {
				g.set_file_module(source_file)
				emit_implementation_directives := g.should_emit_current_file()
				g.collect_directives_from_stmts(source_file.stmts, source_file.name,
					emit_implementation_directives, mut seen)
			}
		}
		return parsed_paths
	}
	for file in g.files {
		source_path := file.name
		if source_path == '' || source_path in parsed_paths || !os.exists(source_path) {
			continue
		}
		parsed_paths[source_path] = true
		source_files := par.parse_files([source_path], mut file_set)
		for source_file in source_files {
			g.set_file_module(source_file)
			emit_implementation_directives := g.should_emit_current_file()
			g.collect_directives_from_stmts(source_file.stmts, source_file.name,
				emit_implementation_directives, mut seen)
		}
	}
	return parsed_paths
}

fn (mut g Gen) collect_directives_from_stmts(stmts []ast.Stmt, file_name string, emit_implementation_directives bool, mut seen map[string]bool) {
	g.collect_directives_from_stmts_with_ct_cond(stmts, file_name, emit_implementation_directives,
		'', mut seen)
}

fn (mut g Gen) collect_directives_from_cursor_stmts(stmts ast.CursorList, file_name string, emit_implementation_directives bool, mut seen map[string]bool) {
	g.collect_directives_from_cursor_stmts_with_ct_cond(stmts, file_name,
		emit_implementation_directives, '', mut seen)
}

fn (mut g Gen) collect_directives_from_cursor_stmts_with_ct_cond(stmts ast.CursorList, file_name string, emit_implementation_directives bool, outer_ct_cond string, mut seen map[string]bool) {
	g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(stmts, file_name,
		emit_implementation_directives, outer_ct_cond, '', mut seen)
}

fn (mut g Gen) collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(stmts ast.CursorList, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if outer_ct_cond != '' && g.target_os_name() == 'cross' {
		if guard := g.cross_directive_guard(outer_ct_cond) {
			if guard == '0' {
				return
			}
			if guard != '' {
				g.sb.writeln('#if ${guard}')
				g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(stmts,
					file_name, emit_implementation_directives, '', combine_ct_conditions(active_seen_guard,
					guard), mut seen)
				g.sb.writeln('#endif')
				return
			}
		}
	}
	for i in 0 .. stmts.len() {
		stmt := stmts.at(i)
		match stmt.kind() {
			.stmt_directive {
				g.emit_directive_cursor_with_outer_ct_cond_and_seen_guard(stmt, file_name,
					emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
			}
			.stmt_expr {
				g.collect_directives_from_expr_cursor_with_ct_cond_and_seen_guard(stmt.edge(0),
					file_name, emit_implementation_directives, outer_ct_cond, active_seen_guard, mut
					seen)
			}
			else {}
		}
	}
}

fn (mut g Gen) collect_directives_from_stmts_with_ct_cond(stmts []ast.Stmt, file_name string, emit_implementation_directives bool, outer_ct_cond string, mut seen map[string]bool) {
	g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(stmts, file_name,
		emit_implementation_directives, outer_ct_cond, '', mut seen)
}

fn (mut g Gen) collect_directives_from_stmts_with_ct_cond_and_seen_guard(stmts []ast.Stmt, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if outer_ct_cond != '' && g.target_os_name() == 'cross' {
		if guard := g.cross_directive_guard(outer_ct_cond) {
			if guard == '0' {
				return
			}
			if guard != '' {
				g.sb.writeln('#if ${guard}')
				g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(stmts, file_name,
					emit_implementation_directives, '', combine_ct_conditions(active_seen_guard,
					guard), mut seen)
				g.sb.writeln('#endif')
				return
			}
		}
	}
	for stmt in stmts {
		if stmt is ast.Directive {
			g.emit_directive_with_outer_ct_cond_and_seen_guard(stmt, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		} else if stmt is ast.ExprStmt {
			g.collect_directives_from_expr_with_ct_cond_and_seen_guard(stmt.expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
	}
}

fn (mut g Gen) collect_directives_from_expr(expr ast.Expr, file_name string, emit_implementation_directives bool, mut seen map[string]bool) {
	g.collect_directives_from_expr_with_ct_cond(expr, file_name, emit_implementation_directives,
		'', mut seen)
}

fn (mut g Gen) collect_directives_from_expr_with_ct_cond(expr ast.Expr, file_name string, emit_implementation_directives bool, outer_ct_cond string, mut seen map[string]bool) {
	g.collect_directives_from_expr_with_ct_cond_and_seen_guard(expr, file_name,
		emit_implementation_directives, outer_ct_cond, '', mut seen)
}

fn (mut g Gen) collect_directives_from_expr_with_ct_cond_and_seen_guard(expr ast.Expr, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if expr is ast.ComptimeExpr {
		if expr.expr is ast.IfExpr {
			g.collect_directives_from_active_comptime_if(expr.expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		} else {
			g.collect_directives_from_expr_with_ct_cond_and_seen_guard(expr.expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
	} else if expr is ast.IfExpr {
		g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(expr.stmts, file_name,
			emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		if expr.else_expr !is ast.EmptyExpr {
			g.collect_directives_from_expr_with_ct_cond_and_seen_guard(expr.else_expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
	}
}

fn (mut g Gen) collect_directives_from_expr_cursor_with_ct_cond_and_seen_guard(expr ast.Cursor, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if !expr.is_valid() {
		return
	}
	if expr.kind() == .expr_comptime {
		inner := expr.edge(0)
		if inner.kind() == .expr_if {
			g.collect_directives_from_active_comptime_if_cursor(inner, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		} else {
			g.collect_directives_from_expr_cursor_with_ct_cond_and_seen_guard(inner, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
		return
	}
	if expr.kind() == .expr_if {
		g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(if_expr_body_cursor_list(expr),
			file_name, emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		else_expr := expr.edge(1)
		if else_expr.is_valid() && else_expr.kind() != .expr_empty {
			g.collect_directives_from_expr_cursor_with_ct_cond_and_seen_guard(else_expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
	}
}

fn (mut g Gen) emit_directive_with_outer_ct_cond(stmt ast.Directive, file_name string, emit_implementation_directives bool, outer_ct_cond string, mut seen map[string]bool) {
	g.emit_directive_with_outer_ct_cond_and_seen_guard(stmt, file_name,
		emit_implementation_directives, outer_ct_cond, '', mut seen)
}

fn (mut g Gen) emit_directive_with_outer_ct_cond_and_seen_guard(stmt ast.Directive, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if outer_ct_cond == '' {
		g.emit_directive_with_seen_guard(stmt, file_name, emit_implementation_directives,
			active_seen_guard, mut seen)
		return
	}
	g.emit_directive_fields_with_seen_guard(stmt.name, stmt.value, combine_ct_conditions(outer_ct_cond,
		stmt.ct_cond), file_name, emit_implementation_directives, active_seen_guard, mut seen)
}

fn (mut g Gen) emit_directive_cursor_with_outer_ct_cond_and_seen_guard(stmt ast.Cursor, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if !stmt.is_valid() || stmt.kind() != .stmt_directive {
		return
	}
	ct_cond := if stmt.edge_count() > 0 { stmt.edge(0).name() } else { '' }
	resolved_ct_cond := if outer_ct_cond == '' {
		ct_cond
	} else {
		combine_ct_conditions(outer_ct_cond, ct_cond)
	}
	g.emit_directive_fields_with_seen_guard(stmt.name(), stmt.extra_str(), resolved_ct_cond,
		file_name, emit_implementation_directives, active_seen_guard, mut seen)
}

fn (mut g Gen) collect_directives_from_active_comptime_if(expr ast.IfExpr, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if g.target_os_name() == 'cross' {
		if cond := ast_ct_cond_string(expr.cond) {
			if g.c_preprocessor_expr_for_ct_cond(cond) != none {
				g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(expr.stmts, file_name,
					emit_implementation_directives, combine_ct_conditions(outer_ct_cond, cond),
					active_seen_guard, mut seen)
				next_outer_cond := combine_ct_conditions(outer_ct_cond, '!(${cond})')
				if expr.else_expr is ast.IfExpr {
					if expr.else_expr.cond is ast.EmptyExpr {
						g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(expr.else_expr.stmts,
							file_name, emit_implementation_directives, next_outer_cond,
							active_seen_guard, mut seen)
					} else {
						g.collect_directives_from_active_comptime_if(expr.else_expr, file_name,
							emit_implementation_directives, next_outer_cond, active_seen_guard, mut
							seen)
					}
				} else if expr.else_expr !is ast.EmptyExpr {
					g.collect_directives_from_expr_with_ct_cond_and_seen_guard(expr.else_expr,
						file_name, emit_implementation_directives, next_outer_cond,
						active_seen_guard, mut seen)
				}
				return
			}
		}
	}
	if g.ast_comptime_simple_cond_matches(expr.cond) {
		g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(expr.stmts, file_name,
			emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		return
	}
	if expr.else_expr is ast.IfExpr {
		if expr.else_expr.cond is ast.EmptyExpr {
			g.collect_directives_from_stmts_with_ct_cond_and_seen_guard(expr.else_expr.stmts,
				file_name, emit_implementation_directives, outer_ct_cond, active_seen_guard, mut
				seen)
		} else {
			g.collect_directives_from_active_comptime_if(expr.else_expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
	} else if expr.else_expr !is ast.EmptyExpr {
		g.collect_directives_from_expr_with_ct_cond_and_seen_guard(expr.else_expr, file_name,
			emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
	}
}

fn (mut g Gen) collect_directives_from_active_comptime_if_cursor(expr ast.Cursor, file_name string, emit_implementation_directives bool, outer_ct_cond string, active_seen_guard string, mut seen map[string]bool) {
	if !expr.is_valid() || expr.kind() != .expr_if {
		return
	}
	cond_expr := expr.edge(0)
	if g.target_os_name() == 'cross' {
		if cond := ast_ct_cond_string_cursor(cond_expr) {
			if g.c_preprocessor_expr_for_ct_cond(cond) != none {
				g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(if_expr_body_cursor_list(expr),
					file_name, emit_implementation_directives, combine_ct_conditions(outer_ct_cond,
					cond), active_seen_guard, mut seen)
				next_outer_cond := combine_ct_conditions(outer_ct_cond, '!(${cond})')
				else_expr := expr.edge(1)
				if else_expr.kind() == .expr_if {
					if else_expr.edge(0).kind() == .expr_empty {
						g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(if_expr_body_cursor_list(else_expr),
							file_name, emit_implementation_directives, next_outer_cond,
							active_seen_guard, mut seen)
					} else {
						g.collect_directives_from_active_comptime_if_cursor(else_expr, file_name,
							emit_implementation_directives, next_outer_cond, active_seen_guard, mut
							seen)
					}
				} else if else_expr.is_valid() && else_expr.kind() != .expr_empty {
					g.collect_directives_from_expr_cursor_with_ct_cond_and_seen_guard(else_expr,
						file_name, emit_implementation_directives, next_outer_cond,
						active_seen_guard, mut seen)
				}
				return
			}
		}
	}
	if g.ast_comptime_simple_cond_matches_cursor(cond_expr) {
		g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(if_expr_body_cursor_list(expr),
			file_name, emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		return
	}
	else_expr := expr.edge(1)
	if else_expr.kind() == .expr_if {
		if else_expr.edge(0).kind() == .expr_empty {
			g.collect_directives_from_cursor_stmts_with_ct_cond_and_seen_guard(if_expr_body_cursor_list(else_expr),
				file_name, emit_implementation_directives, outer_ct_cond, active_seen_guard, mut
				seen)
		} else {
			g.collect_directives_from_active_comptime_if_cursor(else_expr, file_name,
				emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
		}
	} else if else_expr.is_valid() && else_expr.kind() != .expr_empty {
		g.collect_directives_from_expr_cursor_with_ct_cond_and_seen_guard(else_expr, file_name,
			emit_implementation_directives, outer_ct_cond, active_seen_guard, mut seen)
	}
}

fn if_expr_body_cursor_list(expr ast.Cursor) ast.CursorList {
	return ast.CursorList{
		flat:      expr.flat
		parent_id: expr.id
		offset:    2
	}
}

fn (g &Gen) ast_comptime_simple_cond_matches(expr ast.Expr) bool {
	if expr is ast.Ident {
		return g.ast_comptime_flag_matches(expr.name)
	}
	if expr is ast.ComptimeExpr {
		return g.ast_comptime_simple_cond_matches(expr.expr)
	}
	if expr is ast.CallExpr {
		if pkg_name := cleanc_pkgconfig_call_name(expr) {
			return vpref.comptime_pkgconfig_value(pkg_name)
		}
	}
	if expr is ast.CallOrCastExpr {
		if pkg_name := cleanc_pkgconfig_call_name(expr) {
			return vpref.comptime_pkgconfig_value(pkg_name)
		}
	}
	if expr is ast.PrefixExpr {
		if expr.op == .not {
			return !g.ast_comptime_simple_cond_matches(expr.expr)
		}
		return false
	}
	if expr is ast.InfixExpr {
		if expr.op == .and {
			return g.ast_comptime_simple_cond_matches(expr.lhs)
				&& g.ast_comptime_simple_cond_matches(expr.rhs)
		}
		if expr.op == .logical_or {
			return g.ast_comptime_simple_cond_matches(expr.lhs)
				|| g.ast_comptime_simple_cond_matches(expr.rhs)
		}
		return false
	}
	if expr is ast.PostfixExpr {
		if expr.op == .question && expr.expr is ast.Ident {
			return g.has_target_define(expr.expr.name)
		}
		return false
	}
	if expr is ast.ParenExpr {
		return g.ast_comptime_simple_cond_matches(expr.expr)
	}
	return false
}

fn (g &Gen) ast_comptime_simple_cond_matches_cursor(expr ast.Cursor) bool {
	if !expr.is_valid() {
		return false
	}
	match expr.kind() {
		.expr_ident {
			return g.ast_comptime_flag_matches(expr.name())
		}
		.expr_comptime, .expr_paren {
			return g.ast_comptime_simple_cond_matches_cursor(expr.edge(0))
		}
		.expr_call, .expr_call_or_cast {
			if pkg_name := cleanc_pkgconfig_call_name_cursor(expr) {
				return vpref.comptime_pkgconfig_value(pkg_name)
			}
		}
		.expr_prefix {
			if unsafe { token.Token(int(expr.aux())) } == .not {
				return !g.ast_comptime_simple_cond_matches_cursor(expr.edge(0))
			}
		}
		.expr_infix {
			op := unsafe { token.Token(int(expr.aux())) }
			if op == .and {
				return g.ast_comptime_simple_cond_matches_cursor(expr.edge(0))
					&& g.ast_comptime_simple_cond_matches_cursor(expr.edge(1))
			}
			if op == .logical_or {
				return g.ast_comptime_simple_cond_matches_cursor(expr.edge(0))
					|| g.ast_comptime_simple_cond_matches_cursor(expr.edge(1))
			}
		}
		.expr_postfix {
			if unsafe { token.Token(int(expr.aux())) } == .question
				&& expr.edge(0).kind() == .expr_ident {
				return g.has_target_define(expr.edge(0).name())
			}
		}
		else {}
	}

	return false
}

fn (g &Gen) ast_comptime_flag_matches(name string) bool {
	lower_name := name.to_lower()
	if g.pref == unsafe { nil } {
		return false
	}
	match lower_name {
		'macos', 'darwin', 'mac', 'linux', 'windows', 'bsd', 'freebsd', 'openbsd', 'netbsd',
		'dragonfly', 'android', 'termux', 'ios', 'solaris', 'qnx', 'serenity', 'plan9', 'vinix',
		'none' {
			return vpref.comptime_flag_value(g.pref, lower_name)
		}
		'cross', 'freestanding', 'bare' {
			return vpref.comptime_flag_value(g.pref, lower_name)
				|| vpref.define_list_contains(g.pref.user_defines, lower_name)
		}
		else {}
	}

	return vpref.define_list_contains(g.pref.user_defines, lower_name)
}

fn cleanc_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 cleanc_string_literal_value(expr.args[0])
			}
		}
		ast.CallOrCastExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'pkgconfig' {
				return cleanc_string_literal_value(expr.expr)
			}
		}
		else {}
	}

	return none
}

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

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

fn cleanc_string_literal_value_cursor(expr ast.Cursor) ?string {
	if !expr.is_valid() || (expr.kind() != .expr_string && expr.kind() != .expr_basic_literal) {
		return none
	}
	return cleanc_unquote_string_literal_value(expr.name())
}

fn cleanc_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
}

fn c_directive_emits_linked_symbols(value string) bool {
	lower_value := value.trim_space().to_lower()
	for marker in ['.c"', ".c'", '.c>', '.m"', ".m'", '.m>'] {
		if lower_value.contains(marker) {
			return true
		}
	}
	return lower_value.contains('"miniz.h"') || lower_value.contains('<miniz.h>')
		|| lower_value.contains('/miniz.h"') || lower_value.contains('/miniz.h>')
}

fn c_define_enables_linked_symbols(value string) bool {
	upper_value := value.trim_space().to_upper()
	return upper_value.contains('IMPLEMENTATION')
}

fn (mut g Gen) emit_directive(stmt ast.Directive, file_name string, emit_implementation_directives bool, mut seen map[string]bool) {
	g.emit_directive_with_seen_guard(stmt, file_name, emit_implementation_directives, '', mut seen)
}

fn (mut g Gen) emit_directive_with_seen_guard(stmt ast.Directive, file_name string, emit_implementation_directives bool, active_seen_guard string, mut seen map[string]bool) {
	g.emit_directive_fields_with_seen_guard(stmt.name, stmt.value, stmt.ct_cond, file_name,
		emit_implementation_directives, active_seen_guard, mut seen)
}

fn (mut g Gen) emit_directive_fields_with_seen_guard(raw_name string, raw_value string, ct_cond string, file_name string, emit_implementation_directives bool, active_seen_guard string, mut seen map[string]bool) {
	name := raw_name.trim_space()
	if name == '' || name == 'flag' {
		return
	}
	if !g.directive_ct_cond_matches(ct_cond) {
		return
	}
	if name !in ['include', 'define', 'undef', 'ifdef', 'ifndef', 'if', 'elif', 'else', 'endif',
		'pragma', 'insert'] {
		return
	}
	// #insert is V's directive to inline a file; for C backend, emit as #include.
	emit_name := if name == 'insert' { 'include' } else { name }
	// Skip includes with corrupt paths (ARM64 backend may corrupt string data)
	if emit_name == 'include' {
		v := raw_value.trim_space()
		if v.len > 0 && !v.contains('/') && !v.contains('.') && !v.starts_with('"')
			&& !v.starts_with('<') {
			return
		}
	}
	vroot := if g.pref != unsafe { nil } { g.pref.vroot } else { '' }
	value := normalize_c_directive_value(emit_name, raw_value, file_name, vroot)
	if !emit_implementation_directives && emit_name == 'include'
		&& c_directive_emits_linked_symbols(value) {
		return
	}
	if !emit_implementation_directives && emit_name == 'define'
		&& c_define_enables_linked_symbols(value) {
		return
	}
	line := if value == '' { '#${emit_name}' } else { '#${emit_name} ${value}' }
	guard := g.cross_directive_guard(ct_cond) or { '' }
	if guard == '0' {
		return
	}
	mut seen_key := if guard == '' { line } else { '#if ${guard}\n${line}' }
	if active_seen_guard != '' {
		seen_key = '#if ${active_seen_guard}\n${seen_key}'
	}
	deduplicate := emit_name !in ['if', 'ifdef', 'ifndef', 'elif', 'else', 'endif']
	if deduplicate {
		if seen_key in seen {
			return
		}
		seen[seen_key] = true
	}
	if emit_name == 'include' && value.contains('/thirdparty/stdatomic/nix/atomic.h') {
		if guard != '' {
			g.sb.writeln('#if ${guard}')
		}
		g.sb.writeln('#if defined(__TINYC__) && defined(__APPLE__) && defined(__aarch64__)')
		g.sb.writeln('#define extern static')
		g.sb.writeln('#endif')
		g.sb.writeln(line)
		g.sb.writeln('#if defined(__TINYC__) && defined(__APPLE__) && defined(__aarch64__)')
		g.sb.writeln('#undef extern')
		g.sb.writeln('#endif')
		if guard != '' {
			g.sb.writeln('#endif')
		}
		return
	}
	// Defer .m (Objective-C) includes until after type definitions,
	// because they reference V-generated C types like gg__Color, string, etc.
	if emit_name == 'include' && (value.contains('.m"') || value.contains(".m'")) {
		deferred_guard := combine_ct_conditions(active_seen_guard, guard)
		g.deferred_m_includes << if deferred_guard == '' {
			line
		} else {
			'#if ${deferred_guard}\n${line}\n#endif'
		}
		return
	}
	if guard != '' {
		g.sb.writeln('#if ${guard}')
		g.sb.writeln(line)
		g.sb.writeln('#endif')
		return
	}
	g.sb.writeln(line)
}

fn (mut g Gen) emit_deferred_m_includes() {
	// Skip .m includes when compiling as shared library (avoids duplicate ObjC classes)
	if g.pref != unsafe { nil } && g.pref.is_shared_lib {
		return
	}
	for line in g.deferred_m_includes {
		g.sb.writeln(line)
	}
}

fn (mut g Gen) emit_vec_simd_fallback_aliases() {
	g.sb.writeln('#if defined(__clang__)')
	g.sb.writeln('typedef float vec__SimdFloat2 __attribute__((ext_vector_type(2)));')
	g.sb.writeln('typedef float vec__SimdFloat4 __attribute__((ext_vector_type(4)));')
	g.sb.writeln('typedef int vec__SimdInt4 __attribute__((ext_vector_type(4)));')
	g.sb.writeln('typedef unsigned int vec__SimdU32_4 __attribute__((ext_vector_type(4)));')
	g.sb.writeln('#elif defined(__GNUC__)')
	g.sb.writeln('typedef float vec__SimdFloat2 __attribute__((vector_size(8)));')
	g.sb.writeln('typedef float vec__SimdFloat4 __attribute__((vector_size(16)));')
	g.sb.writeln('typedef int vec__SimdInt4 __attribute__((vector_size(16)));')
	g.sb.writeln('typedef unsigned int vec__SimdU32_4 __attribute__((vector_size(16)));')
	g.sb.writeln('#else')
	g.sb.writeln('typedef struct vec__SimdFloat2 { f32 x; f32 y; } vec__SimdFloat2;')
	g.sb.writeln('typedef struct vec__SimdFloat4 { f32 x; f32 y; f32 z; f32 w; } vec__SimdFloat4;')
	g.sb.writeln('typedef struct vec__SimdInt4 { i32 x; i32 y; i32 z; i32 w; } vec__SimdInt4;')
	g.sb.writeln('typedef struct vec__SimdU32_4 { u32 x; u32 y; u32 z; u32 w; } vec__SimdU32_4;')
	g.sb.writeln('#endif')
}

fn (mut g Gen) emit_tinyc_arm_cpu_relax_fallback() {
	g.sb.writeln('#if defined(__TINYC__) && (defined(__aarch64__) || defined(_M_ARM64) || defined(__arm__) || defined(_M_ARM))')
	g.sb.writeln('#ifdef cpu_relax')
	g.sb.writeln('#undef cpu_relax')
	g.sb.writeln('#endif')
	g.sb.writeln('#define cpu_relax() ((void)0)')
	g.sb.writeln('#endif')
}

fn (mut g Gen) emit_stdatomic_compat_include() {
	if g.pref == unsafe { nil } || g.pref.vroot.len == 0 {
		return
	}
	dir_name := if g.target_os_name() == 'windows' { 'win' } else { 'nix' }
	header_path := os.join_path(g.pref.vroot, 'thirdparty', 'stdatomic', dir_name, 'atomic.h')
	if !os.exists(header_path) {
		return
	}
	include_path := header_path.replace('\\', '/')
	// The `extern -> static` hack only matters for tcc on Apple arm64; keep
	// the __APPLE__ guard out of non-macos target preambles (they are
	// asserted apple-free by target_codegen_test).
	apple_target := g.target_os_name() == 'macos'
	if apple_target {
		g.sb.writeln('#if defined(__TINYC__) && defined(__APPLE__) && defined(__aarch64__)')
		g.sb.writeln('#define extern static')
		g.sb.writeln('#endif')
	}
	g.sb.writeln('#include "${include_path}"')
	if apple_target {
		g.sb.writeln('#if defined(__TINYC__) && defined(__APPLE__) && defined(__aarch64__)')
		g.sb.writeln('#undef extern')
		g.sb.writeln('#endif')
	}
}

fn (mut g Gen) emit_v_architecture_macros() {
	g.sb.writeln('#if defined(__x86_64__) || defined(_M_AMD64)')
	g.sb.writeln('#define __V_amd64 1')
	g.sb.writeln('#define __V_architecture 1')
	g.sb.writeln('#elif defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64)')
	g.sb.writeln('#define __V_arm64 1')
	g.sb.writeln('#define __V_architecture 2')
	g.sb.writeln('#elif defined(__arm__) || defined(_M_ARM)')
	g.sb.writeln('#define __V_arm32 1')
	g.sb.writeln('#define __V_architecture 3')
	g.sb.writeln('#elif defined(__riscv) && __riscv_xlen == 64')
	g.sb.writeln('#define __V_rv64 1')
	g.sb.writeln('#define __V_architecture 4')
	g.sb.writeln('#elif defined(__riscv) && __riscv_xlen == 32')
	g.sb.writeln('#define __V_rv32 1')
	g.sb.writeln('#define __V_architecture 5')
	g.sb.writeln('#elif defined(__i386__) || defined(_M_IX86)')
	g.sb.writeln('#define __V_x86 1')
	g.sb.writeln('#define __V_architecture 6')
	g.sb.writeln('#elif defined(__s390x__)')
	g.sb.writeln('#define __V_s390x 1')
	g.sb.writeln('#define __V_architecture 7')
	g.sb.writeln('#elif defined(__powerpc64__) && defined(__LITTLE_ENDIAN__)')
	g.sb.writeln('#define __V_ppc64le 1')
	g.sb.writeln('#define __V_architecture 8')
	g.sb.writeln('#elif defined(__loongarch64)')
	g.sb.writeln('#define __V_loongarch64 1')
	g.sb.writeln('#define __V_architecture 9')
	g.sb.writeln('#elif defined(__sparc__)')
	g.sb.writeln('#define __V_sparc64 1')
	g.sb.writeln('#define __V_architecture 10')
	g.sb.writeln('#elif defined(__powerpc64__) && defined(__BIG_ENDIAN__)')
	g.sb.writeln('#define __V_ppc64 1')
	g.sb.writeln('#define __V_architecture 11')
	g.sb.writeln('#elif (defined(__powerpc__) || defined(__powerpc) || defined(__POWERPC__) || defined(__ppc__) || defined(__ppc) || defined(__PPC__)) && !defined(__powerpc64__) && !defined(__ppc64__) && !defined(__PPC64__)')
	g.sb.writeln('#define __V_ppc 1')
	g.sb.writeln('#define __V_architecture 12')
	g.sb.writeln('#else')
	g.sb.writeln('#define __V_architecture 0')
	g.sb.writeln('#endif')
}

fn (mut g Gen) emit_v_commit_hash_fallback() {
	g.sb.writeln('#ifndef V_COMMIT_HASH')
	g.sb.writeln('#define V_COMMIT_HASH "@@@"')
	g.sb.writeln('#endif')
}

fn (mut g Gen) emit_stub_rwmutex() {
	g.sb.writeln('typedef struct sync__RwMutex { u32 inited; } sync__RwMutex;')
	g.sb.writeln('static inline void sync__RwMutex_rlock(sync__RwMutex* m) { (void)m; }')
	g.sb.writeln('static inline void sync__RwMutex_runlock(sync__RwMutex* m) { (void)m; }')
	g.sb.writeln('static inline void sync__RwMutex_lock(sync__RwMutex* m) { (void)m; }')
	g.sb.writeln('static inline void sync__RwMutex_unlock(sync__RwMutex* m) { (void)m; }')
	g.emitted_types['body_sync__RwMutex'] = true
}

fn (mut g Gen) emit_pthread_rwmutex() {
	g.sb.writeln('typedef struct sync__RwMutex { pthread_rwlock_t mutex; u32 inited; } sync__RwMutex;')
	g.sb.writeln('static inline void sync__RwMutex_rlock(sync__RwMutex* m) { pthread_rwlock_rdlock(&m->mutex); }')
	g.sb.writeln('static inline void sync__RwMutex_runlock(sync__RwMutex* m) { pthread_rwlock_unlock(&m->mutex); }')
	g.sb.writeln('static inline void sync__RwMutex_lock(sync__RwMutex* m) { pthread_rwlock_wrlock(&m->mutex); }')
	g.sb.writeln('static inline void sync__RwMutex_unlock(sync__RwMutex* m) { pthread_rwlock_unlock(&m->mutex); }')
	g.emitted_types['body_sync__RwMutex'] = true
}

fn (mut g Gen) emit_windows_rwmutex() {
	g.sb.writeln('typedef struct sync__RwMutex { SRWLOCK mutex; u32 inited; } sync__RwMutex;')
	g.sb.writeln('static inline void sync__RwMutex_rlock(sync__RwMutex* m) { AcquireSRWLockShared(&m->mutex); }')
	g.sb.writeln('static inline void sync__RwMutex_runlock(sync__RwMutex* m) { ReleaseSRWLockShared(&m->mutex); }')
	g.sb.writeln('static inline void sync__RwMutex_lock(sync__RwMutex* m) { AcquireSRWLockExclusive(&m->mutex); }')
	g.sb.writeln('static inline void sync__RwMutex_unlock(sync__RwMutex* m) { ReleaseSRWLockExclusive(&m->mutex); }')
	g.emitted_types['body_sync__RwMutex'] = true
}

fn (mut g Gen) emit_cross_rwmutex() {
	g.sb.writeln('#if defined(_WIN32)')
	g.emit_windows_rwmutex()
	g.sb.writeln('#else')
	g.emit_pthread_rwmutex()
	g.sb.writeln('#endif')
	g.emitted_types['body_sync__RwMutex'] = true
}

fn (mut g Gen) emit_target_rwmutex() {
	target_os := g.target_os_name()
	if g.is_freestanding_target() {
		g.emit_stub_rwmutex()
		return
	}
	if target_os == 'windows' {
		g.emit_windows_rwmutex()
		return
	}
	if target_os == 'cross' {
		g.emit_cross_rwmutex()
		return
	}
	g.emit_pthread_rwmutex()
}

fn (mut g Gen) write_preamble() {
	minimal_preamble := g.use_minimal_preamble()
	g.sb.write_string(g.preamble_includes(minimal_preamble))
	g.emit_linux_gettid_compat(minimal_preamble)
	g.emit_stdatomic_compat_include()
	g.emit_v_architecture_macros()
	g.emit_v_commit_hash_fallback()
	g.emit_collected_c_directives()
	g.emit_tinyc_arm_cpu_relax_fallback()
	if g.pref != unsafe { nil } && g.pref.prealloc && !g.is_freestanding_target() {
		g.sb.writeln('#define _VPREALLOC (1)')
		// Save the real free() before redefining it as a no-op.
		// prealloc_vcleanup needs the real free to release arena chunks.
		g.sb.writeln('static inline void _v_cfree(void *p) { free(p); }')
		g.sb.writeln('#define free(p) ((void)(p), (void)0)')
	}
	g.sb.writeln('')

	// V primitive type aliases
	g.sb.writeln('// V primitive types')
	g.sb.writeln('typedef int8_t i8;')
	g.sb.writeln('typedef int16_t i16;')
	g.sb.writeln('typedef int32_t i32;')
	g.sb.writeln('typedef int64_t i64;')
	g.sb.writeln('typedef uint8_t u8;')
	g.sb.writeln('typedef uint16_t u16;')
	g.sb.writeln('typedef uint32_t u32;')
	g.sb.writeln('typedef uint64_t u64;')
	g.sb.writeln('typedef float f32;')
	g.sb.writeln('typedef double f64;')
	g.sb.writeln('typedef u8 byte;')
	g.sb.writeln('typedef size_t usize;')
	g.sb.writeln('typedef ptrdiff_t isize;')
	g.sb.writeln('typedef u32 rune;')
	g.sb.writeln('typedef char* byteptr;')
	g.sb.writeln('typedef char* charptr;')
	g.sb.writeln('typedef void* voidptr;')
	g.sb.writeln('typedef struct sync__Channel* chan;')
	g.sb.writeln('typedef double float_literal;')
	g.sb.writeln('typedef int64_t int_literal;')
	g.sb.writeln('extern int g_main_argc;')
	g.sb.writeln('extern void* g_main_argv;')
	g.emit_freestanding_platform_hook_decls()
	g.emit_vec_simd_fallback_aliases()
	if minimal_preamble {
		g.emit_target_rwmutex()
		g.sb.writeln('')
		return
	}
	// wyhash implementation used by builtin/map and hash modules.
	g.sb.writeln('#ifndef wyhash_final_version_4_2')
	g.sb.writeln('#define wyhash_final_version_4_2')
	g.sb.writeln('#define WYHASH_CONDOM 1')
	g.sb.writeln('#define WYHASH_32BIT_MUM 0')
	g.sb.writeln('#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)')
	g.sb.writeln('  #define _likely_(x) __builtin_expect(x,1)')
	g.sb.writeln('  #define _unlikely_(x) __builtin_expect(x,0)')
	g.sb.writeln('#else')
	g.sb.writeln('  #define _likely_(x) (x)')
	g.sb.writeln('  #define _unlikely_(x) (x)')
	g.sb.writeln('#endif')
	g.sb.writeln('static inline uint64_t _wyrot(uint64_t x) { return (x>>32)|(x<<32); }')
	g.sb.writeln('static inline void _wymum(uint64_t *A, uint64_t *B){')
	g.sb.writeln('#if defined(__SIZEOF_INT128__)')
	g.sb.writeln('  __uint128_t r=*A; r*=*B; *A=(uint64_t)r; *B=(uint64_t)(r>>64);')
	g.sb.writeln('#elif defined(_MSC_VER) && defined(_M_X64)')
	g.sb.writeln('  *A=_umul128(*A,*B,B);')
	g.sb.writeln('#else')
	g.sb.writeln('  uint64_t ha=*A>>32, hb=*B>>32, la=(uint32_t)*A, lb=(uint32_t)*B, hi, lo;')
	g.sb.writeln('  uint64_t rh=ha*hb, rm0=ha*lb, rm1=hb*la, rl=la*lb, t=rl+(rm0<<32), c=t<rl;')
	g.sb.writeln('  lo=t+(rm1<<32); c+=lo<t; hi=rh+(rm0>>32)+(rm1>>32)+c;')
	g.sb.writeln('  *A=lo; *B=hi;')
	g.sb.writeln('#endif')
	g.sb.writeln('}')
	g.sb.writeln('static inline uint64_t _wymix(uint64_t A, uint64_t B){ _wymum(&A,&B); return A^B; }')
	g.sb.writeln('#ifndef WYHASH_LITTLE_ENDIAN')
	g.sb.writeln('  #if defined(__LITTLE_ENDIAN__) || defined(__aarch64__) || defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86) || defined(TARGET_ORDER_IS_LITTLE)')
	g.sb.writeln('    #define WYHASH_LITTLE_ENDIAN 1')
	g.sb.writeln('  #else')
	g.sb.writeln('    #define WYHASH_LITTLE_ENDIAN 0')
	g.sb.writeln('  #endif')
	g.sb.writeln('#endif')
	g.sb.writeln('#if (WYHASH_LITTLE_ENDIAN)')
	g.sb.writeln('  static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v;}')
	g.sb.writeln('  static inline uint64_t _wyr4(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return v;}')
	g.sb.writeln('#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)')
	g.sb.writeln('  static inline uint64_t _wyr8(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return __builtin_bswap64(v);}')
	g.sb.writeln('  static inline uint64_t _wyr4(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return __builtin_bswap32(v);}')
	g.sb.writeln('#else')
	g.sb.writeln('  static inline uint64_t _wyr8(const uint8_t *p) {')
	g.sb.writeln('    uint64_t v; memcpy(&v, p, 8);')
	g.sb.writeln('    return (((v >> 56) & 0xff)| ((v >> 40) & 0xff00)| ((v >> 24) & 0xff0000)| ((v >>  8) & 0xff000000)| ((v <<  8) & 0xff00000000)| ((v << 24) & 0xff0000000000)| ((v << 40) & 0xff000000000000)| ((v << 56) & 0xff00000000000000));')
	g.sb.writeln('  }')
	g.sb.writeln('  static inline uint64_t _wyr4(const uint8_t *p) {')
	g.sb.writeln('    uint32_t v; memcpy(&v, p, 4);')
	g.sb.writeln('    return (((v >> 24) & 0xff)| ((v >>  8) & 0xff00)| ((v <<  8) & 0xff0000)| ((v << 24) & 0xff000000));')
	g.sb.writeln('  }')
	g.sb.writeln('#endif')
	g.sb.writeln('static inline uint64_t _wyr3(const uint8_t *p, size_t k) { return (((uint64_t)p[0])<<16)|(((uint64_t)p[k>>1])<<8)|p[k-1];}')
	g.sb.writeln('static inline uint64_t wyhash(const void *key, size_t len, uint64_t seed, const uint64_t *secret){')
	g.sb.writeln('  const uint8_t *p=(const uint8_t *)key; seed^=_wymix(seed^secret[0]^len,secret[1]); uint64_t a, b;')
	g.sb.writeln('  if(_likely_(len<=16)){')
	g.sb.writeln('    if(_likely_(len>=4)){ a=(_wyr4(p)<<32)|_wyr4(p+((len>>3)<<2)); b=(_wyr4(p+len-4)<<32)|_wyr4(p+len-4-((len>>3)<<2)); }')
	g.sb.writeln('    else if(_likely_(len>0)){ a=_wyr3(p,len); b=0; }')
	g.sb.writeln('    else a=b=0;')
	g.sb.writeln('  } else {')
	g.sb.writeln('    size_t i=len;')
	g.sb.writeln('    if(_unlikely_(i>=48)){')
	g.sb.writeln('      uint64_t see1=seed, see2=seed;')
	g.sb.writeln('      do{')
	g.sb.writeln('        seed=_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed);')
	g.sb.writeln('        see1=_wymix(_wyr8(p+16)^secret[2],_wyr8(p+24)^see1);')
	g.sb.writeln('        see2=_wymix(_wyr8(p+32)^secret[3],_wyr8(p+40)^see2);')
	g.sb.writeln('        p+=48; i-=48;')
	g.sb.writeln('      }while(_likely_(i>=48));')
	g.sb.writeln('      seed^=see1^see2;')
	g.sb.writeln('    }')
	g.sb.writeln('    while(_unlikely_(i>16)){ seed=_wymix(_wyr8(p)^secret[1],_wyr8(p+8)^seed); i-=16; p+=16; }')
	g.sb.writeln('    a=_wyr8(p+i-16); b=_wyr8(p+i-8);')
	g.sb.writeln('  }')
	g.sb.writeln('  a^=secret[1]; b^=seed; _wymum(&a,&b);')
	g.sb.writeln('  return _wymix(a^secret[0]^len,b^secret[1]);')
	g.sb.writeln('}')
	g.sb.writeln('static const uint64_t _wyp[4] = {0x2d358dccaa6c78a5ull, 0x8bb84b93962eacc9ull, 0x4b33a62ed433d4a3ull, 0x4d5a2da51de1aa47ull};')
	g.sb.writeln('static inline uint64_t wyhash64(uint64_t A, uint64_t B){ A^=0x2d358dccaa6c78a5ull; B^=0x8bb84b93962eacc9ull; _wymum(&A,&B); return _wymix(A^0x2d358dccaa6c78a5ull,B^0x8bb84b93962eacc9ull);}')
	g.sb.writeln('#endif')
	g.sb.writeln('#define _MOV')
	if g.target_os_name() != 'windows' && !g.is_freestanding_target() {
		g.sb.writeln('typedef u8 termios__Cc;')
	}
	// sync__RwMutex for shared variables
	g.emit_target_rwmutex()
	g.sb.writeln('')
	g.sb.writeln('')
}

fn (mut g Gen) emit_freestanding_platform_hook_decls() {
	if !g.has_freestanding_hooks() {
		return
	}
	g.sb.writeln('')
	if g.has_freestanding_hook_capability('output') {
		g.sb.writeln('isize v_platform_write(int stream, const u8* buf, isize len);')
	}
	if g.has_freestanding_hook_capability('panic') {
		g.sb.writeln('void v_platform_panic(const u8* msg, isize len);')
	}
	if g.has_freestanding_hook_capability('alloc') {
		g.sb.writeln('void* v_platform_malloc(isize n);')
		g.sb.writeln('void* v_platform_realloc(void* ptr, isize n);')
		g.sb.writeln('void v_platform_free(void* ptr);')
	}
}

fn (g &Gen) use_minimal_preamble() bool {
	return g.emit_modules.len == 1 && 'main' in g.emit_modules
}

fn (mut g Gen) emit_runtime_aliases() {
	mut array_names := g.array_aliases.keys()
	array_names.sort()
	if 'Array_math__T' !in g.array_aliases {
		g.sb.writeln('typedef array Array_math__T;')
	}
	// Emit dynamic array aliases (skip fixed arrays)
	for name in array_names {
		if name.starts_with('Array_fixed_') {
			continue
		}
		g.emit_array_alias_decl(name)
	}
	// Pointer element typedefs (e.g. 'typedef Coord* Coordptr;') are deferred
	// to emit_pointer_typedefs() which runs after pass 2 (enum/alias definitions).
	// Emit primitive fixed array typedefs (non-primitive ones deferred until after struct defs)
	for name in array_names {
		if !name.starts_with('Array_fixed_') {
			continue
		}
		if info := g.collected_fixed_array_types[name] {
			if info.elem_type in primitive_types
				|| info.elem_type in ['char', 'voidptr', 'charptr', 'byteptr', 'void*', 'char*'] {
				g.sb.writeln('typedef ${info.elem_type} ${name} [${info.size}];')
				alias_key := 'alias_${name}'
				body_key := 'body_${name}'
				g.emitted_types[alias_key] = true
				g.emitted_types[body_key] = true
				// Emit fallback str macros for fixed array types (only if no real function was generated)
				str_fn := '${name}_str'
				if str_fn !in g.fn_return_types {
					g.sb.writeln('#define ${name}_str(a) ((string){.str = "${name}", .len = ${name.len}, .is_lit = 1})')
					g.sb.writeln('#define ${name}__str(a) ${name}_str(a)')
				}
			}
		}
	}
	g.sb.writeln('typedef array VArg_string;')
	g.sb.writeln('bool map_map_eq(map a, map b);')
	mut map_names := g.map_aliases.keys()
	map_names.sort()
	for name in map_names {
		g.emit_map_alias_decl(name)
	}
	// Option/Result forward declarations (struct definitions emitted later
	// after IError is defined, via emit_option_result_structs)
	mut option_names := g.option_aliases.keys()
	option_names.sort()
	for name in option_names {
		if g.should_skip_shadowed_option_result_alias(name) {
			continue
		}
		val_type := option_value_type(name)
		g.emit_option_result_forward_decl(name, val_type)
	}
	if '_option_string' in g.option_aliases {
		g.sb.writeln('static _option_string builtin__Option_string__clone(_option_string s);')
	}
	mut result_names := g.result_aliases.keys()
	result_names.sort()
	for name in result_names {
		if g.should_skip_shadowed_option_result_alias(name) {
			continue
		}
		val_type := g.result_value_type(name)
		g.emit_option_result_forward_decl(name, val_type)
	}
}

fn (mut g Gen) emit_option_result_forward_decl(name string, val_type string) {
	if g.option_result_payload_invalid(val_type) {
		return
	}
	key := 'option_result_forward_${name}'
	if key in g.emitted_types {
		return
	}
	g.emitted_types[key] = true
	if val_type != '' && val_type != 'void' {
		g.sb.writeln('typedef struct ${name} ${name};')
	} else if name.starts_with('_option_') {
		g.sb.writeln('typedef _option ${name};')
	} else {
		g.sb.writeln('typedef _result ${name};')
	}
}

// emit_pointer_typedefs emits pointer element typedefs needed by array helper functions.
// e.g. Array_Coordptr needs 'typedef Coord* Coordptr;'.
// Must run AFTER pass 2 so that enum and type alias definitions are available.
fn (mut g Gen) emit_pointer_typedefs() {
	mut array_names := g.array_aliases.keys()
	array_names.sort()
	for name in array_names {
		if name.starts_with('Array_fixed_') {
			continue
		}
		elem := name['Array_'.len..]
		if elem.len > 3 && elem.ends_with('ptr') {
			base := elem[..elem.len - 3]
			if base !in ['void', 'char', 'byte'] && !elem.starts_with('Array_')
				&& !elem.starts_with('Map_') {
				g.sb.writeln('typedef ${base}* ${elem};')
			}
		}
	}
}

fn (mut g Gen) get_enum_name(node ast.EnumDecl) string {
	if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
		return '${g.cur_module}__${node.name}'
	}
	return node.name
}

fn (mut g Gen) emit_array_alias_decl(name string) {
	array_name := name.trim_right('*')
	if !array_name.starts_with('Array_') || array_name.starts_with('Array_fixed_') {
		return
	}
	alias_key := 'alias_${array_name}'
	if alias_key in g.emitted_types {
		return
	}
	g.emitted_types[alias_key] = true
	g.array_aliases[array_name] = true
	g.sb.writeln('typedef array ${array_name};')
}

fn (mut g Gen) emit_map_alias_decl(name string) {
	map_name := name.trim_right('*')
	if !map_name.starts_with('Map_') {
		return
	}
	alias_key := 'alias_${map_name}'
	if alias_key in g.emitted_types {
		return
	}
	g.emitted_types[alias_key] = true
	g.map_aliases[map_name] = true
	g.sb.writeln('typedef map ${map_name};')
	// Forward-declare map helper functions (bodies generated later).
	map_str_fn := '${map_name}_str'
	if map_str_fn !in g.fn_return_types {
		g.sb.writeln('string ${map_name}_str(${map_name} m);')
	}
	g.sb.writeln('bool ${map_name}_map_eq(${map_name} a, ${map_name} b);')
}

fn (mut g Gen) gen_enum_decl(node ast.EnumDecl) {
	name := g.get_enum_name(node)
	enum_key := 'enum_${name}'
	if enum_key in g.emitted_types {
		return
	}
	g.emitted_types[enum_key] = true
	mut is_flag := false
	for attribute in node.attributes {
		if attribute.name == 'flag' {
			is_flag = true
			break
		}
		if attribute.name == '' && attribute.value is ast.Ident && attribute.value.name == 'flag' {
			is_flag = true
			break
		}
	}

	g.sb.writeln('typedef enum {')
	for i, field in node.fields {
		g.sb.write_string('\t${g.enum_member_c_name(name, field.name)}')
		if field.value !is ast.EmptyExpr {
			g.sb.write_string(' = ')
			if enum_value := g.enum_field_value_int_expr(field.value) {
				g.sb.write_string(enum_value)
			} else {
				g.expr(field.value)
			}
		} else if is_flag {
			g.sb.write_string(' = ${u64(1) << i}U')
		}
		if i < node.fields.len - 1 {
			g.sb.writeln(',')
		} else {
			g.sb.writeln('')
		}
	}
	g.sb.writeln('} ${name};')
	g.sb.writeln('')
	enum_str_fn := '${name}__str'
	has_explicit_str := g.has_explicit_str_method_for_c_type(name)
	if !has_explicit_str && ((g.cache_bundle_name == 'virtuals' && g.should_emit_current_file())
		|| enum_str_fn in g.force_emit_fn_names) {
		mut enum_str_expr := c_static_v_string_expr('unknown enum value')
		for i := node.fields.len - 1; i >= 0; i-- {
			field := node.fields[i]
			enum_str_expr = '((v == ${g.enum_member_c_name(name, field.name)}) ? ${c_static_v_string_expr(field.name)} : ${enum_str_expr})'
		}
		g.late_struct_defs << 'string ${name}__str(${name} v) { return ${enum_str_expr}; }\n'
		g.fn_return_types[enum_str_fn] = 'string'
	} else if enum_str_fn !in g.fn_return_types {
		// Emit a macro so the expression is type-checked only at use sites,
		// where `string` is fully defined.
		mut enum_str_expr := c_static_v_string_expr('unknown enum value')
		for i := node.fields.len - 1; i >= 0; i-- {
			field := node.fields[i]
			enum_str_expr = '((_e == ${g.enum_member_c_name(name, field.name)}) ? ${c_static_v_string_expr(field.name)} : ${enum_str_expr})'
		}
		g.sb.writeln('#define ${name}__str(v) ({ ${name} _e = (v); ${enum_str_expr}; })')
	}
	enum_short_str_fn := '${name}_str'
	if enum_short_str_fn !in g.fn_return_types {
		g.sb.writeln('#define ${name}_str(v) ${name}__str(v)')
	}
	// Runtime enum values array for lowered `EnumType.values` usages. Keep the
	// helper name distinct from enum fields; enums can have a field named `values`.
	values_name := '${name}__values_array'
	values_data_name := '__enum_values_data_${name}'
	if node.fields.len > 0 {
		g.sb.write_string('static ${name} ${values_data_name}[${node.fields.len}] = {')
		for i, field in node.fields {
			if i > 0 {
				g.sb.write_string(', ')
			}
			g.sb.write_string(g.enum_member_c_name(name, field.name))
		}
		g.sb.writeln('};')
		g.sb.writeln('#define ${values_name} ((array){ .data = ${values_data_name}, .offset = 0, .len = ${node.fields.len}, .cap = ${node.fields.len}, .flags = 0, .element_size = sizeof(${name}) })')
	} else {
		g.sb.writeln('#define ${values_name} ((array){ .data = 0, .offset = 0, .len = 0, .cap = 0, .flags = 0, .element_size = sizeof(${name}) })')
	}
	g.sb.writeln('')
}

fn (mut g Gen) gen_enum_from_string_helper(node ast.EnumDecl) {
	name := g.get_enum_name(node)
	opt_name := '_option_' + mangle_alias_component(name)
	if opt_name !in g.option_aliases || !g.should_emit_current_file() {
		return
	}
	helper_name := '${name}__from_string'
	helper_key := 'enum_from_string_${helper_name}'
	if helper_key in g.emitted_types {
		return
	}
	g.emitted_types[helper_key] = true
	g.declared_fn_names[helper_name] = true
	g.sb.writeln('${opt_name} ${helper_name}(string s);')
	g.sb.writeln('${opt_name} ${helper_name}(string s) {')
	for field in node.fields {
		field_lit := c_string_literal_content_to_c(field.name)
		g.sb.writeln('\tif (s.len == ${field.name.len} && memcmp(s.str, ${field_lit}, ${field.name.len}) == 0) {')
		g.sb.writeln('\t\t${name} _val = ${g.enum_member_c_name(name, field.name)};')
		g.sb.writeln('\t\t${opt_name} _opt = (${opt_name}){ .state = 2 };')
		g.sb.writeln('\t\t_option_ok(&_val, (_option*)&_opt, sizeof(_val));')
		g.sb.writeln('\t\treturn _opt;')
		g.sb.writeln('\t}')
	}
	g.sb.writeln('\treturn (${opt_name}){ .state = 2 };')
	g.sb.writeln('}')
	g.sb.writeln('')
}

fn (mut g Gen) emit_enum_from_string_helpers() {
	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_enum_decl {
					g.gen_enum_from_string_helper(stmt.enum_decl(true))
				}
			}
		}
		return
	}
	for file in g.files {
		g.set_file_module(file)
		for stmt in file.stmts {
			if !stmt_has_valid_data(stmt) {
				continue
			}
			if stmt is ast.EnumDecl {
				g.gen_enum_from_string_helper(stmt)
			}
		}
	}
}

fn (mut g Gen) enum_field_value_int_expr(expr ast.Expr) ?string {
	match expr {
		ast.BasicLiteral {
			if expr.kind == .number {
				return sanitize_c_number_literal(expr.value)
			}
		}
		ast.CallOrCastExpr {
			return g.enum_field_value_int_expr(expr.expr)
		}
		ast.CastExpr {
			return g.enum_field_value_int_expr(expr.expr)
		}
		ast.ParenExpr {
			return g.enum_field_value_int_expr(expr.expr)
		}
		ast.PrefixExpr {
			if expr.op == .minus {
				if value := g.enum_field_value_int_expr(expr.expr) {
					return '-${value}'
				}
			}
		}
		ast.SelectorExpr {
			return g.enum_selector_int_value(expr)
		}
		else {}
	}

	return none
}

fn (mut g Gen) enum_selector_int_value(sel ast.SelectorExpr) ?string {
	rhs_name := sel.rhs.name
	if sel.lhs is ast.SelectorExpr {
		lhs_sel := sel.lhs as ast.SelectorExpr
		if lhs_sel.lhs is ast.Ident {
			lhs_mod := lhs_sel.lhs as ast.Ident
			mut module_names := [lhs_mod.name]
			resolved_mod_name := g.resolve_module_name(lhs_mod.name)
			if resolved_mod_name !in module_names {
				module_names << resolved_mod_name
			}
			for mod_name in module_names {
				enum_name := '${mod_name}__${lhs_sel.rhs.name}'
				if value := g.enum_decl_field_int_value(enum_name, rhs_name) {
					return value
				}
			}
		}
	}
	if sel.lhs is ast.Ident {
		lhs_name := sel.lhs.name
		mut enum_names := [lhs_name]
		if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
			enum_names << '${g.cur_module}__${lhs_name}'
		}
		for enum_name in enum_names {
			if value := g.enum_decl_field_int_value(enum_name, rhs_name) {
				return value
			}
		}
	}
	return none
}

fn (mut g Gen) enum_decl_field_int_value(enum_name string, field_name string) ?string {
	short_name := enum_name.all_after_last('__')
	module_name := if enum_name.contains('__') {
		enum_name.all_before_last('__')
	} else {
		g.cur_module
	}
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			fc := g.flat.file_cursor(i)
			if module_name != '' && flat_file_module_name(fc) != module_name {
				continue
			}
			stmts := fc.stmts()
			for j in 0 .. stmts.len() {
				stmt := stmts.at(j)
				if stmt.kind() != .stmt_enum_decl || stmt.name() != short_name {
					continue
				}
				decl := stmt.enum_decl(true)
				mut next_value := 0
				for field in decl.fields {
					if field.value !is ast.EmptyExpr {
						if value := g.enum_field_value_int_expr(field.value) {
							next_value = value.int()
						}
					}
					if field.name == field_name {
						return '${next_value}'
					}
					next_value++
				}
			}
		}
		return none
	}
	for file in g.files {
		if module_name != '' && file.mod != module_name {
			continue
		}
		for stmt in file.stmts {
			if stmt is ast.EnumDecl && stmt.name == short_name {
				mut next_value := 0
				for field in stmt.fields {
					if field.value !is ast.EmptyExpr {
						if value := g.enum_field_value_int_expr(field.value) {
							next_value = value.int()
						}
					}
					if field.name == field_name {
						return '${next_value}'
					}
					next_value++
				}
			}
		}
	}
	return none
}

// collect_force_emit_str_fns scans map_aliases and array_aliases to find which
// str functions will be called from generated map/array str code, and adds them
// to force_emit_fn_names so they get emitted even if mark_used didn't trace them.
fn (mut g Gen) collect_force_emit_str_fns() {
	if g.used_fn_keys.len == 0 {
		return
	}
	for name, _ in g.map_aliases {
		if '${name}_str' in g.fn_return_types {
			continue // user-defined map str function
		}
		without_prefix := name.all_after('Map_')
		_, value_type := g.parse_map_kv_types(without_prefix)
		if value_type == '' {
			continue
		}
		g.add_force_emit_str_fn(value_type)
	}
	// Force-emit all Array_*_str functions that have registered signatures.
	// These are generated by the transformer for string interpolation but the
	// calls to them are emitted directly by cleanc (in write_sprintf_arg),
	// so markused may not trace them.
	for fn_name, _ in g.fn_return_types {
		if fn_name.starts_with('Array_') && fn_name.ends_with('_str') {
			g.force_emit_fn_names[fn_name] = true
		}
	}
}

fn (mut g Gen) add_force_emit_str_fn(type_name string) {
	// Primitive types don't need force-emitting (already in builtin)
	if type_name in ['string', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32',
		'f64', 'bool', 'rune', 'voidptr'] {
		return
	}
	if str_fn := g.get_str_fn_for_type(type_name) {
		g.force_emit_fn_names[str_fn] = true
	}
}

// emit_map_str_functions generates Map_K_V_str functions for all map types.
fn (mut g Gen) emit_map_str_functions() {
	mut map_names := g.map_aliases.keys()
	map_names.sort()
	for name in map_names {
		// Skip if the user already defined this function
		if '${name}_str' in g.fn_return_types {
			continue
		}
		// Skip map aliases whose typedef wasn't emitted (late-registered aliases
		// that reference unresolved short-name types). Without a typedef, the
		// generated helper would reference an undeclared type.
		if 'alias_${name}' !in g.emitted_types {
			continue
		}
		// Parse key and value types from Map_K_V name
		key_type, value_type := g.map_alias_key_value_types(name)
		if key_type == '' || value_type == '' {
			continue
		}
		// Skip generic placeholder types (single uppercase letters like K, V, T)
		if key_type.len == 1 && key_type[0] >= `A` && key_type[0] <= `Z` {
			continue
		}
		// Skip types that can't be safely used as local variables (fixed arrays, etc.)
		if !g.can_emit_map_str_for_type(key_type) || !g.can_emit_map_str_for_type(value_type) {
			// Emit a fallback that returns the type name
			g.sb.writeln('')
			g.sb.writeln('string ${name}_str(${name} m) {')
			g.sb.writeln('\treturn (string){.str = "${name}", .len = ${name.len}, .is_lit = 1};')
			g.sb.writeln('}')
			continue
		}
		g.sb.writeln('')
		g.sb.writeln('string ${name}_str(${name} m) {')
		g.sb.writeln('\tstrings__Builder sb = strings__new_builder(2 + m.key_values.len * 10);')
		g.sb.writeln('\tstrings__Builder__write_string(&sb, (string){.str = "{", .len = 1, .is_lit = 1});')
		g.sb.writeln('\tbool is_first = true;')
		g.sb.writeln('\tfor (int i = 0; i < m.key_values.len; ++i) {')
		g.sb.writeln('\t\tif (!DenseArray__has_index(&m.key_values, i)) continue;')
		g.sb.writeln('\t\tif (!is_first) strings__Builder__write_string(&sb, (string){.str = ", ", .len = 2, .is_lit = 1});')
		// Key
		if key_type.starts_with('Array_fixed_') {
			elem_type, arr_len := g.parse_fixed_array_type(key_type)
			g.sb.writeln('\t\t${elem_type}* key_ptr = (${elem_type}*)DenseArray__key(&m.key_values, i);')
			g.emit_fixed_array_str_write('key_ptr', elem_type, arr_len)
		} else {
			g.sb.writeln('\t\t${key_type} key = *(${key_type}*)DenseArray__key(&m.key_values, i);')
			g.emit_map_str_write_val('key', key_type)
		}
		// Separator
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = ": ", .len = 2, .is_lit = 1});')
		// Value
		if value_type.starts_with('Array_fixed_') {
			// Fixed arrays can't be assigned to local variables; use pointer
			elem_type, arr_len := g.parse_fixed_array_type(value_type)
			g.sb.writeln('\t\t${elem_type}* val_ptr = (${elem_type}*)DenseArray__value(&m.key_values, i);')
			g.emit_fixed_array_str_write('val_ptr', elem_type, arr_len)
		} else {
			g.sb.writeln('\t\t${value_type} val = *(${value_type}*)DenseArray__value(&m.key_values, i);')
			g.emit_map_str_write_val('val', value_type)
		}
		g.sb.writeln('\t\tis_first = false;')
		g.sb.writeln('\t}')
		g.sb.writeln('\tstrings__Builder__write_string(&sb, (string){.str = "}", .len = 1, .is_lit = 1});')
		g.sb.writeln('\treturn strings__Builder__str(&sb);')
		g.sb.writeln('}')
	}
}

fn (g &Gen) can_emit_map_str_for_type(type_name string) bool {
	// Primitive types are always OK
	if type_name in ['string', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32',
		'f64', 'bool', 'rune', 'voidptr'] {
		return true
	}
	// Fixed arrays — need special handling but can be emitted
	if type_name.starts_with('Array_fixed_') {
		return true
	}
	// Pointer-like types that may not be valid C type names
	if type_name in ['intptr', 'charptr', 'byteptr'] || type_name.ends_with('ptr') {
		return false
	}
	// Check if a str function exists for this type
	if '${type_name}_str' in g.fn_return_types || '${type_name}__str' in g.fn_return_types {
		return true
	}
	// Map types can call their own str function (recursive)
	if type_name.starts_with('Map_') {
		return true
	}
	// Array types — check if Array_T_str exists
	if type_name.starts_with('Array_') {
		return '${type_name}_str' in g.fn_return_types
	}
	// For other types (structs, enums, etc.), check if str function exists
	return '${type_name}_str' in g.fn_return_types || '${type_name}__str' in g.fn_return_types
}

fn (mut g Gen) emit_map_str_write_val(var_name string, type_name string) {
	if type_name == 'string' {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = "\'", .len = 1, .is_lit = 1});')
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, ${var_name});')
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = "\'", .len = 1, .is_lit = 1});')
	} else if type_name == 'rune' {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = "`", .len = 1, .is_lit = 1});')
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, rune__str(${var_name}));')
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = "`", .len = 1, .is_lit = 1});')
	} else if type_name in ['int', 'i8', 'i16', 'i32', 'i64'] {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, int__str((int)(${var_name})));')
	} else if type_name in ['u8', 'u16', 'u32', 'u64'] {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, u64__str((u64)(${var_name})));')
	} else if type_name == 'f32' {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, f32__str(${var_name}));')
	} else if type_name == 'f64' {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, f64__str(${var_name}));')
	} else if type_name == 'bool' {
		g.sb.writeln('\t\tstrings__Builder__write_string(&sb, ${var_name} ? (string){.str = "true", .len = 4, .is_lit = 1} : (string){.str = "false", .len = 5, .is_lit = 1});')
	} else if type_name == 'voidptr' {
		g.sb.writeln('\t\t{ uintptr_t _addr = (uintptr_t)(${var_name}); char _buf[2 + sizeof(uintptr_t) * 2]; _buf[0] = \'0\'; _buf[1] = \'x\'; for (int _i = 0; _i < (int)(sizeof(uintptr_t) * 2); ++_i) { int _shift = (int)((sizeof(uintptr_t) * 2 - 1 - _i) * 4); _buf[2 + _i] = "0123456789abcdef"[(_addr >> _shift) & 0xf]; } strings__Builder__write_string(&sb, (string){.str = (u8*)_buf, .len = (int)sizeof(_buf), .is_lit = 0}); }')
	} else {
		// For custom types, pick whichever str symbol exists (`Type_str` or `Type__str`).
		if str_fn := g.get_str_fn_for_type(type_name) {
			// Check if the str function expects a pointer receiver
			ptr_params := g.fn_param_is_ptr[str_fn] or { []bool{} }
			if ptr_params.len > 0 && ptr_params[0] {
				g.sb.writeln('\t\tstrings__Builder__write_string(&sb, ${str_fn}(&${var_name}));')
			} else {
				g.sb.writeln('\t\tstrings__Builder__write_string(&sb, ${str_fn}(${var_name}));')
			}
		} else {
			// Keep the legacy fallback so missing str support still fails loudly in C.
			g.sb.writeln('\t\tstrings__Builder__write_string(&sb, ${type_name}_str(${var_name}));')
		}
	}
}

// parse_fixed_array_type parses "Array_fixed_f64_2" into ("f64", 2).
fn (g &Gen) parse_fixed_array_type(type_name string) (string, int) {
	// Format: Array_fixed_<elem_type>_<len>
	without_prefix := type_name.all_after('Array_fixed_')
	// The last _N is the length
	last_underscore := without_prefix.last_index('_') or { return '', 0 }
	elem_type := without_prefix[..last_underscore]
	arr_len := without_prefix[last_underscore + 1..].int()
	return elem_type, arr_len
}

// emit_fixed_array_str_write generates code to format a fixed array as "[e1, e2, ...]".
fn (mut g Gen) emit_fixed_array_str_write(ptr_var string, elem_type string, arr_len int) {
	g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = "[", .len = 1, .is_lit = 1});')
	for j in 0 .. arr_len {
		if j > 0 {
			g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = ", ", .len = 2, .is_lit = 1});')
		}
		g.emit_map_str_write_val('${ptr_var}[${j}]', elem_type)
	}
	g.sb.writeln('\t\tstrings__Builder__write_string(&sb, (string){.str = "]", .len = 1, .is_lit = 1});')
}

// emit_map_eq_functions generates Map_K_V_map_eq functions for all map types.
fn (mut g Gen) emit_map_eq_functions() {
	// Generic fallback for when the specific map type is not known.
	// Only emit if not already provided via the V source (builtin/map.v)
	// or via the cache (builtin.o).
	if 'map_map_eq' !in g.fn_return_types && g.cached_init_calls.len == 0 {
		g.sb.writeln('')
		g.sb.writeln('bool map_map_eq(map a, map b) {')
		g.sb.writeln('\tif (a.len != b.len) return false;')
		g.sb.writeln('\tfor (int i = 0; i < a.key_values.len; ++i) {')
		g.sb.writeln('\t\tif (!DenseArray__has_index(&a.key_values, i)) continue;')
		g.sb.writeln('\t\tvoid* k = DenseArray__key(&a.key_values, i);')
		g.sb.writeln('\t\tif (!map__exists(&b, k)) return false;')
		g.sb.writeln('\t\tvoid* va = DenseArray__value(&a.key_values, i);')
		g.sb.writeln('\t\tvoid* vb_p = map__get(&b, k, va);')
		g.sb.writeln('\t\tif (memcmp(va, vb_p, a.value_bytes) != 0) return false;')
		g.sb.writeln('\t}')
		g.sb.writeln('\treturn true;')
		g.sb.writeln('}')
	}

	mut map_names := g.map_aliases.keys()
	map_names.sort()
	for name in map_names {
		// Skip late-registered map aliases without a typedef (see emit_map_str_functions).
		if 'alias_${name}' !in g.emitted_types {
			continue
		}
		key_type, value_type := g.map_alias_key_value_types(name)
		if key_type == '' || value_type == '' {
			g.sb.writeln('')
			g.sb.writeln('bool ${name}_map_eq(${name} a, ${name} b) { return map_map_eq(a, b); }')
			continue
		}
		// Skip generic placeholder types
		if value_type.len == 1 && value_type[0] >= `A` && value_type[0] <= `Z` {
			g.sb.writeln('')
			g.sb.writeln('bool ${name}_map_eq(${name} a, ${name} b) { return map_map_eq(a, b); }')
			continue
		}
		g.sb.writeln('')
		g.sb.writeln('bool ${name}_map_eq(${name} a, ${name} b) {')
		g.sb.writeln('\tif (a.len != b.len) return false;')
		g.sb.writeln('\tfor (int i = 0; i < a.key_values.len; ++i) {')
		g.sb.writeln('\t\tif (!DenseArray__has_index(&a.key_values, i)) continue;')
		g.sb.writeln('\t\tvoid* k = DenseArray__key(&a.key_values, i);')
		g.sb.writeln('\t\tif (!map__exists(&b, k)) return false;')
		// Compare values based on value type
		if value_type == 'string' {
			g.sb.writeln('\t\tstring va = *(string*)map__get(&a, k, &(string){0});')
			g.sb.writeln('\t\tstring vb = *(string*)map__get(&b, k, &(string){0});')
			g.sb.writeln('\t\tif (!string__eq(va, vb)) return false;')
		} else if value_type in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32',
			'f64', 'bool', 'rune', 'voidptr'] {
			g.sb.writeln('\t\t${value_type} va = *(${value_type}*)map__get(&a, k, &(${value_type}){0});')
			g.sb.writeln('\t\t${value_type} vb = *(${value_type}*)map__get(&b, k, &(${value_type}){0});')
			g.sb.writeln('\t\tif (va != vb) return false;')
		} else if value_type in ['intptr', 'u8ptr', 'charptr', 'byteptr']
			|| value_type.ends_with('ptr') {
			// Pointer-like types (V aliases and module-qualified pointer types): compare as void*
			g.sb.writeln('\t\tvoid* va = *(void**)map__get(&a, k, &(void*){0});')
			g.sb.writeln('\t\tvoid* vb = *(void**)map__get(&b, k, &(void*){0});')
			g.sb.writeln('\t\tif (va != vb) return false;')
		} else if value_type.starts_with('Array_fixed_') {
			// Fixed arrays: use memcmp (they are plain C arrays)
			g.sb.writeln('\t\tvoid* va = map__get(&a, k, &(${value_type}){0});')
			g.sb.writeln('\t\tvoid* vb = map__get(&b, k, &(${value_type}){0});')
			g.sb.writeln('\t\tif (memcmp(va, vb, sizeof(${value_type})) != 0) return false;')
		} else if value_type == 'array' || value_type.starts_with('Array_') {
			// Array values: use __v2_array_eq for deep comparison
			g.sb.writeln('\t\tarray va = *(array*)map__get(&a, k, &(${value_type}){0});')
			g.sb.writeln('\t\tarray vb = *(array*)map__get(&b, k, &(${value_type}){0});')
			g.sb.writeln('\t\tif (!__v2_array_eq(va, vb)) return false;')
		} else if value_type.starts_with('Map_') {
			// Map values: use the map's own eq function for deep comparison
			g.sb.writeln('\t\t${value_type} va = *(${value_type}*)map__get(&a, k, &(${value_type}){0});')
			g.sb.writeln('\t\t${value_type} vb = *(${value_type}*)map__get(&b, k, &(${value_type}){0});')
			g.sb.writeln('\t\tif (!${value_type}_map_eq(va, vb)) return false;')
		} else {
			// Try to look up struct fields for deep comparison
			struct_type := g.lookup_struct_type_by_c_name(value_type)
			if struct_type.fields.len > 0 {
				g.sb.writeln('\t\t${value_type} va = *(${value_type}*)map__get(&a, k, &(${value_type}){0});')
				g.sb.writeln('\t\t${value_type} vb = *(${value_type}*)map__get(&b, k, &(${value_type}){0});')
				g.emit_struct_field_eq(struct_type, 'va', 'vb')
			} else {
				// Fallback: use memcmp on the value
				g.sb.writeln('\t\tvoid* va = map__get(&a, k, &(${value_type}){0});')
				g.sb.writeln('\t\tvoid* vb = map__get(&b, k, &(${value_type}){0});')
				g.sb.writeln('\t\tif (memcmp(va, vb, sizeof(${value_type})) != 0) return false;')
			}
		}
		g.sb.writeln('\t}')
		g.sb.writeln('\treturn true;')
		g.sb.writeln('}')
	}
}

// lookup_struct_type_by_c_name resolves a C type name to a types.Struct by searching
// all known module scopes. C names may be like "MValue" (current module) or "os__File".
// Returns empty Struct for sum types/aliases (their merged fields aren't safe for field access).
fn (mut g Gen) lookup_struct_type_by_c_name(c_name string) types.Struct {
	if g.env == unsafe { nil } {
		return types.Struct{}
	}
	cache_key := '${g.cur_module}|${c_name}'
	if cached := g.struct_type_lookup_cache[cache_key] {
		return cached
	}
	if cache_key in g.struct_type_lookup_miss {
		return types.Struct{}
	}
	// Try extracting module from mangled name (e.g. "os__File" -> module "os", name "File")
	mut mod_name := ''
	mut struct_name := c_name
	if idx := c_name.index('__') {
		mod_name = c_name[..idx]
		struct_name = c_name[idx + 2..]
	}
	if mod_name != '' {
		if mut scope := g.env_scope(mod_name) {
			if obj := scope.lookup_parent(struct_name, 0) {
				typ := obj.typ()
				// Skip sum types - their merged fields aren't safe for direct access
				if typ is types.Alias || typ is types.SumType {
					g.struct_type_lookup_miss[cache_key] = true
					return types.Struct{}
				}
				if typ is types.Struct {
					g.struct_type_lookup_cache[cache_key] = typ
					return typ
				}
			}
		}
	}
	// Bare C type names belong to main/builtin. Non-main module types are
	// emitted with a module prefix, so do not let the current module shadow them.
	mut tried := map[string]bool{}
	cur_mod := if g.cur_module != '' { g.cur_module } else { 'main' }
	mut modules_to_try := []string{}
	if mod_name == '' && cur_mod != 'main' && cur_mod != 'builtin' {
		modules_to_try << 'main'
		modules_to_try << 'builtin'
	}
	modules_to_try << cur_mod
	if 'main' !in modules_to_try {
		modules_to_try << 'main'
	}
	if 'builtin' !in modules_to_try {
		modules_to_try << 'builtin'
	}
	for try_mod in modules_to_try {
		if tried[try_mod] {
			continue
		}
		tried[try_mod] = true
		if mut scope := g.env_scope(try_mod) {
			if obj := scope.lookup_parent(struct_name, 0) {
				typ := obj.typ()
				if typ is types.Alias {
					g.struct_type_lookup_miss[cache_key] = true
					return types.Struct{}
				}
				if typ is types.Struct {
					g.struct_type_lookup_cache[cache_key] = typ
					return typ
				}
			}
		}
	}
	// Try all module scopes from files
	if g.has_flat() {
		for i in 0 .. g.flat.files.len {
			file_mod := flat_file_module_name(g.flat.file_cursor(i))
			if tried[file_mod] {
				continue
			}
			tried[file_mod] = true
			if mut scope := g.env_scope(file_mod) {
				if obj := scope.lookup_parent(struct_name, 0) {
					typ := obj.typ()
					if typ is types.Alias {
						g.struct_type_lookup_miss[cache_key] = true
						return types.Struct{}
					}
					if typ is types.Struct {
						g.struct_type_lookup_cache[cache_key] = typ
						return typ
					}
				}
			}
		}
	} else {
		for file in g.files {
			file_mod := file.mod
			if tried[file_mod] {
				continue
			}
			tried[file_mod] = true
			if mut scope := g.env_scope(file_mod) {
				if obj := scope.lookup_parent(struct_name, 0) {
					typ := obj.typ()
					if typ is types.Alias {
						g.struct_type_lookup_miss[cache_key] = true
						return types.Struct{}
					}
					if typ is types.Struct {
						g.struct_type_lookup_cache[cache_key] = typ
						return typ
					}
				}
			}
		}
	}
	g.struct_type_lookup_miss[cache_key] = true
	return types.Struct{}
}

// emit_struct_field_eq generates field-by-field comparison code for a struct type.
fn (mut g Gen) emit_struct_field_eq(s types.Struct, va string, vb string) {
	for field in s.fields {
		fname := escape_c_keyword(field.name)
		ftype := field.typ
		match ftype {
			types.String {
				g.sb.writeln('\t\tif (!string__eq(${va}.${fname}, ${vb}.${fname})) return false;')
			}
			types.Map {
				c_type := g.types_type_to_c(ftype)
				if c_type.starts_with('Map_') {
					g.sb.writeln('\t\tif (!${c_type}_map_eq(${va}.${fname}, ${vb}.${fname})) return false;')
				} else {
					g.sb.writeln('\t\tif (!map_map_eq(${va}.${fname}, ${vb}.${fname})) return false;')
				}
			}
			types.Array {
				g.sb.writeln('\t\tif (!__v2_array_eq(${va}.${fname}, ${vb}.${fname})) return false;')
			}
			types.Primitive {
				g.sb.writeln('\t\tif (${va}.${fname} != ${vb}.${fname}) return false;')
			}
			types.Pointer {
				g.sb.writeln('\t\tif (${va}.${fname} != ${vb}.${fname}) return false;')
			}
			types.Rune {
				g.sb.writeln('\t\tif (${va}.${fname} != ${vb}.${fname}) return false;')
			}
			types.Enum {
				g.sb.writeln('\t\tif (${va}.${fname} != ${vb}.${fname}) return false;')
			}
			types.Struct {
				c_type := g.types_type_to_c(ftype)
				if g.struct_has_ref_fields(ftype) {
					g.emit_struct_field_eq(ftype, '${va}.${fname}', '${vb}.${fname}')
				} else {
					g.sb.writeln('\t\tif (memcmp(&${va}.${fname}, &${vb}.${fname}, sizeof(${c_type})) != 0) return false;')
				}
			}
			else {
				c_type := g.types_type_to_c(ftype)
				g.sb.writeln('\t\tif (memcmp(&${va}.${fname}, &${vb}.${fname}, sizeof(${c_type})) != 0) return false;')
			}
		}
	}
}

fn (mut g Gen) map_alias_key_value_types(name string) (string, string) {
	if info := g.ensure_map_type_info(name) {
		if info.key_c_type != '' && info.value_c_type != '' {
			return info.key_c_type, info.value_c_type
		}
	}
	without_prefix := name.all_after('Map_')
	return g.parse_map_kv_types(without_prefix)
}

// parse_map_kv_types parses key and value types from a "key_value" string.
fn (g &Gen) parse_map_kv_types(kv_str string) (string, string) {
	// Try simple primitive types first (they're unambiguous since they don't
	// contain underscores — except for the separator underscore)
	simple_types := ['string', 'int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32',
		'f64', 'bool', 'rune', 'voidptr', 'charptr', 'byteptr']
	for st in simple_types {
		if kv_str.starts_with('${st}_') {
			return st, kv_str.all_after('${st}_')
		}
	}
	// For compound key types: try each underscore position and check if the
	// key type is a known type alias/struct. Keep the longest match: generic
	// struct names can have their base type emitted too, e.g.
	// `ApiResponse_T_Array_FileInfo_Array_int`.
	mut best_key := ''
	mut best_value := ''
	for i := 1; i < kv_str.len; i++ {
		if kv_str[i] == `_` {
			key := kv_str[..i]
			value := kv_str[i + 1..]
			if value == '' {
				continue
			}
			// Verify key is a known type
			if g.is_known_map_key_type(key, simple_types) {
				best_key = key
				best_value = value
			}
		}
	}
	if best_key != '' {
		return best_key, best_value
	}
	// Last resort: split on last underscore
	last_idx := kv_str.last_index('_') or { return '', '' }
	if last_idx > 0 && last_idx < kv_str.len - 1 {
		return kv_str[..last_idx], kv_str[last_idx + 1..]
	}
	return '', ''
}

fn (g &Gen) is_known_map_key_type(key string, simple_types []string) bool {
	if key.starts_with('Array_fixed_') {
		_, arr_len := g.parse_fixed_array_type(key)
		return arr_len > 0
	}
	return key in g.map_aliases || key in g.array_aliases || key in g.emitted_types
		|| 'body_${key}' in g.emitted_types || 'alias_${key}' in g.emitted_types
		|| 'enum_${key}' in g.emitted_types || key in simple_types
}