module markused

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

fn minimal_pos(id int) token.Pos {
	return token.Pos{
		offset: id
		id:     id
	}
}

fn minimal_ident(name string, id int) ast.Ident {
	return ast.Ident{
		name: name
		pos:  minimal_pos(id)
	}
}

fn minimal_selector(lhs string, rhs string, id int) ast.SelectorExpr {
	return ast.SelectorExpr{
		lhs: minimal_ident(lhs, id)
		rhs: minimal_ident(rhs, id + 1)
		pos: minimal_pos(id)
	}
}

fn minimal_c_selector(name string, id int) ast.SelectorExpr {
	return minimal_selector('C', name, id)
}

fn minimal_c_call(name string, id int, args []ast.Expr) ast.CallExpr {
	return ast.CallExpr{
		lhs:  minimal_c_selector(name, id)
		args: args
		pos:  minimal_pos(id)
	}
}

fn mark_used_flat_minimal(files []ast.File, env &types.Environment) map[string]bool {
	flat := ast.flatten_files(files)
	return mark_used_flat_with_options(&flat, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
}

fn local_call_minimal_files() []ast.File {
	return [
		ast.File{
			mod:   'main'
			name:  'local_calls.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(10)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Expr(minimal_ident('foo', 11))
								pos: minimal_pos(11)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'foo'
					typ:   ast.FnType{}
					pos:   minimal_pos(12)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Expr(minimal_ident('status', 13))
								pos: minimal_pos(13)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'status'
					typ:  ast.FnType{}
					pos:  minimal_pos(14)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'dead'
					typ:  ast.FnType{}
					pos:  minimal_pos(15)
				}),
			]
		},
	]
}

fn assert_local_call_minimal_used(used map[string]bool, files []ast.File, env &types.Environment, label string) {
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	foo_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	status_key := decl_key('main', files[0].stmts[2] as ast.FnDecl, env)
	dead_key := decl_key('main', files[0].stmts[3] as ast.FnDecl, env)

	assert used[main_key], '${label}: main root was not kept'
	assert used[foo_key], '${label}: local foo call was not marked'
	assert used[status_key], '${label}: transitive local status call was not marked'
	assert !used[dead_key], '${label}: unused local function should stay pruned'
}

fn test_minimal_runtime_roots_pointer_guards_accept_low_canonical_pointers() {
	assert sumtype_payload_word_is_valid(1, 0x10000)
	assert !sumtype_payload_word_is_valid(1, 0)
	assert !sumtype_payload_word_is_valid(1, 3)
	assert string_ok('foo')
	assert string_ok('status')
}

fn test_minimal_runtime_roots_keep_local_calls_legacy() {
	mut env := types.Environment.new()
	files := local_call_minimal_files()
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	assert_local_call_minimal_used(used, files, env, 'legacy')
}

fn test_minimal_runtime_roots_keep_local_calls_flat() {
	mut env := types.Environment.new()
	files := local_call_minimal_files()
	used := mark_used_flat_minimal(files, env)
	assert_local_call_minimal_used(used, files, env, 'flat')
}

fn selective_import_minimal_files() []ast.File {
	return [
		ast.File{
			mod:     'main'
			name:    'examples/submodule/main.v'
			imports: [
				ast.ImportStmt{
					name:    'mymodules'
					alias:   'mymodules'
					symbols: [ast.Expr(minimal_ident('add_xy', 60))]
				},
				ast.ImportStmt{
					name:    'mymodules.submodule'
					alias:   'submodule'
					symbols: [ast.Expr(minimal_ident('sub_xy', 61))]
				},
			]
			stmts:   [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(62)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Expr(minimal_ident('add_xy', 63))
								pos: minimal_pos(63)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Expr(minimal_ident('sub_xy', 64))
								pos: minimal_pos(64)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'mymodules'
			name:  'examples/submodule/mymodules/main_functions.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'add_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(65)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_add'
					typ:  ast.FnType{}
					pos:  minimal_pos(66)
				}),
			]
		},
		ast.File{
			mod:   'submodule'
			name:  'examples/submodule/mymodules/submodule/sub_functions.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'sub_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(67)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_sub'
					typ:  ast.FnType{}
					pos:  minimal_pos(68)
				}),
			]
		},
	]
}

fn assert_selective_import_minimal_used(used map[string]bool, files []ast.File, env &types.Environment, label string) {
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	add_key := decl_key('mymodules', files[1].stmts[0] as ast.FnDecl, env)
	unused_add_key := decl_key('mymodules', files[1].stmts[1] as ast.FnDecl, env)
	sub_key := decl_key('submodule', files[2].stmts[0] as ast.FnDecl, env)
	unused_sub_key := decl_key('submodule', files[2].stmts[1] as ast.FnDecl, env)

	assert used[main_key], '${label}: main root was not kept'
	assert used[add_key], '${label}: selective import add_xy was not resolved to mymodules__add_xy'
	assert used[sub_key], '${label}: selective import sub_xy was not resolved to submodule__sub_xy'
	assert !used[unused_add_key], '${label}: unused mymodules function should stay pruned'
	assert !used[unused_sub_key], '${label}: unused submodule function should stay pruned'
}

fn test_minimal_runtime_roots_keep_selective_imported_function_calls_legacy() {
	mut env := types.Environment.new()
	files := selective_import_minimal_files()
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	assert_selective_import_minimal_used(used, files, env, 'legacy')
}

