module builder

import os
import v2.abi
import v2.ast
import v2.gen.x64
import v2.pref

fn test_native_x64_windows_selects_coff_and_windows_abi() {
    assert is_windows_x64_native_target(.x64, 'windows')
    assert native_x64_object_format_for_os('windows') == x64.ObjectFormat.coff
    assert native_x64_codegen_abi_for_os('windows') == x64.X64Abi.windows
    assert native_x64_lowering_abi_for_os('windows') == abi.X64Abi.windows
}

fn test_native_x64_non_windows_keeps_existing_object_formats_and_sysv() {
    assert !is_windows_x64_native_target(.x64, 'linux')
    assert native_x64_object_format_for_os('linux') == x64.ObjectFormat.elf
    assert native_x64_codegen_abi_for_os('linux') == x64.X64Abi.sysv
    assert native_x64_lowering_abi_for_os('linux') == abi.X64Abi.sysv

    assert !is_windows_x64_native_target(.x64, 'macos')
    assert native_x64_object_format_for_os('macos') == x64.ObjectFormat.macho
    assert native_x64_codegen_abi_for_os('macos') == x64.X64Abi.sysv
    assert native_x64_lowering_abi_for_os('macos') == abi.X64Abi.sysv
    assert is_macos_native_target('macos')
    assert is_macos_native_target('darwin')
    assert native_x64_object_format_for_os('darwin') == x64.ObjectFormat.macho
    assert native_x64_codegen_abi_for_os('darwin') == x64.X64Abi.sysv
    assert native_x64_lowering_abi_for_os('darwin') == abi.X64Abi.sysv
}

fn test_minimal_x64_runtime_and_macos_tiny_object_targets() {
    old_linux_tiny := os.getenv_opt('V2_X64_LINUX_TINY')
    os.unsetenv('V2_X64_LINUX_TINY')
    defer {
        if old := old_linux_tiny {
            os.setenv('V2_X64_LINUX_TINY', old, true)
        } else {
            os.unsetenv('V2_X64_LINUX_TINY')
        }
    }

    mut prefs := pref.new_preferences()
    prefs.backend = .x64
    prefs.arch = .x64

    prefs.target_os = 'linux'
    linux_builder := new_builder(&prefs)
    assert !linux_builder.uses_minimal_windows_x64_runtime()
    assert linux_builder.uses_minimal_linux_x64_runtime()
    assert linux_builder.uses_minimal_x64_runtime()
    assert !linux_builder.uses_minimal_linux_x64_runtime_roots()
    assert !linux_builder.uses_minimal_x64_runtime_roots()

    os.setenv('V2_X64_LINUX_TINY', '1', true)
    linux_tiny_builder := new_builder(&prefs)
    assert linux_tiny_builder.uses_minimal_linux_x64_runtime()
    assert linux_tiny_builder.uses_minimal_linux_x64_runtime_roots()
    assert linux_tiny_builder.uses_minimal_x64_runtime_roots()
    os.unsetenv('V2_X64_LINUX_TINY')

    prefs.target_os = 'macos'
    macos_builder := new_builder(&prefs)
    assert !macos_builder.uses_minimal_windows_x64_runtime()
    assert !macos_builder.uses_minimal_linux_x64_runtime()
    assert !macos_builder.uses_minimal_x64_runtime()
    assert !macos_builder.uses_minimal_x64_runtime_roots()
    assert macos_builder.uses_macos_x64_tiny_object(.x64)
    assert !macos_builder.uses_macos_x64_tiny_object(.arm64)

    macos_tiny_builder := new_builder(&prefs)
    assert !macos_tiny_builder.uses_minimal_x64_runtime()
    assert !macos_tiny_builder.uses_minimal_x64_runtime_roots()
    assert macos_tiny_builder.uses_macos_x64_tiny_object(.x64)
    assert !macos_tiny_builder.uses_macos_x64_tiny_object(.arm64)

    prefs.macos_tiny = false
    macos_no_tiny_builder := new_builder(&prefs)
    assert !macos_no_tiny_builder.uses_macos_x64_tiny_object(.x64)

    prefs.macos_tiny = true
    prefs.arch = .auto
    macos_auto_arch_builder := new_builder(&prefs)
    assert !macos_auto_arch_builder.uses_minimal_x64_runtime_roots()
    assert macos_auto_arch_builder.uses_macos_x64_tiny_object(.x64)
    assert !macos_auto_arch_builder.uses_macos_x64_tiny_object(.arm64)
    prefs.arch = .x64

    prefs.target_os = 'darwin'
    darwin_builder := new_builder(&prefs)
    assert !darwin_builder.uses_minimal_windows_x64_runtime()
    assert !darwin_builder.uses_minimal_linux_x64_runtime()
    assert !darwin_builder.uses_minimal_x64_runtime()
    assert !darwin_builder.uses_minimal_x64_runtime_roots()
    assert darwin_builder.uses_macos_x64_tiny_object(.x64)

    prefs.target_os = 'windows'
    windows_builder := new_builder(&prefs)
    assert windows_builder.uses_minimal_windows_x64_runtime()
    assert !windows_builder.uses_minimal_linux_x64_runtime()
    assert windows_builder.uses_minimal_x64_runtime()
    assert windows_builder.uses_minimal_x64_runtime_roots()
    assert !windows_builder.uses_macos_x64_tiny_object(.x64)
}

