v3: address active-header review feedback

Author: medvednikov

ci/qemu_linux_tests.sh

@@ -202,15 +202,15 @@ if ((provision)); then
 fi
 
 host_head=$(git -C "$repo_root" rev-parse HEAD)
-guest_head=$(ssh "${ssh_options[@]}" "$guest" "git -C '${guest_repo}' rev-parse HEAD")
+printf -v guest_repo_q '%q' "$guest_repo"
+guest_head=$(ssh "${ssh_options[@]}" "$guest" "git -C ${guest_repo_q} rev-parse HEAD")
 if [[ "$host_head" != "$guest_head" ]]; then
 	echo "Host and guest baselines differ (${host_head} != ${guest_head})." >&2
 	echo "Update ${guest_repo} in the guest before syncing local changes." >&2
 	exit 1
 fi
 
 if ((sync_checkout)); then
-	printf -v guest_repo_q '%q' "$guest_repo"
 	# Remove every untracked path copied by the previous sync before restoring the
 	# current set. This keeps a locally deleted untracked source from lingering in
 	# guest module discovery without cleaning unrelated guest build artifacts.
@@ -267,7 +267,6 @@ if (($# == 0)); then
 	set -- test-all
 fi
 
-printf -v guest_repo_q '%q' "$guest_repo"
 printf -v jobs_q '%q' "$jobs"
 printf -v vflags_q '%q' "$vflags"
 printf -v no_fallback_q '%q' "$no_fallback"

doc/docs.md

@@ -82,7 +82,9 @@ target OS different from the host, the established compiler in `vlib/v` is
 used. V scripts (`.vsh`, including `v run script.vsh`), the `crun` and
 `build-module` commands, and debug builds selected with `-g`/`-debug` also
 remain on the established compiler. Same-OS cross-architecture builds can still
-use V3 when the target is supported.
+use V3 when the target is supported. Copies or symlinks whose resolved compiler
+executable is not named `v` or `vnew` also remain on the established compiler by
+default; pass `-new-compiler` to select V3 explicitly in those installations.
 
 You normally do not need to do anything: when V3 cannot yet build an eligible
 program, `v` automatically falls back to the established compiler, so your build

vlib/v3/gen/c/cleanc.v

@@ -4530,12 +4530,12 @@ fn (mut g FlatGen) collect_preserved_header_file(path string, include_dirs []str
 	}
 	g.preserved_header_files_seen[real_path] = true
 	text := os.read_file(real_path) or { return }
-	possible_text := c_header_possible_active_text(text, g.c_flags, g.c99_mode, g.target)
-	g.collect_inlined_c_structs(possible_text)
-	g.collect_inlined_c_fns(possible_text)
-	g.collect_inlined_c_declared_fns(possible_text)
+	active_text := c_header_definitely_active_text(text, g.c_flags, g.c99_mode, g.target)
+	g.collect_inlined_c_structs(active_text)
+	g.collect_inlined_c_fns(active_text)
+	g.collect_inlined_c_declared_fns(active_text)
 	mut in_block_comment := false
-	for line in possible_text.split_into_lines() {
+	for line in active_text.split_into_lines() {
 		clean, next_in_block_comment := c_preprocessor_directive_scan_line(line, in_block_comment)
 		in_block_comment = next_in_block_comment
 		if c_directive_name(clean) !in ['include', 'import'] {
@@ -4559,17 +4559,17 @@ fn (mut g FlatGen) collect_preserved_header_file(path string, include_dirs []str
 	}
 }
 
-// c_header_possible_active_text removes declarations from preprocessor branches
-// known to be inactive for the current target and C flags. Unknown branches stay
-// in the scan so a declaration that the real compiler may see remains authoritative.
-fn c_header_possible_active_text(text string, flags []string, c99_mode bool, target pref.Target) string {
+// c_header_definitely_active_text retains declarations only from preprocessor
+// branches known to be active for the current target and C flags. A declaration
+// in an unresolved branch cannot safely suppress a generated C prototype.
+fn c_header_definitely_active_text(text string, flags []string, c99_mode bool, target pref.Target) string {
 	mut defined := map[string]bool{}
 	mut undefined := map[string]bool{}
 	mut uncertain := map[string]bool{}
-	// A preserved header inherits macros from its including source and parent
-	// headers. That context is not carried through this lightweight recursive
-	// scan, so an otherwise unknown macro must keep both branches possible.
-	mut external_macros_possible := true
+	// Preinclude headers begin before generated source declarations. An earlier
+	// nested include can still introduce unknown macros, which makes later
+	// conditions unresolved and therefore unsuitable for prototype suppression.
+	mut external_macros_possible := false
 	mut i := 0
 	for i < flags.len {
 		clean := trimmed_space(flags[i])
@@ -4685,19 +4685,17 @@ fn c_header_possible_active_text(text string, flags []string, c99_mode bool, tar
 			output.writeln('')
 			continue
 		}
-		mut possibly_active := true
 		mut definitely_active := true
 		for depth in 0 .. condition_known.len {
 			if condition_known[depth] && !condition_active[depth] {
-				possibly_active = false
 				definitely_active = false
 				break
 			}
 			if !condition_known[depth] {
 				definitely_active = false
 			}
 		}
-		if !possibly_active {
+		if !definitely_active {
 			output.writeln('')
 			continue
 		}
@@ -4717,10 +4715,6 @@ fn c_header_possible_active_text(text string, flags []string, c99_mode bool, tar
 						defined.delete(macro_name)
 						undefined[macro_name] = true
 					}
-				} else {
-					defined.delete(macro_name)
-					undefined.delete(macro_name)
-					uncertain[macro_name] = true
 				}
 			}
 		}
@@ -4732,8 +4726,8 @@ fn c_header_possible_active_text(text string, flags []string, c99_mode bool, tar
 fn c_preprocessor_ifdef_macro_state(name string, defined map[string]bool, undefined map[string]bool, uncertain map[string]bool, external_macros_possible bool, strict_iso_mode bool, target pref.Target) (bool, bool) {
 	if external_macros_possible && name !in defined && name !in undefined && name !in uncertain
 		&& name !in ['__linux__', '__linux', 'linux', 'unix', '__APPLE__', '__MACH__', '_WIN32', '_WIN64', '__FreeBSD__', '__OpenBSD__', '__NetBSD__'] {
-		// An earlier include can define an otherwise unknown macro. Keep both
-		// branches in that case so the declaration scan never drops active code.
+		// An earlier include can define an otherwise unknown macro, so its state
+		// cannot be inferred by this lightweight scan.
 		return false, true
 	}
 	return c_preprocessor_macro_state(name, defined, undefined, uncertain, strict_iso_mode, target)

vlib/v3/gen/c/source_directive_test.v

@@ -57,7 +57,7 @@ fn test_preserved_header_trees_scan_shared_files_once() {
 	assert g.preserved_header_files_seen.len == 3
 }
 
-fn test_preserved_header_ignores_known_inactive_declarations() {
+fn test_preserved_header_collects_only_definitely_active_declarations() {
 	root := os.join_path(os.vtmp_dir(), 'v3_preserved_inactive_${os.getpid()}')
 	os.rmdir_all(root) or {}
 	os.mkdir_all(root) or { panic(err) }
@@ -71,18 +71,26 @@ fn test_preserved_header_ignores_known_inactive_declarations() {
 	os.write_file(macro_header,
 		'#if defined(PARENT_HEADER_FEATURE)\nint parent_enabled_fn(void);\n#endif\n#define PRESERVED_HEADER_FEATURE 1\n')!
 	os.write_file(header,
-		'#if 0\nint inactive_fn(void);\n#include "inactive.h"\n#else\nint active_fn(void);\n#endif\n#define PARENT_HEADER_FEATURE 1\n#include "macro.h"\n#if defined(PRESERVED_HEADER_FEATURE)\nint include_enabled_fn(void);\n#endif\n')!
+		'#ifdef OPTIONAL_API\nint optional_fn(void);\n#endif\n#if 0\nint inactive_fn(void);\n#include "inactive.h"\n#else\nint active_fn(void);\n#endif\n#define PARENT_HEADER_FEATURE 1\n#include "macro.h"\n#if defined(PRESERVED_HEADER_FEATURE)\nint include_enabled_fn(void);\n#endif\n')!
 
 	mut g := FlatGen.new()
 	g.collect_preserved_header_file(header, [root])
 
 	assert 'inactive_fn' !in g.inlined_c_declared_fns
 	assert 'nested_inactive_fn' !in g.inlined_c_declared_fns
 	assert 'active_fn' in g.inlined_c_declared_fns
-	assert 'include_enabled_fn' in g.inlined_c_declared_fns
-	assert 'parent_enabled_fn' in g.inlined_c_declared_fns
+	assert 'optional_fn' !in g.inlined_c_declared_fns
+	// Macro changes in recursively scanned headers are not carried back into the
+	// parent scan, so those declarations cannot safely suppress prototypes either.
+	assert 'include_enabled_fn' !in g.inlined_c_declared_fns
+	assert 'parent_enabled_fn' !in g.inlined_c_declared_fns
 	assert os.real_path(inactive_header) !in g.preserved_header_files_seen
 	assert os.real_path(macro_header) in g.preserved_header_files_seen
+
+	mut enabled_g := FlatGen.new()
+	enabled_g.c_flags << '-DOPTIONAL_API'
+	enabled_g.collect_preserved_header_file(header, [root])
+	assert 'optional_fn' in enabled_g.inlined_c_declared_fns
 }
 
 fn collect_external_input_tree_status(root string, entry string, ambient_ambiguous bool) (bool, []string) {