fn test_minimal_runtime_roots_keep_selective_imported_function_calls_flat() {
	mut env := types.Environment.new()
	files := selective_import_minimal_files()
	used := mark_used_flat_minimal(files, env)
	assert_selective_import_minimal_used(used, files, env, 'flat')
}

fn selective_import_shadow_minimal_files(use_function_value bool) []ast.File {
	mut main_body := []ast.Stmt{}
	if use_function_value {
		main_body << ast.Stmt(ast.AssignStmt{
			op:  .decl_assign
			lhs: [ast.Expr(minimal_ident('f', 150))]
			rhs: [ast.Expr(minimal_ident('add_xy', 151))]
			pos: minimal_pos(150)
		})
	} else {
		main_body << ast.Stmt(ast.ExprStmt{
			expr: ast.CallExpr{
				lhs: ast.Expr(minimal_ident('add_xy', 152))
				pos: minimal_pos(152)
			}
		})
	}
	return [
		ast.File{
			mod:     'main'
			name:    'shadow/main.v'
			imports: [
				ast.ImportStmt{
					name:    'mymodules'
					alias:   'mymodules'
					symbols: [ast.Expr(minimal_ident('add_xy', 153))]
				},
			]
			stmts:   [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(154)
					stmts: main_body
				}),
				ast.Stmt(ast.FnDecl{
					name: 'add_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(155)
				}),
			]
		},
		ast.File{
			mod:   'mymodules'
			name:  'shadow/mymodules/main_functions.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'add_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(156)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_remote'
					typ:  ast.FnType{}
					pos:  minimal_pos(157)
				}),
			]
		},
		ast.File{
			mod:   'othermod'
			name:  'shadow/othermod/main_functions.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'add_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(158)
				}),
			]
		},
	]
}

fn assert_selective_import_shadow_uses_local(used map[string]bool, files []ast.File, env &types.Environment, label string) {
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	local_add_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	imported_add_key := decl_key('mymodules', files[1].stmts[0] as ast.FnDecl, env)
	unused_remote_key := decl_key('mymodules', files[1].stmts[1] as ast.FnDecl, env)
	other_add_key := decl_key('othermod', files[2].stmts[0] as ast.FnDecl, env)

	assert used[main_key], '${label}: main root was not kept'
	assert used[local_add_key], '${label}: local add_xy should shadow the selective import'
	assert !used[imported_add_key], '${label}: shadowed selective import should stay pruned'
	assert !used[unused_remote_key], '${label}: unused imported-module function should stay pruned'
	assert !used[other_add_key], '${label}: bare global add_xy fallback marked a colliding module function'
}

fn test_minimal_runtime_roots_selective_import_call_uses_local_shadow_legacy() {
	mut env := types.Environment.new()
	files := selective_import_shadow_minimal_files(false)
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	assert_selective_import_shadow_uses_local(used, files, env, 'legacy call')
}

fn test_minimal_runtime_roots_selective_import_call_uses_local_shadow_flat() {
	mut env := types.Environment.new()
	files := selective_import_shadow_minimal_files(false)
	used := mark_used_flat_minimal(files, env)
	assert_selective_import_shadow_uses_local(used, files, env, 'flat call')
}

fn test_minimal_runtime_roots_selective_import_function_value_uses_local_shadow_legacy() {
	mut env := types.Environment.new()
	files := selective_import_shadow_minimal_files(true)
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	assert_selective_import_shadow_uses_local(used, files, env, 'legacy function value')
}

fn test_minimal_runtime_roots_selective_import_function_value_uses_local_shadow_flat() {
	mut env := types.Environment.new()
	files := selective_import_shadow_minimal_files(true)
	used := mark_used_flat_minimal(files, env)
	assert_selective_import_shadow_uses_local(used, files, env, 'flat function value')
}

fn selective_import_function_value_minimal_files() []ast.File {
	return [
		ast.File{
			mod:     'main'
			name:    'fnvalue/main.v'
			imports: [
				ast.ImportStmt{
					name:    'mymodules'
					alias:   'mymodules'
					symbols: [ast.Expr(minimal_ident('add_xy', 160))]
				},
			]
			stmts:   [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(161)
					stmts: [
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [ast.Expr(minimal_ident('f', 162))]
							rhs: [ast.Expr(minimal_ident('add_xy', 163))]
							pos: minimal_pos(162)
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'mymodules'
			name:  'fnvalue/mymodules/main_functions.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'add_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(164)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_remote'
					typ:  ast.FnType{}
					pos:  minimal_pos(165)
				}),
			]
		},
		ast.File{
			mod:   'othermod'
			name:  'fnvalue/othermod/main_functions.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'add_xy'
					typ:  ast.FnType{}
					pos:  minimal_pos(166)
				}),
			]
		},
	]
}

fn assert_selective_import_function_value_uses_imported_target(used map[string]bool, files []ast.File, env &types.Environment, label string) {
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	imported_add_key := decl_key('mymodules', files[1].stmts[0] as ast.FnDecl, env)
	unused_remote_key := decl_key('mymodules', files[1].stmts[1] as ast.FnDecl, env)
	other_add_key := decl_key('othermod', files[2].stmts[0] as ast.FnDecl, env)

	assert used[main_key], '${label}: main root was not kept'
	assert used[imported_add_key], '${label}: selective import function value did not resolve to mymodules__add_xy'
	assert !used[unused_remote_key], '${label}: unused imported-module function should stay pruned'
	assert !used[other_add_key], '${label}: bare global add_xy fallback marked a colliding module function'
}

