module builder

import os

const target_linux_marker = '<target_marker_linux.h>'
const target_macos_marker = '<target_marker_macos.h>'
const target_windows_marker = '<target_marker_windows.h>'
const target_cross_marker = '<target_marker_cross.h>'
const target_freestanding_marker = '<target_marker_freestanding.h>'
const inactive_windows_marker = '<inactive_windows_marker.h>'
const inactive_freestanding_marker = '<inactive_freestanding_marker.h>'
const active_comptime_marker = '<active_comptime_marker.h>'
const e2e_freestanding_missing_alloc_hook_message = 'v2: freestanding target requires freestanding_alloc hook for heap allocation'
const e2e_freestanding_missing_format_hook_message = 'v2: freestanding target cannot print non-string values without formatting support'
const e2e_freestanding_missing_heap_runtime_message = 'v2: freestanding target cannot use V runtime heap helpers with --skip-builtin'
const e2e_freestanding_missing_output_hook_message = 'v2: freestanding target requires freestanding_output hook for output'
const e2e_freestanding_missing_panic_hook_message = 'v2: freestanding target requires freestanding_panic hook for panic'

struct CleancCliResult {
    exit_code int
    output    string
    c_source  string
    out_path  string
    c_path    string
}

fn e2e_repo_root() string {
    mut dir := os.dir(@FILE)
    for _ in 0 .. 10 {
        if os.exists(os.join_path(dir, 'cmd', 'v2', 'v2.v'))
            && os.exists(os.join_path(dir, 'vlib', 'builtin')) {
            return dir
        }
        dir = os.dir(dir)
    }
    panic('could not locate repo root for cleanc target e2e')
}

fn normalize_e2e_os_name(target_os string) string {
    return match target_os.to_lower() {
        'darwin', 'mac' { 'macos' }
        else { target_os.to_lower() }
    }
}

fn e2e_v2_binary_name() string {
    mut name := 'cleanc_target_e2e'
    $if windows {
        name += '.exe'
    }
    return name
}

fn build_v2_for_target_e2e(tmp_dir string) string {
    vroot := e2e_repo_root()
    v2_source := os.join_path(vroot, 'cmd', 'v2', 'v2.v')
    v2_binary := os.join_path(tmp_dir, e2e_v2_binary_name())
    res :=
        os.execute('"${@VEXE}" -path "${os.join_path(vroot, 'vlib')}|@vlib|@vmodules" -gc none -nocache "${v2_source}" -o "${v2_binary}"')
    if res.exit_code != 0 {
        panic('failed to build cmd/v2 for cleanc target e2e:\n${res.output}')
    }
    return v2_binary
}

fn build_v1_for_target_e2e(tmp_dir string) string {
    vroot := e2e_repo_root()
    v1_source := os.join_path(vroot, 'cmd', 'v')
    v1_binary := os.join_path(tmp_dir, 'v1_public_wrapper')
    res :=
        os.execute('"${@VEXE}" -path "${os.join_path(vroot, 'vlib')}|@vlib|@vmodules" -gc none -nocache "${v1_source}" -o "${v1_binary}"')
    if res.exit_code != 0 {
        panic('failed to build cmd/v for cleanc target e2e:\n${res.output}')
    }
    return v1_binary
}

fn run_v2_to_c(v2_binary string, tmp_dir string, name string, args []string, source string) CleancCliResult {
    return run_v2_to_c_with_env(v2_binary, tmp_dir, name, args, source, '')
}

