module cleanc

import os
import v2.ast
import v2.parser
import v2.pref as vpref
import v2.token
import v2.transformer
import v2.types

fn new_target_test_gen(target_os string, user_defines []string) &Gen {
    return new_target_test_gen_with_freestanding(target_os, user_defines, false)
}

fn new_target_test_gen_with_freestanding(target_os string, user_defines []string, freestanding bool) &Gen {
    return new_target_test_gen_with_options(target_os, user_defines, freestanding, false)
}

fn new_target_test_gen_with_options(target_os string, user_defines []string, freestanding bool, prealloc bool) &Gen {
    return new_target_test_gen_with_options_and_hooks(target_os, user_defines, freestanding,
        prealloc, [])
}

fn new_target_test_gen_with_options_and_hooks(target_os string, user_defines []string, freestanding bool, prealloc bool, freestanding_hooks []string) &Gen {
    return new_target_test_gen_with_options_hooks_and_skip_builtin(target_os, user_defines,
        freestanding, prealloc, freestanding_hooks, false)
}

fn new_target_test_gen_with_options_hooks_and_skip_builtin(target_os string, user_defines []string, freestanding bool, prealloc bool, freestanding_hooks []string, skip_builtin bool) &Gen {
    prefs := &vpref.Preferences{
        backend:               .cleanc
        target_os:             target_os
        freestanding:          freestanding
        prealloc:              prealloc
        skip_builtin:          skip_builtin
        user_defines:          user_defines
        explicit_user_defines: user_defines.clone()
        freestanding_hooks:    freestanding_hooks
        no_parallel:           true
    }
    env := types.Environment.new()
    return Gen.new_with_env_and_pref([]ast.File{}, env, prefs)
}

fn freestanding_hook_defines(hooks []string) []string {
    mut defines := ['freestanding', 'freestanding_hooks']
    for hook in hooks {
        defines << 'freestanding_${hook}'
        defines << 'freestanding_hooks_${hook}'
    }
    return defines
}

fn c_directive_output_for_target(cond string, target_os string, user_defines []string) string {
    return c_directive_output_for_target_with_explicit(cond, target_os, user_defines,
        user_defines.clone(), false)
}

fn c_directive_output_for_target_with_explicit(cond string, target_os string, user_defines []string, explicit_user_defines []string, freestanding bool) string {
    prefs := &vpref.Preferences{
        backend:               .cleanc
        target_os:             target_os
        freestanding:          freestanding
        user_defines:          user_defines
        explicit_user_defines: explicit_user_defines
        no_parallel:           true
    }
    env := types.Environment.new()
    mut g := Gen.new_with_env_and_pref([]ast.File{}, env, prefs)
    mut seen := map[string]bool{}
    g.emit_directive(ast.Directive{
        name:    'include'
        value:   '<target_marker.h>'
        ct_cond: cond
    }, 'target_test.v', true, mut seen)
    return g.sb.str()
}

fn c_directive_output_for_freestanding_target(cond string, target_os string) string {
    return c_directive_output_for_target_with_explicit(cond, target_os, [
        'freestanding',
    ], [], true)
}

fn preamble_for_target(target_os string, user_defines []string) string {
    mut g := new_target_test_gen(target_os, user_defines)
    g.set_emit_modules(['main'])
    g.write_preamble()
    return g.sb.str()
}

fn preamble_for_freestanding_field(target_os string) string {
    mut g := new_target_test_gen_with_freestanding(target_os, [], true)
    g.set_emit_modules(['main'])
    g.write_preamble()
    return g.sb.str()
}

fn full_preamble_for_target(target_os string, user_defines []string) string {
    mut g := new_target_test_gen(target_os, user_defines)
    g.write_preamble()
    return g.sb.str()
}

fn full_preamble_for_freestanding_field(target_os string) string {
    mut g := new_target_test_gen_with_freestanding(target_os, [], true)
    g.write_preamble()
    return g.sb.str()
}

fn full_preamble_for_options(target_os string, user_defines []string, freestanding bool, prealloc bool) string {
    mut g := new_target_test_gen_with_options(target_os, user_defines, freestanding, prealloc)
    g.write_preamble()
    return g.sb.str()
}

fn full_preamble_for_freestanding_hooks(hooks []string) string {
    mut g := new_target_test_gen_with_options_and_hooks('linux', freestanding_hook_defines(hooks),
        true, false, hooks)
    g.write_preamble()
    return g.sb.str()
}

