v3: preserve fallback failure stages (PR #28131 review)

Author: medvednikov

cmd/tools/modules/vbugreport/c_error_storage_test.v

@@ -47,7 +47,8 @@ fn test_c_error_string_returns_empty_without_error_line() {
 
 fn test_c_error_string_preserves_v3_internal_error_message() {
 	// v3-compiler-error reports stage an `error:`-prefixed message so it survives
-	// c_error_string as a nonempty, stable, groupable diagnostic (PR #28131 review).
-	msg := 'error: the experimental V3 compiler hit an internal compiler error building this program (the stable V compiler built it successfully)'
+	// c_error_string as a nonempty, groupable diagnostic. Preserve the compiler stage
+	// too, so unrelated V3 failures do not collapse into the same stored error.
+	msg := 'error: the experimental V3 compiler hit an internal compiler error building this program during semantic checking (the stable V compiler built it successfully)'
 	assert c_error_string(msg) == msg
 }

cmd/v/macos_v3_dispatch.c.v

@@ -37,9 +37,21 @@ const macos_v3_c_error_source_name_file = 'source_name'
 // `macos_v3_compiler_error_fallback` the report describes a V3 internal compiler
 // error (V source only) instead of a generated-C compilation error.
 const macos_v3_c_error_kind_file = 'kind'
-// the diagnostic uploaded for a V3 internal compiler error (starts with `error:` so the
-// receiver's c_error_string parser stores a nonempty, groupable diagnostic).
-const macos_v3_compiler_error_message = 'error: the experimental V3 compiler hit an internal compiler error building this program (the stable V compiler built it successfully)'
+// the base diagnostic uploaded for a V3 internal compiler error (starts with `error:` so
+// the receiver's c_error_string parser stores a nonempty, groupable diagnostic).
+const macos_v3_compiler_error_message_base = 'error: the experimental V3 compiler hit an internal compiler error building this program'
+
+fn macos_v3_compiler_error_message(stage string) string {
+	stage_suffix := if stage == '' { '' } else { ' during ${stage}' }
+	return '${macos_v3_compiler_error_message_base}${stage_suffix} (the stable V compiler built it successfully)'
+}
+
+fn macos_v3_fallback_reason_and_stage(payload string) (string, string) {
+	if !payload.contains('\n') {
+		return payload, ''
+	}
+	return payload.all_before('\n'), payload.all_after_first('\n').trim_space()
+}
 
 fn maybe_delegate_to_macos_v3(command string, prefs &pref.Preferences) ?MacosV3CErrorReport {
 	if os.getenv(macos_v3_retry_env) == '1' {
@@ -195,7 +207,8 @@ fn replace_macos_v3_process_environment(environment map[string]string) {
 }
 
 fn retry_macos_v3_with_old_compiler(caller_environment map[string]string, fallback_file string, c_error_dir string, retry_args []string, is_verbose bool, input_path string) {
-	fallback_reason := os.read_file(fallback_file) or { return }
+	fallback_payload := os.read_file(fallback_file) or { return }
+	fallback_reason, fallback_stage := macos_v3_fallback_reason_and_stage(fallback_payload)
 	os.rm(fallback_file) or {}
 	if fallback_reason !in [macos_v3_inline_asm_fallback, macos_v3_compiler_error_fallback,
 		macos_v3_c_error_fallback] {
@@ -242,7 +255,8 @@ fn retry_macos_v3_with_old_compiler(caller_environment map[string]string, fallba
 		// or non-V input yields no source, so the report stays metadata-only but the
 		// fallback is never silent.
 		export_macos_v3_report_content(macos_v3_compiler_error_fallback, 'v3',
-			macos_v3_compiler_error_message, macos_v3_compiler_error_input_source(input_path))
+			macos_v3_compiler_error_message(fallback_stage),
+			macos_v3_compiler_error_input_source(input_path))
 		os.rmdir_all(c_error_dir) or {}
 		if should_report {
 			eprintln('V3 compilation failed; retrying with `-old-compiler`.')

cmd/v/macos_v3_test.v

@@ -1488,10 +1488,12 @@ fn test_macos_v3_compiler_error_content_extraction() {
 		}
 		whole := lines.join('\n')
 		os.write_file(source, whole)!
+		compiler_error := macos_v3_compiler_error_message('source parsing')
 		v_file, v_source := builder.bounded_v3_fallback_source(macos_v3_compiler_error_fallback,
-			macos_v3_compiler_error_message, macos_v3_compiler_error_input_source(source))
+			compiler_error, macos_v3_compiler_error_input_source(source))
 		assert v_file == 'prog.v'
 		assert v_source != ''
+		assert compiler_error.contains('during source parsing')
 		// A bounded strict subset — never the whole file.
 		assert v_source.len < whole.len
 		// A directory build, a non-V file, or a missing input yields no source, so the
@@ -1501,10 +1503,16 @@ fn test_macos_v3_compiler_error_content_extraction() {
 		for empty in [root, note, os.join_path(root, 'missing.v'), ''] {
 			resolved := macos_v3_compiler_error_input_source(empty)
 			ef, es := builder.bounded_v3_fallback_source(macos_v3_compiler_error_fallback,
-				macos_v3_compiler_error_message, resolved)
+				compiler_error, resolved)
 			assert ef == '', empty
 			assert es == '', empty
 		}
+		legacy_reason, legacy_stage := macos_v3_fallback_reason_and_stage('compiler_error')
+		assert legacy_reason == macos_v3_compiler_error_fallback
+		assert legacy_stage == ''
+		reason, stage := macos_v3_fallback_reason_and_stage('compiler_error\nsemantic checking')
+		assert reason == macos_v3_compiler_error_fallback
+		assert stage == 'semantic checking'
 	}
 }
 
@@ -1741,15 +1749,15 @@ fn test_take_macos_v3_report_content_carries_no_path() {
 		}
 		os.unsetenv(macos_v3_c_error_dir_env)
 		// A forwarded content report round-trips as content only.
-		export_macos_v3_report_content(macos_v3_compiler_error_fallback, 'v3',
-			macos_v3_compiler_error_message, '')
+		compiler_error := macos_v3_compiler_error_message('type specialization')
+		export_macos_v3_report_content(macos_v3_compiler_error_fallback, 'v3', compiler_error, '')
 		report := take_macos_v3_report_content() or {
 			assert false, 'the forwarded content report must be returned'
 			return
 		}
 		assert report.kind == macos_v3_compiler_error_fallback
 		assert report.ccompiler == 'v3'
-		assert report.c_output == macos_v3_compiler_error_message
+		assert report.c_output == compiler_error
 		// The variables are cleared, so a second take finds nothing.
 		if _ := take_macos_v3_report_content() {
 			assert false, 'the content variables must be cleared after a take'

vlib/v3/driver/driver.v

@@ -5967,9 +5967,12 @@ fn record_user_define(mut defines []string, mut values map[string]string, define
 	values[name] = value
 }
 
-fn stage_macos_v3_compiler_error_fallback(fallback_file string) {
+fn stage_macos_v3_compiler_error_fallback(fallback_file string, stage string) {
 	if fallback_file != '' {
-		os.write_file(fallback_file, macos_v3_compiler_error_fallback) or {}
+		// The first line remains the machine-readable fallback reason. The second
+		// carries only a controlled stage name, so a successful compatibility build
+		// can report where V3 failed even when no source excerpt is available.
+		os.write_file(fallback_file, '${macos_v3_compiler_error_fallback}\n${stage}') or {}
 	}
 }
 
@@ -6430,7 +6433,7 @@ pub fn run(args []string) {
 	// produced its output. Specialized failures overwrite it below. Successful
 	// run/test programs clear it before launch, so their exit status is never
 	// mistaken for a compiler failure by the macOS driver.
-	stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file)
+	stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file, 'command-line processing')
 
 	mut input_file := ''
 	mut output_file := ''
@@ -7334,6 +7337,7 @@ pub fn run(args []string) {
 	// Cache markers and scoped output are stable across ordered worker chunks, so cached
 	// and preallocated builds use the same parallel function-body generator.
 	mut cache_no_parallel_cgen := current_no_parallel
+	stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file, 'source parsing')
 	mut p := parser.Parser.new(prefs)
 	if building_v || cmd_v_build {
 		p.reserve_selfhost_ast()
@@ -7876,6 +7880,7 @@ pub fn run(args []string) {
 	// Type-collect + check BEFORE transform, so the transformer is type-aware
 	// (like v2: check runs before transform). The transformer reads cached
 	// per-expression types for type-dependent lowering.
+	stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file, 'semantic checking')
 	mut pre_tc := types.TypeChecker.new(a)
 	mut checker_notice_count := 0
 	mut checker_warning_count := 0
@@ -8258,6 +8263,7 @@ pub fn run(args []string) {
 		// Transform (match lowering, string/in lowering, etc.). Threaded transform is enabled
 		// by default for compatible builds, and `-no-parallel` disables both threaded transform
 		// and cgen.
+		stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file, 'AST transformation')
 		mut transform_was_parallel := false
 		mut transform_errors := []string{}
 		mut incremental_synthesized_helpers := []string{}
@@ -8671,6 +8677,7 @@ pub fn run(args []string) {
 	// Monomorphization only adds specialized generic instantiations to `used_fns`.
 	// Markused and Cgen already exclude unreachable generic templates, so builds
 	// with no reachable generic use need no generic cleanup pass at all.
+	stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file, 'type specialization')
 	if cgen_cache_hit {
 		// The cached C plan and metadata are the only consumers of the specialized
 		// AST and checker state on this path.
@@ -8828,6 +8835,7 @@ pub fn run(args []string) {
 	} else {
 		b.step('finalize')
 	}
+	stage_macos_v3_compiler_error_fallback(macos_v3_fallback_file, 'backend code generation')
 	if backend == 'wasm' {
 		if msg := unsupported_backend_error(a, &pre_tc, used_fns, backend) {
 			eprintln(msg)

vlib/v3/tests/driver_cli_test.v

@@ -1003,7 +1003,9 @@ fn main() {
 	result := run_driver_with_environment(v3_bin, ['-silent', '-no-parallel', '-nocache',
 		'-no-memory-limit', source], environment)
 	assert result.exit_code != 0
-	assert os.read_file(fallback_file)! == 'compiler_error'
+	fallback_payload := os.read_file(fallback_file)!
+	assert fallback_payload.starts_with('compiler_error\n')
+	assert fallback_payload.all_after_first('\n').trim_space() != ''
 
 	compat_output := os.join_path(root, 'compat')
 	compat := cmdexec.run(@VEXE, ['-old-compiler', '-o', compat_output, source])