fn test_macos_tiny_candidate_source_snapshot_is_auto_by_default_with_opt_out() {
    mut prefs := pref.new_preferences()
    prefs.backend = .x64
    prefs.arch = .auto
    prefs.target_os = 'macos'

    mut hosted_builder := new_builder(&prefs)
    hosted_builder.files = [
        ast.File{
            mod:  'main'
            name: 'main.v'
        },
    ]
    hosted_builder.prepare_macos_tiny_candidate_source_files()
    assert hosted_builder.macos_tiny_candidate_source_files.len == 1
    assert hosted_builder.macos_tiny_candidate_source_files[0].name == 'main.v'

    prefs.macos_tiny = false
    mut opt_out_builder := new_builder(&prefs)
    opt_out_builder.files = [
        ast.File{
            mod:  'main'
            name: 'main.v'
        },
    ]
    opt_out_builder.prepare_macos_tiny_candidate_source_files()
    assert opt_out_builder.macos_tiny_candidate_source_files.len == 0
    assert !opt_out_builder.uses_minimal_x64_runtime_roots()
}

fn test_macos_tiny_candidate_source_snapshot_uses_flat_when_enabled() {
    mut prefs := pref.new_preferences()
    prefs.backend = .x64
    prefs.arch = .auto
    prefs.target_os = 'macos'

    source_files := [
        ast.File{
            mod:   'main'
            name:  'flat_main.v'
            stmts: [
                ast.Stmt(ast.FnDecl{
                    name: 'main'
                }),
            ]
        },
    ]
    mut tiny_builder := new_builder(&prefs)
    tiny_builder.files = [
        ast.File{
            mod:  'stale'
            name: 'stale.v'
        },
    ]
    tiny_builder.flat = ast.flatten_files(source_files)
    tiny_builder.prepare_macos_tiny_candidate_source_files()
    assert tiny_builder.macos_tiny_candidate_source_files.len == 0
    assert tiny_builder.macos_tiny_candidate_source_flat.files.len == source_files.len
    assert tiny_builder.macos_tiny_candidate_source_flat.file_name(tiny_builder.macos_tiny_candidate_source_flat.files[0]) == 'flat_main.v'
    assert tiny_builder.macos_tiny_candidate_source_flat.string_at(tiny_builder.macos_tiny_candidate_source_flat.files[0].mod_idx) == 'main'
}

fn test_macos_tiny_candidate_native_mir_build_policy_is_sequential_only_for_candidate() {
    mut prefs := pref.new_preferences()
    prefs.backend = .x64
    prefs.arch = .x64
    prefs.target_os = 'macos'
    prefs.no_parallel = false
    prefs.hot_fn = ''
    builder := new_builder(&prefs)

    assert !builder.native_mir_build_sequential('')
    assert builder.native_mir_build_sequential(macos_tiny_candidate_graph_label)

    prefs.no_parallel = true
    no_parallel_builder := new_builder(&prefs)
    assert no_parallel_builder.native_mir_build_sequential('')
}

