import os
import v3.flat
import v3.gen.c as cgen
import v3.markused
import v3.parser
import v3.pref
import v3.transform
import v3.types

const vexe = @VEXE
const tests_dir = os.dir(@FILE)
const v3_dir = os.dir(tests_dir)
const vlib_dir = os.dir(v3_dir)
const v3_src = os.join_path(v3_dir, 'v3.v')

// parse_checked_source reads parse checked source input for v3 tests.
fn parse_checked_source(name string, source string) (&flat.FlatAst, &types.TypeChecker) {
    src := os.join_path(os.temp_dir(), 'v3_markused_${name}.v')
    os.write_file(src, source) or { panic(err) }
    prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    mut a := p.parse_file(src)
    mut tc := types.TypeChecker.new(a)
    tc.collect(a)
    tc.diagnose_unknown_calls = true
    tc.diagnostic_files[src] = true
    tc.check_semantics()
    assert tc.errors.len == 0, tc.errors.str()
    return a, &tc
}

fn parse_checked_project(name string, files map[string]string, main_file string) (&flat.FlatAst, &types.TypeChecker) {
    root := os.join_path(os.temp_dir(), 'v3_markused_${name}')
    os.rmdir_all(root) or {}
    for rel, source in files {
        path := os.join_path(root, rel)
        os.mkdir_all(os.dir(path)) or { panic(err) }
        os.write_file(path, source) or { panic(err) }
    }
    mut paths := []string{}
    if main_file.len > 0 {
        paths << os.join_path(root, main_file)
    }
    mut rel_paths := []string{}
    for rel, _ in files {
        if rel != main_file {
            rel_paths << rel
        }
    }
    rel_paths.sort()
    for rel in rel_paths {
        paths << os.join_path(root, rel)
    }
    prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    mut a := p.parse_files(paths)
    mut tc := types.TypeChecker.new(a)
    tc.collect(a)
    tc.diagnose_unknown_calls = true
    for path in paths {
        tc.diagnostic_files[path] = true
    }
    tc.check_semantics()
    assert tc.errors.len == 0, tc.errors.str()
    return a, &tc
}

fn parse_checked_project_in_order(name string, rels []string, sources []string) (&flat.FlatAst, &types.TypeChecker) {
    root := os.join_path(os.temp_dir(), 'v3_markused_${name}')
    os.rmdir_all(root) or {}
    mut paths := []string{}
    for i, rel in rels {
        path := os.join_path(root, rel)
        os.mkdir_all(os.dir(path)) or { panic(err) }
        os.write_file(path, sources[i]) or { panic(err) }
        paths << path
    }
    prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    mut a := p.parse_files(paths)
    mut tc := types.TypeChecker.new(a)
    tc.collect(a)
    tc.diagnose_unknown_calls = true
    for path in paths {
        tc.diagnostic_files[path] = true
    }
    tc.check_semantics()
    assert tc.errors.len == 0, tc.errors.str()
    return a, &tc
}

// mark_used_source updates mark used source state for v3 tests.
fn mark_used_source(name string, source string) map[string]bool {
    a, tc := parse_checked_source(name, source)
    return markused.mark_used(a, tc)
}