fn test_minimal_runtime_roots_keep_selective_imported_function_values_legacy() {
	mut env := types.Environment.new()
	files := selective_import_function_value_minimal_files()
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	assert_selective_import_function_value_uses_imported_target(used, files, env,
		'legacy function value')
}

fn test_minimal_runtime_roots_keep_selective_imported_function_values_flat() {
	mut env := types.Environment.new()
	files := selective_import_function_value_minimal_files()
	used := mark_used_flat_minimal(files, env)
	assert_selective_import_function_value_uses_imported_target(used, files, env,
		'flat function value')
}

fn test_minimal_runtime_roots_selective_import_add_fn_name_indices_legacy() {
	mut env := types.Environment.new()
	files := selective_import_function_value_minimal_files()
	mut w := new_walker(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	w.collect_defs()
	w.cur_fn_file = files[0].name
	mut indices := []int{}
	w.add_fn_name_indices('add_xy', 'main', mut indices)
	target_key := decl_key('mymodules', files[1].stmts[0] as ast.FnDecl, env)

	assert indices.len == 1
	assert w.fns[indices[0]].key == target_key
}

fn test_minimal_runtime_roots_selective_import_add_fn_name_indices_flat() {
	mut env := types.Environment.new()
	files := selective_import_function_value_minimal_files()
	flat := ast.flatten_files(files)
	mut w := new_walker(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	w.collect_defs_from_flat(&flat)
	w.cur_fn_file = files[0].name
	mut indices := []int{}
	w.add_fn_name_indices('add_xy', 'main', mut indices)
	target_key := decl_key('mymodules', files[1].stmts[0] as ast.FnDecl, env)

	assert indices.len == 1
	assert w.fns[indices[0]].key == target_key
}

fn test_minimal_runtime_roots_keep_explicit_calls_only() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(120)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'println'
									pos:  minimal_pos(121)
								}
								pos: minimal_pos(121)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/builtin.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'println'
					typ:   ast.FnType{}
					pos:   minimal_pos(122)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'write_stdout'
									pos:  minimal_pos(123)
								}
								pos: minimal_pos(123)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'write_stdout'
					typ:  ast.FnType{}
					pos:  minimal_pos(124)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'print_backtrace'
					typ:  ast.FnType{}
					pos:  minimal_pos(125)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'builtin_keep_helper'
					typ:  ast.FnType{}
					pos:  minimal_pos(126)
				}),
			]
		},
		ast.File{
			mod:   'time'
			name:  'time.v'
			stmts: [
				ast.Stmt(ast.StructDecl{
					name: 'Time'
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 't'
						typ:  ast.Ident{
							name: 'Time'
							pos:  minimal_pos(127)
						}
						pos:  minimal_pos(127)
					}
					name:      'str'
					typ:       ast.FnType{}
					pos:       minimal_pos(128)
				}),
			]
		},
		ast.File{
			mod:   'dep'
			name:  'dep.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'init'
					typ:  ast.FnType{}
					pos:  minimal_pos(129)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	println_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	write_stdout_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)
	print_backtrace_key := decl_key('builtin', files[1].stmts[2] as ast.FnDecl, env)
	builtin_keep_key := decl_key('builtin', files[1].stmts[3] as ast.FnDecl, env)
	time_str_key := decl_key('time', files[2].stmts[1] as ast.FnDecl, env)
	dep_init_key := decl_key('dep', files[3].stmts[0] as ast.FnDecl, env)

	assert used[main_key]
	assert used[println_key]
	assert used[write_stdout_key]
	assert !used[print_backtrace_key]
	assert !used[builtin_keep_key]
	assert !used[time_str_key]
	assert !used[dep_init_key]
}