fn test_macos_tiny_link_command_adds_hygiene_only_for_tiny_object() {
    normal := macos_native_link_command('/tmp/out', 'main.o', '/SDK Path', 'x86_64', false, '')
    tiny := macos_native_link_command('/tmp/out', 'main.o', '/SDK Path', 'x86_64', true, '')

    assert normal == 'ld -o ${os.quoted_path('/tmp/out')} ${os.quoted_path('main.o')} -lSystem -syslibroot ${os.quoted_path('/SDK Path')} -e _main -arch x86_64 -platform_version macos 11.0.0 11.0.0'
    assert tiny == '${normal} -dead_strip -x -S'
    assert !normal.contains('-dead_strip')
    assert !normal.contains(' -x')
    assert !normal.contains(' -S')
}

fn test_macos_sdk_path_from_xcrun_output_accepts_simple_sdk_path() {
    output := '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk\n'
    assert macos_sdk_path_from_xcrun_output(output)! == '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk'
}

fn test_macos_sdk_path_from_xcrun_output_ignores_diagnostics_before_sdk_path() {
    output :=
        '2026-06-07 16:19:11.428 xcodebuild[1002:7567] Requested but did not find extension point\n' +
        '2026-06-07 16:19:14.880 xcodebuild[1004:7681] Requested but did not find extension point\n' +
        '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk\n'
    assert macos_sdk_path_from_xcrun_output(output)! == '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk'
}

fn test_macos_sdk_path_from_xcrun_output_handles_empty_lines_spaces_and_crlf() {
    output := ' \r\n\t\r\n  /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk  \r\n'
    assert macos_sdk_path_from_xcrun_output(output)! == '/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk'
}

fn test_macos_sdk_path_from_xcrun_output_rejects_missing_sdk_path() {
    path := macos_sdk_path_from_xcrun_output('xcodebuild diagnostic only\nnot a path\n') or {
        assert err.msg().contains('could not find a clean macOS SDK path')
        return
    }
    assert false, 'expected missing SDK path error, got ${path}'
}

fn test_macos_sdk_path_from_xcrun_output_preserves_spaces_inside_path() {
    output := '/Applications/Xcode With Spaces.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk\n'
    assert macos_sdk_path_from_xcrun_output(output)! == '/Applications/Xcode With Spaces.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk'
}

fn test_macos_sdk_path_from_xcrun_output_rejects_relative_or_non_macos_sdk_lines() {
    output := 'relative/MacOSX12.3.sdk\n/Applications/Xcode.app/Contents/Developer/SDKs/iPhoneOS.sdk\n/Applications/Xcode.app/Contents/Developer/SDKs/NotMacOSX.sdk\n'
    path := macos_sdk_path_from_xcrun_output(output) or {
        assert err.msg().contains('could not find a clean macOS SDK path')
        return
    }
    assert false, 'expected invalid SDK path lines to be rejected, got ${path}'
}

fn test_macos_sdk_path_from_xcrun_output_uses_last_valid_sdk_line() {
    output := '/Applications/Old.app/Contents/Developer/SDKs/MacOSX11.0.sdk\n' +
        '/Applications/New.app/Contents/Developer/SDKs/MacOSX12.3.sdk\n'
    assert macos_sdk_path_from_xcrun_output(output)! == '/Applications/New.app/Contents/Developer/SDKs/MacOSX12.3.sdk'
}

fn test_validate_macos_sdk_path_for_native_link_accepts_libsystem_tbd() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_macos_sdk_tbd_${os.getpid()}')
    sdk_path := os.join_path(tmp_dir, 'MacOSX.test.sdk')
    lib_dir := os.join_path(sdk_path, 'usr', 'lib')
    os.mkdir_all(lib_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    os.write_file(os.join_path(lib_dir, 'libSystem.tbd'), '') or { panic(err) }
    validate_macos_sdk_path_for_native_link(sdk_path)!
}

fn test_validate_macos_sdk_path_for_native_link_accepts_libsystem_dylib() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_macos_sdk_dylib_${os.getpid()}')
    sdk_path := os.join_path(tmp_dir, 'MacOSX.test.sdk')
    lib_dir := os.join_path(sdk_path, 'usr', 'lib')
    os.mkdir_all(lib_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    os.write_file(os.join_path(lib_dir, 'libSystem.dylib'), '') or { panic(err) }
    validate_macos_sdk_path_for_native_link(sdk_path)!
}

