cmd/v: export the build facts and defines to the test runner again (#28801)

`v test <dir>` evaluates every `// vtest build:` expression through
`cmd/tools/testing`, which reads its facts from the `VBUILD_FACTS` and
`VBUILD_DEFINES` environment variables. Nothing has set them since
2a7447b removed the launcher's `setup_vbuild_env_vars`, so the runner
saw an empty fact set: `amd64`, `windows`, `tinyc`, `gcc` were all false
and `!windows`, `!tinyc` always true, on every host (`v test vlib/context`
skipped its four `amd64 || arm64` tests). The compiler's own evaluation
for `v file_test.v` (`v3_test_build_facts`) was unaffected, so the two
disagreed.

Factor the C compiler selection and the libc define out of `driver.run`
into `v3_select_c_compiler` / `v3_apply_libc_define`, build the facts and
defines of a set of compiler options on top of them in
`driver.vtest_build_environment`, and have the launcher export the result
with `pref.set_build_flags_and_defines` before it starts a tool that runs
a test session (`test`, `test-self`, `test-cleancode`, `test-fmt`,
`build-examples`, `build-tools`, `build-vbinaries`).

`cmd/tools/vtest_build_facts_test.v` runs `v test` on fixtures constrained
by the host OS and arch, their negations and an optional define, and
checks which ones executed; it fails on the previous launcher.
`vlib/v/driver/vtest_build_environment_test.v` pins the resolver.

Fixes #28798

Co-authored-by: Richard Wheeler <18647491+PythonWillRule@users.noreply.github.com>
Co-authored-by: WOZCODE <contact@withwoz.com>

Author: 3 people

cmd/tools/vtest_build_facts_test.v

@@ -0,0 +1,85 @@
+import os
+import v.cmdexec
+import v.pref
+
+// `v test` evaluates `// vtest build:` in cmd/tools/testing against the facts the
+// launcher exports, while `v file_test.v` derives them in the compiler. Both must
+// see the same host, compiler and defines; these fixtures pin the runner's side.
+
+const facts_root = os.join_path(os.vtmp_dir(), 'vtest.build_facts.${os.getpid()}')
+const facts_original_cwd = os.getwd()
+
+fn write_facts_fixture(name string, constraint string, passing bool) {
+	body := if passing {
+		"import os\nfn test_probe() { os.write_file(@FILE + '.executed', 'passed')!; assert true }\n"
+	} else {
+		"fn test_probe() { assert false, 'a skipped fixture must not run' }\n"
+	}
+	os.write_file(os.join_path(facts_root, name), '// vtest build: ${constraint}\n\n' + body) or {
+		panic(err)
+	}
+}
+
+fn testsuite_begin() {
+	os.rmdir_all(facts_root) or {}
+	os.mkdir_all(facts_root)!
+	// The nested `v test` must not rebuild the tool over the runner executing this
+	// test; the cached tool binary is keyed by the prefix options and lives elsewhere.
+	for name in ['VTEST_ONLY', 'VTEST_ONLY_FN', 'VTEST_RUNNER', 'VBUILD_FACTS', 'VBUILD_DEFINES',
+		'VTOOLS_NO_CACHE'] {
+		os.unsetenv(name)
+	}
+	os.setenv('VEXE', @VEXE, true)
+	os.setenv('VJOBS', '1', true)
+	os.setenv('VCOLORS', 'never', true)
+	os.setenv('VTEST_HIDE_OK', '0', true)
+	os.setenv('VTEST_HIDE_SKIP', '0', true)
+	// One attempt: the runner compiles `VTEST_MAX_COMPILATION_RETRIES` times, so 0 would skip compiling.
+	os.setenv('VTEST_MAX_COMPILATION_RETRIES', '1', true)
+	os.setenv('V_C_ERROR_BUG_REPORT_DISABLED', '1', true)
+	os.setenv('V_MACOS_V3_NO_FALLBACK', '1', true)
+	host := pref.host_target()
+	write_facts_fixture('host_os_test.v', host.os, true)
+	write_facts_fixture('not_host_os_test.v', '!${host.os}', false)
+	write_facts_fixture('host_arch_test.v', host.arch, true)
+	write_facts_fixture('not_host_arch_test.v', '!${host.arch}', false)
+	write_facts_fixture('define_test.v', 'build_facts_probe?', true)
+	write_facts_fixture('not_define_test.v', '!build_facts_probe?', true)
+	os.chdir(facts_root)!
+}
+
+fn testsuite_end() {
+	os.chdir(facts_original_cwd) or { panic(err) }
+	os.rmdir_all(facts_root) or {}
+}
+
+fn run_facts_session(prefix_args []string) os.Result {
+	for marker in os.walk_ext(facts_root, '.executed') {
+		os.rm(marker) or { panic(err) }
+	}
+	mut args := prefix_args.clone()
+	args << ['test', facts_root]
+	return cmdexec.run_with_timeout(@VEXE, args, 300_000)
+}
+
+fn assert_facts_summary(result os.Result, expected string, executed []string) {
+	assert result.exit_code == 0, result.output
+	summaries := result.output.split_into_lines().map(it.trim_space()).filter(it.starts_with('Summary for all V _test.v files:'))
+	assert summaries.len == 1, result.output
+	assert summaries[0].starts_with('Summary for all V _test.v files: ${expected}.'), result.output
+	mut markers := os.walk_ext(facts_root, '.executed').map(os.file_name(it).all_before('.executed'))
+	markers.sort()
+	assert markers == executed, result.output
+}
+
+fn test_the_runner_sees_the_host_facts() {
+	result := run_facts_session([])
+	assert_facts_summary(result, '3 passed, 3 skipped, 6 total', ['host_arch_test.v', 'host_os_test.v',
+		'not_define_test.v'])
+}
+
+fn test_the_runner_sees_the_user_defines() {
+	result := run_facts_session(['-d', 'build_facts_probe'])
+	assert_facts_summary(result, '3 passed, 3 skipped, 6 total', ['define_test.v', 'host_arch_test.v',
+		'host_os_test.v'])
+}

cmd/v/v.v

@@ -320,9 +320,27 @@ fn run_external_tool(args []string, command_index int, command string) {
 	if command_index >= 0 {
 		tool_args = external_tool_runtime_args(command, prefix_args, args[command_index..])
 	}
+	if command in test_session_commands {
+		export_vtest_build_environment(vroot, prefix_args)
+	}
 	launch_external_tool(vroot, tool_name, tool_source, prefix_args, tool_args)
 }
 
+// test_session_commands start a `cmd/tools/` program that evaluates the
+// `// vtest build:` constraints of the files it compiles, through
+// `cmd/tools/testing`, against the `VBUILD_FACTS`/`VBUILD_DEFINES` environment.
+const test_session_commands = ['test', 'test-self', 'test-cleancode', 'test-fmt', 'build-examples',
+	'build-tools', 'build-vbinaries']
+
+// export_vtest_build_environment records the facts and defines of the
+// compilation that the prefix compiler options describe, as the compiler itself
+// resolves them, so that the test runner skips and builds the same files that
+// `v file_test.v` would.
+fn export_vtest_build_environment(vroot string, prefix_args []string) {
+	environment := driver.vtest_build_environment(vroot, prefix_args)
+	pref.set_build_flags_and_defines(environment.facts, environment.defines)
+}
+
 fn external_tool_runtime_args(command string, prefix_args []string, command_args []string) []string {
 	mut tool_args := []string{}
 	// `v build-tools` consumes compiler options itself and applies them to every

vlib/v/driver/driver.v

@@ -7324,6 +7324,73 @@ fn v3_select_implicit_c_compiler(c_compiler string, c_compiler_explicit bool, im
 	return c_compiler
 }
 
+// V3CCompilerSelection is the C compiler that receives a compilation's first
+// build attempt, and the name (`tinyc`, `gcc`, `clang`, ...) the generated code
+// and the `// vtest build:` facts describe it by.
+struct V3CCompilerSelection {
+	bundled_tcc_available      bool
+	implicit_tcc               string
+	c_compiler                 string
+	use_implicit_tcc_semantics bool
+	effective_c_compiler       string
+}
+
+// v3_select_c_compiler normalises the requested C compiler (a Windows target
+// built on another host uses the MinGW GCC instead of TCC; `msvc` on Windows is
+// `cl`) and resolves it against the bundled and the system TCC: an implicit TCC
+// takes over from the platform default when the compilation allows it, and an
+// explicit `-cc` is kept as given.
+fn v3_select_c_compiler(vroot string, requested V3BundledTccProbeOptions) V3CCompilerSelection {
+	options := V3BundledTccProbeOptions{
+		...requested
+		c_compiler: v3_c_compiler_command_alias(v3_windows_cross_c_compiler(requested.c_compiler,
+			requested.host_target, requested.target), requested.host_os)
+	}
+	bundled_tcc_available := v3_bundled_tcc_available(options)
+	allow_system_tcc := options.backend == 'c' && !options.c_only && !options.is_prod
+		&& !options.is_c_debug && !options.c_compiler_explicit
+		&& (!options.parallel_cc || options.target.os == 'windows')
+		&& options.target.os == options.host_target.os
+		&& options.target.arch == options.host_target.arch
+		&& v3_system_tcc_runtime_available(vroot, options.target.os)
+	implicit_tcc := v3_default_tcc_compiler(options.bundled_tcc, bundled_tcc_available,
+		allow_system_tcc, options.dump_c_flags, options.host_os)
+	c_compiler := v3_select_implicit_c_compiler(options.c_compiler, options.c_compiler_explicit,
+		implicit_tcc)
+	// Generate for the compiler that receives the first build attempt. If implicit
+	// TCC cannot be used, the caller regenerates before invoking the `cc` fallback.
+	use_implicit_tcc_semantics := options.backend == 'c' && !options.c_compiler_explicit
+		&& implicit_tcc != ''
+	return V3CCompilerSelection{
+		bundled_tcc_available:      bundled_tcc_available
+		implicit_tcc:               implicit_tcc
+		c_compiler:                 c_compiler
+		use_implicit_tcc_semantics: use_implicit_tcc_semantics
+		effective_c_compiler:       v3_effective_c_compiler_for_codegen(options.backend,
+			c_compiler, use_implicit_tcc_semantics, options.target)
+	}
+}
+
+// v3_apply_libc_define records the C library a compilation targets as its
+// `musl`/`glibc` define: the requested one (`-musl`, `-glibc`, a `*musl-gcc`
+// compiler), or, when `infer_host` allows it, the host's own. It returns the
+// libc mode the compilation should use.
+fn v3_apply_libc_define(mut user_defines []string, mut compile_values map[string]string, requested_libc_mode string, c_compiler string, infer_host bool) string {
+	mut libc_mode := requested_libc_mode
+	if v3_c_compiler_implies_musl(c_compiler) {
+		libc_mode = 'musl'
+	}
+	if libc_mode != '' {
+		v3_set_libc_define(mut user_defines, mut compile_values, libc_mode)
+	} else if !v3_has_libc_define(user_defines) && infer_host {
+		host_libc := v3_detect_host_libc()
+		if host_libc != '' {
+			v3_set_libc_define(mut user_defines, mut compile_values, host_libc)
+		}
+	}
+	return libc_mode
+}
+
 fn v3_platform_c_compiler(host_os string) string {
 	return if host_os == 'windows' { 'gcc' } else { 'cc' }
 }
@@ -10060,9 +10127,7 @@ pub fn run(args []string) {
 	bundled_tcc := os.join_path(prefs.vroot, 'thirdparty', 'tcc', 'tcc.exe')
 	host_os := os.user_os()
 	host_target := pref.host_target()
-	c_compiler = v3_windows_cross_c_compiler(c_compiler, host_target, target)
-	c_compiler = v3_c_compiler_command_alias(c_compiler, host_os)
-	bundled_tcc_available := v3_bundled_tcc_available(V3BundledTccProbeOptions{
+	selection := v3_select_c_compiler(prefs.vroot, V3BundledTccProbeOptions{
 		backend:             backend
 		c_only:              c_only
 		is_prod:             is_prod
@@ -10076,31 +10141,16 @@ pub fn run(args []string) {
 		target:              target
 		bundled_tcc:         bundled_tcc
 	})
-	allow_system_tcc := backend == 'c' && !c_only && !is_prod && !is_c_debug && !c_compiler_explicit
-		&& (!parallel_cc || target.os == 'windows') && target.os == host_target.os
-		&& target.arch == host_target.arch
-		&& v3_system_tcc_runtime_available(prefs.vroot, target.os)
-	implicit_tcc := v3_default_tcc_compiler(bundled_tcc, bundled_tcc_available, allow_system_tcc, dump_c_flags.len > 0, host_os)
-	c_compiler = v3_select_implicit_c_compiler(c_compiler, c_compiler_explicit, implicit_tcc)
-	// Generate for the compiler that receives the first build attempt. If implicit
-	// TCC cannot be used, regenerate below before invoking the `cc` fallback.
-	use_implicit_tcc_semantics := backend == 'c' && !c_compiler_explicit && implicit_tcc != ''
-	effective_c_compiler := v3_effective_c_compiler_for_codegen(backend, c_compiler, use_implicit_tcc_semantics, target)
+	bundled_tcc_available := selection.bundled_tcc_available
+	implicit_tcc := selection.implicit_tcc
+	c_compiler = selection.c_compiler
+	use_implicit_tcc_semantics := selection.use_implicit_tcc_semantics
+	effective_c_compiler := selection.effective_c_compiler
 	macos_linux_cross_compile := v3_macos_linux_cross_compile(host_target, target, backend,
 		c_compiler)
-	if v3_c_compiler_implies_musl(c_compiler) {
-		libc_mode = 'musl'
-	}
-	if libc_mode != '' {
-		v3_set_libc_define(mut user_defines, mut compile_values, libc_mode)
-	} else if !v3_has_libc_define(user_defines)
-		&& v3_should_infer_host_libc(c_only, is_o, generate_c_project, output_cross_c, target,
-			host_target) {
-		host_libc := v3_detect_host_libc()
-		if host_libc != '' {
-			v3_set_libc_define(mut user_defines, mut compile_values, host_libc)
-		}
-	}
+	libc_mode = v3_apply_libc_define(mut user_defines, mut compile_values, libc_mode, c_compiler,
+		v3_should_infer_host_libc(c_only, is_o, generate_c_project, output_cross_c, target,
+			host_target))
 	incompatible_direct_test := v3_direct_test_input_is_incompatible(is_test_command, input_file, backend, target, effective_c_compiler, is_prod, user_defines)
 	if incompatible_direct_test {
 		// Directory test discovery already excludes incompatible backend/platform files.

vlib/v/driver/vtest_build_environment.v

@@ -0,0 +1,124 @@
+module driver
+
+import os
+import v.pref
+
+// TestBuildEnvironment is what a `// vtest build:` expression is evaluated
+// against: the facts of a compilation (its OS, architecture, C compiler kind,
+// `prod`, the CI job) and the defines it sets.
+pub struct TestBuildEnvironment {
+pub:
+	facts   []string
+	defines []string
+}
+
+// vtest_build_environment resolves the facts and defines of the compilation
+// that the compiler options `args` describe (`-os`, `-arch`, `-cc`, `-prod`,
+// `-d`, ...), the way `run` resolves them for `v <args> file_test.v`. A test
+// runner started with those options exports the result through
+// pref.set_build_flags_and_defines, so that its `// vtest build:` decisions
+// match the compiler's own.
+pub fn vtest_build_environment(vroot string, args []string) TestBuildEnvironment {
+	mut backend := 'c'
+	mut target_os := os.user_os()
+	mut target_arch := pref.host_arch()
+	mut cross_output := false
+	mut c_compiler := 'cc'
+	mut c_compiler_explicit := false
+	mut is_prod := false
+	mut is_c_debug := false
+	mut parallel_cc := false
+	mut dump_c_flags := false
+	mut libc_mode := ''
+	mut user_defines := []string{}
+	mut compile_values := map[string]string{}
+	mut i := 0
+	for i < args.len {
+		arg := args[i]
+		has_value := i + 1 < args.len
+		if arg in ['-b', '-backend'] && has_value {
+			backend = if args[i + 1] in ['js_browser', 'js_node'] { 'js' } else { args[i + 1] }
+			i += 2
+		} else if arg == '-os' && has_value {
+			target_os = args[i + 1]
+			i += 2
+		} else if arg == '-cross' {
+			cross_output = true
+			i++
+		} else if arg == '-arch' && has_value {
+			target_arch = args[i + 1]
+			i += 2
+		} else if arg == '-cc' && has_value {
+			c_compiler = args[i + 1]
+			c_compiler_explicit = true
+			i += 2
+		} else if arg == '-prod' {
+			is_prod = true
+			i++
+		} else if arg in ['-cg', '-cdebug'] {
+			is_c_debug = true
+			i++
+		} else if arg == '-parallel-cc' {
+			parallel_cc = true
+			i++
+		} else if arg == '-musl' {
+			libc_mode = 'musl'
+			i++
+		} else if arg == '-glibc' {
+			libc_mode = 'glibc'
+			i++
+		} else if arg in ['-d', '-define'] && has_value {
+			record_user_define(mut user_defines, mut compile_values, args[i + 1])
+			i += 2
+		} else if arg == '-dump-c-flags' {
+			// Its value is optional, so it must not be read as a `-d` shorthand.
+			dump_c_flags = true
+			i += if has_value { 2 } else { 1 }
+		} else if arg.starts_with('-d') && arg.len > 2 && !v3_driver_option_consumes_value(arg) {
+			record_user_define(mut user_defines, mut compile_values, arg[2..])
+			i++
+		} else if v3_driver_option_consumes_value(arg) && has_value {
+			i += 2
+		} else {
+			i++
+		}
+	}
+	if pref.normalized_os(target_os.trim_space().to_lower()) == 'cross' {
+		cross_output = true
+		target_os = os.user_os()
+	}
+	target := pref.target_from(target_os, target_arch) or { pref.host_target() }
+	host_target := pref.host_target()
+	selection := v3_select_c_compiler(vroot, V3BundledTccProbeOptions{
+		backend:             backend
+		is_prod:             is_prod
+		is_c_debug:          is_c_debug
+		c_compiler:          c_compiler
+		c_compiler_explicit: c_compiler_explicit
+		dump_c_flags:        dump_c_flags
+		parallel_cc:         parallel_cc
+		host_os:             os.user_os()
+		host_target:         host_target
+		target:              target
+		bundled_tcc:         os.join_path(vroot, 'thirdparty', 'tcc', 'tcc.exe')
+	})
+	v3_apply_libc_define(mut user_defines, mut compile_values, libc_mode, selection.c_compiler,
+		v3_should_infer_host_libc(false, false, '', cross_output, target, host_target))
+	mut defines := []string{}
+	for define in os.getenv('VBUILD_DEFINES').split_any(',') {
+		name := define.trim_space()
+		if name.len > 0 && name !in defines {
+			defines << name
+		}
+	}
+	for define in user_defines {
+		name := define.all_before('=').trim_space()
+		if name.len > 0 && name !in defines {
+			defines << name
+		}
+	}
+	return TestBuildEnvironment{
+		facts:   v3_test_build_facts(target, selection.effective_c_compiler, is_prod)
+		defines: defines
+	}
+}