fn run_v2_to_c_with_env(v2_binary string, tmp_dir string, name string, args []string, source string, env_prefix string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    out_path := os.join_path(tmp_dir, '${name}.c')
    os.write_file(source_path, source) or { panic(err) }
    cmd := 'cd "${e2e_repo_root()}" && ${env_prefix}"${v2_binary}" -gc none -nocache --no-parallel ${args.join(' ')} -o "${out_path}" "${source_path}"'
    res := os.execute(cmd)
    c_source := if os.exists(out_path) { os.read_file(out_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  out_path
        c_path:    out_path
    }
}

fn run_v2_to_c_files(v2_binary string, tmp_dir string, name string, args []string, sources map[string]string) CleancCliResult {
    case_dir := os.join_path(tmp_dir, name)
    out_path := os.join_path(tmp_dir, '${name}.c')
    os.mkdir_all(case_dir) or { panic(err) }
    mut source_paths := []string{}
    mut source_names := sources.keys()
    source_names.sort()
    for source_name in source_names {
        source_path := os.join_path(case_dir, source_name)
        os.mkdir_all(os.dir(source_path)) or { panic(err) }
        os.write_file(source_path, sources[source_name]) or { panic(err) }
        source_paths << source_path
    }
    cmd := 'cd "${e2e_repo_root()}" && "${v2_binary}" -gc none -nocache --no-parallel ${args.join(' ')} -o "${out_path}" ${source_paths.map('"${it}"').join(' ')}'
    res := os.execute(cmd)
    c_source := if os.exists(out_path) { os.read_file(out_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  out_path
        c_path:    out_path
    }
}

fn run_v2_to_c_project_files(v2_binary string, tmp_dir string, name string, args []string, sources map[string]string, entry string) CleancCliResult {
    case_dir := os.join_path(tmp_dir, name)
    out_path := os.join_path(tmp_dir, '${name}.c')
    os.mkdir_all(case_dir) or { panic(err) }
    for source_name, source in sources {
        source_path := os.join_path(case_dir, source_name)
        os.mkdir_all(os.dir(source_path)) or { panic(err) }
        os.write_file(source_path, source) or { panic(err) }
    }
    entry_path := os.join_path(case_dir, entry)
    cmd := 'cd "${e2e_repo_root()}" && "${v2_binary}" -gc none -nocache --no-parallel ${args.join(' ')} -o "${out_path}" "${entry_path}"'
    res := os.execute(cmd)
    c_source := if os.exists(out_path) { os.read_file(out_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  out_path
        c_path:    out_path
    }
}

fn generated_c_output_path(output_path string) string {
    if output_path.ends_with('.c') {
        return output_path
    }
    return output_path + '.c'
}

fn e2e_binary_output_path(tmp_dir string, name string) string {
    mut path := os.join_path(tmp_dir, name)
    $if windows {
        path += '.exe'
    }
    return path
}

fn run_v2_to_binary(v2_binary string, tmp_dir string, name string, args []string, source string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    out_path := e2e_binary_output_path(tmp_dir, name)
    os.write_file(source_path, source) or { panic(err) }
    env_prefix := if host_c_e2e_flags().len > 0 { 'V2CFLAGS="${host_c_e2e_flags()}" ' } else { '' }
    cmd := 'cd "${e2e_repo_root()}" && ${env_prefix}"${v2_binary}" -gc none -nocache --no-parallel ${args.join(' ')} -o "${out_path}" "${source_path}"'
    res := os.execute(cmd)
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        out_path:  out_path
        c_path:    generated_c_output_path(out_path)
    }
}

fn run_v2_to_output(v2_binary string, tmp_dir string, name string, args []string, source string, output_path string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    os.write_file(source_path, source) or { panic(err) }
    cmd := 'cd "${e2e_repo_root()}" && "${v2_binary}" -gc none -nocache --no-parallel ${args.join(' ')} -o "${output_path}" "${source_path}"'
    res := os.execute(cmd)
    c_path := generated_c_output_path(output_path)
    c_source := if os.exists(c_path) { os.read_file(c_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  output_path
        c_path:    c_path
    }
}

fn run_v2_without_output_in_dir(v2_binary string, tmp_dir string, name string, args []string, source string, work_dir string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    os.write_file(source_path, source) or { panic(err) }
    os.mkdir_all(work_dir) or { panic(err) }
    env_prefix := if host_c_e2e_flags().len > 0 { 'V2CFLAGS="${host_c_e2e_flags()}" ' } else { '' }
    cmd := 'cd "${work_dir}" && ${env_prefix}"${v2_binary}" -gc none -nocache --no-parallel ${args.join(' ')} "${source_path}"'
    res := os.execute(cmd)
    c_path := os.join_path(work_dir, '${name}.c')
    c_source := if os.exists(c_path) { os.read_file(c_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  e2e_binary_output_path(work_dir, name)
        c_path:    c_path
    }
}

fn run_v2_without_output(v2_binary string, tmp_dir string, name string, args []string, source string) CleancCliResult {
    return run_v2_without_output_in_dir(v2_binary, tmp_dir, name, args, source, tmp_dir)
}

fn run_v1_v2_without_output_in_dir(v1_binary string, v2_binary string, tmp_dir string, name string, args []string, source string, work_dir string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    os.write_file(source_path, source) or { panic(err) }
    os.mkdir_all(work_dir) or { panic(err) }
    repo_vexe := os.join_path(e2e_repo_root(), 'v')
    env_prefix := if host_c_e2e_flags().len > 0 { 'V2CFLAGS="${host_c_e2e_flags()}" ' } else { '' }
    cmd := 'cd "${work_dir}" && ${env_prefix}VEXE="${repo_vexe}" V_V2_EXE="${v2_binary}" "${v1_binary}" -v2 -gc none -nocache --no-parallel ${args.join(' ')} "${source_path}"'
    res := os.execute(cmd)
    c_path := os.join_path(work_dir, '${name}.c')
    c_source := if os.exists(c_path) { os.read_file(c_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  e2e_binary_output_path(work_dir, name)
        c_path:    c_path
    }
}

fn run_v1_v2_to_output(v1_binary string, v2_binary string, tmp_dir string, name string, args []string, source string, output_path string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    os.write_file(source_path, source) or { panic(err) }
    repo_vexe := os.join_path(e2e_repo_root(), 'v')
    cmd := 'cd "${e2e_repo_root()}" && VEXE="${repo_vexe}" V_V2_EXE="${v2_binary}" "${v1_binary}" -v2 -gc none -nocache --no-parallel ${args.join(' ')} -o "${output_path}" "${source_path}"'
    res := os.execute(cmd)
    c_source := if os.exists(output_path) { os.read_file(output_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  output_path
        c_path:    output_path
    }
}

fn run_v2_to_output_with_cache(v2_binary string, tmp_dir string, name string, args []string, source string, output_path string) CleancCliResult {
    source_path := os.join_path(tmp_dir, '${name}.v')
    os.write_file(source_path, source) or { panic(err) }
    cmd := 'cd "${e2e_repo_root()}" && "${v2_binary}" -gc none --no-parallel ${args.join(' ')} -o "${output_path}" "${source_path}"'
    res := os.execute(cmd)
    c_path := generated_c_output_path(output_path)
    c_source := if os.exists(c_path) { os.read_file(c_path) or { '' } } else { '' }
    return CleancCliResult{
        exit_code: res.exit_code
        output:    res.output
        c_source:  c_source
        out_path:  output_path
        c_path:    c_path
    }
}

fn assert_cli_success(res CleancCliResult) {
    assert res.exit_code == 0, res.output
    assert os.exists(res.out_path), res.output
    assert res.c_source.len > 0, res.output
}

fn assert_generated_c_static_assert_contains(res CleancCliResult, expected string) {
    assert_cli_success(res)
    assert res.c_source.contains('_Static_assert(0, "${expected}'), res.c_source
}

fn assert_generated_c_heap_runtime_static_assert_contains(res CleancCliResult, helper string) {
    assert_generated_c_static_assert_contains(res,
        '${e2e_freestanding_missing_heap_runtime_message}: ${helper}')
}

fn assert_binary_success(res CleancCliResult) {
    assert res.exit_code == 0, res.output
    assert os.exists(res.out_path), res.output
}

fn assert_generated_c_only(res CleancCliResult) {
    assert res.exit_code == 0, res.output
    assert os.exists(res.c_path), res.output
    assert res.c_source.len > 0, res.output
    assert !os.exists(res.out_path), 'unexpected local executable ${res.out_path}\n${res.output}'
    assert res.output.contains('local C compilation disabled for this target'), res.output
}

fn assert_cli_failure_contains(res CleancCliResult, expected string) {
    assert res.exit_code != 0, res.output
    assert res.output.contains(expected), res.output
    assert !os.exists(res.out_path), 'failed command wrote unexpected output ${res.out_path}\n${res.output}'
    if res.c_path != res.out_path {
        assert !os.exists(res.c_path), 'failed command wrote unexpected C output ${res.c_path}\n${res.output}'
    }
}

fn host_cc_available() bool {
    $if windows {
        return false
    }
    return os.execute('cc --version').exit_code == 0
}

fn host_c_e2e_flags() string {
    return '-D_GNU_SOURCE -Wno-error=incompatible-pointer-types -Wno-error=implicit-function-declaration'
}

fn concrete_non_host_e2e_os() string {
    host_os := normalize_e2e_os_name(os.user_os())
    return match host_os {
        'windows' { 'linux' }
        else { 'windows' }
    }
}

fn target_fixture_source(name string) string {
    path := os.join_path(e2e_repo_root(), 'vlib', 'v2', 'tests', 'target_codegen_example', name)
    return os.read_file(path) or { panic('cannot read ${path}: ${err}') }
}

fn target_directive_source() string {
    return target_fixture_source('target_directives.vv2')
}

fn cross_directive_source() string {
    return target_fixture_source('cross_directives.vv2')
}

fn freestanding_directive_source() string {
    return target_fixture_source('freestanding_directives.vv2')
}

fn freestanding_none_source() string {
    return target_fixture_source('freestanding_none.vv2')
}

fn assert_concrete_target_markers(c_source string, target string) {
    assert c_source.contains(match target {
        'linux' { target_linux_marker }
        'macos' { target_macos_marker }
        'windows' { target_windows_marker }
        else { '' }
    })
    if target != 'linux' {
        assert !c_source.contains(target_linux_marker)
    }
    if target != 'macos' {
        assert !c_source.contains(target_macos_marker)
    }
    if target != 'windows' {
        assert !c_source.contains(target_windows_marker)
    }
    assert !c_source.contains(target_cross_marker)
    assert !c_source.contains(target_freestanding_marker)
}

fn assert_no_os_runtime_headers(c_source string) {
    for header in ['#include <unistd.h>', '#include <pthread.h>', '#include <dirent.h>',
        '#include <windows.h>', '#include <mach/mach.h>', '#include <termios.h>',
        '#include <sys/wait.h>'] {
        assert !c_source.contains(header)
    }
}

fn assert_no_obvious_hosted_headers(c_source string) {
    for header in ['#include <stdio.h>', '#include <stdlib.h>', '#include <unistd.h>'] {
        assert !c_source.contains(header)
    }
}

fn c_source_line_matches(c_source string, idx int, line string) bool {
    end_idx := idx + line.len
    return (idx == 0 || c_source[idx - 1] == `\n`)
        && (end_idx == c_source.len || c_source[end_idx] == `\n`)
}

fn c_source_find_complete_line(c_source string, line string) ?int {
    mut search_from := 0
    for {
        idx := c_source.index_after(line, search_from) or { return none }
        if c_source_line_matches(c_source, idx, line) {
            return idx
        }
        search_from = idx + 1
    }
    return none
}

fn c_source_count_complete_lines(c_source string, line string) int {
    mut count := 0
    mut search_from := 0
    for {
        idx := c_source.index_after(line, search_from) or { break }
        if c_source_line_matches(c_source, idx, line) {
            count++
        }
        search_from = idx + 1
    }
    return count
}

fn c_source_find_line_prefix(c_source string, prefix string) ?int {
    mut search_from := 0
    for {
        idx := c_source.index_after(prefix, search_from) or { return none }
        if idx == 0 || c_source[idx - 1] == `\n` {
            return idx
        }
        search_from = idx + 1
    }
    return none
}

fn c_source_find_line_prefix_after(c_source string, prefix string, start int) ?int {
    mut search_from := start
    for {
        idx := c_source.index_after(prefix, search_from) or { return none }
        if idx == 0 || c_source[idx - 1] == `\n` {
            return idx
        }
        search_from = idx + 1
    }
    return none
}

fn assert_array_contains_fallback_decl_order(c_source string, fn_name string, prototype string) {
    prototype_count := c_source_count_complete_lines(c_source, prototype)
    assert prototype_count == 1, 'expected exactly one complete-line fallback prototype `${prototype}`, found ${prototype_count}'
    proto_idx := c_source_find_complete_line(c_source, prototype) or {
        assert false, 'missing array contains fallback prototype `${prototype}`'
        return
    }
    symbol := '${fn_name}('
    first_symbol_idx := c_source.index(symbol) or {
        assert false, 'missing array contains fallback symbol `${symbol}`'
        return
    }
    assert first_symbol_idx == proto_idx + 'bool '.len, '`${fn_name}` appears before its fallback prototype'

    first_use_idx := c_source.index_after(symbol, proto_idx + prototype.len) or {
        assert false, 'missing array contains fallback use `${symbol}` after prototype'
        return
    }
    assert proto_idx < first_use_idx, '`${fn_name}` fallback prototype must precede first use'
    body_prefix := 'bool ${fn_name}('
    if body_idx := c_source_find_line_prefix_after(c_source, body_prefix, proto_idx + prototype.len) {
        assert first_use_idx < body_idx, '`${fn_name}` first use should occur before generated body'
    }
    weak_body := '__attribute__((weak)) bool ${fn_name}('
    if weak_idx := c_source_find_line_prefix(c_source, weak_body) {
        assert first_use_idx < weak_idx, '`${fn_name}` first use should occur before fallback weak body'
        assert proto_idx < weak_idx, '`${fn_name}` fallback prototype must precede weak body'
    }
}

fn test_cleanc_cli_array_contains_fallback_decls_precede_pass5_uses() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_array_contains_fallback_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)
    res := run_v2_to_c_project_files(v2_binary, tmp_dir, 'array_contains_fallback', [], {
        'ssa/ids.v':     'module ssa

pub type ValueID = int
pub type BlockID = int
'
        'types/types.v': 'module types

pub type Type = int
'
        'main.v':        'module main

import ssa
import types

fn main() {
    values := [ssa.ValueID(1)]
    blocks := [ssa.BlockID(2)]
    type_ids := [types.Type(3)]
    assert values.contains(ssa.ValueID(1))
    assert blocks.contains(ssa.BlockID(2))
    assert type_ids.contains(types.Type(3))
}
'
    }, 'main.v')
    assert_cli_success(res)
    assert_array_contains_fallback_decl_order(res.c_source, 'Array_ssa__ValueID_contains',
        'bool Array_ssa__ValueID_contains(Array_ssa__ValueID a, ssa__ValueID v);')
    assert_array_contains_fallback_decl_order(res.c_source, 'Array_ssa__BlockID_contains',
        'bool Array_ssa__BlockID_contains(Array_ssa__BlockID a, ssa__BlockID v);')
    assert_array_contains_fallback_decl_order(res.c_source, 'Array_types__Type_contains',
        'bool Array_types__Type_contains(Array_types__Type a, types__Type v);')
}

fn test_cleanc_cli_generated_c_target_matrix() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_target_e2e_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)
    source := target_directive_source()

    default_res := run_v2_to_c(v2_binary, tmp_dir, 'default_host', [], source)
    assert_cli_success(default_res)
    assert !default_res.c_source.contains(target_cross_marker)
    assert !default_res.c_source.contains(target_freestanding_marker)
    host_os := normalize_e2e_os_name(os.user_os())
    if host_os in ['linux', 'macos', 'windows'] {
        assert_concrete_target_markers(default_res.c_source, host_os)
    }

    for target in ['linux', 'macos', 'windows'] {
        res := run_v2_to_c(v2_binary, tmp_dir, 'target_${target}', ['-os', target], source)
        assert_cli_success(res)
        assert_concrete_target_markers(res.c_source, target)
    }

    cross_res := run_v2_to_c(v2_binary, tmp_dir, 'target_cross', ['-os', 'cross'],
        cross_directive_source())
    assert_cli_success(cross_res)
    assert cross_res.c_source.contains(target_linux_marker)
    assert cross_res.c_source.contains(target_macos_marker)
    assert cross_res.c_source.contains(target_windows_marker)
    assert cross_res.c_source.contains(target_cross_marker)
    assert cross_res.c_source.contains('defined(__linux__)')
    assert cross_res.c_source.contains('defined(_WIN32)')
    assert cross_res.c_source.contains('defined(__APPLE__)')

    free_res := run_v2_to_c(v2_binary, tmp_dir, 'target_freestanding', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], freestanding_directive_source())
    assert_cli_success(free_res)
    assert free_res.c_source.contains(target_linux_marker)
    assert free_res.c_source.contains(target_freestanding_marker)
    assert !free_res.c_source.contains(target_windows_marker)
    assert_no_os_runtime_headers(free_res.c_source)
}

fn test_cleanc_cli_comptime_if_directives_follow_active_branch() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_comptime_directives_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)

    linux_res := run_v2_to_c(v2_binary, tmp_dir, 'linux_inactive_windows_directive', [
        '-os',
        'linux',
    ], 'module main

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

#include <active_comptime_marker.h>

fn main() {}
')
    assert_cli_success(linux_res)
    assert !linux_res.c_source.contains(inactive_windows_marker)
    assert linux_res.c_source.contains(active_comptime_marker)

    freestanding_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_inactive_directive', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

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

#include freestanding <active_comptime_marker.h>

fn main() {}
')
    assert_cli_success(freestanding_res)
    assert !freestanding_res.c_source.contains(inactive_freestanding_marker)
    assert freestanding_res.c_source.contains(active_comptime_marker)
}