// build_v3_bin builds v3 bin data for v3 tests.
fn build_v3_bin(name string) string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_markused_${name}')
    build :=
        os.execute('${vexe} -gc none -path "${vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

// test_map_literals_seed_new_map_runtime_helper validates this v3 regression case.
fn test_map_literals_seed_new_map_runtime_helper() {
    used := mark_used_source('map_literal_new_map', '
fn make_map() map[string]int {
    return map[string]int{}
}

fn main() {
    _ := make_map()
}
')
    assert used['new_map']
}

// test_optional_map_or_seeds_new_map_runtime_helper validates this v3 regression case.
fn test_optional_map_or_seeds_new_map_runtime_helper() {
    used := mark_used_source('option_map_or_new_map', '
fn maybe_map() ?map[string]int {
    return none
}

fn main() {
    m := maybe_map() or { return }
    _ := m
}
')
    assert used['new_map']
}

// test_string_membership_seeds_contains_runtime_helpers validates this v3 regression case.
fn test_string_membership_seeds_contains_runtime_helpers() {
    used := mark_used_source('string_membership_contains', '
fn has_needle() bool {
    return "bc" in "abcd"
}

fn main() {
    _ := has_needle()
}
')
    assert used['string__contains']
    assert used['string__contains_u8']
}

// test_string_interpolation_seeds_string_plus_and_formatter_helpers
// validates this v3 regression case.
fn test_string_interpolation_seeds_string_plus_and_formatter_helpers() {
    used := mark_used_source('string_interp_plus_formatter', '
fn message(name string) string {
    return "hello \${name} \${true}"
}

fn main() {
    _ := message("v")
}
')
    assert used['string__plus']
    assert used['bool.str']
}

// test_print_bool_seeds_formatter_runtime_helper validates this v3 regression case.
fn test_print_bool_seeds_formatter_runtime_helper() {
    used := mark_used_source('print_bool_formatter', '
fn println(s string) {}

fn main() {
    println(true)
}
')
    assert used['bool.str']
}

// test_string_compound_assign_seeds_string_plus_runtime_helper validates this v3 regression case.
fn test_string_compound_assign_seeds_string_plus_runtime_helper() {
    used := mark_used_source('string_plus_assign', '
fn main() {
    mut s := "a"
    s += "b"
    _ := s
}
')
    assert used['string__plus']
}

fn test_moduleless_export_after_module_file_is_rooted() {
    a, tc := parse_checked_project_in_order('moduleless_export_after_module', [
        'helper/helper.v',
        'lonely.v',
    ], ['module helper

pub fn helper_marker() int {
    return 1
}
', "@[export: 'raw_lonely']
fn lonely() int {
    return 7
}
"])
    used := markused.mark_used(a, tc)
    assert used['lonely']
}

fn test_receiver_method_call_in_selector_assign_rhs_is_used() {
    used := mark_used_source('receiver_method_selector_assign_rhs', '
struct Builder {
mut:
    name string
}

fn (b &Builder) main_module_name() string {
    return "main"
}

fn build_with_options() string {
    mut b := Builder{}
    b.name = b.main_module_name()
    return b.name
}

fn main() {
    _ := build_with_options()
}
')
    assert used['Builder.main_module_name']
}

fn test_unreachable_interface_implementer_method_is_not_rooted() {
    used := mark_used_source('unreachable_interface_implementer', '
interface Reader {
    read() int
}

struct File {}

fn (f File) read() int {
    return 1
}

fn main() {}
')
    assert !used['File.read']
}

fn test_reachable_interface_dispatch_keeps_implementer_method() {
    used := mark_used_source('reachable_interface_dispatch', '
interface Reader {
    read() int
}

struct File {}

fn (f File) read() int {
    return 1
}

fn call_reader(r Reader) int {
    return r.read()
}

fn main() {
    _ := call_reader(File{})
}
')
    assert used['File.read']
}

fn test_global_interface_dispatch_keeps_implementer_method() {
    used := mark_used_source('global_interface_dispatch', '
interface Reader {
    read() int
}

struct File {}

__global default_reader &Reader

fn (f File) read() int {
    return 1
}

fn call_default_reader() int {
    return default_reader.read()
}

fn main() {
    _ := call_default_reader()
}
')
    assert used['Reader.read']
    assert used['File.read']
}

fn test_unreachable_interface_dispatch_stub_is_not_emitted_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('unreachable_interface_dispatch_cgen', '
interface Reader {
    read() int
}

struct File {}

fn (f File) read() int {
    return 1
}

fn main() {}
')
    mut used := markused.mark_used(a, tc)
    assert !used['Reader.read']
    assert !used['File.read']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert !c_code.contains('Reader__read(')
}

fn test_short_interface_dispatch_does_not_emit_imported_name_collision_stub() {
    mut a, mut tc := parse_checked_project('interface_dispatch_name_collision', {
        'main.v':      'module main

import moda

interface Reader {
    read() int
}

struct Local {}

fn (l Local) read() int {
    return 1
}

fn call_reader(r Reader) int {
    return r.read()
}

fn main() {
    _ := call_reader(Local{})
}
'
        'moda/moda.v': 'module moda

interface Reader {
    read(path string) string
}

struct Remote {}

fn (r Remote) read(path string) string {
    return path
}
'
    }, 'main.v')
    mut used := markused.mark_used(a, tc)
    assert used['Reader.read']
    assert !used['moda.Reader.read']
    assert !used['moda.Remote.read']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('Reader__read(')
    assert !c_code.contains('moda__Reader__read(')
}

fn test_local_receiver_method_does_not_root_imported_interface_by_short_name() {
    mut a, mut tc := parse_checked_project('local_receiver_imported_interface_short_name', {
        'main.v':      'module main

import moda

struct Reader {}

fn (r Reader) read() int {
    return 1
}

fn main() {
    _ := Reader{}.read()
}
'
        'moda/moda.v': 'module moda

pub interface Reader {
    read() int
}

pub struct Remote {}

pub fn (r Remote) read() int {
    return 2
}
'
    }, 'main.v')
    mut used := markused.mark_used(a, tc)
    assert used['Reader.read']
    assert !used['moda.Reader.read']
    assert !used['moda.Remote.read']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('Reader__read(')
    assert !c_code.contains('moda__Reader__read(')
    assert !c_code.contains('moda__Remote__read(')
}

fn test_imported_interface_dispatch_is_emitted_when_exactly_used() {
    mut a, mut tc := parse_checked_project('imported_interface_dispatch_used', {
        'main.v':      'module main

import moda

fn call_reader(r moda.Reader) string {
    return r.read("ok")
}

fn main() {
    _ := call_reader(moda.Remote{})
}
'
        'moda/moda.v': 'module moda

pub interface Reader {
    read(path string) string
}

pub struct Remote {}

pub fn (r Remote) read(path string) string {
    return path
}
'
    }, 'main.v')
    mut used := markused.mark_used(a, tc)
    assert used['moda.Reader.read']
    assert used['moda.Remote.read']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('moda__Reader__read(')
    assert c_code.contains('moda__Remote__read(')
}

fn test_interface_dispatch_target_does_not_use_bare_method_key_for_imported_homonym() {
    mut a, mut tc := parse_checked_project('interface_dispatch_target_homonym', {
        'main.v':      'module main

import moda

interface Reader {
    read() int
}

struct Local {}

fn (l Local) read() int {
    return 1
}

fn read() int {
    return 9
}

fn call_reader(r Reader) int {
    return r.read()
}

fn main() {
    _ := read()
    _ := call_reader(Local{})
}
'
        'moda/moda.v': 'module moda

pub struct Remote {}

pub fn (r Remote) read() int {
    return 2
}
'
    }, 'main.v')
    mut used := markused.mark_used(a, tc)
    assert used['read']
    assert used['Reader.read']
    used.delete('moda.Remote.read')
    used.delete('Remote.read')
    used.delete('moda__Remote__read')
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('Reader__read(')
    assert !c_code.contains('moda__Remote__read(')
}

fn test_unused_main_method_with_interface_dispatch_is_pruned_with_stub() {
    mut a, mut tc := parse_checked_source('unused_main_method_interface_dispatch_cgen', '
interface Reader {
    read() int
}

struct File {}

fn (f File) read() int {
    return 1
}

struct X {}

fn (x X) unused(r Reader) int {
    return r.read()
}

fn main() {}
')
    mut used := markused.mark_used(a, tc)
    assert !used['X.unused']
    assert !used['Reader.read']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert !c_code.contains('X__unused(')
    assert !c_code.contains('Reader__read(')
}

fn test_unused_main_helper_with_method_call_is_pruned_with_method() {
    mut a, mut tc := parse_checked_source('unused_main_helper_method_call_cgen',
        'module main\n\nstruct X {}\n\nfn (x X) m() int {\n\treturn 1\n}\n\nfn helper() int {\n\treturn X{}.m()\n}\n\nfn main() {}\n')
    mut used := markused.mark_used(a, tc)
    assert !used['helper']
    assert !used['X.m']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert !c_code.contains('helper(')
    assert !c_code.contains('X__m(')
}

fn test_reachable_main_fn_literal_is_emitted_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('reachable_main_fn_literal_cgen',
        'module main\n\nfn callback_value(cb fn () int) int {\n\treturn cb()\n}\n\nfn main() {\n\t_ := callback_value(fn () int {\n\t\treturn 7\n\t})\n}\n')
    mut used := markused.mark_used(a, tc)
    assert used['callback_value']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('int __anon_fn_')
    assert c_code.contains('callback_value(__anon_fn_')
}

fn test_top_level_fn_value_roots_helper() {
    mut a, mut tc := parse_checked_source('top_level_fn_value_helper_cgen',
        'module main\n\nfn helper() int {\n\treturn 41\n}\n\nf := helper\nprintln(int_str(f() + 1))\n')
    mut used := markused.mark_used(a, tc)
    assert used['helper']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('helper(')
}

fn test_top_level_fn_value_compile_keeps_helper() {
    v3_bin := build_v3_bin('top_level_fn_value_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_top_level_fn_value_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_top_level_fn_value_input')
    os.write_file(src, '
fn helper() int {
    return 41
}

f := helper
println(int_str(f() + 1))
') or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
    run := os.execute(bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == '42'
    c_code := os.read_file(bin + '.c') or { panic(err) }
    assert c_code.contains('helper('), c_code
}

fn test_top_level_fn_value_respects_prior_local_shadow() {
    used := mark_used_source('top_level_fn_value_prior_shadow', '
fn helper() int {
    return 1
}

helper := 10
f := helper
println(int_str(f))
')
    assert !used['helper']
}

fn test_local_fn_value_keeps_helper_before_future_local_shadow() {
    used := mark_used_source('local_fn_value_future_shadow', '
fn cb() int {
    return 1
}

fn takes(f fn () int) int {
    return f()
}

fn main() {
    takes(cb)
    cb := 0
    _ = cb
}
')
    assert used['cb']
}

fn test_local_ident_reference_does_not_root_dead_function() {
    mut a, mut tc := parse_checked_source('local_ident_shadow_dead_fn_cgen', '
fn C.v3_dead_local_shadow_should_not_link() int

fn unused() int {
    return C.v3_dead_local_shadow_should_not_link()
}

fn echo(unused int) int {
    println(unused)
    return unused
}

fn main() {
    unused := 1
    println(unused)
    _ := echo(unused)
}
')
    mut used := markused.mark_used(a, tc)
    assert !used['unused']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert !c_code.contains('unused('), c_code
    assert !c_code.contains('v3_dead_local_shadow_should_not_link'), c_code
}

fn test_local_fn_value_call_does_not_root_shadowed_dead_function() {
    mut a, mut tc := parse_checked_source('local_fn_value_shadow_dead_fn_cgen', '
fn C.v3_dead_local_fn_value_shadow_should_not_link() int

fn unused() int {
    return C.v3_dead_local_fn_value_shadow_should_not_link()
}

fn used() int {
    return 7
}

fn main() {
    unused := used
    println(unused())
}
')
    mut used := markused.mark_used(a, tc)
    assert used['used']
    assert !used['unused']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('used('), c_code
    assert !c_code.contains('int unused(void)'), c_code
    assert !c_code.contains('v3_dead_local_fn_value_shadow_should_not_link'), c_code
}

fn test_flag_default_value_lowering_keeps_escape_helper() {
    mut a, mut tc := parse_checked_source('flag_default_value_escape_helper_cgen',
        'module main\n\nfn escape_default_string(value string) string {\n\treturn value\n}\n\nfn flag_default_value(value string) string {\n\treturn value\n}\n\nfn main() {\n\t_ := flag_default_value("abc")\n}\n')
    mut used := markused.mark_used(a, tc)
    assert used['escape_default_string']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('escape_default_string(')
}

// test_return_local_address_seeds_memdup_runtime_helper validates this v3 regression case.
fn test_return_local_address_seeds_memdup_runtime_helper() {
    used := mark_used_source('return_local_address_memdup', '
struct Box {
    x int
}

fn make_box() &Box {
    b := Box{
        x: 1
    }
    return &b
}

fn main() {
    _ := make_box()
}
')
    assert used['memdup']
}

// test_map_literals_lower_to_new_map_after_used_filter_transform validates this v3 regression case.
fn test_map_literals_lower_to_new_map_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('map_literal_new_map_cgen', '
fn make_map() map[string]int {
    return map[string]int{}
}

fn main() {
    _ := make_map()
}
')
    mut used := markused.mark_used(a, tc)
    assert used['new_map']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('new_map(sizeof(string), sizeof(int)')
}

// test_optional_map_or_lowers_to_new_map_after_used_filter_transform
// validates this v3 regression case.
fn test_optional_map_or_lowers_to_new_map_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('option_map_or_new_map_cgen', '
fn maybe_map() ?map[string]int {
    return none
}

fn main() {
    m := maybe_map() or { return }
    _ := m
}
')
    mut used := markused.mark_used(a, tc)
    assert used['new_map']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('new_map(sizeof(string), sizeof(int)')
}

// test_string_membership_lowers_to_contains_after_used_filter_transform
// validates this v3 regression case.
fn test_string_membership_lowers_to_contains_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('string_membership_contains_cgen', '
fn has_needle() bool {
    return "bc" in "abcd"
}

fn main() {
    _ := has_needle()
}
')
    mut used := markused.mark_used(a, tc)
    assert used['string__contains']
    assert used['string__contains_u8']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('string__contains(')
}

// test_string_compound_assign_lowers_to_plus_after_used_filter_transform
// validates this v3 regression case.
fn test_string_compound_assign_lowers_to_plus_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('string_plus_assign_cgen', '
fn main() {
    mut s := "a"
    s += "b"
    _ := s
}
')
    mut used := markused.mark_used(a, tc)
    assert used['string__plus']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('string__plus(')
}

// test_string_interpolation_lowers_to_formatter_after_used_filter_transform
// validates this v3 regression case.
fn test_string_interpolation_lowers_to_formatter_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('string_interp_formatter_cgen', '
fn main() {
    _ := "\${true}"
}
')
    mut used := markused.mark_used(a, tc)
    assert used['bool.str']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('bool__str(')
}

// test_print_bool_lowers_to_formatter_after_used_filter_transform
// validates this v3 regression case.
fn test_print_bool_lowers_to_formatter_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('print_bool_formatter_cgen', '
fn println(s string) {}

fn main() {
    println(true)
}
')
    mut used := markused.mark_used(a, tc)
    assert used['bool.str']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('bool__str(')
}

// test_return_local_address_lowers_to_memdup_after_used_filter_transform
// validates this v3 regression case.
fn test_return_local_address_lowers_to_memdup_after_used_filter_transform() {
    mut a, mut tc := parse_checked_source('return_local_address_memdup_cgen', '
struct Box {
    x int
}

fn make_box() &Box {
    b := Box{
        x: 1
    }
    return &b
}

fn main() {
    _ := make_box()
}
')
    mut used := markused.mark_used(a, tc)
    assert used['memdup']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('memdup(')
}

// test_map_literal_compile_keeps_new_map_runtime_helper validates this v3 regression case.
fn test_map_literal_compile_keeps_new_map_runtime_helper() {
    v3_bin := build_v3_bin('map_literal_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_map_literal_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_map_literal_input')
    os.write_file(src, '
fn make_map() map[string]int {
    return map[string]int{}
}

fn main() {
    _ := make_map()
}
') or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
}

// test_optional_map_or_compile_keeps_new_map_runtime_helper validates this v3 regression case.
fn test_optional_map_or_compile_keeps_new_map_runtime_helper() {
    v3_bin := build_v3_bin('option_map_or_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_option_map_or_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_option_map_or_input')
    os.write_file(src, '
fn maybe_map() ?map[string]int {
    return none
}

fn main() {
    m := maybe_map() or { return }
    _ := m
}
') or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
}

// test_return_local_address_compile_keeps_memdup_runtime_helper validates this v3 regression case.
fn test_return_local_address_compile_keeps_memdup_runtime_helper() {
    v3_bin := build_v3_bin('return_local_address_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_return_local_address_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_return_local_address_input')
    os.write_file(src, '
struct Box {
    x int
}

fn make_box() &Box {
    b := Box{
        x: 1
    }
    return &b
}

fn main() {
    _ := make_box()
}
') or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
}

// test_print_bool_compile_keeps_formatter_runtime_helper validates this v3 regression case.
fn test_print_bool_compile_keeps_formatter_runtime_helper() {
    v3_bin := build_v3_bin('print_bool_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_print_bool_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_print_bool_input')
    os.write_file(src, '
fn main() {
    println(true)
}
') or { panic(err) }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
}

// test_print_signed_width_compile_keeps_str_runtime_helpers validates this v3 regression case.
fn test_print_signed_width_compile_keeps_str_runtime_helpers() {
    v3_bin := build_v3_bin('print_signed_width_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_print_signed_width_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_print_signed_width_input')
    os.write_file(src, "
fn main() {
    println(i8(-5))
    println(i16(-300))
    println(i32(-70000))
    println(i64(-5000000000))
    println('\${i64(42)}')
}
") or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
    assert !compile.output.contains('implicit declaration'), compile.output
    run := os.execute(bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == '-5\n-300\n-70000\n-5000000000\n42', run.output
}

// test_string_plus_compile_keeps_plus_runtime_helper validates this v3 regression case.
fn test_string_plus_compile_keeps_plus_runtime_helper() {
    v3_bin := build_v3_bin('string_plus_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_string_plus_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_string_plus_input')
    os.write_file(src, '
fn main() {
    flag := true
    mut s := "a"
    s += "\${flag}"
    _ := s
}
') or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
}

// test_string_membership_compile_keeps_contains_runtime_helpers validates this v3 regression case.
fn test_string_membership_compile_keeps_contains_runtime_helpers() {
    v3_bin := build_v3_bin('string_membership_test')

    src := os.join_path(os.temp_dir(), 'v3_markused_string_membership_input.v')
    bin := os.join_path(os.temp_dir(), 'v3_markused_string_membership_input')
    os.write_file(src, '
fn has_needle() bool {
    return "bc" in "abcd"
}

fn main() {
    _ := has_needle()
}
') or {
        panic(err)
    }
    compile := os.execute('${v3_bin} -o ${bin} ${src}')
    assert compile.exit_code == 0, compile.output
}