module builder

import os
import v2.ast
import v2.abi
import v2.gen.x64
import v2.insel
import v2.markused
import v2.mir
import v2.pref
import v2.ssa
import v2.ssa.optimize as ssa_optimize
import v2.transformer
import v2.types

fn write_test_file(path string) {
	os.write_file(path, 'module main\nfn marker() {}\n') or { panic(err) }
}

fn parse_test_files(mut b Builder, paths []string) []ast.File {
	b.parse_files(paths)
	b.flat = b.flat_builder.flat
	return b.flat.to_files()
}

fn parse_test_builder_files(mut b Builder, paths []string) {
	b.files = b.parse_files(paths)
	b.flat = b.flat_builder.flat
}

fn transform_test_builder_files(mut b Builder, mut trans transformer.Transformer) {
	new_flat, files_out := trans.transform_files_to_flat(&b.flat, b.files)
	b.flat = new_flat
	b.files = files_out
}

fn mark_used_windows_x64_test(mut b Builder) map[string]bool {
	opts := markused.MarkUsedOptions{
		minimal_runtime_roots: true
	}
	return markused.mark_used_flat_with_options(&b.flat, b.env, opts)
}

fn build_test_ssa(mut b Builder, mut ssa_builder ssa.Builder) {
	ssa_builder.build_all_from_flat(&b.flat)
}

fn test_flat_codegen_backends_keep_flat_for_codegen() {
	mut prefs := pref.Preferences{
		backend: .c
	}
	mut b := Builder{
		pref: &prefs
	}

	assert b.should_keep_flat_for_codegen()
	b.flat = ast.FlatAst{
		files: [ast.FlatFile{}]
	}
	assert b.should_build_ssa_from_flat()

	prefs.backend = .cleanc
	assert b.should_keep_flat_for_codegen()
	prefs.backend = .v
	assert !b.should_keep_flat_for_codegen()
	prefs.backend = .x64
	assert b.should_keep_flat_for_codegen()
}

fn test_gen_ssa_c_consumes_flat_codegen_input() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_ssa_c_flat_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	output_path := os.join_path(tmp_dir, 'ssa_flat.c')
	files := [
		ast.File{
			name:  'main.v'
			mod:   'main'
			stmts: [
				ast.Stmt(ast.ModuleStmt{
					name: 'main'
				}),
			]
		},
	]
	mut prefs := pref.Preferences{
		backend:     .c
		output_file: output_path
	}
	mut b := Builder{
		pref:  &prefs
		files: files
		env:   types.Environment.new()
		flat:  ast.flatten_files(files)
	}

	b.gen_ssa_c()

	assert b.flat.files.len == 0
	assert os.exists(output_path)
	c_source := os.read_file(output_path) or { panic(err) }
	assert c_source.len > 0
}

fn test_get_v_files_from_dir_uses_windows_target_os() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_filter_windows_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	write_test_file(os.join_path(tmp_dir, 'common.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_windows.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_nix.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_termux.c.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_linux.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_darwin.v'))

	names := get_v_files_from_dir(tmp_dir, []string{}, 'windows').map(os.file_name(it))
	assert 'common.v' in names
	assert 'platform_windows.v' in names
	assert 'platform_nix.v' !in names
	assert 'platform_termux.c.v' !in names
	assert 'platform_linux.v' !in names
	assert 'platform_darwin.v' !in names
}

fn test_get_v_files_from_dir_uses_linux_and_macos_target_os() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_filter_unix_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	write_test_file(os.join_path(tmp_dir, 'common.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_windows.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_nix.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_termux.c.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_linux.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_macos.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_darwin.v'))

	linux_names := get_v_files_from_dir(tmp_dir, []string{}, 'linux').map(os.file_name(it))
	assert 'common.v' in linux_names
	assert 'platform_nix.v' in linux_names
	assert 'platform_linux.v' in linux_names
	assert 'platform_windows.v' !in linux_names
	assert 'platform_termux.c.v' !in linux_names
	assert 'platform_macos.v' !in linux_names
	assert 'platform_darwin.v' !in linux_names

	macos_names := get_v_files_from_dir(tmp_dir, []string{}, 'macos').map(os.file_name(it))
	assert 'common.v' in macos_names
	assert 'platform_nix.v' in macos_names
	assert 'platform_macos.v' in macos_names
	assert 'platform_darwin.v' in macos_names
	assert 'platform_windows.v' !in macos_names
	assert 'platform_termux.c.v' !in macos_names
	assert 'platform_linux.v' !in macos_names
}

fn test_get_v_files_from_dir_uses_termux_target_os() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_filter_termux_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	write_test_file(os.join_path(tmp_dir, 'common.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_nix.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_termux.c.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_android_outside_termux.c.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_android.c.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_linux.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_windows.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_macos.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_darwin.v'))

	termux_names := get_v_files_from_dir(tmp_dir, []string{}, 'termux').map(os.file_name(it))
	assert 'common.v' in termux_names
	assert 'platform_nix.v' in termux_names
	assert 'platform_termux.c.v' in termux_names
	assert 'platform_android.c.v' in termux_names
	assert 'platform_android_outside_termux.c.v' !in termux_names
	assert 'platform_linux.v' !in termux_names
	assert 'platform_windows.v' !in termux_names
	assert 'platform_macos.v' !in termux_names
	assert 'platform_darwin.v' !in termux_names
}