fn test_cleanc_cli_freestanding_diagnostics_and_user_directives() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_target_diag_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)

    help_res := os.execute('"${v2_binary}" --definitely-unknown-freestanding-flag')
    assert help_res.exit_code != 0, help_res.output
    assert help_res.output.contains('-fhooks <values>'), help_res.output
    assert help_res.output.contains('Advanced freestanding hooks for --skip-builtin --skip-type-check stubs'), help_res.output
    assert help_res.output.contains('-b <name>'), help_res.output
    assert help_res.output.contains('omit for cleanc'), help_res.output

    assert help_res.output.contains('Override target OS (default: host OS)'), help_res.output

    fixture_empty := target_fixture_source('freestanding_empty.vv2')
    fixture_output := target_fixture_source('freestanding_output.vv2')
    fixture_panic := target_fixture_source('freestanding_panic.vv2')
    fixture_alloc := target_fixture_source('freestanding_alloc.vv2')
    none_without_freestanding_res := run_v2_to_c(v2_binary, tmp_dir, 'none_without_freestanding', [
        '-os',
        'none',
    ], fixture_empty)
    assert_cli_failure_contains(none_without_freestanding_res, '-os none requires -freestanding')

    freestanding_cross_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_cross', [
        '-freestanding',
        '-os',
        'cross',
        '--skip-builtin',
    ], fixture_empty)
    assert_cli_failure_contains(freestanding_cross_res, '-freestanding -os cross is not supported')

    os_import_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_os_import', [
        '-freestanding',
        '-os',
        'linux',
    ], 'module main

import os

fn main() {
    _ := os.args.len
}
    ')
    assert_cli_failure_contains(os_import_res, 'freestanding target cannot use module os')

    flat_os_import_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_flat_os_import', [
        '-freestanding',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

import os