fn test_validate_macos_sdk_path_for_native_link_rejects_sdk_without_libsystem() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_macos_sdk_missing_libsystem_${os.getpid()}')
    sdk_path := os.join_path(tmp_dir, 'MacOSX.test.sdk')
    os.mkdir_all(os.join_path(sdk_path, 'usr', 'lib')) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    validate_macos_sdk_path_for_native_link(sdk_path) or {
        assert err.msg().contains('missing usr/lib/libSystem')
        return
    }
    assert false, 'expected SDK without libSystem to be rejected'
}

fn test_validate_macos_sdk_path_for_native_link_rejects_missing_sdk_dir() {
    missing_sdk := os.join_path(os.vtmp_dir(), 'v2_missing_macos_sdk_${os.getpid()}',
        'MacOSX.test.sdk')
    validate_macos_sdk_path_for_native_link(missing_sdk) or {
        assert err.msg().contains('does not exist')
        return
    }
    assert false, 'expected missing SDK directory to be rejected'
}

fn test_native_link_commands_append_directive_link_flags() {
    linux := linux_native_link_command('cc', '/tmp/out', 'main.o', '-lm')
    macos := macos_native_link_command('/tmp/out', 'main.o', '/SDK Path', 'x86_64', false, '-lm')

    assert linux == 'cc ${os.quoted_path('main.o')} -o ${os.quoted_path('/tmp/out')} -no-pie -lm'
    assert macos == 'ld -o ${os.quoted_path('/tmp/out')} ${os.quoted_path('main.o')} -lm -lSystem -syslibroot ${os.quoted_path('/SDK Path')} -e _main -arch x86_64 -platform_version macos 11.0.0 11.0.0'
}

fn test_linux_native_link_command_uses_configured_driver_and_link_flags() {
    cmd := linux_native_link_command('custom-cc', '/tmp/out', 'main.o', '-fopenmp')

    assert cmd.starts_with('custom-cc ${os.quoted_path('main.o')}'), cmd
    assert cmd.contains('-fopenmp'), cmd
}

fn test_native_link_commands_keep_wl_for_linux_and_translate_for_macos_ld() {
    linux := linux_native_link_command('cc', '/tmp/out', 'main.o', '-Wl,-rpath,/tmp/lib')
    macos := macos_native_link_command('/tmp/out', 'main.o', '/SDK Path', 'x86_64', false,
        '-Wl,-rpath,@loader_path/lib')

    assert linux.contains('-Wl,-rpath,/tmp/lib'), linux
    assert macos.contains(' -rpath @loader_path/lib '), macos
    assert !macos.contains('-Wl,'), macos
}

fn test_native_link_commands_translate_xlinker_for_macos_ld() {
    macos := macos_native_link_command('/tmp/out', 'main.o', '/SDK Path', 'x86_64', false,
        '-Xlinker -rpath -Xlinker @loader_path/lib')

    assert macos.contains(' -rpath @loader_path/lib '), macos
    assert !macos.contains('-Xlinker'), macos
}

fn test_macos_native_link_command_keeps_framework_search_paths() {
    macos := macos_native_link_command('/tmp/out', 'main.o', '/SDK Path', 'x86_64', false,
        '-F /tmp/Fw -F/opt/Fw -framework Foo')

    assert macos.contains(' -F /tmp/Fw -F/opt/Fw -framework Foo '), macos
}

fn test_split_compile_and_link_flags_duplicates_dual_use_driver_flags() {
    compile_flags, link_flags :=
        split_compile_and_link_flags('-I include -fopenmp -fopenmp=libomp -pthread helper.c')

    assert compile_flags == '-I include -fopenmp -fopenmp=libomp -pthread'
    assert link_flags == '-fopenmp -fopenmp=libomp -pthread helper.c'
}

fn test_split_compile_and_link_flags_keeps_framework_search_paths_dual_use() {
    compile_flags, link_flags :=
        split_compile_and_link_flags('-F /tmp/Fw -F/opt/Fw -framework Foo helper.m')

    assert compile_flags == '-F /tmp/Fw -F/opt/Fw'
    assert link_flags == '-F /tmp/Fw -F/opt/Fw -framework Foo helper.m'
}

fn test_macos_native_ld_rejects_dual_use_driver_link_flags() {
    validate_macos_native_ld_link_flags('-lm')!
    validate_macos_native_ld_link_flags('-fopenmp') or {
        assert err.msg().contains('macOS native ld cannot consume driver linker flags'), err.msg()
        return
    }
    assert false, 'expected macOS native ld driver flag diagnostic'
}