fn test_minimal_runtime_roots_keep_functions_used_as_values() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(180)
					stmts: [
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [ast.Expr(minimal_ident('f', 181))]
							rhs: [ast.Expr(minimal_ident('assigned_cleanup', 182))]
							pos: minimal_pos(181)
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs:  minimal_ident('run', 183)
								args: [ast.Expr(minimal_ident('argument_cleanup', 184))]
								pos:  minimal_pos(183)
							}
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [ast.Expr(minimal_ident('g', 185))]
							rhs: [
								ast.Expr(ast.CallExpr{
									lhs: minimal_ident('choose_cleanup', 186)
									pos: minimal_pos(186)
								}),
							]
							pos: minimal_pos(185)
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'run'
					typ:  ast.FnType{}
					pos:  minimal_pos(187)
				}),
				ast.Stmt(ast.FnDecl{
					name:  'choose_cleanup'
					typ:   ast.FnType{}
					pos:   minimal_pos(188)
					stmts: [
						ast.Stmt(ast.ReturnStmt{
							exprs: [
								ast.Expr(minimal_ident('returned_cleanup', 189)),
							]
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'assigned_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(190)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'argument_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(191)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'returned_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(192)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(193)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	run_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	choose_key := decl_key('main', files[0].stmts[2] as ast.FnDecl, env)
	assigned_key := decl_key('main', files[0].stmts[3] as ast.FnDecl, env)
	argument_key := decl_key('main', files[0].stmts[4] as ast.FnDecl, env)
	returned_key := decl_key('main', files[0].stmts[5] as ast.FnDecl, env)
	unused_key := decl_key('main', files[0].stmts[6] as ast.FnDecl, env)

	assert used[main_key]
	assert used[run_key]
	assert used[choose_key]
	assert used[assigned_key]
	assert used[argument_key]
	assert used[returned_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_keep_functions_used_as_const_values() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.ConstDecl{
					fields: [
						ast.FieldInit{
							name:  'cb'
							value: ast.Expr(minimal_ident('abc', 200))
						},
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(201)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('cb', 202)
								pos: minimal_pos(202)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'abc'
					typ:  ast.FnType{}
					pos:  minimal_pos(203)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused'
					typ:  ast.FnType{}
					pos:  minimal_pos(204)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	abc_key := decl_key('main', files[0].stmts[2] as ast.FnDecl, env)
	unused_key := decl_key('main', files[0].stmts[3] as ast.FnDecl, env)

	assert used[main_key]
	assert used[abc_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_flat_keeps_const_alias_return_and_const_field_function_values() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.ConstDecl{
					fields: [
						ast.FieldInit{
							name:  'cb'
							value: ast.Expr(minimal_ident('alias_cleanup', 300))
						},
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(301)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('cb', 302)
								pos: minimal_pos(302)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('choose_cleanup', 303)
								pos: minimal_pos(303)
							}
						}),
						ast.Stmt(ast.ConstDecl{
							fields: [
								ast.FieldInit{
									name:  'local_cb'
									value: ast.Expr(minimal_ident('field_cleanup', 304))
								},
							]
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'choose_cleanup'
					typ:   ast.FnType{}
					pos:   minimal_pos(305)
					stmts: [
						ast.Stmt(ast.ReturnStmt{
							exprs: [
								ast.Expr(minimal_ident('returned_cleanup', 306)),
							]
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'alias_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(307)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'returned_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(308)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'field_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(309)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(310)
				}),
			]
		},
	]
	used := mark_used_flat_minimal(files, env)
	main_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	choose_key := decl_key('main', files[0].stmts[2] as ast.FnDecl, env)
	alias_key := decl_key('main', files[0].stmts[3] as ast.FnDecl, env)
	returned_key := decl_key('main', files[0].stmts[4] as ast.FnDecl, env)
	field_key := decl_key('main', files[0].stmts[5] as ast.FnDecl, env)
	unused_key := decl_key('main', files[0].stmts[6] as ast.FnDecl, env)

	assert used[main_key]
	assert used[choose_key]
	assert used[alias_key]
	assert used[returned_key]
	assert used[field_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_keep_qualified_const_function_aliases() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:     'main'
			name:    'main.v'
			imports: [
				ast.ImportStmt{
					name:       'dep'
					alias:      'd'
					is_aliased: true
				},
				ast.ImportStmt{
					name: 'tools'
				},
			]
			stmts:   [
				ast.Stmt(ast.ConstDecl{
					fields: [
						ast.FieldInit{
							name:  'dep_cb'
							value: ast.Expr(minimal_selector('d', 'cleanup', 210))
						},
						ast.FieldInit{
							name:  'tools_cb'
							value: ast.Expr(minimal_selector('tools', 'teardown', 213))
						},
						ast.FieldInit{
							name:  'c_cb'
							value: ast.Expr(minimal_c_selector('cleanup', 216))
						},
						ast.FieldInit{
							name:  'field_cb'
							value: ast.Expr(minimal_selector('hooks', 'cleanup', 219))
						},
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(220)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('dep_cb', 221)
								pos: minimal_pos(221)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('tools_cb', 222)
								pos: minimal_pos(222)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('c_cb', 223)
								pos: minimal_pos(223)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('field_cb', 224)
								pos: minimal_pos(224)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(225)
				}),
			]
		},
		ast.File{
			mod:   'dep'
			name:  'dep.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(226)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused'
					typ:  ast.FnType{}
					pos:  minimal_pos(227)
				}),
			]
		},
		ast.File{
			mod:   'tools'
			name:  'tools.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'teardown'
					typ:  ast.FnType{}
					pos:  minimal_pos(228)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused'
					typ:  ast.FnType{}
					pos:  minimal_pos(229)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	main_cleanup_key := decl_key('main', files[0].stmts[2] as ast.FnDecl, env)
	dep_cleanup_key := decl_key('dep', files[1].stmts[0] as ast.FnDecl, env)
	dep_unused_key := decl_key('dep', files[1].stmts[1] as ast.FnDecl, env)
	tools_teardown_key := decl_key('tools', files[2].stmts[0] as ast.FnDecl, env)
	tools_unused_key := decl_key('tools', files[2].stmts[1] as ast.FnDecl, env)

	assert used[main_key]
	assert used[dep_cleanup_key]
	assert used[tools_teardown_key]
	assert !used[main_cleanup_key]
	assert !used[dep_unused_key]
	assert !used[tools_unused_key]
}

fn test_minimal_runtime_roots_keep_functions_used_in_composite_literals() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.StructDecl{
					name:   'Hooks'
					fields: [
						ast.FieldDecl{
							name: 'cb'
						},
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(220)
					stmts: [
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [ast.Expr(minimal_ident('hook', 221))]
							rhs: [
								ast.Expr(ast.InitExpr{
									typ:    ast.Expr(minimal_ident('Hooks', 222))
									fields: [
										ast.FieldInit{
											name:  'cb'
											value: ast.Expr(minimal_ident('struct_cleanup', 223))
										},
									]
									pos:    minimal_pos(222)
								}),
							]
							pos: minimal_pos(221)
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [
								ast.Expr(minimal_ident('items', 224)),
							]
							rhs: [
								ast.Expr(ast.ArrayInitExpr{
									exprs: [
										ast.Expr(minimal_ident('array_cleanup', 225)),
									]
									pos:   minimal_pos(224)
								}),
							]
							pos: minimal_pos(224)
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [
								ast.Expr(minimal_ident('init_items', 226)),
							]
							rhs: [
								ast.Expr(ast.ArrayInitExpr{
									init: ast.Expr(minimal_ident('init_cleanup', 227))
									pos:  minimal_pos(226)
								}),
							]
							pos: minimal_pos(226)
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [
								ast.Expr(minimal_ident('tuple', 228)),
							]
							rhs: [
								ast.Expr(ast.Tuple{
									exprs: [
										ast.Expr(minimal_ident('tuple_cleanup', 229)),
									]
									pos:   minimal_pos(228)
								}),
							]
							pos: minimal_pos(228)
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [
								ast.Expr(minimal_ident('assoc_hook', 230)),
							]
							rhs: [
								ast.Expr(ast.AssocExpr{
									typ:    ast.Expr(minimal_ident('Hooks', 231))
									expr:   ast.Expr(minimal_ident('hook', 232))
									fields: [
										ast.FieldInit{
											name:  'cb'
											value: ast.Expr(minimal_ident('assoc_cleanup', 233))
										},
									]
									pos:    minimal_pos(230)
								}),
							]
							pos: minimal_pos(230)
						}),
						ast.Stmt(ast.AssignStmt{
							op:  .decl_assign
							lhs: [
								ast.Expr(minimal_ident('lookup', 234)),
							]
							rhs: [
								ast.Expr(ast.MapInitExpr{
									keys: [
										ast.Expr(ast.StringLiteral{
											value: 'cleanup'
											pos:   minimal_pos(235)
										}),
									]
									vals: [
										ast.Expr(minimal_ident('map_cleanup', 236)),
									]
									pos:  minimal_pos(234)
								}),
							]
							pos: minimal_pos(234)
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'struct_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(237)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'array_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(238)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'init_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(239)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'tuple_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(240)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'assoc_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(241)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'map_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(242)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_cleanup'
					typ:  ast.FnType{}
					pos:  minimal_pos(243)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[1] as ast.FnDecl, env)
	struct_key := decl_key('main', files[0].stmts[2] as ast.FnDecl, env)
	array_key := decl_key('main', files[0].stmts[3] as ast.FnDecl, env)
	init_key := decl_key('main', files[0].stmts[4] as ast.FnDecl, env)
	tuple_key := decl_key('main', files[0].stmts[5] as ast.FnDecl, env)
	assoc_key := decl_key('main', files[0].stmts[6] as ast.FnDecl, env)
	map_key := decl_key('main', files[0].stmts[7] as ast.FnDecl, env)
	unused_key := decl_key('main', files[0].stmts[8] as ast.FnDecl, env)

	assert used[main_key]
	assert used[struct_key]
	assert used[array_key]
	assert used[init_key]
	assert used[tuple_key]
	assert used[assoc_key]
	assert used[map_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_do_not_treat_c_globals_as_v_functions() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(140)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'touch_c_stdio_globals'
									pos:  minimal_pos(141)
								}
								pos: minimal_pos(141)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/stdio_globals.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'touch_c_stdio_globals'
					typ:   ast.FnType{}
					pos:   minimal_pos(142)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.SelectorExpr{
								lhs: ast.Ident{
									name: 'C'
									pos:  minimal_pos(143)
								}
								rhs: ast.Ident{
									name: 'stdout'
									pos:  minimal_pos(144)
								}
								pos: minimal_pos(144)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.SelectorExpr{
								lhs: ast.Ident{
									name: 'C'
									pos:  minimal_pos(145)
								}
								rhs: ast.Ident{
									name: 'stderr'
									pos:  minimal_pos(146)
								}
								pos: minimal_pos(146)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'os'
			name:  'vlib/os/file.c.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'stdout'
					typ:  ast.FnType{}
					pos:  minimal_pos(147)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'stderr'
					typ:  ast.FnType{}
					pos:  minimal_pos(148)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	touch_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	os_stdout_key := decl_key('os', files[2].stmts[0] as ast.FnDecl, env)
	os_stderr_key := decl_key('os', files[2].stmts[1] as ast.FnDecl, env)

	assert used[main_key]
	assert used[touch_key]
	assert !used[os_stdout_key]
	assert !used[os_stderr_key]
}

fn test_minimal_runtime_roots_do_not_keep_unreached_windows_stdin_crt_helpers() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(160)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('println', 161)
								pos: minimal_pos(161)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/builtin_windows.c.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'println'
					typ:   ast.FnType{}
					pos:   minimal_pos(162)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('write_stdout', 163)
								pos: minimal_pos(163)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'write_stdout'
					typ:  ast.FnType{}
					pos:  minimal_pos(164)
				}),
				ast.Stmt(ast.FnDecl{
					name:  'read_from_std_input_handle'
					typ:   ast.FnType{}
					pos:   minimal_pos(165)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: minimal_c_call('GetStdHandle', 166, [
								ast.Expr(minimal_c_selector('STD_INPUT_HANDLE', 167)),
							])
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'fd_from_crt_handle'
					typ:   ast.FnType{}
					pos:   minimal_pos(168)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: minimal_c_call('_get_osfhandle', 169, [])
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'touch_c_stdin_global'
					typ:   ast.FnType{}
					pos:   minimal_pos(170)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: minimal_c_selector('stdin', 171)
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'os'
			name:  'vlib/os/file.c.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'fread'
					typ:   ast.FnType{}
					pos:   minimal_pos(172)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: minimal_c_call('fread', 173, [])
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  'read_file_chunk'
					typ:   ast.FnType{}
					pos:   minimal_pos(174)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: minimal_ident('fread', 175)
								pos: minimal_pos(175)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'stdin'
					typ:  ast.FnType{}
					pos:  minimal_pos(176)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	println_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	write_stdout_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)
	std_input_handle_key := decl_key('builtin', files[1].stmts[2] as ast.FnDecl, env)
	crt_handle_key := decl_key('builtin', files[1].stmts[3] as ast.FnDecl, env)
	stdin_global_key := decl_key('builtin', files[1].stmts[4] as ast.FnDecl, env)
	fread_key := decl_key('os', files[2].stmts[0] as ast.FnDecl, env)
	read_file_chunk_key := decl_key('os', files[2].stmts[1] as ast.FnDecl, env)
	os_stdin_key := decl_key('os', files[2].stmts[2] as ast.FnDecl, env)

	assert used[main_key]
	assert used[println_key]
	assert used[write_stdout_key]
	assert !used[std_input_handle_key]
	assert !used[crt_handle_key]
	assert !used[stdin_global_key]
	assert !used[fread_key]
	assert !used[read_file_chunk_key]
	assert !used[os_stdin_key]
}

fn test_minimal_runtime_roots_keep_array_push_noscan_wrapper() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(320)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'builtin__array_push_noscan'
									pos:  minimal_pos(321)
								}
								pos: minimal_pos(321)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/array_notd_gcboehm_opt.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'a'
						typ:  ast.Ident{
							name: 'array'
							pos:  minimal_pos(322)
						}
						pos:  minimal_pos(322)
					}
					name:      'push_noscan'
					typ:       ast.FnType{}
					pos:       minimal_pos(323)
					stmts:     [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.SelectorExpr{
									lhs: ast.Ident{
										name: 'a'
										pos:  minimal_pos(324)
									}
									rhs: ast.Ident{
										name: 'push'
										pos:  minimal_pos(327)
									}
									pos: minimal_pos(327)
								}
								pos: minimal_pos(327)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'a'
						typ:  ast.Ident{
							name: 'array'
							pos:  minimal_pos(325)
						}
						pos:  minimal_pos(325)
					}
					name:      'push'
					typ:       ast.FnType{}
					pos:       minimal_pos(326)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	push_noscan_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	push_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)
	assert used[push_noscan_key]
	assert used[push_key]
}

fn minimal_array_eq_runtime_dependency_files() []ast.File {
	return [
		ast.File{
			mod:   'main'
			name:  'array_eq_transformed.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(360)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs:  ast.Expr(minimal_ident('array__eq', 360))
								args: [
									ast.Expr(minimal_ident('path', 361)),
									ast.Expr(minimal_ident('expected', 362)),
								]
								pos:  minimal_pos(363)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/map.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'map_map_eq'
					typ:  ast.FnType{}
					pos:  minimal_pos(364)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'map_clone_string'
					typ:  ast.FnType{}
					pos:  minimal_pos(365)
				}),
			]
		},
	]
}