fn main() {}
    ')
    assert_cli_failure_contains(flat_os_import_res, 'freestanding target cannot use module os')

    for import_name in ['time', 'term', 'net', 'net.http', 'sync'] {
        import_res := run_v2_to_c(v2_binary, tmp_dir,
            'freestanding_${import_name.replace('.', '_')}_import', [
            '-freestanding',
            '-os',
            'linux',
            '--skip-builtin',
        ], 'module main

import ${import_name}

fn main() {}
')
        assert_cli_failure_contains(import_res,
            'freestanding target cannot use module ${import_name.all_before('.')}')
    }

    print_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_print', [
        '-freestanding',
        '-os',
        'linux',
    ], fixture_output)
    assert_cli_failure_contains(print_res, 'freestanding target cannot use builtin println')

    minimal_runtime_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_minimal_runtime', [
        '-freestanding',
        '-os',
        'linux',
    ], fixture_empty)
    assert_cli_success(minimal_runtime_res)
    assert_no_os_runtime_headers(minimal_runtime_res.c_source)

    output_hook_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_output_hook', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_output)
    assert_cli_success(output_hook_res)
    assert output_hook_res.c_source.contains('isize v_platform_write(int stream, const u8* buf, isize len);')
    assert output_hook_res.c_source.contains('v_platform_write(fd, ptr, remaining_bytes)')
    assert !output_hook_res.c_source.contains('v_platform_panic'), output_hook_res.c_source
    assert !output_hook_res.c_source.contains('v_platform_malloc'), output_hook_res.c_source
    assert !output_hook_res.c_source.contains('v_platform_realloc'), output_hook_res.c_source
    assert !output_hook_res.c_source.contains('v_platform_free'), output_hook_res.c_source

    define_prealloc_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_define_prealloc', [
        '-freestanding',
        '-d',
        'prealloc',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_output)
    assert_cli_success(define_prealloc_res)
    assert !define_prealloc_res.output.contains('freestanding target cannot use -prealloc')

    output_hook_builtin_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_output_hook_builtin_runtime', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
    ], fixture_output)
    assert_cli_failure_contains(output_hook_builtin_res,
        'freestanding target platform hooks currently require --skip-builtin and --skip-type-check')
    assert !output_hook_builtin_res.output.contains('__malloc'), output_hook_builtin_res.output

    output_hook_skip_builtin_typecheck_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_output_hook_skip_builtin_typecheck_gate', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
    ], fixture_output)
    assert_cli_failure_contains(output_hook_skip_builtin_typecheck_res,
        'freestanding target platform hooks currently require --skip-builtin and --skip-type-check')
    assert !output_hook_skip_builtin_typecheck_res.output.contains('unknown ident'), output_hook_skip_builtin_typecheck_res.output

    for hook_name in ['output', 'panic', 'alloc', 'minimal'] {
        hook_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
            'freestanding_${hook_name}_builtin_runtime_gate', [
            '-freestanding',
            '-fhooks',
            hook_name,
            '-os',
            'linux',
        ], fixture_empty)
        assert_cli_failure_contains(hook_runtime_res,
            'freestanding target platform hooks currently require --skip-builtin and --skip-type-check')
        assert !hook_runtime_res.output.contains('__malloc'), hook_runtime_res.output
    }

    output_missing_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_output_missing', [
        '-freestanding',
        '-fhooks',
        'panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_output)
    assert_cli_failure_contains(output_missing_res,
        'freestanding target cannot use builtin println without output platform hook')

    spoofed_output_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_spoofed_output_define', [
        '-freestanding',
        '-d',
        'freestanding_output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_output)
    assert_cli_failure_contains(spoofed_output_res,
        'freestanding target cannot use builtin println without output platform hook')

    for helper_call in ['_write_buf_to_fd(1, 0, 0)', "_writeln_to_fd(1, '')", 'flush_stdout()',
        'flush_stderr()'] {
        helper_res := run_v2_to_c(v2_binary, tmp_dir,
            'freestanding_output_helper_${helper_call.all_before('(')}', [
            '-freestanding',
            '-os',
            'linux',
            '--skip-builtin',
            '--skip-type-check',
        ], 'module main

fn main() {
    ${helper_call}
}
')
        assert_generated_c_static_assert_contains(helper_res,
            e2e_freestanding_missing_output_hook_message)
    }

    for print_call in ['println(123)', 'print(true)'] {
        print_conversion_res := run_v2_to_c(v2_binary, tmp_dir,
            'freestanding_output_only_${print_call.all_before('(')}_conversion', [
            '-freestanding',
            '-fhooks',
            'output',
            '-os',
            'linux',
            '--skip-builtin',
            '--skip-type-check',
        ], 'module main

fn main() {
    ${print_call}
}
')
        assert_generated_c_static_assert_contains(print_conversion_res,
            e2e_freestanding_missing_format_hook_message)
    }

    output_hook_string_literal_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_output_hook_string_literal', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    println('ok')
}
    ")
    assert_cli_success(output_hook_string_literal_res)
    assert output_hook_string_literal_res.c_source.contains('v_platform_write')
    assert !output_hook_string_literal_res.c_source.contains(e2e_freestanding_missing_format_hook_message), output_hook_string_literal_res.c_source

    output_hook_unknown_print_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_output_hook_unknown_print_arg', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_value() int

fn main() {
    x := C.platform_value()
    println(x)
}
    ')
    assert_generated_c_static_assert_contains(output_hook_unknown_print_res,
        e2e_freestanding_missing_format_hook_message)

    panic_hook_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_panic_hook', [
        '-freestanding',
        '-fhooks',
        'panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_panic)
    assert_cli_success(panic_hook_res)
    assert panic_hook_res.c_source.contains('void v_platform_panic(const u8* msg, isize len);')
    assert !panic_hook_res.c_source.contains('v_platform_write'), panic_hook_res.c_source
    assert !panic_hook_res.c_source.contains('v_platform_malloc'), panic_hook_res.c_source

    panic_missing_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_panic_missing', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
    ], fixture_panic)
    assert_cli_failure_contains(panic_missing_res,
        'freestanding target cannot use builtin panic without panic platform hook')

    bang_missing_panic_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_bang_missing_panic', [
        '-freestanding',
        '-fhooks',
        'output,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn fallible() !int {
    return error('x')
}

fn main() {
    _ := fallible()!
}
    ")
    assert_generated_c_static_assert_contains(bang_missing_panic_res,
        e2e_freestanding_missing_panic_hook_message)

    bang_panic_hook_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_bang_panic_hook', [
        '-freestanding',
        '-fhooks',
        'panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn fallible() !int {
    return error('x')
}

fn main() {
    _ := fallible()!
}
    ")
    assert_generated_c_heap_runtime_static_assert_contains(bang_panic_hook_res, 'IError__str')

    panic_ierror_hook_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_panic_ierror_hook', [
        '-freestanding',
        '-fhooks',
        'output,panic,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    err := error('x')
    panic(err)
}
    ")
    assert_generated_c_heap_runtime_static_assert_contains(panic_ierror_hook_res, 'IError__str')

    bang_result_propagation_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_bang_result_propagation', [
        '-freestanding',
        '-fhooks',
        'output,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn fallible() !int {
    return error('x')
}

fn wrapper() !int {
    return fallible()!
}

fn main() {}
    ")
    assert_cli_success(bang_result_propagation_res)

    assert_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_assert', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    assert true
}
    ')
    assert_cli_failure_contains(assert_res,
        'freestanding target cannot use assert because failed assertions need hosted output/exit support')

    spoofed_panic_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_spoofed_panic_define', [
        '-freestanding',
        '-d',
        'freestanding_panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_panic)
    assert_cli_failure_contains(spoofed_panic_res,
        'freestanding target cannot use builtin panic without panic platform hook')

    alloc_missing_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_alloc_missing', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_alloc)
    assert_generated_c_static_assert_contains(alloc_missing_res,
        e2e_freestanding_missing_alloc_hook_message)

    spoofed_alloc_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_spoofed_alloc_define', [
        '-freestanding',
        '-d',
        'freestanding_alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_alloc)
    assert_generated_c_static_assert_contains(spoofed_alloc_res,
        e2e_freestanding_missing_alloc_hook_message)

    arguments_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_arguments', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := arguments()
}
')
    assert_generated_c_static_assert_contains(arguments_res,
        e2e_freestanding_missing_alloc_hook_message)

    alloc_hook_string_interpolation_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_alloc_string_interpolation', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    _ := '\${1}'
}
    ")
    assert_generated_c_static_assert_contains(alloc_hook_string_interpolation_res,
        e2e_freestanding_missing_format_hook_message)

    string_concat_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_string_concat_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    s := 'left'
    _ := s + 'right'
}
    ")
    assert_generated_c_heap_runtime_static_assert_contains(string_concat_missing_alloc_res,
        'string__plus')

    ambiguous_string_concat_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_ambiguous_string_concat_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_string() string

fn main() {
    a := C.platform_string()
    b := C.platform_string()
    _ := a + b
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(ambiguous_string_concat_missing_alloc_res,
        'string__plus')

    string_plus_assign_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_string_plus_assign_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    mut s := 'left'
    s += 'right'
}
    ")
    assert_generated_c_heap_runtime_static_assert_contains(string_plus_assign_missing_alloc_res,
        'string__plus')

    ambiguous_string_plus_assign_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_ambiguous_string_plus_assign_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_string() string

