ci: fix remaining master failures

Author: medvednikov

.github/workflows/tccbin_source_recovery.yml

@@ -38,7 +38,7 @@ jobs:
         env:
           EVENT_NAME: ${{ github.event_name }}
           HANDOFF_ID: ${{ inputs.resume_handoff_id || '' }}
-          UPSTREAM_NAME: ${{ github.event.workflow_run.name || '' }}
+          UPSTREAM_PATH: ${{ github.event.workflow_run.path || '' }}
         run: |
           set -euo pipefail
           case "$EVENT_NAME" in
@@ -55,8 +55,8 @@ jobs:
               echo 'handoff_id=' >> "$GITHUB_OUTPUT"
               ;;
             workflow_run)
-              case "$UPSTREAM_NAME" in
-                'Update tccbin'|'TCC bundle revalidation') ;;
+              case "$UPSTREAM_PATH" in
+                '.github/workflows/update_tccbin.yml'|'.github/workflows/tccbin_revalidate.yml') ;;
                 *) exit 1 ;;
               esac
               echo 'mode=workflow_run' >> "$GITHUB_OUTPUT"

vlib/net/jsonrpc/jsonrpc.v

@@ -56,15 +56,42 @@ pub fn error_with_code(message string, code int) ResponseError {
 
 // JSON-RPC standard-ish errors :contentReference[oaicite:3]{index=3}
 
-pub const parse_error = error_with_code('Invalid JSON.', -32700)
-pub const invalid_request = error_with_code('Invalid request.', -32600)
-pub const method_not_found = error_with_code('Method not found.', -32601)
-pub const invalid_params = error_with_code('Invalid params', -32602)
-pub const internal_error = error_with_code('Internal error.', -32693)
-pub const server_error_start = error_with_code('Error occurred when starting server.', -32099)
-pub const server_not_initialized = error_with_code('Server not initialized.', -32002)
-pub const unknown_error = error_with_code('Unknown error.', -32001)
-pub const server_error_end = error_with_code('Error occurred when stopping the server.', -32000)
+pub const parse_error = ResponseError{
+	code:    -32700
+	message: 'Invalid JSON.'
+}
+pub const invalid_request = ResponseError{
+	code:    -32600
+	message: 'Invalid request.'
+}
+pub const method_not_found = ResponseError{
+	code:    -32601
+	message: 'Method not found.'
+}
+pub const invalid_params = ResponseError{
+	code:    -32602
+	message: 'Invalid params'
+}
+pub const internal_error = ResponseError{
+	code:    -32693
+	message: 'Internal error.'
+}
+pub const server_error_start = ResponseError{
+	code:    -32099
+	message: 'Error occurred when starting server.'
+}
+pub const server_not_initialized = ResponseError{
+	code:    -32002
+	message: 'Server not initialized.'
+}
+pub const unknown_error = ResponseError{
+	code:    -32001
+	message: 'Unknown error.'
+}
+pub const server_error_end = ResponseError{
+	code:    -32000
+	message: 'Error occurred when stopping the server.'
+}
 pub const error_codes = [
 	parse_error.code(),
 	invalid_request.code(),

vlib/v3/driver/driver.v

@@ -2497,10 +2497,47 @@ fn register_native_source_typedefs(mut tc types.TypeChecker, state &V3ModuleCach
 				if c_name !in tc.structs {
 					tc.structs[c_name] = []types.StructField{}
 				}
-				tc.c_typedef_structs[c_name] = true
+				if !c_typedef_is_function_pointer(source, name) {
+					tc.c_typedef_structs[c_name] = true
+				}
+			}
+		}
+	}
+}
+
+fn register_headerless_c_types(mut tc types.TypeChecker) {
+	// The C backend always supplies this platform-specific declaration in its
+	// headerless preamble, even when the program does not import `os`.
+	if 'C.stat' !in tc.structs {
+		tc.structs['C.stat'] = []types.StructField{}
+	}
+}
+
+fn c_typedef_is_function_pointer(source string, name string) bool {
+	mut offset := 0
+	for offset < source.len {
+		relative := source[offset..].index(name) or { return false }
+		start := offset + relative
+		end := start + name.len
+		if (start == 0 || (!source[start - 1].is_alnum() && source[start - 1] != `_`))
+			&& (end == source.len || (!source[end].is_alnum() && source[end] != `_`)) {
+			mut i := start - 1
+			for i >= 0 && source[i].is_space() {
+				i--
+			}
+			if i >= 0 && source[i] == `*` {
+				i--
+				for i >= 0 && source[i].is_space() {
+					i--
+				}
+				if i >= 0 && source[i] == `(` {
+					return true
+				}
 			}
 		}
+		offset = end
 	}
+	return false
 }
 
 fn cache_c_compiler_predefined_macros(flags []string, ccompiler string, target pref.Target, native_inputs_language string) (map[string]string, bool) {
@@ -4858,7 +4895,7 @@ fn incremental_changed_functions(snapshot V3IncrementalSnapshot, old map[string]
 	return keys, names
 }
 
-fn incremental_changed_functions_require_reachability_rebuild(a &flat.FlatAst, tc &types.TypeChecker, changed_names map[string]bool, cached map[string]bool, user_files []string) bool {
+fn incremental_changed_functions_require_reachability_rebuild(a &flat.FlatAst, tc &types.TypeChecker, mut changed_names map[string]bool, mut used map[string]bool, user_files []string) bool {
 	if changed_names.len == 0 {
 		return false
 	}
@@ -4891,7 +4928,17 @@ fn incremental_changed_functions_require_reachability_rebuild(a &flat.FlatAst, t
 				if !aliases.any(current[it]) {
 					continue
 				}
-				if !aliases.any(cached[it]) {
+				if !aliases.any(used[it]) {
+					// A newly reached stringifier can be added to the incremental body without
+					// invalidating unchanged functions or the cached support prefix.
+					if name.ends_with('.str') {
+						changed_names[node.value] = true
+						changed_names[name] = true
+						for alias in aliases {
+							used[alias] = true
+						}
+						continue
+					}
 					return true
 				}
 			}
@@ -7967,6 +8014,7 @@ pub fn run(args []string) {
 		}
 		mut cvsw := time.new_stopwatch()
 		pre_tc.collect(a)
+		register_headerless_c_types(mut pre_tc)
 		register_native_source_typedefs(mut pre_tc, &cache_state)
 		if translated_mode {
 			for file in user_files {
@@ -8204,7 +8252,7 @@ pub fn run(args []string) {
 			used_fns = clone_string_bool_map(cached_program_used_fns)
 			uses_generics = true
 			if incremental_cache_hit
-				&& incremental_changed_functions_require_reachability_rebuild(a, markused_tc, incremental_changed_names, cached_program_used_fns, user_files) {
+				&& incremental_changed_functions_require_reachability_rebuild(a, markused_tc, mut incremental_changed_names, mut used_fns, user_files) {
 				os.setenv('V3_CACHE_DISABLE_INCREMENTAL', '1', true)
 				restart_v3_after_cache_invalidation()
 			}
@@ -8757,8 +8805,8 @@ pub fn run(args []string) {
 			base_specialized_fns := a.specialized_fn_nodes.len
 			monomorph_scope := prealloc_scope_begin_for_v3()
 			monomorph_used_fns, monomorph_errors, generated_monomorph_specs = transform.monomorphize_with_used_checked_config_scoped_cached(mut a,
-				&pre_tc, monomorph_input_used, should_parallel_monomorphize(), monomorph_scope,
-				cached_monomorph_specs)
+				&pre_tc, monomorph_input_used, !current_no_parallel
+				&& should_parallel_monomorphize(), monomorph_scope, cached_monomorph_specs)
 			parse_cache_enabled := pre_tc.type_cache_parse_enabled()
 			prealloc_scope_leave_for_v3(monomorph_scope)
 			// Specialization can rewrite payload text on pre-existing nodes as
@@ -8798,8 +8846,9 @@ pub fn run(args []string) {
 			prealloc_scope_free_for_v3(monomorph_scope)
 		} else {
 			monomorph_used_fns, monomorph_errors, generated_monomorph_specs = transform.monomorphize_with_used_checked_config_scoped_cached(mut a,
-				&pre_tc, monomorph_input_used, should_parallel_monomorphize()
-				&& !incremental_cache_hit, unsafe { nil }, cached_monomorph_specs)
+				&pre_tc, monomorph_input_used, !current_no_parallel
+				&& should_parallel_monomorphize() && !incremental_cache_hit, unsafe { nil },
+				cached_monomorph_specs)
 		}
 		// Monomorphization publishes every synthesized or rewritten AST string
 		// after its final worker merge, including the serial/no-worker path.
@@ -11630,7 +11679,9 @@ fn vmod_subdirs(dir string) ![]string {
 	if os.read_file(vmod_path)!.trim_space().len == 0 {
 		return []string{}
 	}
-	manifest := vmod.from_file(vmod_path)!
+	// An invalid v.mod does not make the source directory invalid. This matches
+	// the legacy builder, while still honoring `subdirs` in valid manifests.
+	manifest := vmod.from_file(vmod_path) or { return []string{} }
 	return manifest.unknown['subdirs'] or { []string{} }
 }
 
@@ -11747,8 +11798,7 @@ fn same_dir_module_source_files(test_file string, module_name string, prefs &pre
 	if module_name.len > 0 {
 		for file in all_files {
 			declared_module := declared_module_in_file(file)
-			if declared_module != module_name && !(declared_module in ['', 'main']
-				&& module_name in ['', 'main']) {
+			if declared_module != module_name {
 				continue
 			}
 			files << file

vlib/v3/gen/c/cleanc.v

@@ -1371,13 +1371,13 @@ pub fn cache_external_input_files_with_resolved_flags(a &flat.FlatAst, vroot str
 	mut cur_file_is_program := false
 	mut context_directives := map[string][]string{}
 	mut conditional_context_mutations := map[string]bool{}
-	mut conditional_depth := 0
+	mut conditionals := []CCacheConditional{}
 	for node in a.nodes {
 		if node.kind == .file {
 			cur_file = node.value
 			cur_file_is_program = program_files[cur_file] || program_files[os.real_path(cur_file)]
 			cur_module = ''
-			conditional_depth = 0
+			conditionals.clear()
 			continue
 		}
 		if node.kind == .module_decl {
@@ -1396,20 +1396,46 @@ pub fn cache_external_input_files_with_resolved_flags(a &flat.FlatAst, vroot str
 		}
 		if node.kind == .directive {
 			if node.value in ['if', 'ifdef', 'ifndef'] {
-				conditional_depth++
-			} else if node.value == 'endif' && conditional_depth > 0 {
-				conditional_depth--
+				parent_inactive := conditionals.any(it.inactive)
+				parent_ambiguous := conditionals.any(it.ambiguous)
+				condition := c_cache_known_condition(c_preprocessor_directive_line(node.value,
+					node.typ), include_macros, dynamic_include_macros,
+					compiler_macro_environment_complete)
+				conditionals << CCacheConditional{
+					parent_inactive: parent_inactive
+					condition:       condition
+					inactive:        parent_inactive || condition < 0
+					ambiguous:       parent_ambiguous || condition == 0
+				}
+			} else if node.value in ['else', 'elif'] && conditionals.len > 0 {
+				conditional_idx := conditionals.len - 1
+				mut conditional := conditionals[conditional_idx]
+				if node.value == 'else' {
+					conditional.inactive = conditional.parent_inactive || conditional.condition > 0
+				} else if conditional.condition > 0 {
+					conditional.inactive = true
+				} else {
+					next_condition := c_cache_known_condition(c_preprocessor_directive_line(node.value,
+						node.typ), include_macros, dynamic_include_macros,
+						compiler_macro_environment_complete)
+					conditional.condition = next_condition
+					conditional.ambiguous = conditional.ambiguous || next_condition == 0
+					conditional.inactive = conditional.parent_inactive || next_condition < 0
+				}
+				conditionals[conditional_idx] = conditional
+			} else if node.value == 'endif' && conditionals.len > 0 {
+				conditionals.delete_last()
 			}
 		}
 		if node.kind == .directive && node.value in ['define', 'undef'] {
 			directive := c_preprocessor_directive_line(node.value, node.typ)
-			is_conditional := conditional_depth > 0
-			c_record_include_macro_definition(directive, is_conditional, mut include_macros, mut
+			is_ambiguous := conditionals.any(it.inactive || it.ambiguous)
+			c_record_include_macro_definition(directive, is_ambiguous, mut include_macros, mut
 				dynamic_include_macros)
 			mut module_context := context_directives[owner_module]
 			module_context << directive
 			context_directives[owner_module] = module_context
-			if is_conditional {
+			if is_ambiguous {
 				conditional_context_mutations[owner_module] = true
 			}
 			continue
@@ -1430,7 +1456,7 @@ pub fn cache_external_input_files_with_resolved_flags(a &flat.FlatAst, vroot str
 				has_untracked_include = true
 				continue
 			}
-			context_is_replayable := conditional_depth == 0
+			context_is_replayable := !conditionals.any(it.inactive || it.ambiguous)
 				&& !conditional_context_mutations[owner_module]
 			for path in c_include_file_paths(include_arg, vroot, cur_file, include_dirs) {
 				c_record_cache_resolution_path(path, mut resolution_dirs, mut

vlib/v3/gen/c/fn.v

@@ -772,14 +772,17 @@ fn (mut g FlatGen) should_emit_fn_node_in_module_known(node flat.Node, module_na
 	if g.should_emit_ierror_method(node.value, qfn) {
 		return true
 	}
-	// Every specialization materialized from the combined program/module-cache
-	// graph is a concrete body needed by either main or one of the cached objects.
-	if is_program_specialization {
-		return true
-	}
 	if g.fn_node_is_open_generic_template(node, module_name) {
 		return false
 	}
+	// Every concrete specialization materialized from the combined
+	// program/module-cache graph is needed by either main or a cached object.
+	// Check for an open template first: cache-wide reachability can retain a raw
+	// generic receiver declaration in `specialized_generic_fns`, but it still has
+	// no valid C ABI until monomorphization replaces its type parameters.
+	if is_program_specialization {
+		return true
+	}
 	if g.has_used_fn_filter() {
 		if g.used_fn_contains_in_module(node.value, module_name) {
 			return true
@@ -799,10 +802,23 @@ fn (g &FlatGen) fn_node_is_open_generic_template(node flat.Node, module_name str
 		return false
 	}
 	receiver := node.value.all_before_last('.')
-	base, args, ok := g.shared_generic_app_parts(receiver)
+	// This declaration gate must inspect the source spelling authoritatively. The
+	// shared expression cache can already contain a negative result for the same
+	// string from a different resolution context during cache-wide generation.
+	base, args, ok := parse_shared_generic_app_parts(receiver)
 	if !ok || args.len == 0 {
 		return false
 	}
+	// Receiver declarations encode their own generic parameters in the receiver
+	// text. During cache-wide self-host generation the declaration can outlive
+	// the short-name generic-struct index, so recognize the canonical V generic
+	// parameter spelling directly as well.
+	for arg in args {
+		clean := arg.trim_space()
+		if clean.len == 1 && clean[0] >= `A` && clean[0] <= `Z` {
+			return true
+		}
+	}
 	mut candidates := [base]
 	if !base.contains('.') && module_name.len > 0 && module_name !in ['main', 'builtin'] {
 		candidates << '${module_name}.${base}'
@@ -10188,6 +10204,10 @@ fn (g &FlatGen) call_key(id flat.NodeId, name string) string {
 		}
 	}
 	if resolved := g.tc.resolved_call_name(id) {
+		if resolved == name && !name.contains('.')
+			&& (name in g.tc.fn_param_types || name in g.tc.fn_ret_types) {
+			return name
+		}
 		if resolved_call_matches_target(resolved, name) {
 			return g.normalize_call_key(resolved)
 		}
@@ -10239,10 +10259,13 @@ fn (g &FlatGen) normalize_call_key_uncached(name string) string {
 			return local
 		}
 	}
+	if !name.contains('.') && g.non_generic_fn_decl_exists_in_module(name, g.tc.cur_module)
+		&& (name in g.tc.fn_param_types || name in g.tc.fn_ret_types) {
+		return name
+	}
 	// A selected import belongs to the current source file and must win over a
-	// same-spelled short signature retained from an imported module. The checker
-	// can omit per-node resolution data when the program unit is emitted from the
-	// module cache, so recover the file-local declaration before accepting `name`.
+	// same-spelled short signature retained from another imported module. A real
+	// declaration in the current module still has normal lexical priority.
 	if imported := g.selective_import_call_key_in_file(name, g.tc.cur_file) {
 		return imported
 	}

vlib/v3/gen/c/parallel_worker_test.v

@@ -278,6 +278,19 @@ fn test_parallel_generic_app_cache_uses_frozen_base_and_private_overlays() {
 	assert 'Shared[string]' !in frozen.entries
 }
 
+fn test_open_generic_receiver_template_bypasses_stale_generic_app_cache() {
+	mut g, _ := parallel_worker_test_gen(true)
+	mut cache := g.generic_app_cache
+	cache.entries['AtomicVal[T]'] = GenericAppInfo{}
+	node := flat.Node{
+		kind:  .fn_decl
+		value: 'AtomicVal[T].load'
+	}
+	assert g.fn_node_is_open_generic_template(node, 'stdatomic')
+	assert !g.should_emit_fn_node_in_module_known(node, 'stdatomic', 'atomic.v',
+		'stdatomic__AtomicVal_T__load', true)
+}
+
 fn test_parallel_type_declarations_include_body_discovered_fn_ptr_types() {
 	mut g, _ := parallel_worker_test_gen(true)
 	g.parallel_type_decls = '/* precomputed type declarations */\n'.clone()