fn test_native_linux_tiny_link_allows_runtime_system_libs_when_user_flags_are_empty() {
    assert native_link_flags_allow_builtin_linux_tiny('', '')
    assert native_link_flags_allow_builtin_linux_tiny('   ', '')
    assert native_link_flags_allow_builtin_linux_tiny('-lpthread -lm -ldl -lc', '')
    assert native_link_flags_allow_builtin_linux_tiny('-l pthread -l m -l dl -l c', '')
}

fn test_native_linux_tiny_link_blocks_user_external_link_flags() {
    for user_link_flags in ['-lm', '-Wl,-rpath,/tmp/lib', '/tmp/helper.c', '-fopenmp', '-pthread',
        '-F/tmp/Frameworks'] {
        assert !native_link_flags_allow_builtin_linux_tiny('-lpthread -lm -ldl', user_link_flags), user_link_flags
    }
}

fn test_native_linux_tiny_link_blocks_external_link_inputs_in_global_flags() {
    assert !native_link_flags_allow_builtin_linux_tiny('-Xlinker -rpath', '')
    assert !native_link_flags_allow_builtin_linux_tiny('-L/tmp', '')
    assert !native_link_flags_allow_builtin_linux_tiny('/tmp/helper.o', '')
    assert !native_link_flags_allow_builtin_linux_tiny('/tmp/libhelper.a', '')
    assert !native_link_flags_allow_builtin_linux_tiny('-framework Foundation', '')
    assert !native_link_flags_allow_builtin_linux_tiny('-lfoo', '')
}

fn test_native_external_link_inputs_replace_sources_with_objects_in_order() {
    inputs := native_external_link_inputs('-L/tmp/lib /tmp/foo.c -lfoo /tmp/bar.m /tmp/baz.o',
        '/tmp/out')!

    assert inputs.source_files == ['/tmp/foo.c', '/tmp/bar.m']
    assert inputs.object_files.len == 2
    assert inputs.link_flags == '-L/tmp/lib ${os.quoted_path(inputs.object_files[0])} -lfoo ${os.quoted_path(inputs.object_files[1])} /tmp/baz.o'
    assert !inputs.link_flags.contains('/tmp/foo.c')
    assert !inputs.link_flags.contains('/tmp/bar.m')
}

fn test_native_external_link_inputs_reject_unsupported_c_family_sources() {
    for source in ['/tmp/foo.cc', '/tmp/foo.cpp', '/tmp/foo.cxx', '/tmp/foo.mm'] {
        native_external_link_inputs(source, '/tmp/out') or {
            assert err.msg().starts_with('x64: unsupported backend feature: '), err.msg()
            continue
        }
        assert false, 'expected ${source} source to be rejected'
    }
}

fn test_native_external_link_inputs_reject_quoted_source_tokens() {
    native_external_link_inputs('"foo.c"', '/tmp/out') or {
        assert err.msg().starts_with('x64: unsupported backend feature: quoted #flag source path'), err.msg()

        return
    }
    assert false, 'expected quoted source token to be rejected'
}

fn test_macos_native_link_command_uses_rewritten_external_objects() {
    tmp_dir := os.real_path(os.vtmp_dir())
    foo_c := os.join_path(tmp_dir, 'foo.c')
    bar_m := os.join_path(tmp_dir, 'bar.m')
    out_path := os.join_path(tmp_dir, 'out')
    inputs := native_external_link_inputs('${foo_c} -framework Foundation ${bar_m}', out_path)!
    cmd := macos_native_link_command(out_path, 'main.o', '/SDK Path', 'x86_64', false,
        inputs.link_flags)

    assert cmd.contains(os.quoted_path(inputs.object_files[0])), cmd
    assert cmd.contains(os.quoted_path(inputs.object_files[1])), cmd
    assert cmd.contains('-framework Foundation'), cmd
    assert !cmd.contains(foo_c), cmd
    assert !cmd.contains(bar_m), cmd
}

fn test_native_external_source_compile_command_adds_macos_sdk_and_arch() {
    cmd := native_external_source_compile_command('cc', '/tmp/foo.c', '/tmp/foo.o',
        '-I /tmp/include -DHELPER', '/SDK Path', 'x86_64', 'macos')

    assert cmd.starts_with('cc -c '), cmd
    assert cmd.contains('-isysroot ${os.quoted_path('/SDK Path')}'), cmd
    assert cmd.contains('-arch x86_64'), cmd
    assert cmd.contains('-I /tmp/include -DHELPER'), cmd
    assert cmd.contains(os.quoted_path('/tmp/foo.c')), cmd
    assert cmd.contains('-o ${os.quoted_path('/tmp/foo.o')}'), cmd
}