fn main() {
    mut s := C.platform_string()
    s += C.platform_string()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(ambiguous_string_plus_assign_missing_alloc_res,
        'string__plus')

    numeric_plus_without_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_numeric_plus_without_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := 1 + 2
    mut n := 1
    n += 2
}
    ')
    assert_cli_success(numeric_plus_without_alloc_res)

    fixed_array_index_without_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_fixed_array_index_without_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    mut xs := [3]int{init: 0}
    xs[0] = 7
}
    ')
    assert_cli_success(fixed_array_index_without_alloc_res)

    dynamic_array_literal_alloc_hook_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_dynamic_array_literal_alloc_hook', [
        '-freestanding',
        '-fhooks',
        'output,panic,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := [1, 2, 3]
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(dynamic_array_literal_alloc_hook_res,
        'new_array_from_c_array')

    map_literal_alloc_hook_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_map_literal_alloc_hook', [
        '-freestanding',
        '-fhooks',
        'output,panic,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := {
        1: 2
    }
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(map_literal_alloc_hook_res, 'new_map')

    numeric_shift_without_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_numeric_shift_without_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    mut flags := 1
    _ := flags << 1
    flags <<= 1
}
    ')
    assert_cli_success(numeric_shift_without_alloc_res)

    user_map_method_without_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_user_map_method_without_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

struct Device {}

fn (d Device) map() int {
    return 7
}

fn main() {
    d := Device{}
    _ := d.map()
}
    ')
    assert_cli_success(user_map_method_without_alloc_res)

    user_clone_substr_methods_without_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_user_clone_substr_methods_without_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

struct Device {}

fn (d Device) clone() Device {
    return d
}

fn (d Device) substr(start int, end int) Device {
    return d
}

fn main() {
    d := Device{}
    _ := d.clone()
    _ := d.substr(0, 1)
}
    ')
    assert_cli_success(user_clone_substr_methods_without_alloc_res)

    array_append_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_array_append_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_array() []int

fn main() {
    mut nums := C.platform_array()
    nums << 2
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(array_append_missing_alloc_res,
        'array__push')

    map_assign_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_map_assign_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_map() map[int]int

fn main() {
    mut m := C.platform_map()
    m[1] = 1
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(map_assign_missing_alloc_res, 'map__set')

    nested_map_assign_missing_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_nested_map_assign_missing_runtime', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], "module main

fn main() {
    mut res := map[string]map[string]string{}
    lang := 'en'
    key := 'msg'
    res[lang][key] = 'Hello'
}
    ")
    assert_generated_c_heap_runtime_static_assert_contains(nested_map_assign_missing_runtime_res,
        'map__get_and_set')

    map_value_array_append_missing_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_map_value_array_append_missing_runtime', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

fn C.platform_map() map[int][]int

fn main() {
    mut m := C.platform_map()
    m[1] << 2
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(map_value_array_append_missing_runtime_res,
        'map__get_and_set')
    assert map_value_array_append_missing_runtime_res.c_source.contains('__new_array_with_default_noscan(0, 0, sizeof(int), NULL)'), map_value_array_append_missing_runtime_res.c_source
    assert !map_value_array_append_missing_runtime_res.c_source.contains('map__get(&m'), map_value_array_append_missing_runtime_res.c_source
    assert !map_value_array_append_missing_runtime_res.c_source.contains('map__get(&(m)'), map_value_array_append_missing_runtime_res.c_source

    array_clone_missing_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_array_clone_missing_runtime', [
        '-freestanding',
        '-fhooks',
        'output,panic,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_array() []int

fn main() {
    nums := C.platform_array()
    _ := nums.clone()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(array_clone_missing_runtime_res,
        'array__clone_to_depth')

    string_clone_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_string_clone_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_string() string

fn main() {
    s := C.platform_string()
    _ := s.clone()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(string_clone_missing_alloc_res,
        'string__clone')

    map_clone_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_map_clone_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_map() map[int]int

fn main() {
    m := C.platform_map()
    _ := m.clone()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(map_clone_missing_alloc_res,
        'map__clone')

    range_slice_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_range_slice_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_string() string

fn main() {
    s := C.platform_string()
    _ := s[0..1]
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(range_slice_missing_alloc_res,
        'string__substr')

    string_substr_missing_alloc_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_string_substr_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_string() string

fn main() {
    s := C.platform_string()
    _ := s.substr(0, 1)
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(string_substr_missing_alloc_res,
        'string__substr')

    split_map_assign_missing_alloc_res := run_v2_to_c_files(v2_binary, tmp_dir,
        'freestanding_split_map_assign_missing_alloc', [
        '-freestanding',
        '-fhooks',
        'output,panic',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], {
        'main.v':     'module main

fn main() {
    mut m := C.platform_map()
    m[1] = 1
}
'
        'platform.v': 'module main

fn C.platform_map() map[int]int
'
    })
    assert_generated_c_heap_runtime_static_assert_contains(split_map_assign_missing_alloc_res,
        'map__set')

    alloc_hook_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_alloc_hook', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], fixture_alloc)
    assert_cli_success(alloc_hook_res)
    assert alloc_hook_res.c_source.contains('void* v_platform_malloc(isize n);')
    assert alloc_hook_res.c_source.contains('void* v_platform_realloc(void* ptr, isize n);')
    assert alloc_hook_res.c_source.contains('void v_platform_free(void* ptr);')
    assert !alloc_hook_res.c_source.contains('v_platform_write'), alloc_hook_res.c_source
    assert !alloc_hook_res.c_source.contains('v_platform_panic'), alloc_hook_res.c_source

    explicit_array_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_array_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := new_array_from_c_array(0, 0, 0, 0)
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_array_runtime_res,
        'new_array_from_c_array')

    explicit_array_noscan_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_array_noscan_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := new_array_from_c_array_noscan(0, 0, 0, 0)
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_array_noscan_runtime_res,
        'new_array_from_c_array_noscan')

    explicit_array_no_alloc_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_array_no_alloc_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'output,panic,alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := new_array_from_c_array_no_alloc(0, 0, 0, 0)
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_array_no_alloc_runtime_res,
        'new_array_from_c_array_no_alloc')

    explicit_array_default_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_array_default_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := __new_array_with_default_noscan(0, 0, 0, 0)
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_array_default_runtime_res,
        '__new_array_with_default_noscan')

    explicit_array_repeat_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_array_repeat_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := array__repeat()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_array_repeat_runtime_res,
        'array__repeat')

    explicit_map_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_map_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := new_map()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_map_runtime_res, 'new_map')

    explicit_array_spread_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_array_spread_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := new_array_from_array_and_c_array()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_array_spread_runtime_res,
        'new_array_from_array_and_c_array')

    explicit_builtin_array_spread_runtime_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_explicit_builtin_array_spread_runtime_helper', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn main() {
    _ := builtin__new_array_from_array_and_c_array()
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(explicit_builtin_array_spread_runtime_res,
        'builtin__new_array_from_array_and_c_array')

    tracked_heap_ops_alloc_hook_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_tracked_heap_ops_alloc_hook', [
        '-freestanding',
        '-fhooks',
        'output,panic,alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_array() []int
fn C.platform_map() map[int]int
fn C.platform_string() string

fn main() {
    mut nums := C.platform_array()
    nums << 2
    mut m := C.platform_map()
    m[1] = 1
    _ := m.clone()
    s := C.platform_string()
    _ := s[0..1]
    _ := s.clone()
    _ := s.substr(0, 1)
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(tracked_heap_ops_alloc_hook_res,
        'array__push')
    assert_generated_c_heap_runtime_static_assert_contains(tracked_heap_ops_alloc_hook_res,
        'map__set')
    assert_generated_c_heap_runtime_static_assert_contains(tracked_heap_ops_alloc_hook_res,
        'map__clone')
    assert_generated_c_heap_runtime_static_assert_contains(tracked_heap_ops_alloc_hook_res,
        'string__clone')
    assert_generated_c_heap_runtime_static_assert_contains(tracked_heap_ops_alloc_hook_res,
        'string__substr')

    string_concat_alloc_hook_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_string_concat_alloc_hook', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    s := 'left'
    _ := s + 'right'
}
    ")
    assert_generated_c_heap_runtime_static_assert_contains(string_concat_alloc_hook_res,
        'string__plus')

    ambiguous_string_concat_alloc_hook_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_ambiguous_string_concat_alloc_hook', [
        '-freestanding',
        '-fhooks',
        'alloc',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

fn C.platform_string() string

fn main() {
    a := C.platform_string()
    b := C.platform_string()
    _ := a + b
}
    ')
    assert_generated_c_heap_runtime_static_assert_contains(ambiguous_string_concat_alloc_hook_res,
        'string__plus')

    prealloc_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_prealloc', [
        '-freestanding',
        '-prealloc',
        '-os',
        'linux',
        '--skip-builtin',
    ], fixture_empty)
    assert_cli_failure_contains(prealloc_res, 'freestanding target cannot use -prealloc')

    shared_lib_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_shared_lib', [
        '-freestanding',
        '-shared',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