fn test_parse_files_uses_host_source_filter_for_cross_target() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_filter_cross_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	write_test_file(os.join_path(tmp_dir, 'common.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_nix.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_linux.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_macos.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_darwin.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_windows.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_termux.c.v'))

	mut prefs := pref.new_preferences()
	prefs.skip_builtin = true
	prefs.skip_imports = true
	prefs.target_os = 'cross'
	prefs.output_cross_c = true
	prefs.user_defines = ['cross']
	mut b := new_builder(&prefs)
	files := parse_test_files(mut b, [tmp_dir])
	cross_names := files.map(os.file_name(it.name))
	host_os := normalize_target_os_name(os.user_os())
	assert 'common.v' in cross_names
	assert ('platform_nix.v' in cross_names) == (host_os != 'windows')
	assert ('platform_linux.v' in cross_names) == (host_os == 'linux')
	assert ('platform_macos.v' in cross_names) == (host_os == 'macos')
	assert ('platform_darwin.v' in cross_names) == (host_os == 'macos')
	assert ('platform_windows.v' in cross_names) == (host_os == 'windows')
	assert ('platform_termux.c.v' in cross_names) == (host_os == 'termux')
}

fn test_parse_files_excludes_os_variants_for_freestanding_none_target() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_filter_none_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	write_test_file(os.join_path(tmp_dir, 'common.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_nix.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_linux.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_macos.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_darwin.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_windows.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_termux.c.v'))

	mut prefs := pref.new_preferences()
	prefs.skip_builtin = true
	prefs.skip_imports = true
	prefs.freestanding = true
	prefs.target_os = 'none'
	prefs.user_defines = ['freestanding']
	mut b := new_builder(&prefs)
	files := parse_test_files(mut b, [tmp_dir])
	names := files.map(os.file_name(it.name))
	assert 'common.v' in names
	assert 'platform_nix.v' !in names
	assert 'platform_termux.c.v' !in names
	assert 'platform_linux.v' !in names
	assert 'platform_macos.v' !in names
	assert 'platform_darwin.v' !in names
	assert 'platform_windows.v' !in names
}

fn test_parse_files_uses_target_os_preference_for_windows_files() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_parse_windows_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	os.write_file(os.join_path(tmp_dir, 'main.v'), 'module main\nfn main() {}\n') or { panic(err) }
	write_test_file(os.join_path(tmp_dir, 'platform_windows.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_nix.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_termux.c.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_linux.v'))
	write_test_file(os.join_path(tmp_dir, 'platform_darwin.v'))

	mut prefs := pref.new_preferences()
	prefs.skip_builtin = true
	prefs.skip_imports = true
	prefs.target_os = 'windows'
	mut b := new_builder(&prefs)
	files := parse_test_files(mut b, [tmp_dir])
	names := files.map(os.file_name(it.name))

	assert 'main.v' in names
	assert 'platform_windows.v' in names
	assert 'platform_nix.v' !in names
	assert 'platform_termux.c.v' !in names
	assert 'platform_linux.v' !in names
	assert 'platform_darwin.v' !in names
}

fn test_default_file_key_strips_all_supported_platform_suffixes() {
	default_key := fname_without_platform_postfix('/tmp/foo_default.c.v')
	for suffix in ['nix', 'windows', 'linux', 'darwin', 'macos', 'bsd', 'android', 'termux',
		'android_outside_termux', 'ios', 'freebsd', 'openbsd', 'netbsd', 'dragonfly', 'solaris',
		'qnx', 'serenity', 'plan9', 'vinix'] {
		assert fname_without_platform_postfix('/tmp/foo_${suffix}.c.v') == default_key
	}
}

fn test_default_files_are_skipped_for_extended_platform_variants() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_extended_platform_defaults_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	for target in ['ios', 'qnx', 'serenity', 'plan9', 'vinix'] {
		write_test_file(os.join_path(tmp_dir, 'foo_default.c.v'))
		write_test_file(os.join_path(tmp_dir, 'foo_${target}.c.v'))
		names := get_v_files_from_dir(tmp_dir, []string{}, target).map(os.file_name(it))
		assert 'foo_${target}.c.v' in names
		assert 'foo_default.c.v' !in names
		os.rm(os.join_path(tmp_dir, 'foo_default.c.v')) or {}
		os.rm(os.join_path(tmp_dir, 'foo_${target}.c.v')) or {}
	}
}