fn minimal_array_eq_runtime_dependency_env() &types.Environment {
	return types.Environment.new()
}

fn test_minimal_runtime_roots_transformed_array_eq_keeps_map_map_eq_dependency_legacy() {
	mut env := minimal_array_eq_runtime_dependency_env()
	files := minimal_array_eq_runtime_dependency_files()
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	map_map_eq_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	unused_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)

	assert used[map_map_eq_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_transformed_array_eq_keeps_map_map_eq_dependency_flat() {
	mut env := minimal_array_eq_runtime_dependency_env()
	files := minimal_array_eq_runtime_dependency_files()
	used := mark_used_flat_minimal(files, env)
	map_map_eq_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	unused_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)

	assert used[map_map_eq_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_do_not_seed_array_rune_string_helper_or_generic_array_methods() {
	mut env := types.Environment.new()
	array_rune_type := ast.Expr(ast.Type(ast.ArrayType{
		elem_type: ast.Expr(ast.Ident{
			name: 'rune'
			pos:  minimal_pos(430)
		})
	}))
	files := [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'main'
					typ:  ast.FnType{}
					pos:  minimal_pos(431)
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/rune.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'arr'
						typ:  ast.Expr(ast.Ident{
							name: 'array'
							pos:  minimal_pos(440)
						})
						pos:  minimal_pos(441)
					}
					name:      'string'
					typ:       ast.FnType{}
					pos:       minimal_pos(442)
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'ra'
						typ:  array_rune_type
						pos:  minimal_pos(432)
					}
					name:      'string'
					typ:       ast.FnType{}
					pos:       minimal_pos(433)
					stmts:     [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'strings__new_builder'
									pos:  minimal_pos(434)
								}
								pos: minimal_pos(434)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'sa'
						typ:  ast.Expr(ast.Type(ast.ArrayType{
							elem_type: ast.Expr(ast.Ident{
								name: 'string'
								pos:  minimal_pos(443)
							})
						}))
						pos:  minimal_pos(444)
					}
					name:      'string'
					typ:       ast.FnType{}
					pos:       minimal_pos(445)
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'sa'
						typ:  ast.Expr(ast.Type(ast.ArrayType{
							elem_type: ast.Expr(ast.Ident{
								name: 'string'
								pos:  minimal_pos(446)
							})
						}))
						pos:  minimal_pos(447)
					}
					name:      'str'
					typ:       ast.FnType{}
					pos:       minimal_pos(448)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_rune_helper'
					typ:  ast.FnType{}
					pos:  minimal_pos(435)
				}),
			]
		},
		ast.File{
			mod:   'strings'
			name:  'vlib/strings/builder.c.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'new_builder'
					typ:   ast.FnType{}
					pos:   minimal_pos(436)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'prepare_builder'
									pos:  minimal_pos(437)
								}
								pos: minimal_pos(437)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'prepare_builder'
					typ:  ast.FnType{}
					pos:  minimal_pos(438)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused_builder'
					typ:  ast.FnType{}
					pos:  minimal_pos(439)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	generic_array_string_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	array_rune_string_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)
	array_string_string_key := decl_key('builtin', files[1].stmts[2] as ast.FnDecl, env)
	array_string_str_key := decl_key('builtin', files[1].stmts[3] as ast.FnDecl, env)
	unused_rune_helper_key := decl_key('builtin', files[1].stmts[4] as ast.FnDecl, env)
	new_builder_key := decl_key('strings', files[2].stmts[0] as ast.FnDecl, env)
	prepare_builder_key := decl_key('strings', files[2].stmts[1] as ast.FnDecl, env)
	unused_builder_key := decl_key('strings', files[2].stmts[2] as ast.FnDecl, env)

	assert used[main_key]
	assert !used[generic_array_string_key]
	assert !used[array_rune_string_key]
	assert !used[array_string_string_key]
	assert !used[array_string_str_key]
	assert !used[new_builder_key]
	assert !used[prepare_builder_key]
	assert !used[unused_rune_helper_key]
	assert !used[unused_builder_key]
}

