v3: guard externs for uncertain C macros

Author: medvednikov

vlib/v3/gen/c/cleanc.v

@@ -336,6 +336,7 @@ mut:
 	inlined_c_typedef_names        map[string]bool
 	inlined_c_fns                  map[string]bool
 	inlined_c_declared_fns         map[string]bool
+	possibly_active_c_macros       map[string]bool
 	inlined_c_static_fns           map[string]bool
 	cache_omitted_c_fns            map[string]bool
 	preserved_header_files_seen    map[string]bool
@@ -1028,6 +1029,7 @@ pub fn FlatGen.new() FlatGen {
 		inlined_c_structs:               map[string]bool{}
 		inlined_c_fns:                   map[string]bool{}
 		inlined_c_declared_fns:          map[string]bool{}
+		possibly_active_c_macros:        map[string]bool{}
 		inlined_c_static_fns:            map[string]bool{}
 		cache_omitted_c_fns:             map[string]bool{}
 		preserved_header_files_seen:     map[string]bool{}
@@ -2587,6 +2589,7 @@ pub fn (mut g FlatGen) gen_with_used_options(a &flat.FlatAst, used_fns map[strin
 	g.inlined_c_structs.clear()
 	g.inlined_c_fns.clear()
 	g.inlined_c_declared_fns.clear()
+	g.possibly_active_c_macros.clear()
 	g.inlined_c_static_fns.clear()
 	g.cache_omitted_c_fns.clear()
 	g.preserved_header_files_seen.clear()
@@ -4646,7 +4649,9 @@ fn (mut g FlatGen) collect_preserved_header_file_with_state_and_scope(path strin
 		g.collect_inlined_c_declared_fns(final_scan.text)
 	}
 	for macro_name in final_scan.possibly_active_macro_names {
-		g.inlined_c_declared_fns[macro_name] = true
+		if macro_name !in g.inlined_c_declared_fns {
+			g.possibly_active_c_macros[macro_name] = true
+		}
 	}
 	result := c_header_macro_state_clone(final_scan.final_state)
 	g.preserved_header_scan_results[visit_key] = c_header_macro_state_clone(result)
@@ -4789,7 +4794,7 @@ fn (mut g FlatGen) collect_possibly_active_header_macros(path string, include_di
 	scan := c_header_definitely_active_scan(text, state, c_effective_strict_iso_mode(g.c_flags,
 		g.c99_mode), g.target)
 	for macro_name in scan.possibly_active_macro_names {
-		g.inlined_c_declared_fns[macro_name] = true
+		g.possibly_active_c_macros[macro_name] = true
 	}
 	for raw_include_arg in scan.include_args {
 		include_arg := c_include_arg(raw_include_arg, g.compiler_vroot, real_path)

vlib/v3/gen/c/fn.v

@@ -14710,7 +14710,8 @@ fn (mut g FlatGen) c_extern_forward_decls() {
 		}
 		specificity := program_decl_priority + c_extern_decl_specificity(g.a, node)
 		if cfn !in decls || specificity > decl_specificity[cfn] {
-			decls[cfn] = c_macro_safe_extern_decl(cfn, g.c_extern_decl_line(node, cfn))
+			decls[cfn] = g.c_possibly_active_macro_extern_decl(cfn, c_macro_safe_extern_decl(cfn,
+				g.c_extern_decl_line(node, cfn)))
 			decl_specificity[cfn] = specificity
 		}
 	}
@@ -14911,6 +14912,17 @@ fn c_macro_safe_extern_decl(cfn string, declaration string) string {
 	return declaration.replace_once('${cfn}(', '(${cfn})(')
 }
 
+// c_possibly_active_macro_extern_decl keeps a prototype available when a lightweight
+// preinclude scan saw a same-named macro only inside an unresolved preprocessor branch.
+// The real C preprocessor selects exactly one safe form: the macro when it exists, or the
+// declaration when it does not.
+fn (g &FlatGen) c_possibly_active_macro_extern_decl(cfn string, declaration string) string {
+	if cfn !in g.possibly_active_c_macros {
+		return declaration
+	}
+	return '#ifndef ${cfn}\n${declaration}\n#endif'
+}
+
 fn (g &FlatGen) should_emit_c_extern_decl(cfn string) bool {
 	if cfn.contains('.') {
 		return false

vlib/v3/gen/c/source_directive_test.v

@@ -233,7 +233,7 @@ fn test_preserved_header_keeps_conditional_macro_mutations_uncertain() {
 	assert 'always_active' in g.inlined_c_declared_fns
 }
 
-fn test_preserved_header_collects_possibly_active_function_macros() {
+fn test_preserved_header_guards_externs_for_possibly_active_function_macros() {
 	root := os.join_path(os.vtmp_dir(), 'v3_preserved_possible_macro_${os.getpid()}')
 	os.rmdir_all(root) or {}
 	os.mkdir_all(root)!
@@ -242,7 +242,7 @@ fn test_preserved_header_collects_possibly_active_function_macros() {
 	}
 	header := os.join_path(root, 'api.h')
 	os.write_file(header,
-		'#ifdef __GNUC__\n#define compiler_api(x) ((x) + 1)\n#endif\n#if 0\n#define inactive_api(x) (x)\n#endif\n')!
+		'#ifdef __MSVC_ONLY__\n#define compiler_api(x) ((x) + 1)\n#endif\n#if 0\n#define inactive_api(x) (x)\n#endif\n')!
 
 	mut g := FlatGen.new()
 	g.collect_preserved_header_file_with_state(header, [root], CHeaderMacroState{
@@ -252,8 +252,12 @@ fn test_preserved_header_collects_possibly_active_function_macros() {
 		external_macros_possible: true
 	})
 
-	assert 'compiler_api' in g.inlined_c_declared_fns
+	assert 'compiler_api' !in g.inlined_c_declared_fns
+	assert 'compiler_api' in g.possibly_active_c_macros
+	assert g.should_emit_c_extern_decl('compiler_api')
+	assert g.c_possibly_active_macro_extern_decl('compiler_api', 'int compiler_api(int x);') == '#ifndef compiler_api\nint compiler_api(int x);\n#endif'
 	assert 'inactive_api' !in g.inlined_c_declared_fns
+	assert 'inactive_api' !in g.possibly_active_c_macros
 }
 
 fn test_preserved_header_scans_includes_in_possibly_active_branches_for_macros() {
@@ -273,7 +277,8 @@ fn test_preserved_header_scans_includes_in_possibly_active_branches_for_macros()
 	mut g := FlatGen.new()
 	g.collect_preserved_header_file(parent, [root])
 
-	assert 'compiler_api' in g.inlined_c_declared_fns
+	assert 'compiler_api' !in g.inlined_c_declared_fns
+	assert 'compiler_api' in g.possibly_active_c_macros
 	assert 'conditionally_declared_api' !in g.inlined_c_declared_fns
 	assert 'always_declared_api' in g.inlined_c_declared_fns
 	assert os.real_path(child) in g.preserved_header_files_seen

vlib/v3/tests/preinclude_uncertain_macro_test.v

@@ -0,0 +1,44 @@
+import os
+
+fn test_preinclude_uncertain_macro_keeps_c_extern_prototype() {
+	$if macos || linux {
+		root := os.join_path(os.vtmp_dir(), 'v3_preinclude_uncertain_macro_${os.getpid()}')
+		os.rmdir_all(root) or {}
+		os.mkdir_all(root)!
+		defer {
+			os.rmdir_all(root) or {}
+		}
+		header := os.join_path(root, 'api.h')
+		implementation := os.join_path(root, 'api.c')
+		source := os.join_path(root, 'main.c.v')
+		output := os.join_path(root, 'main')
+		os.write_file(header, '#ifdef __MSVC_ONLY__\n#define compiler_api(x) ((x) + 1)\n#endif\n')!
+		os.write_file(implementation, 'int compiler_api(int x) { return x + 1; }\n')!
+		os.write_file(source, 'module main
+
+#preinclude "${header}"
+#flag ${implementation}
+
+fn C.compiler_api(int) int
+
+fn main() {
+	assert C.compiler_api(41) == 42
+}
+')!
+		mut environment := os.environ()
+		environment['VFLAGS'] = ''
+		environment['VOSARGS'] = ''
+		mut compiler := os.new_process(@VEXE)
+		compiler.set_args(['-new-compiler', '-gc', 'none', '-o', output, source])
+		compiler.set_environment(environment)
+		compiler.set_redirect_stdio()
+		compiler.run()
+		compiler.wait()
+		compiler_output := compiler.stdout_slurp() + compiler.stderr_slurp()
+		compiler_exit_code := compiler.code
+		compiler.close()
+		assert compiler_exit_code == 0, compiler_output
+		run := os.execute(os.quoted_path(output))
+		assert run.exit_code == 0, run.output
+	}
+}