fn main() {}
')
    assert_cli_failure_contains(shared_lib_res, 'freestanding target cannot use -shared')

    hot_fn_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_hot_fn', [
        '-freestanding',
        '-hot-fn',
        'main',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

fn main() {}
')
    assert_cli_failure_contains(hot_fn_res, 'freestanding target cannot use -hot-fn')

    for call_name in ['eprint', 'eprintln', 'panic'] {
        call_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_${call_name}', [
            '-freestanding',
            '-os',
            'linux',
            '--skip-builtin',
        ], "module main

fn main() {
    ${call_name}('x')
}
")
        assert_cli_failure_contains(call_res, 'freestanding target cannot use builtin ${call_name}')
    }

    spawn_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_spawn', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

fn work() {}

fn main() {
    spawn work()
}
')
    assert_cli_failure_contains(spawn_res, 'freestanding target cannot use spawn')

    lock_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_lock', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

fn main() {
    lock {}
}
')
    assert_cli_failure_contains(lock_res, 'freestanding target cannot use lock/rlock')

    shared_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_shared', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

struct State {
    value shared int
}

fn main() {}
')
    assert_cli_failure_contains(shared_res, 'freestanding target cannot use shared data')

    live_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_live', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

@[live]
fn step() {}

fn main() {}
')
    assert_cli_failure_contains(live_res, 'freestanding target cannot use @[live]')

    inactive_branch_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_inactive_branches', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    \$if !freestanding {
        println('inactive')
    }
    \$if windows {
        eprintln('inactive')
    }
}
    ")
    assert_cli_success(inactive_branch_res)

    inactive_fn_attr_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_inactive_fn_attributes', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

    @[if !freestanding]
    fn hosted_only() {
        println('inactive')
    }

    @[if windows]
    fn windows_only() {
        eprintln('inactive')
    }

    fn main() {}
    ")
    assert_cli_success(inactive_fn_attr_res)

    fixed_array_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_fixed_array_no_alloc', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], 'module main

    fn main() {
        _ := [3]int{init: 0}
        _ := [1, 2, 3]!
    }
    ')
    assert_cli_success(fixed_array_res)

    inactive_import_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_inactive_import', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

\$if !freestanding {
    import os
}

fn main() {}
')
    assert_cli_success(inactive_import_res)

    active_branch_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_active_branch', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    \$if freestanding {
        eprint('active')
    }
}
    ")
    assert_cli_failure_contains(active_branch_res, 'freestanding target cannot use builtin eprint')

    hook_inactive_branch_res := run_v2_to_c(v2_binary, tmp_dir,
        'freestanding_hook_inactive_branch', [
        '-freestanding',
        '-fhooks',
        'output',
        '-os',
        'linux',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

fn main() {
    \$if !freestanding_output {
        println('inactive')
    }
}
    ")
    assert_cli_success(hook_inactive_branch_res)

    user_directive_res := run_v2_to_c(v2_binary, tmp_dir, 'freestanding_user_directives', [
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], 'module main

#include <platform_user_header.h>
#flag -DPLATFORM_USER_FLAG
fn C.platform_external() int

fn main() {
    _ := C.platform_external()
}
    ')
    assert_cli_success(user_directive_res)
    assert user_directive_res.c_source.contains('#include <platform_user_header.h>')
    assert user_directive_res.c_source.contains('platform_external'), user_directive_res.c_source
}

fn test_cleanc_cli_compiles_generated_c_on_host_when_cc_available() {
    if !host_cc_available() {
        eprintln('skip: cc is not available for cleanc host compile e2e')
        return
    }
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_host_cc_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)
    v1_binary := build_v1_for_target_e2e(tmp_dir)
    minimal_source := 'module main

fn main() {}
'

    minimal_res := run_v2_to_binary(v2_binary, tmp_dir, 'host_minimal', [
        '-cc',
        'cc',
    ], minimal_source)
    assert_binary_success(minimal_res)
    minimal_run := os.execute('"${minimal_res.out_path}"')
    assert minimal_run.exit_code == 0, minimal_run.output
    assert !os.exists(minimal_res.c_path), minimal_res.output

    default_no_output_res := run_v2_without_output(v2_binary, tmp_dir, 'host_default_no_output', [
        '-cc',
        'cc',
    ], minimal_source)
    assert_binary_success(default_no_output_res)
    default_no_output_run := os.execute('"${default_no_output_res.out_path}"')
    assert default_no_output_run.exit_code == 0, default_no_output_run.output
    assert !os.exists(default_no_output_res.c_path), default_no_output_res.output

    public_default_cwd := os.join_path(tmp_dir, 'public_default_cwd')
    public_default_no_output_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary, tmp_dir,
        'public_host_default_no_output', [
        '-cc',
        'cc',
    ], minimal_source, public_default_cwd)
    assert_binary_success(public_default_no_output_res)
    public_default_no_output_run := os.execute('"${public_default_no_output_res.out_path}"')
    assert public_default_no_output_run.exit_code == 0, public_default_no_output_run.output
    assert !os.exists(public_default_no_output_res.c_path), public_default_no_output_res.output

    host_os := normalize_e2e_os_name(os.user_os())
    if host_os in ['linux', 'macos', 'windows'] {
        explicit_host_default_res := run_v2_without_output(v2_binary, tmp_dir,
            'host_explicit_default_no_output', [
            '-cc',
            'cc',
            '-os',
            host_os,
        ], minimal_source)
        assert_binary_success(explicit_host_default_res)
        explicit_host_default_run := os.execute('"${explicit_host_default_res.out_path}"')
        assert explicit_host_default_run.exit_code == 0, explicit_host_default_run.output
        assert !os.exists(explicit_host_default_res.c_path), explicit_host_default_res.output

        explicit_host_res := run_v2_to_binary(v2_binary, tmp_dir, 'host_explicit_${host_os}', [
            '-cc',
            'cc',
            '-os',
            host_os,
        ], minimal_source)
        assert_binary_success(explicit_host_res)
        explicit_host_run := os.execute('"${explicit_host_res.out_path}"')
        assert explicit_host_run.exit_code == 0, explicit_host_run.output
        assert !os.exists(explicit_host_res.c_path), explicit_host_res.output

        public_explicit_host_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary, tmp_dir,
            'public_host_explicit_default_no_output', [
            '-cc',
            'cc',
            '-os',
            host_os,
        ], minimal_source, public_default_cwd)
        assert_binary_success(public_explicit_host_res)
        public_explicit_host_run := os.execute('"${public_explicit_host_res.out_path}"')
        assert public_explicit_host_run.exit_code == 0, public_explicit_host_run.output
        assert !os.exists(public_explicit_host_res.c_path), public_explicit_host_res.output
    }

    cross_res := run_v2_to_binary(v2_binary, tmp_dir, 'host_cross', [
        '-cc',
        'cc',
        '-os',
        'cross',
    ], minimal_source)
    assert_binary_success(cross_res)
    cross_run := os.execute('"${cross_res.out_path}"')
    assert cross_run.exit_code == 0, cross_run.output
    assert !os.exists(cross_res.c_path), cross_res.output

    cross_default_res := run_v2_without_output(v2_binary, tmp_dir, 'host_cross_default_no_output', [
        '-cc',
        'cc',
        '-os',
        'cross',
    ], minimal_source)
    assert_binary_success(cross_default_res)
    cross_default_run := os.execute('"${cross_default_res.out_path}"')
    assert cross_default_run.exit_code == 0, cross_default_run.output
    assert !os.exists(cross_default_res.c_path), cross_default_res.output

    public_cross_default_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary, tmp_dir,
        'public_host_cross_default_no_output', [
        '-cc',
        'cc',
        '-os',
        'cross',
    ], minimal_source, public_default_cwd)
    assert_binary_success(public_cross_default_res)
    public_cross_default_run := os.execute('"${public_cross_default_res.out_path}"')
    assert public_cross_default_run.exit_code == 0, public_cross_default_run.output
    assert !os.exists(public_cross_default_res.c_path), public_cross_default_res.output

    cross_impl_path := os.join_path(tmp_dir, 'cross_flag_impl.c')
    os.write_file(cross_impl_path, '#ifndef CROSS_FLAG_FROM_V2
#error CROSS_FLAG_FROM_V2 missing
#endif

int cross_platform_external(void) {
    return 9;
}
') or {
        panic(err)
    }
    cross_flag_res := run_v2_to_binary(v2_binary, tmp_dir, 'host_cross_flag_observable', [
        '-cc',
        'cc',
        '-os',
        'cross',
    ], 'module main

#flag cross -DCROSS_FLAG_FROM_V2
#flag ${cross_impl_path}

fn C.exit(code int)
fn C.cross_platform_external() int

fn main() {
    if C.cross_platform_external() != 9 {
        C.exit(18)
    }
}
')
    assert_binary_success(cross_flag_res)
    cross_flag_run := os.execute('"${cross_flag_res.out_path}"')
    assert cross_flag_run.exit_code == 0, cross_flag_run.output
    assert !os.exists(cross_flag_res.c_path), cross_flag_res.output

    c_impl_path := os.join_path(tmp_dir, 'platform_flag_impl.c')
    os.write_file(c_impl_path, '#ifndef PLATFORM_FLAG_FROM_V2
#error PLATFORM_FLAG_FROM_V2 missing
#endif

int platform_external(void) {
    return 7;
}
') or {
        panic(err)
    }
    flag_res := run_v2_to_binary(v2_binary, tmp_dir, 'host_flag_observable', [
        '-cc',
        'cc',
    ], 'module main

#flag -DPLATFORM_FLAG_FROM_V2
#flag ${c_impl_path}

fn C.exit(code int)
fn C.platform_external() int

fn main() {
    if C.platform_external() != 7 {
        C.exit(17)
    }
}
')
    assert_binary_success(flag_res)
    flag_run := os.execute('"${flag_res.out_path}"')
    assert flag_run.exit_code == 0, flag_run.output
    assert !os.exists(flag_res.c_path), flag_res.output
}

fn test_cleanc_cli_writes_c_only_for_freestanding_and_concrete_non_host_targets() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_c_only_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)
    v1_binary := build_v1_for_target_e2e(tmp_dir)
    missing_cc := os.join_path(tmp_dir, 'cc_must_not_run')
    minimal_source := 'module main