fn array_rune_string_free_exact_target_files() []ast.File {
	return [
		ast.File{
			mod:   'main'
			name:  'main.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(500)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'builtin__Array_rune__string'
									pos:  minimal_pos(501)
								}
								pos: minimal_pos(501)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'builtin'
			name:  'vlib/builtin/rune.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'ra'
						typ:  ast.Expr(ast.Type(ast.ArrayType{
							elem_type: ast.Expr(ast.Ident{
								name: 'rune'
								pos:  minimal_pos(502)
							})
						}))
						pos:  minimal_pos(503)
					}
					name:      'string'
					typ:       ast.FnType{}
					pos:       minimal_pos(504)
					stmts:     [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'strings__Builder__free'
									pos:  minimal_pos(505)
								}
								pos: minimal_pos(505)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'a'
						typ:  ast.Expr(ast.Ident{
							name: 'array'
							pos:  minimal_pos(506)
						})
						pos:  minimal_pos(507)
					}
					name:      'free'
					typ:       ast.FnType{}
					pos:       minimal_pos(508)
				}),
			]
		},
		ast.File{
			mod:   'strings'
			name:  'vlib/strings/builder.v'
			stmts: [
				ast.Stmt(ast.StructDecl{
					name: 'Builder'
				}),
				ast.Stmt(ast.FnDecl{
					is_method: true
					receiver:  ast.Parameter{
						name: 'b'
						typ:  ast.Expr(ast.SelectorExpr{
							lhs: ast.Ident{
								name: 'strings'
								pos:  minimal_pos(509)
							}
							rhs: ast.Ident{
								name: 'Builder'
								pos:  minimal_pos(510)
							}
							pos: minimal_pos(509)
						})
						pos:  minimal_pos(511)
					}
					name:      'free'
					typ:       ast.FnType{}
					pos:       minimal_pos(512)
				}),
			]
		},
	]
}