fn test_active_file_imports_filters_conditional_imports_by_target_os() {
	file := ast.File{
		mod:   'main'
		name:  'main.v'
		stmts: [
			ast.Stmt(ast.ExprStmt{
				expr: ast.ComptimeExpr{
					expr: ast.IfExpr{
						cond:  ast.Ident{
							name: 'linux'
						}
						stmts: [
							ast.Stmt(ast.ImportStmt{
								name: 'linmod'
							}),
						]
					}
				}
			}),
			ast.Stmt(ast.ExprStmt{
				expr: ast.ComptimeExpr{
					expr: ast.IfExpr{
						cond:  ast.Ident{
							name: 'windows'
						}
						stmts: [
							ast.Stmt(ast.ImportStmt{
								name: 'winmod'
							}),
						]
					}
				}
			}),
			ast.Stmt(ast.ExprStmt{
				expr: ast.ComptimeExpr{
					expr: ast.IfExpr{
						cond:  ast.Ident{
							name: 'macos'
						}
						stmts: [
							ast.Stmt(ast.ImportStmt{
								name: 'macmod'
							}),
						]
					}
				}
			}),
			ast.Stmt(ast.ExprStmt{
				expr: ast.ComptimeExpr{
					expr: ast.IfExpr{
						cond:  ast.Ident{
							name: 'none'
						}
						stmts: [
							ast.Stmt(ast.ImportStmt{
								name: 'nonemod'
							}),
						]
					}
				}
			}),
		]
	}
	windows_names := active_file_imports(file, [], 'windows').map(it.name)
	linux_names := active_file_imports(file, [], 'linux').map(it.name)
	macos_names := active_file_imports(file, [], 'macos').map(it.name)
	none_names := active_file_imports(file, [], 'none').map(it.name)
	windows_with_linux_define_names := active_file_imports_with_explicit(file, [
		'linux',
	], [
		'linux',
	], 'windows').map(it.name)

	assert 'winmod' in windows_names
	assert 'linmod' !in windows_names
	assert 'macmod' !in windows_names
	assert 'nonemod' !in windows_names

	assert 'linmod' in linux_names
	assert 'winmod' !in linux_names
	assert 'macmod' !in linux_names
	assert 'nonemod' !in linux_names

	assert 'macmod' in macos_names
	assert 'winmod' !in macos_names
	assert 'linmod' !in macos_names
	assert 'nonemod' !in macos_names

	assert 'nonemod' in none_names
	assert 'linmod' !in none_names
	assert 'winmod' !in none_names
	assert 'macmod' !in none_names

	assert 'winmod' in windows_with_linux_define_names
	assert 'linmod' !in windows_with_linux_define_names
	assert 'macmod' !in windows_with_linux_define_names
	assert 'nonemod' !in windows_with_linux_define_names
}

fn test_header_cache_stamp_uses_target_os_preference() {
	mut linux_prefs := pref.new_preferences()
	linux_prefs.skip_builtin = true
	linux_prefs.target_os = 'linux'
	linux_builder := new_builder(&linux_prefs)
	linux_stamp := linux_builder.header_stamp_for_modules([])

	mut windows_prefs := pref.new_preferences()
	windows_prefs.skip_builtin = true
	windows_prefs.target_os = 'windows'
	windows_builder := new_builder(&windows_prefs)
	windows_stamp := windows_builder.header_stamp_for_modules([])

	assert linux_stamp.contains('target_os=linux')
	assert windows_stamp.contains('target_os=windows')
	assert linux_stamp != windows_stamp
}

fn test_cached_called_fn_names_are_persisted_for_reused_objects() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cached_called_names_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	prefs := pref.new_preferences()
	mut b := new_builder(&prefs)
	b.cached_called_fn_names['local__already'] = true
	b.cached_called_fn_names['json2__decode_T_Foo'] = true
	b.write_cached_called_fn_names(tmp_dir, 'virtuals', {
		'local__already': true
	})

	mut b2 := new_builder(&prefs)
	assert b2.load_cached_called_fn_names(tmp_dir, 'virtuals')
	assert 'json2__decode_T_Foo' in b2.cached_called_fn_names
	assert 'local__already' !in b2.cached_called_fn_names
	assert !b2.load_cached_called_fn_names(tmp_dir, 'missing')
}

fn test_vh_cache_reuse_requires_cached_called_fn_metadata() {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cached_called_names_required_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	for cache_name in [builtin_cache_name, imports_cache_name, virtuals_cache_name] {
		os.write_file(cache_path_join(tmp_dir, '${cache_name}.o'), 'stale object') or { panic(err) }
		os.write_file(cache_path_join(tmp_dir, '${cache_name}.stamp'), 'stale stamp') or {
			panic(err)
		}
	}
	prefs := pref.new_preferences()

	mut module_builder := new_builder(&prefs)
	module_builder.used_vh_for_parse = true
	mut module_reused := true
	_ := module_builder.ensure_cached_module_object(tmp_dir, builtin_cache_name, [], [], 'cc', '',
		'', '', false) or {
		module_reused = false
		''
	}
	assert !module_reused

	mut parsed_builder := new_builder(&prefs)
	parsed_builder.used_import_vh_for_parse = true
	mut parsed_reused := true
	_ := parsed_builder.ensure_cached_parsed_module_object(tmp_dir, imports_cache_name, [], [],
		'cc', '', '', '', false) or {
		parsed_reused = false
		''
	}
	assert !parsed_reused

	mut virtual_builder := new_builder(&prefs)
	virtual_builder.used_virtual_vh_for_parse = true
	mut virtual_reused := true
	_ := virtual_builder.ensure_cached_virtual_module_object(tmp_dir, [], [], 'cc', '', '', '',
		false) or {
		virtual_reused = false
		''
	}
	assert !virtual_reused
}

fn test_linux_x64_builder_default_o0_forces_ssa_optimize() {
	if os.user_os() != 'linux' || os.uname().machine !in ['x86_64', 'amd64'] {
		return
	}
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_linux_x64_default_o0_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	main_path := os.join_path(tmp_dir, 'main.v')
	out_path := os.join_path(tmp_dir, 'main')
	os.write_file(main_path, "module main\nfn main() { println('ok') }\n") or { panic(err) }

	mut prefs := pref.new_preferences_from_args(['-backend', 'x64', '-arch', 'x64', '-o', out_path,
		'-no-parallel', '-nocache'])
	assert prefs.no_optimize
	prefs.target_os = 'linux'

	cwd := os.getwd()
	os.chdir(tmp_dir) or { panic(err) }
	defer {
		os.chdir(cwd) or {}
	}
	mut b := new_builder(&prefs)
	b.build([main_path])

	run := os.execute(os.quoted_path(out_path))
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'ok'
}