fn test_native_external_source_compile_command_keeps_linux_compile_flags() {
    cmd := native_external_source_compile_command('cc', '/tmp/foo.c', '/tmp/foo.o',
        '-I /tmp/include -DHELPER', '', '', 'linux')

    assert cmd.starts_with('cc -c '), cmd
    assert !cmd.contains('-isysroot'), cmd
    assert !cmd.contains('-arch'), cmd
    assert cmd.contains('-I /tmp/include -DHELPER'), cmd
    assert cmd.contains(os.quoted_path('/tmp/foo.c')), cmd
    assert cmd.contains('-o ${os.quoted_path('/tmp/foo.o')}'), cmd
}

fn test_native_external_source_compiler_uses_pref_ccompiler() {
    mut prefs := pref.new_preferences()
    prefs.ccompiler = 'custom-native-cc'
    mut b := new_builder(&prefs)

    assert b.native_external_source_compiler('macos') == 'custom-native-cc'
}

fn test_native_external_source_compiler_uses_v2cc_when_pref_is_empty() {
    old_v2cc := os.getenv_opt('V2CC')
    os.setenv('V2CC', 'env-native-cc', true)
    defer {
        if old := old_v2cc {
            os.setenv('V2CC', old, true)
        } else {
            os.unsetenv('V2CC')
        }
    }

    mut prefs := pref.new_preferences()
    prefs.ccompiler = ''
    mut b := new_builder(&prefs)

    assert b.native_external_source_compiler('macos') == 'env-native-cc'
}

fn test_native_external_source_compiler_defaults_to_cc_for_macos() {
    old_v2cc := os.getenv_opt('V2CC')
    os.unsetenv('V2CC')
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_native_external_cc_${os.getpid()}')
    tcc_dir := os.join_path(tmp_dir, 'thirdparty', 'tcc')
    os.mkdir_all(tcc_dir) or { panic(err) }
    os.write_file(os.join_path(tcc_dir, 'tcc.exe'), '') or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
        if old := old_v2cc {
            os.setenv('V2CC', old, true)
        } else {
            os.unsetenv('V2CC')
        }
    }

    mut prefs := pref.Preferences{
        vroot: tmp_dir
    }
    mut b := new_builder(&prefs)

    assert b.native_external_source_compiler('macos') == 'cc'
    assert b.native_external_source_compiler('darwin') == 'cc'
}

fn test_native_linux_hosted_link_compiler_pref_v2cc_default_order() {
    old_v2cc := os.getenv_opt('V2CC')
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_native_linux_hosted_cc_${os.getpid()}')
    tcc_dir := os.join_path(tmp_dir, 'thirdparty', 'tcc')
    os.mkdir_all(tcc_dir) or { panic(err) }
    os.write_file(os.join_path(tcc_dir, 'tcc.exe'), '') or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
        if old := old_v2cc {
            os.setenv('V2CC', old, true)
        } else {
            os.unsetenv('V2CC')
        }
    }

    os.setenv('V2CC', 'env-hosted-cc', true)
    mut pref_prefs := pref.new_preferences()
    pref_prefs.ccompiler = 'pref-hosted-cc'
    pref_builder := new_builder(&pref_prefs)
    assert pref_builder.native_linux_hosted_link_compiler() == 'pref-hosted-cc'

    mut env_prefs := pref.new_preferences()
    env_prefs.ccompiler = ''
    env_builder := new_builder(&env_prefs)
    assert env_builder.native_linux_hosted_link_compiler() == 'env-hosted-cc'

    os.unsetenv('V2CC')
    mut default_prefs := pref.Preferences{
        vroot: tmp_dir
    }
    default_builder := new_builder(&default_prefs)
    assert default_builder.native_linux_hosted_link_compiler() == 'cc'
}