fn assert_array_rune_string_marks_exact_builder_free(used map[string]bool, files []ast.File, env &types.Environment, label string) {
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	array_rune_string_key := decl_key('builtin', files[1].stmts[0] as ast.FnDecl, env)
	array_free_key := decl_key('builtin', files[1].stmts[1] as ast.FnDecl, env)
	builder_free_key := decl_key('strings', files[2].stmts[1] as ast.FnDecl, env)

	assert used[main_key], '${label}: main root was not kept'
	assert used[array_rune_string_key], '${label}: Array_rune.string was not reached'
	assert used[builder_free_key], '${label}: exact strings__Builder__free target was pruned'
	assert !used[array_free_key], '${label}: array__free alias replaced the exact Builder.free target'
}

fn test_minimal_runtime_roots_array_rune_string_keeps_exact_builder_free_legacy() {
	mut env := types.Environment.new()
	files := array_rune_string_free_exact_target_files()
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	assert_array_rune_string_marks_exact_builder_free(used, files, env, 'legacy')
}

fn test_minimal_runtime_roots_array_rune_string_keeps_exact_builder_free_flat() {
	mut env := types.Environment.new()
	files := array_rune_string_free_exact_target_files()
	used := mark_used_flat_minimal(files, env)
	assert_array_rune_string_marks_exact_builder_free(used, files, env, 'flat')
}