fn main() {}
'

    default_cwd := os.join_path(tmp_dir, 'default_output_cwd')
    freestanding_default_res := run_v2_without_output_in_dir(v2_binary, tmp_dir,
        'freestanding_default_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], minimal_source, default_cwd)
    assert_generated_c_only(freestanding_default_res)
    assert freestanding_default_res.c_path == os.join_path(default_cwd,
        'freestanding_default_generation_only.c')
    assert !os.exists(os.join_path(tmp_dir, 'freestanding_default_generation_only.c')), freestanding_default_res.output

    host_target := normalize_e2e_os_name(os.user_os())
    public_freestanding_host_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary, tmp_dir,
        'public_freestanding_host_default_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        host_target,
    ], minimal_source, default_cwd)
    assert_generated_c_only(public_freestanding_host_res)
    assert public_freestanding_host_res.c_path == os.join_path(default_cwd,
        'public_freestanding_host_default_generation_only.c')
    assert !os.exists(os.join_path(tmp_dir, 'public_freestanding_host_default_generation_only.c')), public_freestanding_host_res.output

    freestanding_none_default_res := run_v2_without_output_in_dir(v2_binary, tmp_dir,
        'freestanding_none_default_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'none',
    ], freestanding_none_source(), default_cwd)
    assert_generated_c_only(freestanding_none_default_res)
    assert freestanding_none_default_res.c_path == os.join_path(default_cwd,
        'freestanding_none_default_generation_only.c')
    assert freestanding_none_default_res.c_source.contains('#include <platform_none.h>')
    assert_no_os_runtime_headers(freestanding_none_default_res.c_source)

    public_freestanding_none_minimal_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary,
        tmp_dir, 'app', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'none',
    ], minimal_source, default_cwd)
    assert_generated_c_only(public_freestanding_none_minimal_res)
    assert public_freestanding_none_minimal_res.c_path == os.join_path(default_cwd, 'app.c')
    assert_no_os_runtime_headers(public_freestanding_none_minimal_res.c_source)

    public_freestanding_none_default_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary,
        tmp_dir, 'public_freestanding_none_default_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'none',
    ], freestanding_none_source(), default_cwd)
    assert_generated_c_only(public_freestanding_none_default_res)
    assert public_freestanding_none_default_res.c_path == os.join_path(default_cwd,
        'public_freestanding_none_default_generation_only.c')
    assert public_freestanding_none_default_res.c_source.contains('#include <platform_none.h>')
    assert_no_os_runtime_headers(public_freestanding_none_default_res.c_source)

    freestanding_out := os.join_path(tmp_dir, 'freestanding_app')
    freestanding_res := run_v2_to_output(v2_binary, tmp_dir, 'freestanding_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'linux',
        '--skip-builtin',
    ], minimal_source, freestanding_out)
    assert_generated_c_only(freestanding_res)
    assert freestanding_res.c_path == freestanding_out + '.c'

    freestanding_none_out := os.join_path(tmp_dir, 'freestanding_none_app')
    freestanding_none_res := run_v2_to_output(v2_binary, tmp_dir,
        'freestanding_none_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'none',
        '--skip-builtin',
    ], freestanding_none_source(), freestanding_none_out)
    assert_generated_c_only(freestanding_none_res)
    assert freestanding_none_res.c_path == freestanding_none_out + '.c'
    assert freestanding_none_res.c_source.contains('#include <platform_none.h>')
    assert freestanding_none_res.c_source.contains('platform_none_tick')
    assert_no_os_runtime_headers(freestanding_none_res.c_source)

    public_wrapper_out := os.join_path(tmp_dir, 'public_wrapper_freestanding_none.c')
    public_wrapper_res := run_v1_v2_to_output(v1_binary, v2_binary, tmp_dir,
        'public_wrapper_freestanding_none', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'none',
        '--skip-builtin',
    ], freestanding_none_source(), public_wrapper_out)
    assert_cli_success(public_wrapper_res)
    assert public_wrapper_res.c_path == public_wrapper_out
    assert public_wrapper_res.c_source.contains('#include <platform_none.h>')
    assert public_wrapper_res.c_source.contains('platform_none_tick')
    assert_no_os_runtime_headers(public_wrapper_res.c_source)

    freestanding_none_hooks_out := os.join_path(tmp_dir, 'freestanding_none_hooks_app')
    freestanding_none_hooks_res := run_v2_to_output(v2_binary, tmp_dir,
        'freestanding_none_hooks_generation_only', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'none',
        '-fhooks',
        'output,panic,alloc',
        '--skip-builtin',
        '--skip-type-check',
    ], "module main

struct HeapBox {
    value int
}