fn runtime_fallbacks_for_called_functions(names []string) string {
    mut g := new_target_test_gen('linux', [])
    g.add_called_fn_names(names)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_called_functions_for_target(target_os string, names []string) string {
    mut g := new_target_test_gen(target_os, [])
    g.add_called_fn_names(names)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_called_functions_with_options(names []string, user_defines []string, freestanding bool) string {
    mut g := new_target_test_gen_with_freestanding('linux', user_defines, freestanding)
    g.add_called_fn_names(names)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_called_functions_with_hooks(names []string, hooks []string) string {
    mut g := new_target_test_gen_with_options_and_hooks('linux', freestanding_hook_defines(hooks),
        true, false, hooks)
    g.add_called_fn_names(names)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_existing_c_source(csrc string) string {
    mut g := new_target_test_gen('linux', [])
    g.sb.write_string(csrc)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_existing_c_source_with_options(csrc string, user_defines []string, freestanding bool) string {
    mut g := new_target_test_gen_with_freestanding('linux', user_defines, freestanding)
    g.sb.write_string(csrc)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_existing_c_source_with_hooks(csrc string, hooks []string) string {
    mut g := new_target_test_gen_with_options_and_hooks('linux', freestanding_hook_defines(hooks),
        true, false, hooks)
    g.sb.write_string(csrc)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin(csrc string, hooks []string) string {
    mut g := new_target_test_gen_with_options_hooks_and_skip_builtin('linux',
        freestanding_hook_defines(hooks), true, false, hooks, true)
    g.sb.write_string(csrc)
    g.emit_missing_runtime_fallbacks()
    return g.sb.str()
}

fn soa_companion_for_options(user_defines []string, freestanding bool) string {
    mut g := new_target_test_gen_with_freestanding('linux', user_defines, freestanding)
    g.gen_soa_companion('Point', types.Struct{
        name:   'Point'
        fields: [
            types.Field{
                name: 'x'
                typ:  types.Type(types.Primitive{
                    props: .integer
                    size:  32
                })
            },
        ]
    })
    return g.sb.str()
}

fn soa_companion_for_hooks(hooks []string) string {
    mut g := new_target_test_gen_with_options_and_hooks('linux', freestanding_hook_defines(hooks),
        true, false, hooks)
    g.gen_soa_companion('Point', types.Struct{
        name:   'Point'
        fields: [
            types.Field{
                name: 'x'
                typ:  types.Type(types.Primitive{
                    props: .integer
                    size:  32
                })
            },
        ]
    })
    return g.sb.str()
}

fn fixed_array_voidptr_str_write_for_options(user_defines []string, freestanding bool) string {
    mut g := new_target_test_gen_with_freestanding('linux', user_defines, freestanding)
    g.emit_fixed_array_str_write('items', 'voidptr', 2)
    return g.sb.str()
}

fn fixed_array_voidptr_str_write_for_hooks(hooks []string) string {
    mut g := new_target_test_gen_with_options_and_hooks('linux', freestanding_hook_defines(hooks),
        true, false, hooks)
    g.emit_fixed_array_str_write('items', 'voidptr', 2)
    return g.sb.str()
}

fn unresolved_generic_stub_for_options(user_defines []string, freestanding bool) string {
    mut g := new_target_test_gen_with_freestanding('linux', user_defines, freestanding)
    g.emit_unresolved_generic_stub('missing_generic_T', 'int')
    return g.sb.str()
}

fn unresolved_generic_stub_for_hooks(hooks []string) string {
    mut g := new_target_test_gen_with_options_and_hooks('linux', freestanding_hook_defines(hooks),
        true, false, hooks)
    g.emit_unresolved_generic_stub('missing_generic_T', 'int')
    return g.sb.str()
}

fn generated_c_for_target_program(name string, source string) string {
    return generated_c_for_target_program_with_options(name, source, 'linux', false, false)
}

fn generated_c_for_target_program_with_options(name string, source string, target_os string, freestanding bool, skip_builtin bool) string {
    return generated_c_for_target_program_with_defines(name, source, target_os, [], freestanding,
        skip_builtin)
}

fn generated_c_for_target_program_with_defines(name string, source string, target_os string, user_defines []string, freestanding bool, skip_builtin bool) string {
    return generated_c_for_target_program_with_defines_and_hooks(name, source, target_os,
        user_defines, freestanding, skip_builtin, [])
}

fn generated_c_for_trace_calls_import_with_defines(name string, user_defines []string) string {
    source := 'module main

import v.trace_calls

pub struct C.FILE {}

pub struct C.timespec {
pub mut:
    tv_sec  i64
    tv_nsec i64
}

__global C.stderr &C.FILE

pub const C.CLOCK_MONOTONIC int

fn C.fprintf(fstream &C.FILE, const_format &char, opt ...voidptr) i32
fn C.fflush(fstream &C.FILE) i32
fn C.clock_gettime(i32, &C.timespec) i32
fn C.pthread_self() usize

fn main() {
    trace_calls.on_call("probe")
}
'
    trace_calls_file := os.join_path(os.getwd(), 'vlib', 'v', 'trace_calls', 'tracing_calls.c.v')
    return generated_c_for_target_program_with_extra_files(name, source, 'linux', user_defines,
        false, false, [trace_calls_file])
}

fn generated_c_for_target_program_with_extra_files(name string, source string, target_os string, user_defines []string, freestanding bool, skip_builtin bool, extra_files []string) string {
    tmp_file := os.join_path(os.temp_dir(), 'v2_cleanc_target_codegen_${name}_${os.getpid()}.v')
    os.write_file(tmp_file, source) or { panic(err) }
    defer {
        os.rm(tmp_file) or {}
    }
    prefs := &vpref.Preferences{
        backend:               .cleanc
        target_os:             target_os
        freestanding:          freestanding
        skip_builtin:          skip_builtin
        user_defines:          user_defines
        explicit_user_defines: user_defines.clone()
        no_parallel:           true
    }
    mut paths := [tmp_file]
    paths << extra_files
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files(paths, mut file_set)
    env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := transformer.Transformer.new_with_pref(env, prefs)
    trans.set_file_set(file_set)
    transformed_files := trans.transform_files(files)
    mut gen := Gen.new_with_env_and_pref(transformed_files, env, prefs)
    return gen.gen()
}

fn generated_c_for_target_program_with_hooks(name string, source string, hooks []string) string {
    return generated_c_for_target_program_with_defines_and_hooks(name, source, 'linux',
        freestanding_hook_defines(hooks), true, true, hooks)
}

fn generated_c_for_target_program_with_defines_and_hooks(name string, source string, target_os string, user_defines []string, freestanding bool, skip_builtin bool, freestanding_hooks []string) string {
    tmp_file := os.join_path(os.temp_dir(), 'v2_cleanc_target_codegen_${name}_${os.getpid()}.v')
    os.write_file(tmp_file, source) or { panic(err) }
    defer {
        os.rm(tmp_file) or {}
    }
    prefs := &vpref.Preferences{
        backend:               .cleanc
        target_os:             target_os
        freestanding:          freestanding
        skip_builtin:          skip_builtin
        user_defines:          user_defines
        explicit_user_defines: user_defines.clone()
        freestanding_hooks:    freestanding_hooks
        no_parallel:           true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp_file], mut file_set)
    env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := transformer.Transformer.new_with_pref(env, prefs)
    trans.set_file_set(file_set)
    transformed_files := trans.transform_files(files)
    mut gen := Gen.new_with_env_and_pref(transformed_files, env, prefs)
    return gen.gen()
}

fn assert_no_hosted_runtime_fallbacks(csrc string) {
    for marker in [
        '__attribute__((weak)) u64 __at_least_one',
        '__attribute__((weak)) Array_string arguments()',
        '__attribute__((weak)) void _write_buf_to_fd',
        '__attribute__((weak)) void _writeln_to_fd',
        '__attribute__((weak)) void eprint',
        '__attribute__((weak)) void flush_stdout',
        '__attribute__((weak)) void flush_stderr',
        '__attribute__((weak)) bool Array_int_contains',
        '__attribute__((weak)) bool Array_string_contains',
        '__attribute__((weak)) int Array_string_index',
        '__attribute__((weak)) string Array_int_str',
        '__attribute__((weak)) void DenseArray__zeros_to_end',
        '__attribute__((weak)) int bits__leading_zeros_64',
        '__attribute__((weak)) int bits__trailing_zeros_32',
        '__attribute__((weak)) int bits__trailing_zeros_64',
        '__attribute__((weak)) u32 bits__rotate_left_32',
        '__attribute__((weak)) u8* malloc_noscan',
        '__attribute__((weak)) void* memdup',
        '__attribute__((weak)) f64 f64_abs',
        '__attribute__((weak)) string f64__str',
        '__attribute__((weak)) string f64__strg',
        '__attribute__((weak)) string f32__str',
        '__attribute__((weak)) string f32__strg',
    ] {
        assert !csrc.contains(marker), marker
    }
}

fn assert_no_hosted_output_runtime(csrc string) {
    assert !csrc.contains('isize written = write(fd, ptr, remaining_bytes)')
    assert !csrc.contains('fflush(')
    assert !csrc.contains('fflush(stdout)')
    assert !csrc.contains('fflush(stderr)')
}

fn assert_no_hosted_alloc_runtime(csrc string) {
    assert !csrc.contains('return malloc(n);')
    assert !csrc.contains(' = malloc(')
    assert !csrc.contains('\tfree(')
    assert !csrc.contains('realloc_data(')
    assert !csrc.contains(' = realloc(')
}

fn assert_no_raw_heap_runtime(csrc string) {
    for marker in ['*)malloc(', ' = malloc(', '\tmalloc(', 'return malloc(', 'calloc(', '*)realloc(',
        ' = realloc(', '\trealloc(', '\tfree(', ' free('] {
        assert !csrc.contains(marker), marker
    }
}

fn assert_freestanding_alloc_refusal_without_hosted_heap(csrc string) {
    assert csrc.contains('_Static_assert(0, "${freestanding_missing_alloc_hook_message}")')
    assert_no_raw_heap_runtime(csrc)
}

fn assert_freestanding_format_refusal_without_hosted_formatting(csrc string) {
    assert csrc.contains('_Static_assert(0, "${freestanding_missing_format_hook_message}")')
    assert_no_hosted_formatting_or_abort_runtime(csrc)
}

fn assert_freestanding_heap_runtime_refusal(csrc string, helper string) {
    assert csrc.contains('_Static_assert(0, "${freestanding_missing_heap_runtime_message}: ${helper}")')
}

fn assert_freestanding_output_refusal_without_hosted_io(csrc string) {
    assert csrc.contains('_Static_assert(0, "${freestanding_missing_output_hook_message}")')
    assert_no_hosted_output_runtime(csrc)
}

fn assert_freestanding_panic_refusal_without_hosted_exit(csrc string) {
    assert csrc.contains('_Static_assert(0, "${freestanding_missing_panic_hook_message}")')
    assert !csrc.contains('v_platform_panic')
    assert !csrc.contains('exit(')
}

fn assert_no_hosted_formatting_or_abort_runtime(csrc string) {
    for marker in ['snprintf(', 'sprintf(', 'printf(', 'fprintf(', 'fputs(', 'stderr', 'abort('] {
        assert !csrc.contains(marker), marker
    }
}

fn assert_no_os_runtime_headers(csrc string) {
    for marker in [
        '#include <stdio.h>',
        '#include <stdlib.h>',
        '#include <unistd.h>',
        '#include <windows.h>',
        '#include <dirent.h>',
        '#include <pthread.h>',
        '#include <mach/mach.h>',
        '#include <termios.h>',
        '#include <sys/wait.h>',
        '#include <sys/ioctl.h>',
        'extern char** environ;',
        'pthread_rwlock_t',
        'SRWLOCK',
    ] {
        assert !csrc.contains(marker), marker
    }
}

fn assert_c_marker_before(csrc string, before string, after string) {
    before_idx := csrc.index(before) or { panic('missing marker: ${before}') }
    after_idx := csrc.index(after) or { panic('missing marker: ${after}') }
    assert before_idx < after_idx
}

fn assert_no_gettid_compat(csrc string) {
    assert !csrc.contains('_GNU_SOURCE')
    assert !csrc.contains('SYS_gettid')
    assert !csrc.contains('v_cleanc_gettid')
    assert !csrc.contains('#define gettid')
}

fn test_eval_comptime_flag_uses_target_os_preference() {
    windows_gen := new_target_test_gen('windows', [])
    assert windows_gen.eval_comptime_flag('windows')
    assert !windows_gen.eval_comptime_flag('linux')
    assert !windows_gen.eval_comptime_flag('macos')

    linux_gen := new_target_test_gen('linux', [])
    assert linux_gen.eval_comptime_flag('linux')
    assert !linux_gen.eval_comptime_flag('windows')

    macos_gen := new_target_test_gen('darwin', [])
    assert macos_gen.eval_comptime_flag('macos')
    assert macos_gen.eval_comptime_flag('darwin')
    assert macos_gen.eval_comptime_flag('mac')
    assert macos_gen.eval_comptime_flag('bsd')

    freebsd_gen := new_target_test_gen('freebsd', [])
    assert freebsd_gen.eval_comptime_flag('bsd')
}

fn test_eval_comptime_flag_uses_target_os_preference_for_extended_targets() {
    for target in [
        'freebsd',
        'openbsd',
        'netbsd',
        'dragonfly',
        'android',
        'termux',
        'ios',
        'solaris',
        'qnx',
        'serenity',
        'plan9',
        'vinix',
    ] {
        gen := new_target_test_gen(target, [])
        assert gen.eval_comptime_flag(target)
        assert !gen.eval_comptime_flag('linux')
    }

    cross_gen := new_target_test_gen('cross', [])
    assert cross_gen.eval_comptime_flag('cross')
    assert !cross_gen.eval_comptime_flag('linux')

    freestanding_gen := new_target_test_gen_with_freestanding('linux', [], true)
    assert freestanding_gen.eval_comptime_flag('freestanding')
}

fn test_freestanding_none_comptime_selects_no_concrete_os() {
    gen := new_target_test_gen_with_freestanding('none', [], true)
    assert gen.eval_comptime_flag('freestanding')
    assert gen.eval_comptime_flag('none')
    assert !gen.eval_comptime_flag('linux')
    assert !gen.eval_comptime_flag('windows')
    assert !gen.eval_comptime_flag('macos')
    assert !gen.eval_comptime_flag('darwin')
    assert !gen.eval_comptime_flag('cross')

    hosted_with_define := new_target_test_gen('linux', ['none'])
    assert !hosted_with_define.eval_comptime_flag('none')
}

fn test_c_directives_use_target_os_preference() {
    assert c_directive_output_for_target('windows', 'windows', []).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('linux', 'windows', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('linux', 'linux', []).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('windows', 'linux', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('mac', 'macos', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('darwin', 'macos', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('bsd', 'freebsd', []).contains('#include <target_marker.h>')
}

fn test_c_directives_use_extended_target_os_preference() {
    for target in [
        'freebsd',
        'openbsd',
        'netbsd',
        'dragonfly',
        'android',
        'termux',
        'ios',
        'solaris',
        'qnx',
        'serenity',
        'plan9',
        'vinix',
    ] {
        assert c_directive_output_for_target(target, target, []).contains('#include <target_marker.h>')
        assert !c_directive_output_for_target('linux', target, []).contains('#include <target_marker.h>')
    }
}

struct CrossGuardCase {
    cond  string
    guard string
}

fn test_c_directives_keep_cross_portable() {
    assert c_directive_output_for_target('', 'cross', []).contains('#include <target_marker.h>')
    cross_src := c_directive_output_for_target('cross', 'cross', [])
    assert cross_src.contains('#include <target_marker.h>')
    assert !cross_src.contains('#if')

    linux_src := c_directive_output_for_target('linux', 'cross', [])
    assert linux_src.contains('#if defined(__linux__)')
    assert linux_src.contains('#include <target_marker.h>')
    assert linux_src.contains('#endif')

    windows_src := c_directive_output_for_target('windows', 'cross', [])
    assert windows_src.contains('#if defined(_WIN32)')
    assert windows_src.contains('#include <target_marker.h>')
    assert windows_src.contains('#endif')

    macos_src := c_directive_output_for_target('macos', 'cross', [])
    assert macos_src.contains('#if ${apple_macos_cross_guard}')
    assert macos_src.contains('#include <target_marker.h>')
    assert macos_src.contains('#endif')
}

fn test_c_directives_keep_cross_extended_targets_portable() {
    for case in [
        CrossGuardCase{'mac', apple_macos_cross_guard},
        CrossGuardCase{'darwin', apple_macos_cross_guard},
        CrossGuardCase{'freebsd', 'defined(__FreeBSD__)'},
        CrossGuardCase{'openbsd', 'defined(__OpenBSD__)'},
        CrossGuardCase{'netbsd', 'defined(__NetBSD__)'},
        CrossGuardCase{'dragonfly', 'defined(__DragonFly__)'},
        CrossGuardCase{'android', 'defined(__ANDROID__)'},
        CrossGuardCase{'termux', 'defined(__TERMUX__)'},
        CrossGuardCase{'ios', apple_ios_cross_guard},
        CrossGuardCase{'solaris', 'defined(__sun)'},
        CrossGuardCase{'qnx', 'defined(__QNX__)'},
        CrossGuardCase{'serenity', 'defined(__serenity__)'},
        CrossGuardCase{'plan9', 'defined(__plan9__)'},
        CrossGuardCase{'vinix', 'defined(__vinix__)'},
    ] {
        src := c_directive_output_for_target(case.cond, 'cross', [])
        assert src.contains('#if ${case.guard}')
        assert src.contains('#include <target_marker.h>')
        assert src.contains('#endif')
    }

    bsd_src := c_directive_output_for_target('bsd', 'cross', [])
    assert bsd_src.contains(apple_macos_cross_guard)
    assert bsd_src.contains('defined(__FreeBSD__)')
    assert bsd_src.contains('defined(__OpenBSD__)')
    assert bsd_src.contains('defined(__NetBSD__)')
    assert bsd_src.contains('defined(__DragonFly__)')
    assert !bsd_src.contains('defined(__APPLE__) ||')
    assert bsd_src.contains('#include <target_marker.h>')
}

fn test_c_directives_keep_cross_complex_os_conditions_portable() {
    not_linux_src := c_directive_output_for_target('!linux', 'cross', [])
    assert not_linux_src.contains('#if !(defined(__linux__))')
    assert not_linux_src.contains('#include <target_marker.h>')

    and_src := c_directive_output_for_target('linux && !windows', 'cross', [])
    assert and_src.contains('#if (defined(__linux__)) && (!(defined(_WIN32)))')
    assert and_src.contains('#include <target_marker.h>')

    cross_and_src := c_directive_output_for_target('cross && linux', 'cross', [])
    assert cross_and_src.contains('#if defined(__linux__)')
    assert cross_and_src.contains('#include <target_marker.h>')
    assert !cross_and_src.contains('cross')

    feature_and_src := c_directive_output_for_target('feature && linux', 'cross', [
        'feature',
    ])
    assert feature_and_src.contains('#if defined(__linux__)')
    assert feature_and_src.contains('#include <target_marker.h>')
    assert !feature_and_src.contains('feature')

    not_feature_and_src := c_directive_output_for_target('!feature && linux', 'cross', [
        'feature',
    ])
    assert !not_feature_and_src.contains('#include <target_marker.h>')

    missing_feature_and_src := c_directive_output_for_target('feature && linux', 'cross', [])
    assert !missing_feature_and_src.contains('#include <target_marker.h>')

    or_src := c_directive_output_for_target('linux || windows', 'cross', [])
    assert or_src.contains('#if (defined(__linux__)) || (defined(_WIN32))')
    assert or_src.contains('#include <target_marker.h>')

    not_and_src := c_directive_output_for_target('!windows && linux', 'cross', [])
    assert not_and_src.contains('#if (!(defined(_WIN32))) && (defined(__linux__))')
    assert not_and_src.contains('#include <target_marker.h>')

    or_and_src := c_directive_output_for_target('linux || windows && macos', 'cross', [])
    assert or_and_src.contains('#if (defined(__linux__)) || ((defined(_WIN32)) && (${apple_macos_cross_guard}))')
    assert or_and_src.contains('#include <target_marker.h>')

    not_group_src := c_directive_output_for_target('!(linux || windows) && macos', 'cross', [])
    assert not_group_src.contains('#if (!((defined(__linux__)) || (defined(_WIN32)))) && (${apple_macos_cross_guard})')
    assert not_group_src.contains('#include <target_marker.h>')

    assert c_directive_output_for_target('linux || windows && macos', 'linux', []).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('linux || windows && macos', 'macos', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('!(linux || windows) && macos', 'macos', []).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('!(linux || windows) && macos', 'windows', []).contains('#include <target_marker.h>')
}

fn test_c_directives_keep_termux_distinct_from_android() {
    assert c_directive_output_for_target('termux', 'termux', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('linux || termux', 'termux', []).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('android', 'termux', []).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('android && !termux', 'termux', []).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('android && !termux', 'android', []).contains('#include <target_marker.h>')
}

fn test_cross_optional_termux_flag_named_like_os_is_not_os_guarded() {
    assert !c_directive_output_for_target('termux ?', 'cross', []).contains('#include <target_marker.h>')
    optional_directive_src := c_directive_output_for_target('termux ?', 'cross', [
        'termux',
    ])
    assert optional_directive_src.contains('#include <target_marker.h>')
    assert !optional_directive_src.contains('defined(__TERMUX__)')
}

fn test_optional_target_mode_directives_ignore_synthesized_defines() {
    assert !c_directive_output_for_target_with_explicit('cross ?', 'cross', ['cross'], [], false).contains('#include <target_marker.h>')
    assert c_directive_output_for_target_with_explicit('cross ?', 'cross', ['cross'], [
        'cross',
    ], false).contains('#include <target_marker.h>')

    assert !c_directive_output_for_freestanding_target('freestanding ?', 'linux').contains('#include <target_marker.h>')
    assert c_directive_output_for_target_with_explicit('freestanding ?', 'linux', [
        'freestanding',
    ], ['freestanding'], true).contains('#include <target_marker.h>')

    assert !c_directive_output_for_target_with_explicit('none ?', 'none', [
        'freestanding',
    ], [], true).contains('#include <target_marker.h>')
    assert c_directive_output_for_target_with_explicit('none ?', 'none', [
        'freestanding',
    ], ['none'], true).contains('#include <target_marker.h>')
}

fn test_comptime_if_directives_support_infix_os_conditions() {
    source := 'module main

\$if linux || windows {
    #include <active_or_marker.h>
}

    \$if linux && !windows {
        #include <active_and_marker.h>
    }

    \$if macos {
        #include <active_macos_marker.h>
    }

    \$if cross && linux {
        #include <cross_linux_marker.h>
    }

fn main() {}
'
    linux_src := generated_c_for_target_program_with_options('comptime_if_infix_linux', source,
        'linux', false, false)
    assert linux_src.contains('#include <active_or_marker.h>')
    assert linux_src.contains('#include <active_and_marker.h>')
    assert !linux_src.contains('#include <active_macos_marker.h>')
    assert !linux_src.contains('#include <cross_linux_marker.h>')

    macos_src := generated_c_for_target_program_with_options('comptime_if_infix_macos', source,
        'macos', false, false)
    assert !macos_src.contains('#include <active_or_marker.h>')
    assert !macos_src.contains('#include <active_and_marker.h>')
    assert macos_src.contains('#include <active_macos_marker.h>')
    assert !macos_src.contains('#include <cross_linux_marker.h>')

    windows_src := generated_c_for_target_program_with_options('comptime_if_infix_windows', source,
        'windows', false, false)
    assert windows_src.contains('#include <active_or_marker.h>')
    assert !windows_src.contains('#include <active_and_marker.h>')
    assert !windows_src.contains('#include <active_macos_marker.h>')
    assert !windows_src.contains('#include <cross_linux_marker.h>')

    cross_src := generated_c_for_target_program_with_options('comptime_if_infix_cross', source,
        'cross', false, false)
    assert cross_src.contains('defined(__linux__)')
    assert cross_src.contains('defined(_WIN32)')
    assert cross_src.contains('#include <active_or_marker.h>')
    assert cross_src.contains('!(defined(_WIN32))')
    assert cross_src.contains('#include <active_and_marker.h>')
    assert cross_src.contains(apple_macos_cross_guard)
    assert cross_src.contains('#include <active_macos_marker.h>')
    assert cross_src.contains('#if defined(__linux__)\n#include <cross_linux_marker.h>\n#endif')
}

fn test_comptime_if_pkgconfig_directives_select_available_branch() {
    if !vpref.comptime_pkgconfig_value('sqlite3') {
        return
    }
    source := 'module main

\$if \$pkgconfig("sqlite3") {
    #include "sqlite3.h"
} \$else \$if darwin {
    #include <sqlite_darwin_fallback_marker.h>
}

fn main() {}
'
    macos_src := generated_c_for_target_program_with_options('pkgconfig_sqlite3_directive_macos',
        source, 'macos', false, false)
    assert macos_src.contains('#include "sqlite3.h"')
    assert !macos_src.contains('#include <sqlite_darwin_fallback_marker.h>')
}

fn test_cross_comptime_if_else_directives_do_not_emit_selected_else_unguarded() {
    source := 'module main

\$if linux {
    #include <linux_marker.h>
} \$else {
    #include <fallback_marker.h>
}

fn main() {}
'
    cross_src := generated_c_for_target_program_with_options('comptime_if_else_cross', source,
        'cross', false, false)
    assert cross_src.contains('#if defined(__linux__)\n#include <linux_marker.h>\n#endif')
    assert cross_src.contains('#if !(defined(__linux__))\n#include <fallback_marker.h>\n#endif')
    assert cross_src.count('#include <fallback_marker.h>') == 1
    assert cross_src.count('#include <linux_marker.h>') == 1
}

fn test_cross_comptime_directive_scope_preserves_nested_preprocessor_blocks() {
    source := 'module main

\$if linux {
    #ifdef HAVE_FOO
    #include <foo.h>
    #endif
}

fn main() {}
'
    cross_src := generated_c_for_target_program_with_options('nested_preprocessor_cross', source,
        'cross', false, false)
    assert cross_src.contains('#if defined(__linux__)\n#ifdef HAVE_FOO\n#include <foo.h>\n#endif\n#endif')
    assert !cross_src.contains('#if defined(__linux__)\n#ifdef HAVE_FOO\n#endif\n#if defined(__linux__)')
    assert cross_src.count('#include <foo.h>') == 1
}

fn test_cross_user_define_comptime_directives_reduce_to_os_guards() {
    source := 'module main

\$if feature && linux {
    #include <feature_linux.h>
}

\$if !feature && linux {
    #include <disabled_feature_linux.h>
}

\$if missing_feature && linux {
    #include <missing_feature_linux.h>
}

fn main() {}
'
    feature_src := generated_c_for_target_program_with_defines('feature_directive_cross', source,
        'cross', ['feature'], false, false)
    assert feature_src.contains('#if defined(__linux__)\n#include <feature_linux.h>\n#endif')
    assert feature_src.count('#include <feature_linux.h>') == 1
    assert !feature_src.contains('#include <disabled_feature_linux.h>')
    assert !feature_src.contains('#include <missing_feature_linux.h>')
    assert !feature_src.contains('feature && linux')
}

fn test_cross_optional_user_flag_named_like_os_is_not_os_guarded() {
    assert !c_directive_output_for_target('linux ?', 'cross', []).contains('#include <target_marker.h>')
    optional_directive_src := c_directive_output_for_target('linux ?', 'cross', [
        'linux',
    ])
    assert optional_directive_src.contains('#include <target_marker.h>')
    assert !optional_directive_src.contains('defined(__linux__)')

    source := 'module main

\$if linux ? {
    #include <optional_linux_marker.h>
}

fn main() {}
'
    missing_src := generated_c_for_target_program_with_options('optional_linux_missing_cross',
        source, 'cross', false, false)
    assert !missing_src.contains('#include <optional_linux_marker.h>')

    defined_src := generated_c_for_target_program_with_defines('optional_linux_defined_cross',
        source, 'cross', ['linux'], false, false)
    assert defined_src.contains('#include <optional_linux_marker.h>')
    assert !defined_src.contains('#if defined(__linux__)\n#include <optional_linux_marker.h>')
}

fn test_optional_user_flag_named_like_os_is_not_target_os_flag() {
    source := 'module main

\$if linux {
    #include <linux_marker.h>
}

\$if linux ? {
    #include <optional_linux_marker.h>
}

\$if linux ? || windows {
    #include <optional_linux_or_windows_marker.h>
}

fn main() {}
'
    linux_src := generated_c_for_target_program_with_options('optional_linux_plain_linux', source,
        'linux', false, false)
    assert linux_src.contains('#include <linux_marker.h>')
    assert !linux_src.contains('#include <optional_linux_marker.h>')
    assert !linux_src.contains('#include <optional_linux_or_windows_marker.h>')

    linux_defined_src := generated_c_for_target_program_with_defines('optional_linux_defined_linux',
        source, 'linux', ['linux'], false, false)
    assert linux_defined_src.contains('#include <linux_marker.h>')
    assert linux_defined_src.contains('#include <optional_linux_marker.h>')
    assert linux_defined_src.contains('#include <optional_linux_or_windows_marker.h>')

    windows_src := generated_c_for_target_program_with_options('optional_linux_windows', source,
        'windows', false, false)
    assert !windows_src.contains('#include <linux_marker.h>')
    assert !windows_src.contains('#include <optional_linux_marker.h>')
    assert windows_src.contains('#include <optional_linux_or_windows_marker.h>')
}

fn test_c_directives_keep_freestanding_user_os_directives_for_concrete_target() {
    assert c_directive_output_for_target('', 'linux', ['freestanding']).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('freestanding', 'linux', ['freestanding']).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('linux', 'linux', ['freestanding']).contains('#include <target_marker.h>')
    assert !c_directive_output_for_target('windows', 'linux', ['freestanding']).contains('#include <target_marker.h>')
    assert c_directive_output_for_target('windows', 'windows', ['freestanding']).contains('#include <target_marker.h>')
    assert c_directive_output_for_freestanding_target('freestanding', 'linux').contains('#include <target_marker.h>')
}

fn test_freestanding_none_c_directives_select_only_freestanding() {
    assert c_directive_output_for_freestanding_target('freestanding', 'none').contains('#include <target_marker.h>')
    for cond in ['linux', 'windows', 'macos', 'darwin', 'cross'] {
        src := c_directive_output_for_freestanding_target(cond, 'none')
        assert !src.contains('#include <target_marker.h>'), cond
    }
}

fn test_freestanding_none_comptime_if_directives_select_only_freestanding() {
    source := 'module main

\$if freestanding {
    #include <freestanding_none_marker.h>
}

\$if linux {
    #include <linux_none_marker.h>
}

\$if windows {
    #include <windows_none_marker.h>
}

\$if macos {
    #include <macos_none_marker.h>
}

\$if cross {
    #include <cross_none_marker.h>
}

fn main() {}
'
    src := generated_c_for_target_program_with_options('freestanding_none_comptime_if', source,
        'none', true, true)
    assert src.contains('#include <freestanding_none_marker.h>')
    assert !src.contains('#include <linux_none_marker.h>')
    assert !src.contains('#include <windows_none_marker.h>')
    assert !src.contains('#include <macos_none_marker.h>')
    assert !src.contains('#include <cross_none_marker.h>')
    assert_no_os_runtime_headers(src)
}

fn test_preamble_specializes_apple_includes_by_target() {
    linux_src := preamble_for_target('linux', [])
    assert !linux_src.contains('__APPLE__')
    assert !linux_src.contains('#include <mach/mach.h>')

    windows_src := preamble_for_target('windows', [])
    assert !windows_src.contains('__APPLE__')
    assert !windows_src.contains('#include <mach/mach.h>')

    macos_src := preamble_for_target('macos', [])
    assert macos_src.contains('#include <mach/mach.h>')
    assert !macos_src.contains('#ifdef __APPLE__')

    cross_src := preamble_for_target('cross', [])
    assert cross_src.contains('#if ${apple_macos_cross_guard}')
    assert !cross_src.contains('#ifdef __APPLE__')
    assert cross_src.contains('#include <mach/mach.h>')
    assert cross_src.contains('#if defined(_WIN32)\n#include <windows.h>\n#else\n#include <dirent.h>\n#include <pthread.h>\n#endif')
    assert cross_src.contains('#if defined(_WIN32)\ntypedef struct sync__RwMutex { SRWLOCK mutex; u32 inited; } sync__RwMutex;')
    assert cross_src.contains('#else\ntypedef struct sync__RwMutex { pthread_rwlock_t mutex; u32 inited; } sync__RwMutex;')
    full_cross_src := full_preamble_for_target('cross', [])
    assert full_cross_src.contains('#if defined(_WIN32)\n#include <windows.h>\n#else\n#include <unistd.h>')
    assert full_cross_src.contains('#include <pthread.h>\n#include <sys/time.h>')
    assert full_cross_src.contains('extern char** environ;\n#endif')
}

fn test_linux_preamble_declares_v_owned_gettid_helper_before_c_calls() {
    src := full_preamble_for_target('linux', [])
    assert src.contains(linux_gettid_feature_define)
    assert src.contains('#include <unistd.h>')
    assert src.contains(linux_gettid_helper)
    assert !src.contains('#define gettid')
    assert_c_marker_before(src, '#define _GNU_SOURCE', '#include <stdio.h>')
    assert_c_marker_before(src, '#include <unistd.h>', '#include <sys/syscall.h>')
    assert_c_marker_before(src, '#include <sys/syscall.h>',
        'static inline uint32_t v_cleanc_gettid(void)')
}

fn test_linux_minimal_preamble_declares_v_owned_gettid_helper() {
    src := preamble_for_target('linux', [])
    assert src.contains(linux_gettid_feature_define)
    assert src.contains('#include <unistd.h>')
    assert src.contains(linux_gettid_helper)
    assert !src.contains('#define gettid')
    assert_c_marker_before(src, '#define _GNU_SOURCE', '#include <stdio.h>')
    assert_c_marker_before(src, '#include <unistd.h>', '#include <sys/syscall.h>')
    assert_c_marker_before(src, '#include <sys/syscall.h>',
        'static inline uint32_t v_cleanc_gettid(void)')
}

fn test_gettid_linux_compat_does_not_leak_to_non_linux_targets() {
    for target in ['windows', 'macos', 'cross', 'freebsd', 'android', 'termux'] {
        minimal_src := preamble_for_target(target, [])
        full_src := full_preamble_for_target(target, [])
        assert_no_gettid_compat(minimal_src)
        assert_no_gettid_compat(full_src)
    }

    freestanding_src := full_preamble_for_options('linux', [], true, false)
    assert_no_gettid_compat(freestanding_src)
    assert_no_os_runtime_headers(freestanding_src)
}

fn test_gettid_linux_compat_respects_no_gettid_and_musl_defines() {
    for define in ['no_gettid', 'musl'] {
        assert_no_gettid_compat(preamble_for_target('linux', [define]))
        assert_no_gettid_compat(full_preamble_for_target('linux', [define]))
    }
}

fn test_generated_linux_gettid_call_has_compat_preamble() {
    source := 'module main

fn C.gettid() u32

fn thread_id() u32 {
    return C.gettid()
}

fn main() {
    _ = thread_id()
}
'
    src := generated_c_for_target_program_with_options('linux_gettid_call', source, 'linux', false,
        false)
    assert src.contains(linux_gettid_feature_define)
    assert src.contains(linux_gettid_helper)
    assert !src.contains('#define gettid')
    assert src.contains('return v_cleanc_gettid();')
    assert !src.contains('return gettid();')
    assert_c_marker_before(src, '#define _GNU_SOURCE', '#include <stdio.h>')
    assert_c_marker_before(src, 'static inline uint32_t v_cleanc_gettid(void)',
        'return v_cleanc_gettid();')
}

fn test_generated_musl_optional_gettid_branch_is_not_selected() {
    source := 'module main

fn C.gettid() u32

fn thread_id() u32 {
    $if linux && !musl ? {
        return C.gettid()
    } $else {
        return 0
    }
}

fn main() {
    _ = thread_id()
}
'
    src := generated_c_for_target_program_with_defines('linux_musl_gettid_branch', source, 'linux', [
        'musl',
    ], false, false)
    assert_no_gettid_compat(src)
    assert !src.contains('return gettid();')
    assert src.contains('return 0;')
}

fn test_generated_no_gettid_optional_branch_does_not_emit_compat() {
    source := 'module main

fn C.gettid() u32

fn thread_id() u32 {
    $if no_gettid ? {
        return 0
    } $else $if linux && !musl ? {
        return C.gettid()
    } $else {
        return 1
    }
}

fn main() {
    _ = thread_id()
}
'
    src := generated_c_for_target_program_with_defines('linux_no_gettid_branch', source, 'linux', [
        'no_gettid',
    ], false, false)
    assert_no_gettid_compat(src)
    assert !src.contains('return gettid();')
    assert src.contains('return 0;')
}

fn test_trace_calls_import_respects_no_gettid_and_musl() {
    for define in ['no_gettid', 'musl'] {
        src := generated_c_for_trace_calls_import_with_defines('trace_calls_${define}_import', [
            define,
        ])
        assert_no_gettid_compat(src)
        assert !src.contains('gettid(')
        assert src.contains('pthread_self()')
    }
}

fn test_label_followed_by_result_or_temp_emits_null_statement() {
    src := generated_c_for_target_program('label_before_result_or_temp', '
fn maybe_label_value() !string {
    return "ok"
}

fn main() {
    start_no_time:
    value := maybe_label_value() or { return }
    _ = value
}
')
    assert src.contains('start_no_time:;')
    assert src.contains('_result_string _or_t')
    assert !src.contains('start_no_time:\n\t_result_string _or_t')
}

fn test_generated_sort_comparator_casts_named_fn_to_fnsortcb() {
    src := generated_c_for_target_program('sort_generated_comparator_fnsortcb_cast', '
struct RepIndex {
    idx int
}

fn main() {
    mut idxs := [RepIndex{idx: 2}, RepIndex{idx: 1}]
    idxs.sort(a.idx < b.idx)
}
')
    assert src.contains('int __sort_cmp_RepIndex_by_idx_asc(RepIndex* a, RepIndex* b);')
    assert src.contains('array__sort_with_compare(idxs, (FnSortCB)__sort_cmp_RepIndex_by_idx_asc);')
    assert !src.contains('array__sort_with_compare(idxs, __sort_cmp_RepIndex_by_idx_asc);')
}

fn test_sort_with_compare_named_comparator_casts_to_fnsortcb() {
    src := generated_c_for_target_program('sort_named_comparator_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

struct Item {
    value int
}

fn array__sort_with_compare(mut items []Item, callback FnSortCB)

fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}

fn main() {
    mut items := [Item{value: 2}, Item{value: 1}]
    array__sort_with_compare(mut items, compare_items)
}
')
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)compare_items);')
    assert !src.contains('array__sort_with_compare(&items, compare_items);')
}

fn test_sort_with_compare_same_name_non_fnsortcb_callback_is_not_cast_to_fnsortcb() {
    src := generated_c_for_target_program('sort_same_name_non_fnsortcb_callback_no_cast', '
struct Item {
    value int
}

type ItemCallback = fn (&Item, &Item) int

fn array__sort_with_compare(mut items []Item, callback ItemCallback)

fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}

fn main() {
    mut items := [Item{value: 2}, Item{value: 1}]
    array__sort_with_compare(mut items, compare_items)
}
')
    assert src.contains('array__sort_with_compare(&items, compare_items);')
    assert !src.contains('(FnSortCB)compare_items')
}

fn test_sort_with_compare_module_qualified_comparator_casts_to_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_module_qualified_comparator_fnsortcb_cast', '
module main

import other

type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut items []other.Item, callback FnSortCB)

fn main() {
    mut items := [other.Item{value: 2}, other.Item{value: 1}]
    array__sort_with_compare(mut items, other.compare_items)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)other__compare_items);')
    assert !src.contains('array__sort_with_compare(&items, other__compare_items);')
}

fn test_sort_with_compare_import_alias_comparator_casts_to_real_module_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_alias_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_import_alias_comparator_fnsortcb_cast', '
module main

import other as oth

type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut items []oth.Item, callback FnSortCB)

fn main() {
    mut items := [oth.Item{value: 2}, oth.Item{value: 1}]
    array__sort_with_compare(mut items, oth.compare_items)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)other__compare_items);')
    assert !src.contains('array__sort_with_compare(&items, other__compare_items);')
    assert !src.contains('(FnSortCB)oth__compare_items')
}

fn test_sort_with_compare_module_global_callback_casts_to_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_global_callback_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub type ItemCallback = fn (&Item, &Item) int

pub __global callback ItemCallback
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_module_global_callback_fnsortcb_cast', '
module main

import other

type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut items []other.Item, callback FnSortCB)

fn main() {
    mut items := [other.Item{value: 2}, other.Item{value: 1}]
    array__sort_with_compare(mut items, other.callback)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)other__callback);')
    assert !src.contains('array__sort_with_compare(&items, other__callback);')
}

fn test_sort_with_compare_import_alias_global_callback_casts_to_real_module_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_alias_global_callback_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub type ItemCallback = fn (&Item, &Item) int

pub __global callback ItemCallback
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_import_alias_global_callback_fnsortcb_cast', '
module main

import other as oth

type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut items []oth.Item, callback FnSortCB)

fn main() {
    mut items := [oth.Item{value: 2}, oth.Item{value: 1}]
    array__sort_with_compare(mut items, oth.callback)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)other__callback);')
    assert !src.contains('array__sort_with_compare(&items, other__callback);')
    assert !src.contains('(FnSortCB)oth__callback')
}