struct WindowsX64BuildResult {
	undefined_symbols []string
	built_functions   []string
	image             []u8
}

fn windows_x64_map_string_wyhash_source() string {
	return "module main

fn sink_map(_ map[string]int) {}

fn main() {
	graph := {
		'A': 1
		'B': 2
	}
	sink_map(graph)
}
"
}

fn assert_windows_x64_map_string_wyhash_resolved(res WindowsX64BuildResult) {
	assert 'wyhash' in res.built_functions, res.built_functions.str()
	assert 'wyhash' !in res.undefined_symbols, res.undefined_symbols.str()
}

fn test_windows_x64_empty_main_links_without_crt_or_darwin_symbols() {
	res := build_windows_x64_sample('module main\nfn main() {}\n', false, true)

	assert 'calloc' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '_errno' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '__stdoutp' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '__stderrp' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '__stdinp' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '__error' !in res.undefined_symbols, res.undefined_symbols.str()

	linked := build_windows_x64_sample('module main\nfn main() {}\n', true, true)
	assert linked.image.len > 0
	assert linked.image[0] == `M`
	assert linked.image[1] == `Z`
}

fn test_windows_x64_c_globals_do_not_use_darwin_symbols() {
	source := 'module main
fn C.sink_ptr(voidptr)
fn C.sink_int(int)

fn main() {
	C.sink_ptr(C.stdout)
	C.sink_ptr(C.stderr)
	C.sink_ptr(C.stdin)
	C.sink_int(C.errno)
}
'
	res := build_windows_x64_sample(source, false, false)

	assert '__stdoutp' !in res.undefined_symbols
	assert '__stderrp' !in res.undefined_symbols
	assert '__stdinp' !in res.undefined_symbols
	assert '__error' !in res.undefined_symbols
	assert 'stdout' in res.undefined_symbols
	assert 'stderr' in res.undefined_symbols
	assert 'stdin' in res.undefined_symbols
	assert '_errno' in res.undefined_symbols
	assert 'errno' !in res.undefined_symbols
}

fn test_windows_x64_c_errno_links_with_minimal_runtime() {
	linked := build_windows_x64_sample('module main

fn main() {
	C.errno = 0
	C.errno += 1
}
',
		true, true)

	assert linked.image.len > 0
	assert linked.image[0] == `M`
	assert linked.image[1] == `Z`
}

fn test_windows_x64_minimal_runtime_builds_markused_core_functions() {
	res := build_windows_x64_sample("module main\nfn main() { println('x') }\n", false, false)

	assert 'builtin__println' in res.built_functions, res.built_functions.str()
	assert 'stderr' !in res.undefined_symbols, res.undefined_symbols.str()
	assert_no_windows_minimal_runtime_retention(res.built_functions)
}

fn test_windows_x64_minimal_runtime_map_string_generates_referenced_wyhash_stub_sequential() {
	res := build_windows_x64_sample(windows_x64_map_string_wyhash_source(), false, true)
	assert_windows_x64_map_string_wyhash_resolved(res)
}

fn test_windows_x64_minimal_runtime_map_string_generates_referenced_wyhash_stub_flat() {
	res :=
		build_windows_x64_sample_configured(windows_x64_map_string_wyhash_source(), false, true, true)
	assert_windows_x64_map_string_wyhash_resolved(res)
}

fn test_windows_x64_minimal_runtime_map_string_generates_referenced_wyhash_stub_native_builder_path() {
	res := build_windows_x64_sample_configured(windows_x64_map_string_wyhash_source(), false, true,
		false)
	assert_windows_x64_map_string_wyhash_resolved(res)
}