fn test_minimal_runtime_roots_keep_synthesized_import_init_calls() {
	mut env := types.Environment.new()
	files := [
		ast.File{
			mod:     'main'
			name:    'main.v'
			imports: [
				ast.ImportStmt{
					name: 'dep'
				},
			]
			stmts:   [
				ast.Stmt(ast.FnDecl{
					name:  'main'
					typ:   ast.FnType{}
					pos:   minimal_pos(220)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'dep__init'
									pos:  minimal_pos(221)
								}
								pos: minimal_pos(221)
							}
						}),
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'dep____v_init_consts_dep'
									pos:  minimal_pos(222)
								}
								pos: minimal_pos(222)
							}
						}),
					]
				}),
			]
		},
		ast.File{
			mod:   'dep'
			name:  'dep.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name:  'init'
					typ:   ast.FnType{}
					pos:   minimal_pos(223)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'touch'
									pos:  minimal_pos(224)
								}
								pos: minimal_pos(224)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name:  '__v_init_consts_dep'
					typ:   ast.FnType{}
					pos:   minimal_pos(225)
					stmts: [
						ast.Stmt(ast.ExprStmt{
							expr: ast.CallExpr{
								lhs: ast.Ident{
									name: 'make_value'
									pos:  minimal_pos(226)
								}
								pos: minimal_pos(226)
							}
						}),
					]
				}),
				ast.Stmt(ast.FnDecl{
					name: 'touch'
					typ:  ast.FnType{}
					pos:  minimal_pos(227)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'make_value'
					typ:  ast.FnType{}
					pos:  minimal_pos(228)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'unused'
					typ:  ast.FnType{}
					pos:  minimal_pos(229)
				}),
			]
		},
	]
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})
	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	dep_init_key := decl_key('dep', files[1].stmts[0] as ast.FnDecl, env)
	dep_const_init_key := decl_key('dep', files[1].stmts[1] as ast.FnDecl, env)
	touch_key := decl_key('dep', files[1].stmts[2] as ast.FnDecl, env)
	make_value_key := decl_key('dep', files[1].stmts[3] as ast.FnDecl, env)
	unused_key := decl_key('dep', files[1].stmts[4] as ast.FnDecl, env)

	assert used[main_key]
	assert used[dep_init_key]
	assert used[dep_const_init_key]
	assert used[touch_key]
	assert used[make_value_key]
	assert !used[unused_key]
}

fn test_minimal_runtime_roots_do_not_seed_forbidden_imports() {
	mut env := types.Environment.new()
	forbidden_modules := ['os', 'time', 'io', 'dl', 'sha256', 'binary']
	mut imports := []ast.ImportStmt{cap: forbidden_modules.len}
	for mod_name in forbidden_modules {
		imports << ast.ImportStmt{
			name: mod_name
		}
	}
	mut files := [
		ast.File{
			mod:     'main'
			name:    'main.v'
			imports: imports
			stmts:   [
				ast.Stmt(ast.FnDecl{
					name: 'main'
					typ:  ast.FnType{}
					pos:  minimal_pos(320)
				}),
			]
		},
	]
	for i, mod_name in forbidden_modules {
		files << ast.File{
			mod:   mod_name
			name:  '${mod_name}.v'
			stmts: [
				ast.Stmt(ast.FnDecl{
					name: 'init'
					typ:  ast.FnType{}
					pos:  minimal_pos(330 + i * 10)
				}),
				ast.Stmt(ast.FnDecl{
					name: '__v_init_consts_${mod_name}'
					typ:  ast.FnType{}
					pos:  minimal_pos(331 + i * 10)
				}),
				ast.Stmt(ast.FnDecl{
					name: 'runtime_entry'
					typ:  ast.FnType{}
					pos:  minimal_pos(332 + i * 10)
				}),
			]
		}
	}
	used := mark_used_with_options(files, env, MarkUsedOptions{
		minimal_runtime_roots: true
	})

	main_key := decl_key('main', files[0].stmts[0] as ast.FnDecl, env)
	assert used[main_key]
	for file_idx in 1 .. files.len {
		mod_name := files[file_idx].mod
		init_key := decl_key(mod_name, files[file_idx].stmts[0] as ast.FnDecl, env)
		const_init_key := decl_key(mod_name, files[file_idx].stmts[1] as ast.FnDecl, env)
		runtime_entry_key := decl_key(mod_name, files[file_idx].stmts[2] as ast.FnDecl, env)
		assert !used[init_key], '${mod_name}.init must not be a minimal root'
		assert !used[const_init_key], '${mod_name} const init must not be a minimal root'
		assert !used[runtime_entry_key], '${mod_name}.runtime_entry must not be a minimal root'
	}
}