fn test_sort_with_compare_module_const_callback_casts_to_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_const_callback_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub type ItemCallback = fn (&Item, &Item) int

pub fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}

pub const callback = ItemCallback(compare_items)
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_module_const_callback_fnsortcb_cast', '
module main

import other

type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut items []other.Item, callback FnSortCB)

fn main() {
    mut items := [other.Item{value: 2}, other.Item{value: 1}]
    array__sort_with_compare(mut items, other.callback)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)other__callback);')
    assert !src.contains('array__sort_with_compare(&items, other__callback);')
}

fn test_sort_with_compare_module_global_non_fn_value_is_not_cast_to_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_global_non_fn_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub __global callback int
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_module_global_non_fn_no_fnsortcb_cast', '
module main

import other

type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut items []other.Item, callback FnSortCB)

fn main() {
    mut items := [other.Item{value: 2}, other.Item{value: 1}]
    array__sort_with_compare(mut items, other.callback)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, other__callback);')
    assert !src.contains('(FnSortCB)other__callback')
}

fn test_sort_with_compare_local_selector_shadowing_module_is_not_cast_to_fnsortcb() {
    other_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_sort_other_shadowed_module_${os.getpid()}.v')
    os.write_file(other_file, '
module other

pub struct Item {
pub:
    value int
}

pub type ItemCallback = fn (&Item, &Item) int

pub __global callback ItemCallback
    ') or {
        panic(err)
    }
    defer {
        os.rm(other_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('sort_local_selector_shadowed_module_no_fnsortcb_cast', '
module main

import other

type FnSortCB = fn (voidptr, voidptr) int

type ItemCallback = fn (&other.Item, &other.Item) int

struct Holder {
    callback ItemCallback
}

fn array__sort_with_compare(mut items []other.Item, callback FnSortCB)

fn compare_items(a &other.Item, b &other.Item) int {
    return a.value - b.value
}

fn main() {
    mut items := [other.Item{value: 2}, other.Item{value: 1}]
    other := Holder{
        callback: compare_items
    }
    array__sort_with_compare(mut items, other.callback)
}
    ',
        'linux', [], false, false, [other_file])
    assert src.contains('array__sort_with_compare(&items, other.callback);')
    assert !src.contains('array__sort_with_compare(&items, (FnSortCB)other.callback);')
    assert !src.contains('(FnSortCB)other__callback')
}

fn test_sort_with_compare_selector_field_callback_is_not_cast_to_fnsortcb() {
    src := generated_c_for_target_program('sort_selector_field_callback_no_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

struct Item {
    value int
}

type ItemCallback = fn (&Item, &Item) int

struct Holder {
    callback ItemCallback
}

fn array__sort_with_compare(mut items []Item, callback FnSortCB)

fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}

fn main() {
    mut items := [Item{value: 2}, Item{value: 1}]
    holder := Holder{
        callback: compare_items
    }
    array__sort_with_compare(mut items, holder.callback)
}
')
    assert src.contains('array__sort_with_compare(&items, holder.callback);')
    assert !src.contains('array__sort_with_compare(&items, (FnSortCB)holder.callback);')
    assert !src.contains('(FnSortCB)holder__callback')
}

fn test_sorted_with_compare_named_comparator_casts_to_fnsortcb() {
    src := generated_c_for_target_program('sorted_named_comparator_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

struct Item {
    value int
}

fn array__sorted_with_compare(items []Item, callback FnSortCB) []Item

fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}

fn main() {
    items := [Item{value: 2}, Item{value: 1}]
    sorted := array__sorted_with_compare(items, compare_items)
    _ = sorted
}
')
    assert src.contains('array__sorted_with_compare(items, (FnSortCB)compare_items);')
    assert !src.contains('array__sorted_with_compare(items, compare_items);')
}

fn test_string_sort_helpers_cast_named_comparators_to_fnsortcb() {
    src := generated_c_for_target_program('string_sort_helpers_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

fn array__sort_with_compare(mut words []string, callback FnSortCB)

fn compare_lower_strings(a &string, b &string) int {
    return 0
}

fn compare_strings_by_len(a &string, b &string) int {
    return 0
}

fn (mut words []string) sort_ignore_case() {
    array__sort_with_compare(mut words, compare_lower_strings)
}

fn (mut words []string) sort_by_len() {
    array__sort_with_compare(mut words, compare_strings_by_len)
}

fn main() {
    mut words := ["Beta", "alpha", "z"]
    words.sort_ignore_case()
    words.sort_by_len()
}
')
    assert src.contains('Array_string__sort_ignore_case(&words);')
    assert src.contains('Array_string__sort_by_len(&words);')
    assert src.contains('array__sort_with_compare(words, (FnSortCB)compare_lower_strings);')
    assert src.contains('array__sort_with_compare(words, (FnSortCB)compare_strings_by_len);')
    assert !src.contains('array__sort_with_compare(words, compare_lower_strings);')
    assert !src.contains('array__sort_with_compare(words, compare_strings_by_len);')
}

fn test_sort_with_compare_capturing_fn_literal_casts_statement_expr_to_fnsortcb() {
    src := generated_c_for_target_program('sort_capturing_fn_literal_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

struct Item {
    value int
}

fn array__sort_with_compare(mut items []Item, callback FnSortCB)

fn main() {
    bias := 1
    mut items := [Item{value: 2}, Item{value: 1}]
    array__sort_with_compare(mut items, fn [bias] (a &Item, b &Item) int {
        return bias + a.value - b.value
    })
}
')
    assert src.contains('array__sort_with_compare(&items, (FnSortCB)({')
    assert src.contains('_anon_fn_')
    assert src.contains('_capture_0 = bias;')
    assert !src.contains('array__sort_with_compare(&items, ({')
}

fn test_sorted_with_compare_fn_literal_casts_to_fnsortcb() {
    src := generated_c_for_target_program('sorted_fn_literal_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

struct Item {
    value int
}

fn array__sorted_with_compare(items []Item, callback FnSortCB) []Item

fn main() {
    items := [Item{value: 2}, Item{value: 1}]
    sorted := array__sorted_with_compare(items, fn (a &Item, b &Item) int {
        return a.value - b.value
    })
    _ = sorted
}
')
    assert src.contains('array__sorted_with_compare(items, (FnSortCB)_anon_fn_')
    assert !src.contains('array__sorted_with_compare(items, _anon_fn_')
}

fn test_sort_with_compare_nil_callback_is_not_cast_to_fnsortcb() {
    src := generated_c_for_target_program('sort_nil_callback_no_fnsortcb_cast', '
type FnSortCB = fn (voidptr, voidptr) int

struct Item {
    value int
}

fn array__sort_with_compare(mut items []Item, callback FnSortCB)

fn main() {
    mut items := [Item{value: 2}, Item{value: 1}]
    array__sort_with_compare(mut items, nil)
}
')
    assert src.contains('array__sort_with_compare(&items, NULL);')
    assert !src.contains('(FnSortCB)nil')
    assert !src.contains('array__sort_with_compare(&items, (FnSortCB)')
}

fn test_non_sort_callback_arg_is_not_cast_to_fnsortcb() {
    src := generated_c_for_target_program('non_sort_callback_no_fnsortcb_cast', '
struct Item {
    value int
}

type ItemCallback = fn (&Item, &Item) int

fn compare_items(a &Item, b &Item) int {
    return a.value - b.value
}

fn use_callback(callback ItemCallback) {
    _ = callback
}

fn main() {
    use_callback(compare_items)
}
')
    assert src.contains('use_callback(compare_items);')
    assert !src.contains('(FnSortCB)compare_items')
}

fn test_non_sort_fn_literal_callback_arg_is_not_cast_to_fnsortcb() {
    src := generated_c_for_target_program('non_sort_fn_literal_callback_no_fnsortcb_cast', '
struct Item {
    value int
}

type ItemCallback = fn (&Item, &Item) int

fn use_callback(callback ItemCallback) {
    _ = callback
}

fn main() {
    bias := 1
    use_callback(fn [bias] (a &Item, b &Item) int {
        return bias + a.value - b.value
    })
}
')
    assert src.contains('use_callback(({')
    assert src.contains('_anon_fn_')
    assert src.contains('_capture_0 = bias;')
    assert !src.contains('(FnSortCB)')
    assert !src.contains('use_callback((FnSortCB)')
}

fn test_fn_pointer_alias_cast_from_voidptr_uses_alias_value_cast() {
    src := generated_c_for_target_program('fn_pointer_alias_voidptr_cast', '
module os

type Signal = int
type SignalHandler = fn (Signal)

fn handler_from_ptr(prev_handler voidptr) !SignalHandler {
    return SignalHandler(prev_handler)
}
')
    assert src.contains('_result_os__SignalHandler os__handler_from_ptr(void* prev_handler)')
    assert src.contains('os__SignalHandler _val = ((os__SignalHandler)(prev_handler));')
    assert !src.contains('os__SignalHandler _val = ((os__SignalHandler*)(prev_handler));')
}

fn test_option_fn_pointer_alias_cast_from_voidptr_uses_alias_value_cast() {
    src := generated_c_for_target_program('option_fn_pointer_alias_voidptr_cast', '
module os

type Signal = int
type SignalHandler = fn (Signal)

fn handler_from_ptr(prev_handler voidptr) ?SignalHandler {
    return SignalHandler(prev_handler)
}
')
    assert src.contains('_option_os__SignalHandler os__handler_from_ptr(void* prev_handler)')
    assert src.contains('os__SignalHandler _val = ((os__SignalHandler)(prev_handler));')
    assert !src.contains('os__SignalHandler _val = ((os__SignalHandler*)(prev_handler));')
}

fn test_explicit_pointer_to_fn_pointer_alias_cast_preserves_star() {
    src := generated_c_for_target_program('fn_pointer_alias_explicit_pointer_cast', '
module os

type Signal = int
type SignalHandler = fn (Signal)

fn handler_ptr_from_ptr(prev_handler voidptr) &SignalHandler {
    return &SignalHandler(prev_handler)
}
')
    assert src.contains('os__SignalHandler* os__handler_ptr_from_ptr(void* prev_handler)')
    assert src.contains('return ((os__SignalHandler*)(prev_handler));')
    assert !src.contains('return ((os__SignalHandler)(prev_handler));')
}

fn test_result_pointer_to_fn_pointer_alias_cast_preserves_payload_pointer() {
    src := generated_c_for_target_program('result_fn_pointer_alias_explicit_pointer_cast', '
module os

type Signal = int
type SignalHandler = fn (Signal)

fn handler_ptr_from_ptr(prev_handler voidptr) !&SignalHandler {
    return &SignalHandler(prev_handler)
}
')
    assert src.contains('_result_os__SignalHandlerptr os__handler_ptr_from_ptr(void* prev_handler)')
    assert src.contains('os__SignalHandler* _val = ((os__SignalHandler*)(prev_handler));')
    assert !src.contains('os__SignalHandler _val = ((os__SignalHandler)(prev_handler));')
}

fn test_option_pointer_to_fn_pointer_alias_cast_preserves_payload_pointer() {
    src := generated_c_for_target_program('option_fn_pointer_alias_explicit_pointer_cast', '
module os

type Signal = int
type SignalHandler = fn (Signal)

fn handler_ptr_from_ptr(prev_handler voidptr) ?&SignalHandler {
    return &SignalHandler(prev_handler)
}
')
    assert src.contains('_option_os__SignalHandlerptr os__handler_ptr_from_ptr(void* prev_handler)')
    assert src.contains('os__SignalHandler* _val = ((os__SignalHandler*)(prev_handler));')
    assert !src.contains('os__SignalHandler _val = ((os__SignalHandler)(prev_handler));')
}

fn test_non_fn_pointer_result_payload_keeps_pointer_cast() {
    src := generated_c_for_target_program('non_fn_pointer_result_payload', '
module os

struct Payload {
    value int
}

fn payload_from_ptr(raw voidptr) !&Payload {
    return &Payload(raw)
}
')
    assert src.contains('_result_os__Payloadptr os__payload_from_ptr(void* raw)')
    assert src.contains('os__Payload* _val = ((os__Payload*)(raw));')
    assert !src.contains('os__Payload _val = ((os__Payload)(raw));')
}

fn test_fn_pointer_alias_helper_has_no_suffix_fallback() {
    g := Gen{
        fn_type_aliases: {
            'os__SignalHandler': true
        }
    }
    assert g.c_type_is_fn_pointer_alias('os__SignalHandler')
    assert !g.c_type_is_fn_pointer_alias('other__SignalHandler')
    assert !g.c_type_is_fn_pointer_alias('os__SignalHandlerptr')
    assert !g.c_type_is_fn_pointer_alias('os__HandlerFn')
    assert g.result_value_type('_result_os__SignalHandlerptr') == 'os__SignalHandler*'
    assert g.result_value_type('_result_os__Payloadptr') == 'os__Payload*'
}

fn test_inter_module_non_fn_alias_cast_is_not_remapped_to_fn_alias_homonym() {
    foo_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_signalhandler_foo_${os.getpid()}.v')
    bar_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_signalhandler_bar_${os.getpid()}.v')
    os.write_file(foo_file, '
module foo

pub type SignalHandler = fn (int)
    ') or { panic(err) }
    os.write_file(bar_file, '
module bar

pub type SignalHandler = int
    ') or { panic(err) }
    defer {
        os.rm(foo_file) or {}
        os.rm(bar_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('inter_module_signalhandler_alias_collision', '
module main

import bar
import foo

fn keep_foo(handler foo.SignalHandler) {
    _ = handler
}

fn cast_bar() bar.SignalHandler {
    return bar.SignalHandler(1)
}
    ',
        'linux', [], false, false, [foo_file, bar_file])
    assert src.contains('typedef void (*foo__SignalHandler)(int);')
    assert src.contains('typedef int bar__SignalHandler;')
    assert src.contains('return ((bar__SignalHandler)(1));')
    assert !src.contains('return ((foo__SignalHandler)(1));')
    assert !src.contains('return ((os__SignalHandler)(1));')
}

fn test_module_local_non_fn_alias_cast_prefers_local_alias_over_main_fn_alias_homonym() {
    bar_file := os.join_path(os.temp_dir(),
        'v2_cleanc_target_codegen_signalhandler_local_bar_${os.getpid()}.v')
    os.write_file(bar_file, '
module bar

pub type SignalHandler = int

pub fn cast_local() SignalHandler {
    return SignalHandler(1)
}
    ') or {
        panic(err)
    }
    defer {
        os.rm(bar_file) or {}
    }
    src := generated_c_for_target_program_with_extra_files('module_local_signalhandler_alias_collision', '
module main

type SignalHandler = fn (int)

fn main() {
}
    ',
        'linux', [], false, false, [bar_file])
    assert src.contains('typedef void (*SignalHandler)(int);')
    assert src.contains('typedef int bar__SignalHandler;')
    assert src.contains('return ((bar__SignalHandler)(1));')
    assert !src.contains('return ((SignalHandler)(1));')
    assert !src.contains('return ((foo__SignalHandler)(1));')
}

fn test_optional_sumtype_field_initializer_wraps_cast_value_as_option() {
    src := generated_c_for_target_program('optional_sumtype_field_initializer', '
type Type = Bool | Int

struct Bool {}
struct Int {}

struct FnType {
    return_type ?Type
}

fn make_fn_type() FnType {
    return FnType{
        return_type: Type(Bool{})
    }
}

fn main() {
    _ = make_fn_type()
}
')
    assert src.contains('struct FnType {\n\t_option_Type return_type;\n};')
    assert src.contains('.return_type = ({ _option_Type _opt = (_option_Type){ .state = 2 }; Type _val = ((Type){')
    assert src.contains('_option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt; })')
    assert !src.contains('.return_type = ((Type){')
    assert !src.contains('.return_type = ((main__Type){')
}

fn test_freestanding_minimal_preamble_avoids_implicit_os_runtime_headers() {
    src := preamble_for_freestanding_field('linux')
    assert src.contains('#include <stdbool.h>')
    assert src.contains('#include <stdint.h>')
    assert src.contains('#include <stddef.h>')
    assert src.contains('#include <string.h>')
    assert !src.contains('#include <stdio.h>')
    assert !src.contains('#include <stdlib.h>')
    assert !src.contains('#include <windows.h>')
    assert !src.contains('#include <dirent.h>')
    assert !src.contains('#include <pthread.h>')
    assert !src.contains('#include <mach/mach.h>')
    assert src.contains('typedef struct sync__RwMutex { u32 inited; } sync__RwMutex;')
    assert !src.contains('pthread_rwlock_t')
}

fn test_freestanding_full_preamble_avoids_implicit_os_runtime_headers() {
    src := full_preamble_for_freestanding_field('linux')
    assert src.contains('#include <stdbool.h>')
    assert src.contains('#include <stdint.h>')
    assert src.contains('#include <stddef.h>')
    assert src.contains('#include <string.h>')
    assert !src.contains('#include <unistd.h>')
    assert !src.contains('#include <windows.h>')
    assert !src.contains('#include <pthread.h>')
    assert !src.contains('#include <dirent.h>')
    assert !src.contains('#include <termios.h>')
    assert !src.contains('#include <sys/wait.h>')
    assert src.contains('typedef struct sync__RwMutex { u32 inited; } sync__RwMutex;')
    assert !src.contains('pthread_rwlock_t')
}

fn test_freestanding_field_full_preamble_avoids_implicit_os_runtime_headers() {
    src := full_preamble_for_freestanding_field('linux')
    assert src.contains('#include <stdbool.h>')
    assert src.contains('#include <stdint.h>')
    assert src.contains('#include <stddef.h>')
    assert src.contains('#include <string.h>')
    assert !src.contains('#include <unistd.h>')
    assert !src.contains('#include <windows.h>')
    assert !src.contains('#include <pthread.h>')
    assert !src.contains('#include <dirent.h>')
    assert !src.contains('#include <termios.h>')
    assert !src.contains('#include <sys/wait.h>')
    assert src.contains('typedef struct sync__RwMutex { u32 inited; } sync__RwMutex;')
    assert !src.contains('pthread_rwlock_t')
}

fn test_user_define_freestanding_does_not_enable_freestanding_codegen() {
    src := full_preamble_for_target('linux', ['freestanding'])
    assert src.contains('#include <unistd.h>')
    assert src.contains('#include <pthread.h>')
    assert src.contains('#include <stdio.h>')
    assert src.contains('#include <stdlib.h>')
    assert src.contains('pthread_rwlock_t')
    assert !src.contains('typedef struct sync__RwMutex { u32 inited; } sync__RwMutex;')
}

fn test_freestanding_none_preamble_avoids_implicit_os_runtime_headers() {
    src := full_preamble_for_options('none', [], true, false)
    assert src.contains('#include <stdbool.h>')
    assert src.contains('#include <stdint.h>')
    assert src.contains('#include <stddef.h>')
    assert src.contains('#include <string.h>')
    assert src.contains('typedef struct sync__RwMutex { u32 inited; } sync__RwMutex;')
    assert_no_os_runtime_headers(src)
}

fn test_freestanding_prealloc_preamble_avoids_implicit_free_contract() {
    freestanding_src := full_preamble_for_options('linux', [], true, true)
    assert !freestanding_src.contains('#define _VPREALLOC (1)')
    assert !freestanding_src.contains('static inline void _v_cfree')
    assert !freestanding_src.contains('#define free(p)')

    hosted_src := full_preamble_for_options('linux', [], false, true)
    assert hosted_src.contains('#define _VPREALLOC (1)')
    assert hosted_src.contains('static inline void _v_cfree(void *p) { free(p); }')
    assert hosted_src.contains('#define free(p) ((void)(p), (void)0)')
}

fn test_freestanding_platform_hooks_preamble_declares_requested_hooks_without_hosted_headers() {
    generic_src := full_preamble_for_options('linux', ['freestanding_hooks'], true, false)
    assert !generic_src.contains('v_platform_write')
    assert !generic_src.contains('v_platform_panic')
    assert !generic_src.contains('v_platform_malloc')

    spoofed_src := full_preamble_for_options('linux', ['freestanding_hooks', 'freestanding_output',
        'freestanding_panic', 'freestanding_alloc'], true, false)
    assert !spoofed_src.contains('v_platform_write')
    assert !spoofed_src.contains('v_platform_panic')
    assert !spoofed_src.contains('v_platform_malloc')

    output_src := full_preamble_for_freestanding_hooks(['output'])
    assert output_src.contains('isize v_platform_write(int stream, const u8* buf, isize len);')
    assert !output_src.contains('v_platform_panic')
    assert !output_src.contains('v_platform_malloc')
    assert !output_src.contains('#include <stdio.h>')
    assert !output_src.contains('#include <stdlib.h>')
    assert !output_src.contains('#include <unistd.h>')

    panic_src := full_preamble_for_freestanding_hooks(['panic'])
    assert panic_src.contains('void v_platform_panic(const u8* msg, isize len);')
    assert !panic_src.contains('v_platform_write')
    assert !panic_src.contains('v_platform_malloc')

    alloc_src := full_preamble_for_freestanding_hooks(['alloc'])
    assert alloc_src.contains('void* v_platform_malloc(isize n);')
    assert alloc_src.contains('void* v_platform_realloc(void* ptr, isize n);')
    assert alloc_src.contains('void v_platform_free(void* ptr);')
    assert !alloc_src.contains('v_platform_write')
    assert !alloc_src.contains('v_platform_panic')

    minimal_src := full_preamble_for_freestanding_hooks(['output', 'panic', 'alloc'])
    assert minimal_src.contains('isize v_platform_write(int stream, const u8* buf, isize len);')
    assert minimal_src.contains('void v_platform_panic(const u8* msg, isize len);')
    assert minimal_src.contains('void* v_platform_malloc(isize n);')
    assert minimal_src.contains('void* v_platform_realloc(void* ptr, isize n);')
    assert minimal_src.contains('void v_platform_free(void* ptr);')
    assert !minimal_src.contains('#include <stdio.h>')
    assert !minimal_src.contains('#include <stdlib.h>')
    assert !minimal_src.contains('#include <unistd.h>')
}

fn test_windows_minimal_preamble_avoids_posix_headers() {
    src := preamble_for_target('windows', [])
    assert !src.contains('#include <dirent.h>')
    assert !src.contains('#include <pthread.h>')
    assert !src.contains('#include <mach/mach.h>')
    assert src.contains('#include <windows.h>')
    assert src.contains('typedef struct sync__RwMutex { SRWLOCK mutex; u32 inited; } sync__RwMutex;')
    assert src.contains('AcquireSRWLockExclusive')
    assert !src.contains('static inline void sync__RwMutex_lock(sync__RwMutex* m) { (void)m; }')
    assert !src.contains('pthread_rwlock_t')
    assert src.contains('#include <stdio.h>')
    assert src.contains('#include <stdlib.h>')
}

fn test_windows_full_preamble_avoids_posix_headers() {
    src := full_preamble_for_target('windows', [])
    assert !src.contains('#include <unistd.h>')
    assert !src.contains('#include <sys/wait.h>')
    assert !src.contains('#include <termios.h>')
    assert !src.contains('#include <sys/ioctl.h>')
    assert !src.contains('#include <dirent.h>')
    assert !src.contains('#include <pthread.h>')
    assert src.contains('#include <windows.h>')
    assert src.contains('typedef struct sync__RwMutex { SRWLOCK mutex; u32 inited; } sync__RwMutex;')
    assert src.contains('AcquireSRWLockExclusive')
    assert !src.contains('static inline void sync__RwMutex_lock(sync__RwMutex* m) { (void)m; }')
    assert !src.contains('pthread_rwlock_t')
    assert src.contains('#include <stdio.h>')
    assert src.contains('#include <stdlib.h>')
    assert src.contains('#include <time.h>')
}

fn test_minimal_generated_c_does_not_emit_unused_runtime_fallbacks() {
    csrc := generated_c_for_target_program('minimal_runtime_fallbacks', 'module main

fn main() {}
')
    assert csrc.contains('int main(')
    assert_no_hosted_runtime_fallbacks(csrc)
    assert !csrc.contains('__v_live_init')
}

fn test_freestanding_skip_builtin_minimal_does_not_emit_hosted_runtime_fallbacks() {
    csrc := generated_c_for_target_program_with_options('freestanding_minimal_runtime_fallbacks', 'module main

fn main() {}
',
        'linux', true, true)
    assert csrc.contains('int main(')
    assert_no_hosted_runtime_fallbacks(csrc)
    assert !csrc.contains('__v_live_init')
}

fn test_live_reload_detects_live_functions_in_active_comptime_blocks() {
    csrc := generated_c_for_target_program('active_live_comptime', 'module main

\$if linux {
    @[live]
    fn hot_reload() {}
}

fn main() {}
')
    assert csrc.contains('void __v_live_init(void);')
    assert csrc.contains('__v_live_init();')
}

fn test_live_reload_ignores_live_functions_in_inactive_comptime_blocks() {
    csrc := generated_c_for_target_program('inactive_live_comptime', 'module main

\$if windows {
    @[live]
    fn hot_reload() {}
}

fn main() {}
')
    assert !csrc.contains('__v_live_init')
}

fn test_runtime_fallbacks_emit_arguments_only_when_referenced() {
    minimal_src := runtime_fallbacks_for_called_functions([])
    assert !minimal_src.contains('__attribute__((weak)) Array_string arguments()')

    args_src := runtime_fallbacks_for_called_functions(['arguments'])
    assert args_src.contains('__attribute__((weak)) Array_string arguments()')
    assert !args_src.contains('__attribute__((weak)) void _write_buf_to_fd')
}

fn test_freestanding_without_alloc_hook_arguments_refuses_without_hosted_alloc() {
    src := runtime_fallbacks_for_called_functions_with_hooks(['arguments'], ['output'])
    assert src.contains('__attribute__((weak)) Array_string arguments()')
    assert !src.contains('__new_array_with_default_noscan')
    assert !src.contains('tos_clone')
    assert !src.contains('array__push')
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_runtime_fallbacks_emit_stdout_helpers_only_when_printing_is_referenced() {
    print_src := runtime_fallbacks_for_called_functions(['println'])
    assert print_src.contains('__attribute__((weak)) void _write_buf_to_fd')
    assert print_src.contains('__attribute__((weak)) void _writeln_to_fd')
    assert print_src.contains('isize written = write(fd, ptr, remaining_bytes)')
    assert !print_src.contains('WriteFile(')
    assert !print_src.contains('__attribute__((weak)) Array_string arguments()')
    assert !print_src.contains('__attribute__((weak)) void eprint')
    assert !print_src.contains('__attribute__((weak)) void flush_stdout')
    assert !print_src.contains('__attribute__((weak)) void flush_stderr')
}

fn test_windows_runtime_fallbacks_use_writefile_for_stdout_helpers() {
    src := runtime_fallbacks_for_called_functions_for_target('windows', ['println'])
    assert src.contains('__attribute__((weak)) void _write_buf_to_fd')
    assert !src.contains('write(fd, ptr, remaining_bytes)')
    assert src.contains('GetStdHandle(fd == 2 ? STD_ERROR_HANDLE : STD_OUTPUT_HANDLE)')
    assert src.contains('WriteFile(handle, ptr, (DWORD)remaining_bytes, &win_written, NULL)')
}

fn test_cross_runtime_fallbacks_guard_windows_stdout_helpers() {
    src := runtime_fallbacks_for_called_functions_for_target('cross', ['println'])
    assert src.contains('__attribute__((weak)) void _write_buf_to_fd')
    assert src.contains('#if defined(_WIN32)')
    assert src.contains('GetStdHandle(fd == 2 ? STD_ERROR_HANDLE : STD_OUTPUT_HANDLE)')
    assert src.contains('WriteFile(handle, ptr, (DWORD)remaining_bytes, &win_written, NULL)')
    assert src.contains('#else\n\t\tisize written = write(fd, ptr, remaining_bytes);\n#endif')
}

fn test_runtime_fallbacks_emit_eprint_and_flush_only_when_referenced() {
    minimal_src := runtime_fallbacks_for_called_functions([])
    assert !minimal_src.contains('__attribute__((weak)) void eprint')
    assert !minimal_src.contains('__attribute__((weak)) void flush_stdout')
    assert !minimal_src.contains('__attribute__((weak)) void flush_stderr')

    eprint_src := runtime_fallbacks_for_called_functions(['eprint'])
    assert eprint_src.contains('__attribute__((weak)) void eprint')
    assert eprint_src.contains('__attribute__((weak)) void _write_buf_to_fd')
    assert eprint_src.contains('__attribute__((weak)) void flush_stdout')
    assert eprint_src.contains('__attribute__((weak)) void flush_stderr')
}

fn test_runtime_fallbacks_emit_structural_helpers_only_when_referenced() {
    minimal_src := runtime_fallbacks_for_called_functions([])
    assert_no_hosted_runtime_fallbacks(minimal_src)

    memdup_src := runtime_fallbacks_for_called_functions(['memdup'])
    assert memdup_src.contains('__attribute__((weak)) u8* malloc_noscan')
    assert memdup_src.contains('__attribute__((weak)) void* memdup')

    array_src := runtime_fallbacks_for_called_functions(['Array_string_contains',
        'Array_string_index', 'Array_int_str'])
    assert array_src.contains('__attribute__((weak)) bool Array_string_contains')
    assert array_src.contains('__attribute__((weak)) int Array_string_index')
    assert array_src.contains('__attribute__((weak)) string Array_int_str')
    assert !array_src.contains('__attribute__((weak)) u8* malloc_noscan')

    bits_src := runtime_fallbacks_for_called_functions(['__at_least_one', 'bits__leading_zeros_64',
        'bits__rotate_left_32', 'f32__str'])
    assert bits_src.contains('__attribute__((weak)) u64 __at_least_one')
    assert bits_src.contains('__attribute__((weak)) int bits__leading_zeros_64')
    assert bits_src.contains('__attribute__((weak)) u32 bits__rotate_left_32')
    assert bits_src.contains('__attribute__((weak)) string f64__str')
    assert bits_src.contains('__attribute__((weak)) string f32__str')
}

fn test_runtime_fallbacks_emit_float_strg_dependency_closure() {
    f32_strg_src := runtime_fallbacks_for_called_functions(['f32__strg'])
    f64_str_idx := f32_strg_src.index('__attribute__((weak)) string f64__str(f64 x)') or {
        panic('missing f64__str fallback')
    }
    f64_strg_idx := f32_strg_src.index('__attribute__((weak)) string f64__strg') or {
        panic('missing f64__strg fallback')
    }
    f32_strg_idx := f32_strg_src.index('__attribute__((weak)) string f32__strg') or {
        panic('missing f32__strg fallback')
    }
    assert f32_strg_src.contains('__attribute__((weak)) u8* malloc_noscan')
    assert f64_str_idx < f64_strg_idx
    assert f64_strg_idx < f32_strg_idx
    assert f32_strg_src.contains('\treturn f64__str(x);')
    assert f32_strg_src.contains('\treturn f64__strg((f64)x);')

    f64_strg_src := runtime_fallbacks_for_called_functions(['f64__strg'])
    f64_str_direct_idx := f64_strg_src.index('__attribute__((weak)) string f64__str(f64 x)') or {
        panic('missing f64__str fallback for f64__strg')
    }
    f64_strg_direct_idx := f64_strg_src.index('__attribute__((weak)) string f64__strg') or {
        panic('missing f64__strg fallback for direct reference')
    }
    assert f64_strg_src.contains('__attribute__((weak)) u8* malloc_noscan')
    assert f64_str_direct_idx < f64_strg_direct_idx

    existing_c_src :=
        runtime_fallbacks_for_existing_c_source('void keep_generated_code(void) { f32__strg((f32)0); }')
    existing_f64_str_idx := existing_c_src.index('__attribute__((weak)) string f64__str(f64 x)') or {
        panic('missing f64__str fallback for existing C reference')
    }
    existing_f64_strg_idx := existing_c_src.index('__attribute__((weak)) string f64__strg') or {
        panic('missing f64__strg fallback for existing C reference')
    }
    existing_f32_strg_idx := existing_c_src.index('__attribute__((weak)) string f32__strg') or {
        panic('missing f32__strg fallback for existing C reference')
    }
    assert existing_f64_str_idx < existing_f64_strg_idx
    assert existing_f64_strg_idx < existing_f32_strg_idx
}

fn test_float_str_fallbacks_rely_on_kept_builtin_float_runtime() {
    for path in [
        'vlib/builtin/float.c.v',
        'vlib/strconv/ftoa.c.v',
        'vlib/strconv/f32_str.c.v',
        'vlib/strconv/f64_str.c.v',
    ] {
        assert is_builtin_runtime_keep_file(path), path
    }
}

fn test_runtime_fallbacks_emit_structural_helpers_for_existing_c_references() {
    src :=
        runtime_fallbacks_for_existing_c_source('void keep_generated_code(void) { memdup(0, 0); Array_string_contains((Array_string){0}, (string){0}); }')
    assert src.contains('void keep_generated_code(void)')
    assert src.contains('__attribute__((weak)) u8* malloc_noscan')
    assert src.contains('__attribute__((weak)) void* memdup')
    assert src.contains('__attribute__((weak)) bool Array_string_contains')
    assert !src.contains('__attribute__((weak)) bool Array_int_contains')
}

fn test_freestanding_output_hooks_runtime_fallbacks_avoid_hosted_io() {
    src := runtime_fallbacks_for_called_functions_with_hooks(['println', 'eprint'], [
        'output',
    ])
    assert src.contains('__attribute__((weak)) void _write_buf_to_fd')
    assert src.contains('v_platform_write(fd, ptr, remaining_bytes)')
    assert src.contains('__attribute__((weak)) void _writeln_to_fd')
    assert src.contains('__attribute__((weak)) void eprint')
    assert src.contains('__attribute__((weak)) void flush_stdout')
    assert src.contains('__attribute__((weak)) void flush_stderr')
    assert_no_hosted_output_runtime(src)
}

fn test_freestanding_without_output_hook_runtime_fallbacks_refuse_without_hosted_io() {
    src := runtime_fallbacks_for_called_functions_with_hooks(['println', 'eprint'], [
        'panic',
    ])
    assert src.contains('__attribute__((weak)) void _write_buf_to_fd')
    assert src.contains('__attribute__((weak)) void _writeln_to_fd')
    assert src.contains('__attribute__((weak)) void eprint')
    assert src.contains('__attribute__((weak)) void flush_stdout')
    assert src.contains('__attribute__((weak)) void flush_stderr')
    assert !src.contains('v_platform_write')
    assert_freestanding_output_refusal_without_hosted_io(src)
}

fn test_freestanding_spoofed_hook_defines_do_not_call_platform_hooks() {
    src := runtime_fallbacks_for_called_functions_with_options(['println', 'panic', 'memdup'], [
        'freestanding_hooks',
        'freestanding_output',
        'freestanding_panic',
        'freestanding_alloc',
    ], true)
    assert !src.contains('v_platform_write')
    assert !src.contains('v_platform_panic')
    assert !src.contains('v_platform_malloc')
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_freestanding_output_hook_non_string_print_refuses_without_hosted_formatting() {
    src := generated_c_for_target_program_with_hooks('freestanding_output_print_non_string', 'module main

fn println(v int) {}

fn main() {
    println(123)
}
        ', [
        'output',
    ])
    assert !src.contains('int__str(')
    assert_freestanding_format_refusal_without_hosted_formatting(src)
}

fn test_freestanding_output_hook_voidptr_print_refuses_without_hosted_formatting() {
    src := generated_c_for_target_program_with_hooks('freestanding_output_print_voidptr', 'module main

fn print(v voidptr) {}

fn main() {
    print(voidptr(0))
}
        ', [
        'output',
    ])
    assert !src.contains('int__str(')
    assert_freestanding_format_refusal_without_hosted_formatting(src)
}

fn test_freestanding_string_interpolation_refuses_without_hosted_formatting() {
    src := generated_c_for_target_program_with_hooks('freestanding_string_interpolation', "module main

fn main() {
    _ := '\${1}'
}
        ", [
        'alloc',
    ])
    assert !src.contains('snprintf(')
    assert !src.contains('memdup(')
    assert_freestanding_format_refusal_without_hosted_formatting(src)
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_alloc_hooks_runtime_fallbacks_avoid_hosted_alloc() {
    src := runtime_fallbacks_for_called_functions_with_hooks(['memdup', 'DenseArray__zeros_to_end'], [
        'alloc',
    ])
    assert src.contains('__attribute__((weak)) u8* malloc_noscan')
    assert src.contains('return (u8*)v_platform_malloc(n);')
    assert src.contains('__attribute__((weak)) void* memdup')
    assert src.contains('void* res = v_platform_malloc(sz);')
    assert src.contains('__attribute__((weak)) void DenseArray__zeros_to_end')
    assert src.contains('void* tmp_value = v_platform_malloc(d->value_bytes);')
    assert src.contains('v_platform_free(tmp_value);')
    assert src.contains('v_platform_realloc(d->values, d->value_bytes * d->cap);')
    assert_no_hosted_alloc_runtime(src)
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_without_alloc_hook_heap_helpers_refuse_without_hosted_alloc() {
    g := new_target_test_gen_with_freestanding('linux', [
        'freestanding_hooks',
        'freestanding_output',
        'freestanding_panic',
    ], true)
    malloc_expr := g.c_heap_malloc_call('n')
    realloc_expr := g.c_heap_realloc_call('p', 'n')
    free_expr := g.c_heap_free_call('p')
    helper_src := '${malloc_expr}\n${realloc_expr}\n${free_expr}'
    assert helper_src.contains('(void*)0')
    assert helper_src.contains('(void)0')
    assert_freestanding_alloc_refusal_without_hosted_heap(helper_src)
}

fn test_freestanding_without_alloc_hook_runtime_heap_paths_refuse_without_hosted_alloc() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks('void keep_generated_code(void) { memdup(0, 1); DenseArray__zeros_to_end(0); }', [
        'output',
        'panic',
    ])
    assert src.contains('__attribute__((weak)) void* memdup')
    assert src.contains('__attribute__((weak)) void DenseArray__zeros_to_end')
    assert src.contains('void* res = ({ _Static_assert')
    assert src.contains('d->values = ({ _Static_assert')
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_freestanding_skip_builtin_runtime_heap_helpers_refuse_in_generated_c() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) { array__push(0, 0); string__plus((string){0}, (string){0}); new_map(); }', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'array__push')
    assert_freestanding_heap_runtime_refusal(src, 'string__plus')
    assert_freestanding_heap_runtime_refusal(src, 'new_map')
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_skip_builtin_runtime_heap_helper_table_refuses_each_helper() {
    for helper in freestanding_heap_runtime_helper_names() {
        src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) { ${helper}(); }', [
            'output',
            'panic',
            'alloc',
        ])
        assert_freestanding_heap_runtime_refusal(src, helper)
        assert !src.contains('__attribute__((weak))')
    }
}

fn test_runtime_symbol_scan_ignores_comments_and_string_literals() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) {
    const char* literal = "array__push(0, 0)";
    /* array__push(0, 0); */
    // &array__push
    array__push_many(0, 0, 0);
}', [
        'output',
        'panic',
        'alloc',
    ])
    assert !src.contains('_Static_assert(0, "${freestanding_missing_heap_runtime_message}: array__push")')
    assert_freestanding_heap_runtime_refusal(src, 'array__push_many')
}

fn test_runtime_symbol_scan_detects_bare_callback_identifier() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) {
    array__sort_with_compare(0, compare_strings);
}', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'array__sort_with_compare')
    assert_freestanding_heap_runtime_refusal(src, 'compare_strings')
}

fn test_freestanding_skip_builtin_structural_array_fallbacks_refuse_clearly() {
    for helper in ['Array_int_contains', 'Array_string_contains', 'Array_string_index',
        'Array_int_str'] {
        src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) { ${helper}(); }', [
            'output',
            'panic',
            'alloc',
        ])
        assert_freestanding_heap_runtime_refusal(src, helper)
    }
}

fn test_freestanding_skip_builtin_ierror_str_refuses_with_panic_hook() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) { v_panic(IError__str((IError){0})); }', [
        'output',
        'panic',
        'alloc',
    ])
    assert src.contains('v_platform_panic(s.str, s.len);')
    assert_freestanding_heap_runtime_refusal(src, 'IError__str')
}

fn test_freestanding_skip_builtin_string_lt_from_v_code_refuses_runtime_helper() {
    src := generated_c_for_target_program_with_hooks('freestanding_string_lt_runtime_helper', 'module main

fn main() {
    a := "a"
    b := "b"
    _ := a < b
}
        ', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'string__lt')
}

fn test_freestanding_skip_builtin_string_concat_from_v_code_refuses_runtime_helper() {
    src := generated_c_for_target_program_with_hooks('freestanding_string_concat_runtime_helper', 'module main

fn main() {
    a := "a"
    b := "b"
    c := "c"
    _ := a + b + c
}
        ', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'string__plus_two')
}

fn test_freestanding_skip_builtin_string_method_runtime_helpers_refuse_in_generated_c() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) {
    string__contains((string){0}, (string){0});
    string__starts_with((string){0}, (string){0});
    string__ends_with((string){0}, (string){0});
    string__clone((string){0});
    string__split((string){0}, (string){0});
}', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'string__contains')
    assert_freestanding_heap_runtime_refusal(src, 'string__starts_with')
    assert_freestanding_heap_runtime_refusal(src, 'string__ends_with')
    assert_freestanding_heap_runtime_refusal(src, 'string__clone')
    assert_freestanding_heap_runtime_refusal(src, 'string__split')
}

fn test_freestanding_skip_builtin_array_equality_from_v_code_refuses_runtime_helper() {
    src := generated_c_for_target_program_with_hooks('freestanding_array_eq_runtime_helper', 'module main

fn main() {
    a := [1]
    b := [1]
    _ := a == b
}
        ', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, '__v2_array_eq')
}

fn test_freestanding_skip_builtin_array_sort_runtime_helper_refuses_in_generated_c() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) { array__sort(0, 0); array__sort_with_compare(0, 0); }', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'array__sort')
    assert_freestanding_heap_runtime_refusal(src, 'array__sort_with_compare')
}

fn test_freestanding_skip_builtin_map_equality_from_v_code_refuses_runtime_helpers() {
    src := generated_c_for_target_program_with_hooks('freestanding_map_eq_runtime_helpers', 'module main

fn main() {
    a := {
        "x": 1
    }
    b := {
        "x": 1
    }
    _ := a == b
}
        ', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'map__exists')
    assert_freestanding_heap_runtime_refusal(src, 'map__get')
    assert_freestanding_heap_runtime_refusal(src, 'DenseArray__has_index')
    assert_freestanding_heap_runtime_refusal(src, 'DenseArray__key')
    assert_freestanding_heap_runtime_refusal(src, 'DenseArray__value')
}

fn test_freestanding_skip_builtin_map_method_runtime_helpers_refuse_in_generated_c() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) {
    map__clear(0);
    map__delete(0, 0);
    map__keys(0);
    map__reserve(0, 0);
    map__move(0);
    map__values(0);
}', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'map__clear')
    assert_freestanding_heap_runtime_refusal(src, 'map__delete')
    assert_freestanding_heap_runtime_refusal(src, 'map__keys')
    assert_freestanding_heap_runtime_refusal(src, 'map__reserve')
    assert_freestanding_heap_runtime_refusal(src, 'map__move')
    assert_freestanding_heap_runtime_refusal(src, 'map__values')
}

fn test_freestanding_skip_builtin_generic_array_contains_from_v_code_refuses_runtime_helper() {
    src := generated_c_for_target_program_with_hooks('freestanding_generic_array_contains_runtime_helper', 'module main

struct Point {
    x int
}

fn main() {
    points := [Point{
        x: 1
    }]
    needle := Point{
        x: 1
    }
    _ := needle in points
}
        ', [
        'output',
        'panic',
        'alloc',
    ])
    assert src.contains('_Static_assert(0, "${freestanding_missing_heap_runtime_message}: Array_')
    assert src.contains('_contains")')
    assert !src.contains('__attribute__((weak)) bool Array_')
    assert !src.contains('array__get(')
}

fn test_freestanding_skip_builtin_string_substr_or_runtime_helper_refuses_in_generated_c() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks_skip_builtin('void keep_generated_code(void) { string__substr_or((string){0}, 0, 1, (string){0}); }', [
        'output',
        'panic',
        'alloc',
    ])
    assert_freestanding_heap_runtime_refusal(src, 'string__substr_or')
}

fn test_freestanding_panic_hook_runtime_fallback_avoids_hosted_exit() {
    src := runtime_fallbacks_for_called_functions_with_hooks(['panic'], ['panic'])
    assert src.contains('__attribute__((weak)) void v_panic(string s)')
    assert src.contains('v_platform_panic(s.str, s.len);')
    assert src.contains('for (;;) {}')
    assert !src.contains('C.exit')
    assert !src.contains('exit(')
}

fn test_freestanding_without_panic_hook_runtime_fallback_refuses_without_unresolved_symbol() {
    src := runtime_fallbacks_for_called_functions_with_hooks(['panic'], ['output'])
    assert src.contains('__attribute__((weak)) void v_panic(string s)')
    assert src.contains('for (;;) {}')
    assert_freestanding_panic_refusal_without_hosted_exit(src)
}

fn test_freestanding_hooks_for_existing_c_references_do_not_drop_generated_c() {
    src := runtime_fallbacks_for_existing_c_source_with_hooks('void keep_generated_code(void) { v_panic((string){0}); memdup(0, 1); }', [
        'output',
        'panic',
        'alloc',
    ])
    assert src.contains('void keep_generated_code(void)')
    assert src.contains('v_platform_panic(s.str, s.len);')
    assert src.contains('void* res = v_platform_malloc(sz);')
    assert_no_hosted_alloc_runtime(src)
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_alloc_hook_generated_c_heap_address_uses_platform_alloc() {
    src := generated_c_for_target_program_with_hooks('freestanding_alloc_heap_address', 'module main

struct Point {
    x int
}

fn main() {
    p := &Point{
        x: 1
    }
    _ := p.x
}
        ', [
        'alloc',
    ])
    assert src.contains('v_platform_malloc(sizeof(Point))')
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_without_alloc_hook_heap_address_refuses_without_hosted_alloc() {
    src := generated_c_for_target_program_with_hooks('freestanding_missing_alloc_heap_address', 'module main

struct Point {
    x int
}

fn main() {
    p := &Point{
        x: 1
    }
    _ := p.x
}
        ', [
        'output',
        'panic',
    ])
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_freestanding_without_alloc_hook_returned_local_clone_refuses_without_hosted_alloc() {
    src := generated_c_for_target_program_with_hooks('freestanding_missing_alloc_returned_local_clone', 'module main

struct Point {
    x int
}

fn make() &Point {
    value := Point{
        x: 1
    }
    ptr := &value
    return ptr
}

fn main() {
    p := make()
    _ := p.x
}
        ', [
        'output',
        'panic',
    ])
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_freestanding_alloc_hook_interface_heap_cast_uses_platform_alloc() {
    src := generated_c_for_target_program_with_hooks('freestanding_alloc_interface_heap_cast', 'module main

interface Runner {
    next() int
}

struct Concrete {}

fn (mut c Concrete) next() int {
    _ = c
    return 7
}

fn make() &Runner {
    mut c := Concrete{}
    return &Runner(c)
}

fn main() {
    r := make()
    _ := r.next()
}
        ', [
        'alloc',
    ])
    assert src.contains('Runner* _iface_t = (Runner*)v_platform_malloc(sizeof(Runner))')
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_without_alloc_hook_interface_heap_cast_refuses_without_hosted_alloc() {
    src := generated_c_for_target_program_with_hooks('freestanding_missing_alloc_interface_heap_cast', 'module main

interface Runner {
    next() int
}

struct Concrete {}

fn (mut c Concrete) next() int {
    _ = c
    return 7
}

fn make() &Runner {
    mut c := Concrete{}
    return &Runner(c)
}

fn main() {
    r := make()
    _ := r.next()
}
        ', [
        'output',
        'panic',
    ])
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_freestanding_alloc_hook_soa_helpers_use_platform_alloc() {
    src := soa_companion_for_hooks(['alloc'])
    assert src.contains('v_platform_malloc(cap * sizeof(int))')
    assert src.contains('memset(soa.x, 0, cap * sizeof(int));')
    assert src.contains('v_platform_realloc(soa->x, new_cap * sizeof(int))')
    assert src.contains('v_platform_free(soa->x);')
    assert_no_raw_heap_runtime(src)
}

fn test_freestanding_without_alloc_hook_soa_helpers_refuse_without_hosted_alloc() {
    src := soa_companion_for_hooks(['output', 'panic'])
    assert src.contains('soa.x = (int*)({ _Static_assert')
    assert src.contains('soa->x = (int*)({ _Static_assert')
    assert src.contains('({ _Static_assert(0, "${freestanding_missing_alloc_hook_message}"); (void)0; });')
    assert_freestanding_alloc_refusal_without_hosted_heap(src)
}

fn test_freestanding_minimal_hooks_runtime_and_heap_paths_avoid_raw_alloc() {
    hooks := ['output', 'panic', 'alloc']
    runtime_src := runtime_fallbacks_for_existing_c_source_with_hooks('void keep_generated_code(void) { v_panic((string){0}); memdup(0, 1); DenseArray__zeros_to_end(0); }',
        hooks)
    assert runtime_src.contains('v_platform_panic(s.str, s.len);')
    assert runtime_src.contains('v_platform_malloc(sz);')
    assert runtime_src.contains('v_platform_realloc(d->values, d->value_bytes * d->cap);')
    assert_no_raw_heap_runtime(runtime_src)

    soa_src := soa_companion_for_hooks(hooks)
    assert soa_src.contains('v_platform_malloc(cap * sizeof(int))')
    assert soa_src.contains('v_platform_realloc(soa->x, new_cap * sizeof(int))')
    assert_no_raw_heap_runtime(soa_src)
}

fn test_freestanding_fixed_array_voidptr_stringification_avoids_hosted_formatting() {
    src := fixed_array_voidptr_str_write_for_hooks(['alloc'])
    assert src.contains('uintptr_t _addr = (uintptr_t)(items[0]);')
    assert src.contains('"0123456789abcdef"')
    assert src.contains('strings__Builder__write_string(&sb')
    assert_no_hosted_formatting_or_abort_runtime(src)
}

fn test_freestanding_unresolved_generic_stub_uses_panic_hook_without_hosted_abort() {
    src := unresolved_generic_stub_for_hooks(['panic'])
    assert src.contains('v_platform_panic((const u8*)')
    assert src.contains('for (;;) {}')
    assert !src.contains('#error')
    assert_no_hosted_formatting_or_abort_runtime(src)
}

fn test_freestanding_unresolved_generic_stub_without_panic_hook_refuses_without_hosted_abort() {
    src := unresolved_generic_stub_for_hooks(['output'])
    assert src.contains('#error "v2: unresolved generic stub requires freestanding panic platform hook"')
    assert_no_hosted_formatting_or_abort_runtime(src)
}