fn main() {
    println('hooked')
    _ := &HeapBox{
        value: 1
    }
    panic('hooked')
}
    ",
        freestanding_none_hooks_out)
    assert_generated_c_only(freestanding_none_hooks_res)
    assert freestanding_none_hooks_res.c_source.contains('isize v_platform_write(int stream, const u8* buf, isize len);')
    assert freestanding_none_hooks_res.c_source.contains('void v_platform_panic(const u8* msg, isize len);')
    assert freestanding_none_hooks_res.c_source.contains('void* v_platform_malloc(isize n);')
    assert freestanding_none_hooks_res.c_source.contains('void* v_platform_realloc(void* ptr, isize n);')
    assert freestanding_none_hooks_res.c_source.contains('void v_platform_free(void* ptr);')
    assert_no_os_runtime_headers(freestanding_none_hooks_res.c_source)
    assert_no_obvious_hosted_headers(freestanding_none_hooks_res.c_source)

    non_host_target := concrete_non_host_e2e_os()
    non_host_default_res := run_v2_without_output_in_dir(v2_binary, tmp_dir,
        'concrete_non_host_default_generation_only', [
        '-cc',
        missing_cc,
        '-os',
        non_host_target,
    ], minimal_source, default_cwd)
    assert_generated_c_only(non_host_default_res)
    assert non_host_default_res.c_path == os.join_path(default_cwd,
        'concrete_non_host_default_generation_only.c')
    assert !os.exists(os.join_path(tmp_dir, 'concrete_non_host_default_generation_only.c')), non_host_default_res.output

    public_non_host_default_res := run_v1_v2_without_output_in_dir(v1_binary, v2_binary, tmp_dir,
        'public_concrete_non_host_default_generation_only', [
        '-cc',
        missing_cc,
        '-os',
        non_host_target,
    ], minimal_source, default_cwd)
    assert_generated_c_only(public_non_host_default_res)
    assert public_non_host_default_res.c_path == os.join_path(default_cwd,
        'public_concrete_non_host_default_generation_only.c')
    assert !os.exists(os.join_path(tmp_dir, 'public_concrete_non_host_default_generation_only.c')), public_non_host_default_res.output

    non_host_out := os.join_path(tmp_dir, 'target_${non_host_target}_app')
    non_host_res := run_v2_to_output(v2_binary, tmp_dir, 'concrete_non_host_generation_only', [
        '-cc',
        missing_cc,
        '-os',
        non_host_target,
    ], minimal_source, non_host_out)
    assert_generated_c_only(non_host_res)
    assert non_host_res.c_path == non_host_out + '.c'

    non_host_cached_out := os.join_path(tmp_dir, 'target_${non_host_target}_cached_app')
    non_host_cached_res := run_v2_to_output_with_cache(v2_binary, tmp_dir,
        'concrete_non_host_generation_only_cached', [
        '-cc',
        missing_cc,
        '-os',
        non_host_target,
    ], 'module main

fn main() {
    println(123)
}
', non_host_cached_out)
    assert_generated_c_only(non_host_cached_res)
    assert non_host_cached_res.c_path == non_host_cached_out + '.c'
    assert non_host_cached_res.c_source.contains('void println(string s) {'), non_host_cached_res.c_source

    flag_obj := os.join_path(tmp_dir, 'generation_only_probe.o')
    flag_c := os.join_path(tmp_dir, 'generation_only_probe.c')
    os.write_file(flag_c, 'int generation_only_probe(void) { return 0; }\n') or { panic(err) }
    explicit_c_out := os.join_path(tmp_dir, 'explicit_generation_only.c')
    explicit_c_res := run_v2_to_output(v2_binary, tmp_dir, 'explicit_c_generation_only', [], 'module main

#flag ${flag_obj}

fn main() {}
',
        explicit_c_out)
    assert_cli_success(explicit_c_res)
    assert !os.exists(flag_obj), 'generation-only .c output compiled unexpected object ${flag_obj}\n${explicit_c_res.output}'

    rejected_none_res := run_v2_without_output_in_dir(v2_binary, tmp_dir,
        'rejected_none_without_freestanding', [
        '-cc',
        missing_cc,
        '-os',
        'none',
    ], minimal_source, default_cwd)
    assert_cli_failure_contains(rejected_none_res, '-os none requires -freestanding')
    assert !os.exists(rejected_none_res.c_path), rejected_none_res.output
    assert !os.exists(rejected_none_res.out_path), rejected_none_res.output

    rejected_freestanding_cross_res := run_v2_without_output_in_dir(v2_binary, tmp_dir,
        'rejected_freestanding_cross', [
        '-cc',
        missing_cc,
        '-freestanding',
        '-os',
        'cross',
        '--skip-builtin',
    ], minimal_source, default_cwd)
    assert_cli_failure_contains(rejected_freestanding_cross_res,
        '-freestanding -os cross is not supported')
    assert !os.exists(rejected_freestanding_cross_res.c_path), rejected_freestanding_cross_res.output
    assert !os.exists(rejected_freestanding_cross_res.out_path), rejected_freestanding_cross_res.output
}

fn test_cleanc_cli_does_not_auto_run_stale_test_binary_for_generation_only_target() {
    $if windows {
        eprintln('skip: stale executable auto-run guard uses a POSIX shell script')
        return
    }
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_no_stale_autorun_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)
    source_path := os.join_path(tmp_dir, 'stale_autorun_test.v')
    stale_path := os.join_path(tmp_dir, 'stale_autorun_test')
    os.write_file(source_path, 'module main

fn main() {}
') or { panic(err) }
    os.write_file(stale_path, '#!/bin/sh
echo STALE_AUTORUN_EXECUTED
exit 73
') or { panic(err) }
    os.chmod(stale_path, 0o755) or { panic(err) }

    res :=
        os.execute('cd "${tmp_dir}" && "${v2_binary}" -gc none -nocache --no-parallel -freestanding -os none --skip-builtin "${source_path}"')
    assert res.exit_code == 0, res.output
    assert !res.output.contains('STALE_AUTORUN_EXECUTED'), res.output
    assert os.exists(os.join_path(tmp_dir, 'stale_autorun_test.c')), res.output
    assert os.exists(stale_path), res.output

    non_host_target := concrete_non_host_e2e_os()
    cleanc_source_path := os.join_path(tmp_dir, 'cleanc_non_host_stale.v')
    cleanc_stale_path := os.join_path(tmp_dir, 'cleanc_non_host_stale')
    os.write_file(cleanc_source_path, 'module main

fn main() {}
') or { panic(err) }
    os.write_file(cleanc_stale_path, '#!/bin/sh
echo CLEANC_NON_HOST_STALE_EXECUTED
exit 75
') or {
        panic(err)
    }
    os.chmod(cleanc_stale_path, 0o755) or { panic(err) }
    cleanc_res :=
        os.execute('cd "${tmp_dir}" && "${v2_binary}" -gc none -nocache --no-parallel -os ${non_host_target} "${cleanc_source_path}"')
    assert cleanc_res.exit_code == 0, cleanc_res.output
    assert !cleanc_res.output.contains('CLEANC_NON_HOST_STALE_EXECUTED'), cleanc_res.output
    assert os.exists(os.join_path(tmp_dir, 'cleanc_non_host_stale.c')), cleanc_res.output
    assert os.exists(cleanc_stale_path), cleanc_res.output

    native_source_path := os.join_path(tmp_dir, 'native_cross_autorun_test.v')
    native_stale_path := os.join_path(tmp_dir, 'native_cross_autorun_test')
    os.write_file(native_source_path, 'module main

fn main() {}
') or { panic(err) }
    os.write_file(native_stale_path, '#!/bin/sh
echo NATIVE_STALE_AUTORUN_EXECUTED
exit 74
') or {
        panic(err)
    }
    os.chmod(native_stale_path, 0o755) or { panic(err) }
    native_res :=
        os.execute('cd "${tmp_dir}" && "${v2_binary}" -gc none -nocache --no-parallel -b x64 -os ${non_host_target} --skip-builtin "${native_source_path}"')
    assert native_res.exit_code == 0, native_res.output
    assert !native_res.output.contains('NATIVE_STALE_AUTORUN_EXECUTED'), native_res.output
    assert os.exists(native_stale_path), native_res.output
}

fn test_cleanc_cli_auto_runs_cross_test_binary_when_compiled_for_host() {
    if !host_cc_available() {
        eprintln('skip: cc is not available for cleanc cross auto-run e2e')
        return
    }
    tmp_dir := os.join_path(os.vtmp_dir(), 'v2_cleanc_cross_autorun_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    v2_binary := build_v2_for_target_e2e(tmp_dir)
    source_path := os.join_path(tmp_dir, 'cross_autorun_test.v')
    os.write_file(source_path, 'module main

fn main() {
    println("CROSS_AUTORUN_OK")
}
') or {
        panic(err)
    }
    env_prefix := if host_c_e2e_flags().len > 0 { 'V2CFLAGS="${host_c_e2e_flags()}" ' } else { '' }
    res :=
        os.execute('cd "${tmp_dir}" && ${env_prefix}"${v2_binary}" -gc none -nocache --no-parallel -cc cc -os cross "${source_path}"')
    assert res.exit_code == 0, res.output
    assert res.output.contains('CROSS_AUTORUN_OK'), res.output
    assert !os.exists(os.join_path(tmp_dir, 'cross_autorun_test')), res.output
}