fn test_windows_x64_minimal_runtime_os_getwd_markused_does_not_retain_stdio_file_helpers() {
	used := build_windows_x64_markused_sample('module main
import os

fn main() {
	wd := os.getwd()
	_ = wd.len
}
')

	assert used['main|f|main'], used.str()
	assert used['os|f|getwd'], used.str()
	assert_no_windows_minimal_targeted_stdio_markused_leaks(used)
	assert !used['os|f|get_raw_line'], used.str()
	assert !used['os|f|get_raw_stdin'], used.str()
	assert !used['os|f|is_atty'], used.str()
	assert !used['os|f|input_password'], used.str()
}

fn test_windows_x64_minimal_runtime_os_getwd_build_does_not_retain_stdin_helpers() {
	res := build_windows_x64_sample('module main
import os

fn main() {
	wd := os.getwd()
	if wd.len == 0 {
		return
	}
}
',
		false, false)

	assert 'os__getwd' in res.built_functions, res.built_functions.str()
	assert 'os__get_raw_line' !in res.built_functions, res.built_functions.str()
	assert 'os__get_raw_stdin' !in res.built_functions, res.built_functions.str()
	assert 'os__is_atty' !in res.built_functions, res.built_functions.str()
	assert 'os__input_password' !in res.built_functions, res.built_functions.str()
	assert 'STD_INPUT_HANDLE' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '_get_osfhandle' !in res.undefined_symbols, res.undefined_symbols.str()
}

fn test_windows_x64_minimal_runtime_get_raw_line_uses_kernel32_stdin_helpers() {
	res := build_windows_x64_sample('module main
import os

fn main() {
	line := os.get_raw_line()
	_ = line.len
}
',
		false, false)

	assert 'os__get_raw_line' in res.built_functions, res.built_functions.str()
	assert 'os__is_atty' in res.built_functions, res.built_functions.str()
	assert 'GetStdHandle' in res.undefined_symbols, res.undefined_symbols.str()
	assert 'GetConsoleMode' in res.undefined_symbols, res.undefined_symbols.str()
	assert 'ReadConsole' in res.undefined_symbols, res.undefined_symbols.str()
	assert 'ReadFile' in res.undefined_symbols, res.undefined_symbols.str()
	assert 'STD_INPUT_HANDLE' !in res.undefined_symbols, res.undefined_symbols.str()
	assert 'INVALID_HANDLE_VALUE' !in res.undefined_symbols, res.undefined_symbols.str()
	assert '_get_osfhandle' !in res.undefined_symbols, res.undefined_symbols.str()
	assert 'stdin' !in res.undefined_symbols, res.undefined_symbols.str()
	assert 'stdout' !in res.undefined_symbols, res.undefined_symbols.str()
	assert 'stderr' !in res.undefined_symbols, res.undefined_symbols.str()
}

fn test_windows_x64_invalid_handle_value_macro_does_not_become_undefined_symbol() {
	res := build_windows_x64_sample('module main

fn invalid_handle() voidptr {
	return C.INVALID_HANDLE_VALUE
}

fn main() {
	_ := invalid_handle()
}
',
		false, false)

	assert 'INVALID_HANDLE_VALUE' !in res.undefined_symbols, res.undefined_symbols.str()
}

fn test_windows_x64_minimal_runtime_prunes_crt_stdio_else_branch_before_markused() {
	used := build_windows_x64_markused_sample('module main
import os

fn C.sink_ptr(voidptr)
fn C.setvbuf(voidptr, voidptr, int, usize) int

fn minimal_marker() {}

fn guarded_stdio_branch() {
	$if v2_native_windows_pe_minimal ? {
		minimal_marker()
	} $else {
		C.sink_ptr(C.stdout)
		C.sink_ptr(C.stderr)
		C.setvbuf(C.stdout, 0, 0, usize(0))
		unbuffer_stdout()
		os.stdout()
		os.stderr()
	}
}

fn main() {
	guarded_stdio_branch()
}
')

	assert used['main|f|main'], used.str()
	assert used['main|f|guarded_stdio_branch'], used.str()
	assert used['main|f|minimal_marker'], used.str()
	assert !used['builtin|f|unbuffer_stdout'], used.str()
	assert !used['os|f|stdout'], used.str()
	assert !used['os|f|stderr'], used.str()
	assert !windows_x64_markused_key_contains(used, 'setvbuf'), used.str()
	assert !windows_x64_markused_key_contains(used, '|f|stdout'), used.str()
	assert !windows_x64_markused_key_contains(used, '|f|stderr'), used.str()
}

fn test_windows_x64_minimal_runtime_dynamic_array_markused_does_not_retain_crt_stdio() {
	used := build_windows_x64_markused_sample("module main

fn main() {
	mut a := [1, 2, 3]
	a[1] = 7
	a << 11
	mut i := 0
	mut sum := 0
	for i < a.len {
		sum += a[i]
		i += 1
	}
	if sum == 22 {
		println('ok')
	}
}
")

	assert used['main|f|main'], used.str()
	assert used['builtin|f|println'], used.str()
	assert_no_windows_minimal_targeted_stdio_markused_leaks(used)
}

fn test_windows_x64_minimal_runtime_fixed_array_slice_copy_markused_does_not_retain_crt_stdio() {
	used := build_windows_x64_markused_sample("module main

fn main() {
	mut f := [5]int{}
	f[0] = 2
	f[1] = 4
	f[2] = 6
	f[3] = 8
	f[4] = 10
	mut a := f[1..4]
	a[1] = 9
	a << 12
	if a.len == 4 && f[2] == 6 {
		println('ok')
	}
}
")

	assert used['main|f|main'], used.str()
	assert used['builtin|f|println'], used.str()
	assert_no_windows_minimal_targeted_stdio_markused_leaks(used)
}

fn test_windows_x64_array_slice_call_uses_sret_and_integer_bounds() {
	mir_mod := build_checked_windows_x64_mir_sample("module main

fn make_array() []int {
	return [1, 2, 3]
}

fn main() {
	mut a := make_array()
	if a.len == 3 && a.cap >= 3 && a[0] == 1 && a[2] == 3 {
		print('N')
	} else {
		print('n')
	}
	a << 4
	if a.len == 4 && a[1] == 2 && a[3] == 4 {
		print('G')
	} else {
		print('g')
	}
	b := a[1..3]
	if b.len == 2 && b[0] == 2 && b[1] == 3 {
		print('S')
	} else {
		print('s')
	}
	unsafe {
		a.free()
	}
	println('F')
}
", true)
	mut found_callee := false
	for f in mir_mod.funcs {
		if f.name != 'builtin__array__slice' {
			continue
		}
		found_callee = true
		assert f.abi_ret_indirect
		assert f.abi_param_class == [.indirect, .in_reg, .in_reg]
	}
	assert found_callee

	mut found_call := false
	for val in mir_mod.values {
		if val.kind != .instruction {
			continue
		}
		instr := mir_mod.instrs[val.index]
		if instr.operands.len == 0 {
			continue
		}
		callee := instr.operands[0]
		if callee <= 0 || callee >= mir_mod.values.len
			|| mir_mod.values[callee].name != 'builtin__array__slice' {
			continue
		}
		found_call = true
		assert instr.op == .call_sret
		assert instr.abi_ret_indirect
		assert instr.abi_arg_class == [.indirect, .in_reg, .in_reg]
		assert instr.operands.len >= 4
		start_arg := instr.operands[2]
		end_arg := instr.operands[3]
		assert mir_mod.type_store.types[mir_mod.values[start_arg].typ].kind == .int_t
		assert mir_mod.type_store.types[mir_mod.values[end_arg].typ].kind == .int_t
	}
	assert found_call
}

fn test_windows_x64_println_links_pe_image() {
	linked := build_windows_x64_sample("module main\nfn main() { println('x') }\n", true, true)

	assert linked.image.len > 0
	assert linked.image[0] == `M`
	assert linked.image[1] == `Z`
	assert 'WriteConsoleW' in linked.undefined_symbols, linked.undefined_symbols.str()
	assert 'MultiByteToWideChar' in linked.undefined_symbols, linked.undefined_symbols.str()
	assert 'GetProcessHeap' in linked.undefined_symbols, linked.undefined_symbols.str()
	assert 'HeapAlloc' in linked.undefined_symbols, linked.undefined_symbols.str()
	assert 'HeapFree' in linked.undefined_symbols, linked.undefined_symbols.str()
	assert 'WriteFile' in linked.undefined_symbols, linked.undefined_symbols.str()
	assert_no_windows_minimal_crt_symbols(linked.undefined_symbols)
	assert_no_windows_minimal_runtime_retention(linked.built_functions)
}

fn test_windows_x64_minimal_runtime_preserves_imported_module_init() {
	linked := build_windows_x64_sample_with_files({
		'main.v':    'module main
import dep

fn main() {}
'
		'dep/dep.v': 'module dep

fn init() {
	touch()
}

fn touch() {}
'
	}, true, true)

	assert 'dep__init' in linked.built_functions, linked.built_functions.str()
	assert 'dep__touch' in linked.built_functions, linked.built_functions.str()
	assert linked.image.len > 0
	assert linked.image[0] == `M`
	assert linked.image[1] == `Z`
}

fn test_windows_x64_minimal_runtime_preserves_imported_module_init_without_optimize() {
	res := build_windows_x64_sample_with_files({
		'main.v':    'module main
import dep

fn main() {}
'
		'dep/dep.v': 'module dep

fn init() {
	touch()
}

fn touch() {}
'
	}, false, false)

	assert 'dep__init' in res.built_functions, res.built_functions.str()
	assert 'dep__touch' in res.built_functions, res.built_functions.str()
	assert_no_windows_minimal_crt_symbols(res.undefined_symbols)
	assert_no_windows_minimal_runtime_retention(res.built_functions)
}

fn test_windows_x64_minimal_runtime_preserves_conditional_imported_module_init() {
	linked := build_windows_x64_sample_with_files({
		'main.v':    'module main
$if windows {
	import dep
}

fn main() {}
'
		'dep/dep.v': 'module dep

fn init() {
	touch()
}

fn touch() {}
'
	}, true, true)

	assert 'dep__init' in linked.built_functions, linked.built_functions.str()
	assert 'dep__touch' in linked.built_functions, linked.built_functions.str()
	assert linked.image.len > 0
	assert linked.image[0] == `M`
	assert linked.image[1] == `Z`
}

fn test_windows_x64_minimal_runtime_preserves_dotted_import_module_init() {
	linked := build_windows_x64_sample_with_files({
		'main.v':                'module main
import fixture.inner

fn main() {}
'
		'fixture/inner/inner.v': 'module inner

const dotted_runtime_value = make_value()

fn init() {
	touch()
}

fn touch() {}

fn make_value() int {
	return 7
}
'
	}, true, true)

	assert 'inner__init' in linked.built_functions, linked.built_functions.str()
	assert 'inner__touch' in linked.built_functions, linked.built_functions.str()
	assert 'inner____v_init_consts_inner' in linked.built_functions, linked.built_functions.str()
	assert 'inner__make_value' in linked.built_functions, linked.built_functions.str()
	assert linked.image.len > 0
	assert linked.image[0] == `M`
	assert linked.image[1] == `Z`
}

fn test_windows_x64_minimal_runtime_preserves_dotted_import_const_init_matrix() {
	for optimize in [false, true] {
		res := build_windows_x64_sample_with_files({
			'main.v':                'module main
import fixture.inner

fn main() {}
'
			'fixture/inner/inner.v': 'module inner

const dotted_runtime_value = make_value()

fn init() {
	touch()
}

fn touch() {}

fn make_value() int {
	return 7
}
'
		}, false, optimize)

		assert 'inner__init' in res.built_functions, res.built_functions.str()
		assert 'inner__touch' in res.built_functions, res.built_functions.str()
		assert 'inner____v_init_consts_inner' in res.built_functions, res.built_functions.str()
		assert 'inner__make_value' in res.built_functions, res.built_functions.str()
		assert_no_windows_minimal_crt_symbols(res.undefined_symbols)
		assert_no_windows_large_runtime_module_retention(res.built_functions)
	}
}

fn assert_no_windows_minimal_crt_symbols(undefined_symbols []string) {
	assert_no_windows_minimal_crt_stdio_symbols(undefined_symbols)
	for name in ['calloc', 'malloc', 'free', 'write', '_get_osfhandle'] {
		assert name !in undefined_symbols, undefined_symbols.str()
	}
}

fn assert_no_windows_minimal_crt_stdio_symbols(undefined_symbols []string) {
	for name in ['stdin', 'stdout', 'stderr', 'printf', 'fprintf', 'dprintf', 'sprintf', 'snprintf',
		'wprintf', 'puts', 'fputs', 'setvbuf', 'fflush', 'fopen', '_wfopen', 'fdopen', 'freopen',
		'_wfreopen', 'fclose', 'pclose', '_pclose', 'fread', 'fwrite', 'fgets', 'getc', 'feof',
		'ferror', 'fseek', 'ftell', 'rewind', 'fileno', '_fileno', 'fgetpos'] {
		assert name !in undefined_symbols, undefined_symbols.str()
	}
}

fn assert_no_windows_minimal_targeted_stdio_markused_leaks(used map[string]bool) {
	assert !used['os|f|stdout'], used.str()
	assert !used['os|f|stderr'], used.str()
	assert !used['builtin|f|is_terminal'], used.str()
	assert !used['builtin|f|write_buf_to_console'], used.str()
	assert !used['builtin|f|unbuffer_stdout'], used.str()
	assert !windows_x64_markused_key_contains(used, 'write_buf_to_fd_windows_non_minimal'), used.str()
	assert !windows_x64_markused_key_contains(used, 'setvbuf'), used.str()
}

fn assert_no_windows_minimal_runtime_retention(built_functions []string) {
	for name in built_functions {
		assert !name.starts_with('os__'), built_functions.str()
		assert !name.starts_with('time__'), built_functions.str()
		assert !name.starts_with('io__'), built_functions.str()
		assert !name.starts_with('dl__'), built_functions.str()
		assert !name.starts_with('sha256__'), built_functions.str()
		assert !name.starts_with('binary__'), built_functions.str()
		assert name != 'builtin__is_terminal', built_functions.str()
		assert name != 'builtin__write_buf_to_console', built_functions.str()
		assert !name.contains('write_buf_to_fd_windows_non_minimal'), built_functions.str()
		if name.starts_with('__v_init_consts_') {
			assert name == '__v_init_consts_main', built_functions.str()
		}
		assert !name.contains('____v_init_consts_'), built_functions.str()
	}
}

fn assert_no_windows_large_runtime_module_retention(built_functions []string) {
	for name in built_functions {
		assert !name.starts_with('os__'), built_functions.str()
		assert !name.starts_with('time__'), built_functions.str()
		assert !name.starts_with('io__'), built_functions.str()
		assert !name.starts_with('dl__'), built_functions.str()
		assert !name.starts_with('sha256__'), built_functions.str()
		assert !name.starts_with('binary__'), built_functions.str()
	}
}

fn build_windows_x64_sample(source string, link bool, optimize bool) WindowsX64BuildResult {
	return build_windows_x64_sample_configured(source, link, optimize, true)
}

fn build_windows_x64_sample_configured(source string, link bool, optimize bool, no_parallel bool) WindowsX64BuildResult {
	return build_windows_x64_sample_with_files_configured({
		'main.v': source
	}, link, optimize, no_parallel)
}

fn build_windows_x64_markused_sample(source string) map[string]bool {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_builder_windows_x64_markused_sample_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	main_path := os.join_path(tmp_dir, 'main.v')
	os.write_file(main_path, source) or { panic(err) }

	mut prefs := pref.new_preferences()
	prefs.backend = .x64
	prefs.arch = .x64
	prefs.target_os = 'windows'
	prefs.skip_type_check = true
	prefs.no_parallel = true
	prefs.no_parallel_transform = true
	prefs.no_cache = true

	mut b := new_builder(&prefs)
	b.user_files = [main_path]
	parse_test_builder_files(mut b, [main_path])
	b.env = types.Environment.new()

	mut trans := transformer.Transformer.new_with_pref(b.env, b.pref)
	trans.set_file_set(b.file_set)
	transform_test_builder_files(mut b, mut trans)
	used := mark_used_windows_x64_test(mut b)
	assert used.len > 0
	return used
}

fn build_checked_windows_x64_mir_sample(source string, optimize bool) mir.Module {
	tmp_dir := os.join_path(os.temp_dir(),
		'v2_builder_windows_x64_checked_mir_${os.getpid()}_${optimize}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	main_path := os.join_path(tmp_dir, 'main.v')
	os.write_file(main_path, source) or { panic(err) }

	mut prefs := pref.new_preferences()
	prefs.backend = .x64
	prefs.arch = .x64
	prefs.target_os = 'windows'
	prefs.no_parallel = true
	prefs.no_parallel_transform = true
	prefs.no_cache = true

	mut b := new_builder(&prefs)
	b.user_files = [main_path]
	parse_test_builder_files(mut b, [main_path])
	b.env = b.type_check_files()

	mut trans := transformer.Transformer.new_with_pref(b.env, b.pref)
	trans.set_file_set(b.file_set)
	transform_test_builder_files(mut b, mut trans)
	b.used_fn_keys = mark_used_windows_x64_test(mut b)
	assert b.used_fn_keys.len > 0

	mut ssa_mod := ssa.Module.new('main')
	mut ssa_builder := ssa.Builder.new_with_env(ssa_mod, b.env)
	ssa_builder.guard_invalid_type_payloads = true
	ssa_builder.target_os = 'windows'
	ssa_builder.minimal_runtime_roots = true
	ssa_builder.native_backend_bulk_zero_alloca = true
	ssa_builder.used_fn_keys = b.used_fn_keys.clone()
	build_test_ssa(mut b, mut ssa_builder)
	if optimize {
		ssa_optimize.optimize(mut ssa_mod)
	}

	mut mir_mod := mir.lower_from_ssa(ssa_mod)
	abi.lower_with_x64_abi(mut mir_mod, .x64, .windows)
	insel.select(mut mir_mod, .x64)
	return mir_mod
}

fn windows_x64_markused_key_contains(used map[string]bool, needle string) bool {
	for key, is_used in used {
		if is_used && key.contains(needle) {
			return true
		}
	}
	return false
}

fn build_windows_x64_sample_with_files(sources map[string]string, link bool, optimize bool) WindowsX64BuildResult {
	return build_windows_x64_sample_with_files_configured(sources, link, optimize, true)
}

fn build_windows_x64_sample_with_files_configured(sources map[string]string, link bool, optimize bool, no_parallel bool) WindowsX64BuildResult {
	tmp_dir := os.join_path(os.temp_dir(),
		'v2_builder_windows_x64_sample_${os.getpid()}_${sources.len}_${link}_${optimize}_${no_parallel}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}

	main_path := os.join_path(tmp_dir, 'main.v')
	obj_path := os.join_path(tmp_dir, 'main.obj')
	exe_path := os.join_path(tmp_dir, 'main.exe')
	for rel_path, source in sources {
		path := os.join_path(tmp_dir, rel_path)
		os.mkdir_all(os.dir(path)) or { panic(err) }
		os.write_file(path, source) or { panic(err) }
	}

	mut prefs := pref.new_preferences()
	prefs.backend = .x64
	prefs.arch = .x64
	prefs.target_os = 'windows'
	prefs.skip_type_check = true
	prefs.no_parallel = no_parallel
	prefs.no_parallel_transform = true
	prefs.no_cache = true
	prefs.no_optimize = !optimize

	mut b := new_builder(&prefs)
	b.user_files = [main_path]
	parse_test_builder_files(mut b, [main_path])
	b.env = types.Environment.new()

	mut trans := transformer.Transformer.new_with_pref(b.env, b.pref)
	trans.set_file_set(b.file_set)
	transform_test_builder_files(mut b, mut trans)
	b.used_fn_keys = mark_used_windows_x64_test(mut b)
	assert b.used_fn_keys.len > 0

	mut ssa_mod := ssa.Module.new('main')
	mut ssa_builder := ssa.Builder.new_with_env(ssa_mod, b.env)
	ssa_builder.guard_invalid_type_payloads = true
	ssa_builder.target_os = 'windows'
	ssa_builder.minimal_runtime_roots = true
	ssa_builder.native_backend_bulk_zero_alloca = true
	ssa_builder.used_fn_keys = b.used_fn_keys.clone()
	mut mir_mod := mir.Module{}
	mut built_functions := []string{}
	if no_parallel {
		build_test_ssa(mut b, mut ssa_builder)
		if optimize {
			ssa_optimize.optimize(mut ssa_mod)
		}
		built_functions = ssa_mod.funcs.filter(it.blocks.len > 0).map(it.name)
		mir_mod = mir.lower_from_ssa(ssa_mod)
		abi.lower_with_x64_abi(mut mir_mod, .x64, .windows)
		insel.select(mut mir_mod, .x64)
	} else {
		mir_mod = b.build_native_mir_from_files(b.files, .x64, 'windows', true, b.used_fn_keys,
			'Windows x64 sample')
		built_functions = mir_mod.funcs.filter(it.blocks.len > 0).map(it.name)
	}

	mut gen := x64.Gen.new_with_format_and_abi(&mir_mod, .coff, .windows)
	gen.gen()
	gen.write_file(obj_path)
	mut image := []u8{}
	if link {
		gen.link_executable(exe_path) or { panic(err) }
		image = os.read_bytes(exe_path) or { panic(err) }
	}
	return WindowsX64BuildResult{
		undefined_symbols: coff_undefined_symbols(os.read_bytes(obj_path) or { panic(err) })
		built_functions:   built_functions
		image:             image
	}
}

fn coff_undefined_symbols(data []u8) []string {
	ptr_to_symbols := int(coff_u32(data, 8))
	number_of_symbols := int(coff_u32(data, 12))
	string_table_off := ptr_to_symbols + number_of_symbols * 18
	mut symbols := []string{}
	mut i := 0
	for i < number_of_symbols {
		off := ptr_to_symbols + i * 18
		section_number := i16(coff_u16(data, off + 12))
		aux_count := int(data[off + 17])
		if section_number == 0 {
			symbols << coff_symbol_name(data, off, string_table_off)
		}
		i += 1 + aux_count
	}
	return symbols
}

fn coff_symbol_name(data []u8, off int, string_table_off int) string {
	if coff_u32(data, off) == 0 {
		name_off := int(coff_u32(data, off + 4))
		return coff_string(data, string_table_off + name_off)
	}
	mut end := off
	for end < off + 8 && data[end] != 0 {
		end++
	}
	return data[off..end].bytestr()
}

fn coff_string(data []u8, off int) string {
	mut end := off
	for end < data.len && data[end] != 0 {
		end++
	}
	return data[off..end].bytestr()
}

fn coff_u16(data []u8, off int) u16 {
	return u16(data[off]) | (u16(data[off + 1]) << 8)
}

fn coff_u32(data []u8, off int) u32 {
	return u32(data[off]) | (u32(data[off + 1]) << 8) | (u32(data[off + 2]) << 16) | (u32(data[
		off + 3]) << 24)
}