fn test_native_link_flags_from_sources_are_not_global() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_native_link_flags_${os.getpid()}')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    no_flag_path := os.join_path(tmp_dir, 'no_flag.v')
    math_flag_path := os.join_path(tmp_dir, 'math_flag.v')
    os.write_file(no_flag_path, 'module main\n') or { panic(err) }
    os.write_file(math_flag_path, 'module main\n#flag -lm\n') or { panic(err) }

    mut prefs := pref.new_preferences()
    prefs.backend = .x64
    prefs.arch = .x64
    prefs.target_os = 'linux'
    prefs.skip_builtin = true

    mut no_flag_builder := new_builder(&prefs)
    no_flag_builder.files = [
        ast.File{
            name: no_flag_path
        },
    ]
    assert no_flag_builder.native_link_flags_from_sources() == ''

    mut math_flag_builder := new_builder(&prefs)
    math_flag_builder.files = [
        ast.File{
            name: math_flag_path
        },
    ]
    assert math_flag_builder.native_link_flags_from_sources() == '-lm'
}

fn test_native_user_link_flags_ignore_internal_vlib_runtime_flags() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_native_user_link_flags_${os.getpid()}')
    vlib_os_dir := os.join_path(tmp_dir, 'vlib', 'os')
    os.mkdir_all(vlib_os_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    main_path := os.join_path(tmp_dir, 'main.v')
    internal_path := os.join_path(vlib_os_dir, 'signal_linux.c.v')
    os.write_file(main_path, 'module main\n#flag -lm\n') or { panic(err) }
    os.write_file(internal_path, 'module os\n#flag -lpthread\n') or { panic(err) }

    mut prefs := pref.Preferences{
        backend:      .x64
        arch:         .x64
        target_os:    'linux'
        vroot:        tmp_dir
        skip_builtin: true
    }

    mut b := new_builder(&prefs)
    b.user_files = [main_path]
    b.files = [
        ast.File{
            name: main_path
        },
        ast.File{
            name: internal_path
        },
    ]
    _, all_link_flags := b.native_compile_and_link_flags_from_sources()
    _, user_link_flags := b.native_user_compile_and_link_flags_from_sources()

    assert all_link_flags.fields().sorted() == ['-lm', '-lpthread']
    assert user_link_flags == '-lm'
    assert !native_link_flags_allow_builtin_linux_tiny(all_link_flags, user_link_flags)

    b.user_files = []
    b.files = [
        ast.File{
            name: internal_path
        },
    ]
    _, internal_only_link_flags := b.native_compile_and_link_flags_from_sources()
    _, no_user_link_flags := b.native_user_compile_and_link_flags_from_sources()

    assert internal_only_link_flags == '-lpthread'
    assert no_user_link_flags == ''
    assert native_link_flags_allow_builtin_linux_tiny(internal_only_link_flags, no_user_link_flags)
}

fn test_native_compile_and_link_flags_from_sources_keep_compile_flags_for_source_inputs() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_native_source_flags_${os.getpid()}')
    include_dir := os.join_path(tmp_dir, 'include')
    os.mkdir_all(include_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    main_path := os.join_path(tmp_dir, 'main.v')
    c_path := os.join_path(tmp_dir, 'helper.c')
    os.write_file(c_path, 'int helper(void) { return 7; }\n') or { panic(err) }
    os.write_file(main_path, 'module main
#flag -I include -DHELPER -fopenmp -pthread helper.c -Wl,-rpath,/tmp/native-lib -lm
') or {
        panic(err)
    }

    mut prefs := pref.new_preferences()
    prefs.backend = .x64
    prefs.arch = .x64
    prefs.target_os = 'linux'
    prefs.skip_builtin = true

    mut b := new_builder(&prefs)
    b.files = [
        ast.File{
            name: main_path
        },
    ]
    compile_flags, link_flags := b.native_compile_and_link_flags_from_sources()
    expected_include_dir := os.real_path(include_dir)
    expected_c_path := os.real_path(c_path)

    assert compile_flags == '-I ${expected_include_dir} -DHELPER -fopenmp -pthread'
    assert link_flags == '-fopenmp -pthread ${expected_c_path} -Wl,-rpath,/tmp/native-lib -lm'
}

fn test_native_x64_requires_ssa_optimization() {
    mut prefs := pref.new_preferences()
    assert prefs.no_optimize
    builder := new_builder(&prefs)
    assert builder.native_backend_requires_ssa_optimization(.x64)
    assert !builder.native_backend_requires_ssa_optimization(.arm64)
}