Commit 1d20ff11d7efc1f07de9a300abc15ad6ae9d6d6f | zig

build.zig+5-6

...	@@ -595,7 +595,7 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {	...	@@ -595,7 +595,7 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
595	run_opt.addArg("-o");	595	run_opt.addArg("-o");
596	run_opt.addFileArg(b.path("stage1/zig1.wasm"));	596	run_opt.addFileArg(b.path("stage1/zig1.wasm"));
597		597
598	const copy_zig_h = b.addWriteFiles();	598	const copy_zig_h = b.addUpdateSourceFiles();
599	copy_zig_h.addCopyFileToSource(b.path("lib/zig.h"), "stage1/zig.h");	599	copy_zig_h.addCopyFileToSource(b.path("lib/zig.h"), "stage1/zig.h");
600		600
601	const update_zig1_step = b.step("update-zig1", "Update stage1/zig1.wasm");	601	const update_zig1_step = b.step("update-zig1", "Update stage1/zig1.wasm");
...	@@ -1261,7 +1261,9 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {	...	@@ -1261,7 +1261,9 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
1261	});	1261	});
1262		1262
1263	var dir = b.build_root.handle.openDir("doc/langref", .{ .iterate = true }) catch \|err\| {	1263	var dir = b.build_root.handle.openDir("doc/langref", .{ .iterate = true }) catch \|err\| {
1264	std.debug.panic("unable to open 'doc/langref' directory: {s}", .{@errorName(err)});	1264	std.debug.panic("unable to open '{}doc/langref' directory: {s}", .{
		1265	b.build_root, @errorName(err),
		1266	});
1265	};	1267	};
1266	defer dir.close();	1268	defer dir.close();
1267		1269
...	@@ -1280,10 +1282,7 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {	...	@@ -1280,10 +1282,7 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
1280	// in a temporary directory	1282	// in a temporary directory
1281	"--cache-root", b.cache_root.path orelse ".",	1283	"--cache-root", b.cache_root.path orelse ".",
1282	});	1284	});
1283	if (b.zig_lib_dir) \|p\| {	1285	cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{}", .{b.graph.zig_lib_directory}) });
1284	cmd.addArg("--zig-lib-dir");
1285	cmd.addDirectoryArg(p);
1286	}
1287	cmd.addArgs(&.{"-i"});	1286	cmd.addArgs(&.{"-i"});
1288	cmd.addFileArg(b.path(b.fmt("doc/langref/{s}", .{entry.name})));	1287	cmd.addFileArg(b.path(b.fmt("doc/langref/{s}", .{entry.name})));
1289		1288

lib/compiler/build_runner.zig+177-85

...	@@ -8,6 +8,9 @@ const process = std.process;	...	@@ -8,6 +8,9 @@ const process = std.process;
8	const ArrayList = std.ArrayList;	8	const ArrayList = std.ArrayList;
9	const File = std.fs.File;	9	const File = std.fs.File;
10	const Step = std.Build.Step;	10	const Step = std.Build.Step;
		11	const Watch = std.Build.Watch;
		12	const Allocator = std.mem.Allocator;
		13	const fatal = std.zig.fatal;
11		14
12	pub const root = @import("@build");	15	pub const root = @import("@build");
13	pub const dependencies = @import("@dependencies");	16	pub const dependencies = @import("@dependencies");
...	@@ -29,21 +32,15 @@ pub fn main() !void {	...	@@ -29,21 +32,15 @@ pub fn main() !void {
29	// skip my own exe name	32	// skip my own exe name
30	var arg_idx: usize = 1;	33	var arg_idx: usize = 1;
31		34
32	const zig_exe = nextArg(args, &arg_idx) orelse {	35	const zig_exe = nextArg(args, &arg_idx) orelse fatal("missing zig compiler path", .{});
33	std.debug.print("Expected path to zig compiler\n", .{});	36	const zig_lib_dir = nextArg(args, &arg_idx) orelse fatal("missing zig lib directory path", .{});
34	return error.InvalidArgs;	37	const build_root = nextArg(args, &arg_idx) orelse fatal("missing build root directory path", .{});
35	};	38	const cache_root = nextArg(args, &arg_idx) orelse fatal("missing cache root directory path", .{});
36	const build_root = nextArg(args, &arg_idx) orelse {	39	const global_cache_root = nextArg(args, &arg_idx) orelse fatal("missing global cache root directory path", .{});
37	std.debug.print("Expected build root directory path\n", .{});	40
38	return error.InvalidArgs;	41	const zig_lib_directory: std.Build.Cache.Directory = .{
39	};	42	.path = zig_lib_dir,
40	const cache_root = nextArg(args, &arg_idx) orelse {	43	.handle = try std.fs.cwd().openDir(zig_lib_dir, .{}),
41	std.debug.print("Expected cache root directory path\n", .{});
42	return error.InvalidArgs;
43	};
44	const global_cache_root = nextArg(args, &arg_idx) orelse {
45	std.debug.print("Expected global cache root directory path\n", .{});
46	return error.InvalidArgs;
47	};	44	};
48		45
49	const build_root_directory: std.Build.Cache.Directory = .{	46	const build_root_directory: std.Build.Cache.Directory = .{
...	@@ -70,6 +67,7 @@ pub fn main() !void {	...	@@ -70,6 +67,7 @@ pub fn main() !void {
70	.zig_exe = zig_exe,	67	.zig_exe = zig_exe,
71	.env_map = try process.getEnvMap(arena),	68	.env_map = try process.getEnvMap(arena),
72	.global_cache_root = global_cache_directory,	69	.global_cache_root = global_cache_directory,
		70	.zig_lib_directory = zig_lib_directory,
73	.host = .{	71	.host = .{
74	.query = .{},	72	.query = .{},
75	.result = try std.zig.system.resolveTargetQuery(.{}),	73	.result = try std.zig.system.resolveTargetQuery(.{}),
...	@@ -97,13 +95,15 @@ pub fn main() !void {	...	@@ -97,13 +95,15 @@ pub fn main() !void {
97	var dir_list = std.Build.DirList{};	95	var dir_list = std.Build.DirList{};
98	var summary: ?Summary = null;	96	var summary: ?Summary = null;
99	var max_rss: u64 = 0;	97	var max_rss: u64 = 0;
100	var skip_oom_steps: bool = false;	98	var skip_oom_steps = false;
101	var color: Color = .auto;	99	var color: Color = .auto;
102	var seed: u32 = 0;	100	var seed: u32 = 0;
103	var prominent_compile_errors: bool = false;	101	var prominent_compile_errors = false;
104	var help_menu: bool = false;	102	var help_menu = false;
105	var steps_menu: bool = false;	103	var steps_menu = false;
106	var output_tmp_nonce: ?[16]u8 = null;	104	var output_tmp_nonce: ?[16]u8 = null;
		105	var watch = false;
		106	var debounce_interval_ms: u16 = 50;
107		107
108	while (nextArg(args, &arg_idx)) \|arg\| {	108	while (nextArg(args, &arg_idx)) \|arg\| {
109	if (mem.startsWith(u8, arg, "-Z")) {	109	if (mem.startsWith(u8, arg, "-Z")) {
...	@@ -185,13 +185,19 @@ pub fn main() !void {	...	@@ -185,13 +185,19 @@ pub fn main() !void {
185	arg, next_arg,	185	arg, next_arg,
186	});	186	});
187	};	187	};
188	} else if (mem.eql(u8, arg, "--zig-lib-dir")) {
189	builder.zig_lib_dir = .{ .cwd_relative = nextArgOrFatal(args, &arg_idx) };
190	} else if (mem.eql(u8, arg, "--seed")) {	188	} else if (mem.eql(u8, arg, "--seed")) {
191	const next_arg = nextArg(args, &arg_idx) orelse	189	const next_arg = nextArg(args, &arg_idx) orelse
192	fatalWithHint("expected u32 after '{s}'", .{arg});	190	fatalWithHint("expected u32 after '{s}'", .{arg});
193	seed = std.fmt.parseUnsigned(u32, next_arg, 0) catch \|err\| {	191	seed = std.fmt.parseUnsigned(u32, next_arg, 0) catch \|err\| {
194	fatal("unable to parse seed '{s}' as 32-bit integer: {s}\n", .{	192	fatal("unable to parse seed '{s}' as unsigned 32-bit integer: {s}\n", .{
		193	next_arg, @errorName(err),
		194	});
		195	};
		196	} else if (mem.eql(u8, arg, "--debounce")) {
		197	const next_arg = nextArg(args, &arg_idx) orelse
		198	fatalWithHint("expected u16 after '{s}'", .{arg});
		199	debounce_interval_ms = std.fmt.parseUnsigned(u16, next_arg, 0) catch \|err\| {
		200	fatal("unable to parse debounce interval '{s}' as unsigned 16-bit integer: {s}\n", .{
195	next_arg, @errorName(err),	201	next_arg, @errorName(err),
196	});	202	});
197	};	203	};
...	@@ -227,6 +233,8 @@ pub fn main() !void {	...	@@ -227,6 +233,8 @@ pub fn main() !void {
227	builder.verbose_llvm_cpu_features = true;	233	builder.verbose_llvm_cpu_features = true;
228	} else if (mem.eql(u8, arg, "--prominent-compile-errors")) {	234	} else if (mem.eql(u8, arg, "--prominent-compile-errors")) {
229	prominent_compile_errors = true;	235	prominent_compile_errors = true;
		236	} else if (mem.eql(u8, arg, "--watch")) {
		237	watch = true;
230	} else if (mem.eql(u8, arg, "-fwine")) {	238	} else if (mem.eql(u8, arg, "-fwine")) {
231	builder.enable_wine = true;	239	builder.enable_wine = true;
232	} else if (mem.eql(u8, arg, "-fno-wine")) {	240	} else if (mem.eql(u8, arg, "-fno-wine")) {
...	@@ -292,6 +300,7 @@ pub fn main() !void {	...	@@ -292,6 +300,7 @@ pub fn main() !void {
292	const main_progress_node = std.Progress.start(.{	300	const main_progress_node = std.Progress.start(.{
293	.disable_printing = (color == .off),	301	.disable_printing = (color == .off),
294	});	302	});
		303	defer main_progress_node.end();
295		304
296	builder.debug_log_scopes = debug_log_scopes.items;	305	builder.debug_log_scopes = debug_log_scopes.items;
297	builder.resolveInstallPrefix(install_prefix, dir_list);	306	builder.resolveInstallPrefix(install_prefix, dir_list);
...	@@ -340,13 +349,16 @@ pub fn main() !void {	...	@@ -340,13 +349,16 @@ pub fn main() !void {
340	.max_rss_is_default = false,	349	.max_rss_is_default = false,
341	.max_rss_mutex = .{},	350	.max_rss_mutex = .{},
342	.skip_oom_steps = skip_oom_steps,	351	.skip_oom_steps = skip_oom_steps,
		352	.watch = watch,
343	.memory_blocked_steps = std.ArrayList(*Step).init(arena),	353	.memory_blocked_steps = std.ArrayList(*Step).init(arena),
		354	.step_stack = .{},
344	.prominent_compile_errors = prominent_compile_errors,	355	.prominent_compile_errors = prominent_compile_errors,
345		356
346	.claimed_rss = 0,	357	.claimed_rss = 0,
347	.summary = summary,	358	.summary = summary orelse if (watch) .new else .failures,
348	.ttyconf = ttyconf,	359	.ttyconf = ttyconf,
349	.stderr = stderr,	360	.stderr = stderr,
		361	.thread_pool = undefined,
350	};	362	};
351		363
352	if (run.max_rss == 0) {	364	if (run.max_rss == 0) {
...	@@ -354,18 +366,78 @@ pub fn main() !void {	...	@@ -354,18 +366,78 @@ pub fn main() !void {
354	run.max_rss_is_default = true;	366	run.max_rss_is_default = true;
355	}	367	}
356		368
357	runStepNames(	369	const gpa = arena;
358	arena,	370	prepare(gpa, arena, builder, targets.items, &run, seed) catch \|err\| switch (err) {
359	builder,
360	targets.items,
361	main_progress_node,
362	thread_pool_options,
363	&run,
364	seed,
365	) catch \|err\| switch (err) {
366	error.UncleanExit => process.exit(1),	371	error.UncleanExit => process.exit(1),
367	else => return err,	372	else => return err,
368	};	373	};
		374
		375	var w = if (watch) try Watch.init() else undefined;
		376
		377	try run.thread_pool.init(thread_pool_options);
		378	defer run.thread_pool.deinit();
		379
		380	rebuild: while (true) {
		381	runStepNames(
		382	gpa,
		383	builder,
		384	targets.items,
		385	main_progress_node,
		386	&run,
		387	) catch \|err\| switch (err) {
		388	error.UncleanExit => {
		389	assert(!run.watch);
		390	process.exit(1);
		391	},
		392	else => return err,
		393	};
		394	if (!watch) return cleanExit();
		395
		396	switch (builtin.os.tag) {
		397	.linux => {},
		398	else => fatal("--watch not yet implemented for {s}", .{@tagName(builtin.os.tag)}),
		399	}
		400
		401	try w.update(gpa, run.step_stack.keys());
		402
		403	// Wait until a file system notification arrives. Read all such events
		404	// until the buffer is empty. Then wait for a debounce interval, resetting
		405	// if any more events come in. After the debounce interval has passed,
		406	// trigger a rebuild on all steps with modified inputs, as well as their
		407	// recursive dependants.
		408	var caption_buf: [std.Progress.Node.max_name_len]u8 = undefined;
		409	const caption = std.fmt.bufPrint(&caption_buf, "Watching {d} Directories", .{
		410	w.dir_table.entries.len,
		411	}) catch &caption_buf;
		412	var debouncing_node = main_progress_node.start(caption, 0);
		413	var debounce_timeout: Watch.Timeout = .none;
		414	while (true) switch (try w.wait(gpa, debounce_timeout)) {
		415	.timeout => {
		416	debouncing_node.end();
		417	markFailedStepsDirty(gpa, run.step_stack.keys());
		418	continue :rebuild;
		419	},
		420	.dirty => if (debounce_timeout == .none) {
		421	debounce_timeout = .{ .ms = debounce_interval_ms };
		422	debouncing_node.end();
		423	debouncing_node = main_progress_node.start("Debouncing (Change Detected)", 0);
		424	},
		425	.clean => {},
		426	};
		427	}
		428	}
		429
		430	fn markFailedStepsDirty(gpa: Allocator, all_steps: []const *Step) void {
		431	for (all_steps) \|step\| switch (step.state) {
		432	.dependency_failure, .failure, .skipped => step.recursiveReset(gpa),
		433	else => continue,
		434	};
		435	// Now that all dirty steps have been found, the remaining steps that
		436	// succeeded from last run shall be marked "cached".
		437	for (all_steps) \|step\| switch (step.state) {
		438	.success => step.result_cached = true,
		439	else => continue,
		440	};
369	}	441	}
370		442
371	const Run = struct {	443	const Run = struct {
...	@@ -373,27 +445,27 @@ const Run = struct {	...	@@ -373,27 +445,27 @@ const Run = struct {
373	max_rss_is_default: bool,	445	max_rss_is_default: bool,
374	max_rss_mutex: std.Thread.Mutex,	446	max_rss_mutex: std.Thread.Mutex,
375	skip_oom_steps: bool,	447	skip_oom_steps: bool,
		448	watch: bool,
376	memory_blocked_steps: std.ArrayList(*Step),	449	memory_blocked_steps: std.ArrayList(*Step),
		450	step_stack: std.AutoArrayHashMapUnmanaged(*Step, void),
377	prominent_compile_errors: bool,	451	prominent_compile_errors: bool,
		452	thread_pool: std.Thread.Pool,
378		453
379	claimed_rss: usize,	454	claimed_rss: usize,
380	summary: ?Summary,	455	summary: Summary,
381	ttyconf: std.io.tty.Config,	456	ttyconf: std.io.tty.Config,
382	stderr: File,	457	stderr: File,
383	};	458	};
384		459
385	fn runStepNames(	460	fn prepare(
386	arena: std.mem.Allocator,	461	gpa: Allocator,
		462	arena: Allocator,
387	b: *std.Build,	463	b: *std.Build,
388	step_names: []const []const u8,	464	step_names: []const []const u8,
389	parent_prog_node: std.Progress.Node,
390	thread_pool_options: std.Thread.Pool.Options,
391	run: *Run,	465	run: *Run,
392	seed: u32,	466	seed: u32,
393	) !void {	467	) !void {
394	const gpa = b.allocator;	468	const step_stack = &run.step_stack;
395	var step_stack: std.AutoArrayHashMapUnmanaged(*Step, void) = .{};
396	defer step_stack.deinit(gpa);
397		469
398	if (step_names.len == 0) {	470	if (step_names.len == 0) {
399	try step_stack.put(gpa, b.default_step, {});	471	try step_stack.put(gpa, b.default_step, {});
...	@@ -416,8 +488,8 @@ fn runStepNames(	...	@@ -416,8 +488,8 @@ fn runStepNames(
416	rand.shuffle(*Step, starting_steps);	488	rand.shuffle(*Step, starting_steps);
417		489
418	for (starting_steps) \|s\| {	490	for (starting_steps) \|s\| {
419	constructGraphAndCheckForDependencyLoop(b, s, &step_stack, rand) catch \|err\| switch (err) {	491	constructGraphAndCheckForDependencyLoop(b, s, &run.step_stack, rand) catch \|err\| switch (err) {
420	error.DependencyLoopDetected => return error.UncleanExit,	492	error.DependencyLoopDetected => return uncleanExit(),
421	else => \|e\| return e,	493	else => \|e\| return e,
422	};	494	};
423	}	495	}
...	@@ -442,17 +514,22 @@ fn runStepNames(	...	@@ -442,17 +514,22 @@ fn runStepNames(
442	if (run.max_rss_is_default) {	514	if (run.max_rss_is_default) {
443	std.debug.print("note: use --maxrss to override the default", .{});	515	std.debug.print("note: use --maxrss to override the default", .{});
444	}	516	}
445	return error.UncleanExit;	517	return uncleanExit();
446	}	518	}
447	}	519	}
		520	}
448		521
449	var thread_pool: std.Thread.Pool = undefined;	522	fn runStepNames(
450	try thread_pool.init(thread_pool_options);	523	gpa: Allocator,
451	defer thread_pool.deinit();	524	b: *std.Build,
		525	step_names: []const []const u8,
		526	parent_prog_node: std.Progress.Node,
		527	run: *Run,
		528	) !void {
		529	const step_stack = &run.step_stack;
		530	const thread_pool = &run.thread_pool;
452		531
453	{	532	{
454	defer parent_prog_node.end();
455
456	const step_prog = parent_prog_node.start("steps", step_stack.count());	533	const step_prog = parent_prog_node.start("steps", step_stack.count());
457	defer step_prog.end();	534	defer step_prog.end();
458		535
...	@@ -468,7 +545,7 @@ fn runStepNames(	...	@@ -468,7 +545,7 @@ fn runStepNames(
468	if (step.state == .skipped_oom) continue;	545	if (step.state == .skipped_oom) continue;
469		546
470	thread_pool.spawnWg(&wait_group, workerMakeOneStep, .{	547	thread_pool.spawnWg(&wait_group, workerMakeOneStep, .{
471	&wait_group, &thread_pool, b, step, step_prog, run,	548	&wait_group, b, step, step_prog, run,
472	});	549	});
473	}	550	}
474	}	551	}
...	@@ -485,8 +562,6 @@ fn runStepNames(	...	@@ -485,8 +562,6 @@ fn runStepNames(
485	var failure_count: usize = 0;	562	var failure_count: usize = 0;
486	var pending_count: usize = 0;	563	var pending_count: usize = 0;
487	var total_compile_errors: usize = 0;	564	var total_compile_errors: usize = 0;
488	var compile_error_steps: std.ArrayListUnmanaged(*Step) = .{};
489	defer compile_error_steps.deinit(gpa);
490		565
491	for (step_stack.keys()) \|s\| {	566	for (step_stack.keys()) \|s\| {
492	test_fail_count += s.test_results.fail_count;	567	test_fail_count += s.test_results.fail_count;
...	@@ -516,7 +591,6 @@ fn runStepNames(	...	@@ -516,7 +591,6 @@ fn runStepNames(
516	const compile_errors_len = s.result_error_bundle.errorMessageCount();	591	const compile_errors_len = s.result_error_bundle.errorMessageCount();
517	if (compile_errors_len > 0) {	592	if (compile_errors_len > 0) {
518	total_compile_errors += compile_errors_len;	593	total_compile_errors += compile_errors_len;
519	try compile_error_steps.append(gpa, s);
520	}	594	}
521	},	595	},
522	}	596	}
...	@@ -524,13 +598,22 @@ fn runStepNames(	...	@@ -524,13 +598,22 @@ fn runStepNames(
524		598
525	// A proper command line application defaults to silently succeeding.	599	// A proper command line application defaults to silently succeeding.
526	// The user may request verbose mode if they have a different preference.	600	// The user may request verbose mode if they have a different preference.
527	const failures_only = run.summary != .all and run.summary != .new;	601	const failures_only = switch (run.summary) {
528	if (failure_count == 0 and failures_only) return cleanExit();	602	.failures, .none => true,
		603	else => false,
		604	};
		605	if (failure_count == 0 and failures_only) {
		606	if (!run.watch) cleanExit();
		607	return;
		608	}
529		609
530	const ttyconf = run.ttyconf;	610	const ttyconf = run.ttyconf;
531	const stderr = run.stderr;
532		611
533	if (run.summary != Summary.none) {	612	if (run.summary != .none) {
		613	std.debug.lockStdErr();
		614	defer std.debug.unlockStdErr();
		615	const stderr = run.stderr;
		616
534	const total_count = success_count + failure_count + pending_count + skipped_count;	617	const total_count = success_count + failure_count + pending_count + skipped_count;
535	ttyconf.setColor(stderr, .cyan) catch {};	618	ttyconf.setColor(stderr, .cyan) catch {};
536	stderr.writeAll("Build Summary:") catch {};	619	stderr.writeAll("Build Summary:") catch {};
...	@@ -544,25 +627,23 @@ fn runStepNames(	...	@@ -544,25 +627,23 @@ fn runStepNames(
544	if (test_fail_count > 0) stderr.writer().print("; {d} failed", .{test_fail_count}) catch {};	627	if (test_fail_count > 0) stderr.writer().print("; {d} failed", .{test_fail_count}) catch {};
545	if (test_leak_count > 0) stderr.writer().print("; {d} leaked", .{test_leak_count}) catch {};	628	if (test_leak_count > 0) stderr.writer().print("; {d} leaked", .{test_leak_count}) catch {};
546		629
547	if (run.summary == null) {
548	ttyconf.setColor(stderr, .dim) catch {};
549	stderr.writeAll(" (disable with --summary none)") catch {};
550	ttyconf.setColor(stderr, .reset) catch {};
551	}
552	stderr.writeAll("\n") catch {};	630	stderr.writeAll("\n") catch {};
553		631
554	// Print a fancy tree with build results.	632	// Print a fancy tree with build results.
		633	var step_stack_copy = try step_stack.clone(gpa);
		634	defer step_stack_copy.deinit(gpa);
		635
555	var print_node: PrintNode = .{ .parent = null };	636	var print_node: PrintNode = .{ .parent = null };
556	if (step_names.len == 0) {	637	if (step_names.len == 0) {
557	print_node.last = true;	638	print_node.last = true;
558	printTreeStep(b, b.default_step, run, stderr, ttyconf, &print_node, &step_stack) catch {};	639	printTreeStep(b, b.default_step, run, stderr, ttyconf, &print_node, &step_stack_copy) catch {};
559	} else {	640	} else {
560	const last_index = if (run.summary == .all) b.top_level_steps.count() else blk: {	641	const last_index = if (run.summary == .all) b.top_level_steps.count() else blk: {
561	var i: usize = step_names.len;	642	var i: usize = step_names.len;
562	while (i > 0) {	643	while (i > 0) {
563	i -= 1;	644	i -= 1;
564	const step = b.top_level_steps.get(step_names[i]).?.step;	645	const step = b.top_level_steps.get(step_names[i]).?.step;
565	const found = switch (run.summary orelse .failures) {	646	const found = switch (run.summary) {
566	.all, .none => unreachable,	647	.all, .none => unreachable,
567	.failures => step.state != .success,	648	.failures => step.state != .success,
568	.new => !step.result_cached,	649	.new => !step.result_cached,
...	@@ -574,30 +655,34 @@ fn runStepNames(	...	@@ -574,30 +655,34 @@ fn runStepNames(
574	for (step_names, 0..) \|step_name, i\| {	655	for (step_names, 0..) \|step_name, i\| {
575	const tls = b.top_level_steps.get(step_name).?;	656	const tls = b.top_level_steps.get(step_name).?;
576	print_node.last = i + 1 == last_index;	657	print_node.last = i + 1 == last_index;
577	printTreeStep(b, &tls.step, run, stderr, ttyconf, &print_node, &step_stack) catch {};	658	printTreeStep(b, &tls.step, run, stderr, ttyconf, &print_node, &step_stack_copy) catch {};
578	}	659	}
579	}	660	}
580	}	661	}
581		662
582	if (failure_count == 0) return cleanExit();	663	if (failure_count == 0) {
		664	if (!run.watch) cleanExit();
		665	return;
		666	}
583		667
584	// Finally, render compile errors at the bottom of the terminal.	668	// Finally, render compile errors at the bottom of the terminal.
585	// We use a separate compile_error_steps array list because step_stack is destructively
586	// mutated in printTreeStep above.
587	if (run.prominent_compile_errors and total_compile_errors > 0) {	669	if (run.prominent_compile_errors and total_compile_errors > 0) {
588	for (compile_error_steps.items) \|s\| {	670	for (step_stack.keys()) \|s\| {
589	if (s.result_error_bundle.errorMessageCount() > 0) {	671	if (s.result_error_bundle.errorMessageCount() > 0) {
590	s.result_error_bundle.renderToStdErr(renderOptions(ttyconf));	672	s.result_error_bundle.renderToStdErr(renderOptions(ttyconf));
591	}	673	}
592	}	674	}
593		675
594	// Signal to parent process that we have printed compile errors. The	676	if (!run.watch) {
595	// parent process may choose to omit the "following command failed"	677	// Signal to parent process that we have printed compile errors. The
596	// line in this case.	678	// parent process may choose to omit the "following command failed"
597	process.exit(2);	679	// line in this case.
		680	std.debug.lockStdErr();
		681	process.exit(2);
		682	}
598	}	683	}
599		684
600	process.exit(1);	685	if (!run.watch) return uncleanExit();
601	}	686	}
602		687
603	const PrintNode = struct {	688	const PrintNode = struct {
...	@@ -768,7 +853,7 @@ fn printTreeStep(	...	@@ -768,7 +853,7 @@ fn printTreeStep(
768	step_stack: std.AutoArrayHashMapUnmanaged(Step, void),	853	step_stack: std.AutoArrayHashMapUnmanaged(Step, void),
769	) !void {	854	) !void {
770	const first = step_stack.swapRemove(s);	855	const first = step_stack.swapRemove(s);
771	const summary = run.summary orelse .failures;	856	const summary = run.summary;
772	const skip = switch (summary) {	857	const skip = switch (summary) {
773	.none => unreachable,	858	.none => unreachable,
774	.all => false,	859	.all => false,
...	@@ -889,12 +974,13 @@ fn constructGraphAndCheckForDependencyLoop(	...	@@ -889,12 +974,13 @@ fn constructGraphAndCheckForDependencyLoop(
889		974
890	fn workerMakeOneStep(	975	fn workerMakeOneStep(
891	wg: *std.Thread.WaitGroup,	976	wg: *std.Thread.WaitGroup,
892	thread_pool: *std.Thread.Pool,
893	b: *std.Build,	977	b: *std.Build,
894	s: *Step,	978	s: *Step,
895	prog_node: std.Progress.Node,	979	prog_node: std.Progress.Node,
896	run: *Run,	980	run: *Run,
897	) void {	981	) void {
		982	const thread_pool = &run.thread_pool;
		983
898	// First, check the conditions for running this step. If they are not met,	984	// First, check the conditions for running this step. If they are not met,
899	// then we return without doing the step, relying on another worker to	985	// then we return without doing the step, relying on another worker to
900	// queue this step up again when dependencies are met.	986	// queue this step up again when dependencies are met.
...	@@ -974,7 +1060,7 @@ fn workerMakeOneStep(	...	@@ -974,7 +1060,7 @@ fn workerMakeOneStep(
974	// Successful completion of a step, so we queue up its dependants as well.	1060	// Successful completion of a step, so we queue up its dependants as well.
975	for (s.dependants.items) \|dep\| {	1061	for (s.dependants.items) \|dep\| {
976	thread_pool.spawnWg(wg, workerMakeOneStep, .{	1062	thread_pool.spawnWg(wg, workerMakeOneStep, .{
977	wg, thread_pool, b, dep, prog_node, run,	1063	wg, b, dep, prog_node, run,
978	});	1064	});
979	}	1065	}
980	}	1066	}
...	@@ -999,7 +1085,7 @@ fn workerMakeOneStep(	...	@@ -999,7 +1085,7 @@ fn workerMakeOneStep(
999	remaining -= dep.max_rss;	1085	remaining -= dep.max_rss;
1000		1086
1001	thread_pool.spawnWg(wg, workerMakeOneStep, .{	1087	thread_pool.spawnWg(wg, workerMakeOneStep, .{
1002	wg, thread_pool, b, dep, prog_node, run,	1088	wg, b, dep, prog_node, run,
1003	});	1089	});
1004	} else {	1090	} else {
1005	run.memory_blocked_steps.items[i] = dep;	1091	run.memory_blocked_steps.items[i] = dep;
...	@@ -1124,6 +1210,8 @@ fn usage(b: *std.Build, out_stream: anytype) !void {	...	@@ -1124,6 +1210,8 @@ fn usage(b: *std.Build, out_stream: anytype) !void {
1124	\\ --maxrss <bytes> Limit memory usage (default is to use available memory)	1210	\\ --maxrss <bytes> Limit memory usage (default is to use available memory)
1125	\\ --skip-oom-steps Instead of failing, skip steps that would exceed --maxrss	1211	\\ --skip-oom-steps Instead of failing, skip steps that would exceed --maxrss
1126	\\ --fetch Exit after fetching dependency tree	1212	\\ --fetch Exit after fetching dependency tree
		1213	\\ --watch Continuously rebuild when source files are modified
		1214	\\ --debounce <ms> Delay before rebuilding after changed file detected
1127	\\	1215	\\
1128	\\Project-Specific Options:	1216	\\Project-Specific Options:
1129	\\	1217	\\
...	@@ -1218,13 +1306,22 @@ fn argsRest(args: [][:0]const u8, idx: usize) ?[][:0]const u8 {	...	@@ -1218,13 +1306,22 @@ fn argsRest(args: [][:0]const u8, idx: usize) ?[][:0]const u8 {
1218	return args[idx..];	1306	return args[idx..];
1219	}	1307	}
1220		1308
		1309	/// Perhaps in the future there could be an Advanced Options flag such as
		1310	/// --debug-build-runner-leaks which would make this function return instead of
		1311	/// calling exit.
1221	fn cleanExit() void {	1312	fn cleanExit() void {
1222	// Perhaps in the future there could be an Advanced Options flag such as	1313	std.debug.lockStdErr();
1223	// --debug-build-runner-leaks which would make this function return instead
1224	// of calling exit.
1225	process.exit(0);	1314	process.exit(0);
1226	}	1315	}
1227		1316
		1317	/// Perhaps in the future there could be an Advanced Options flag such as
		1318	/// --debug-build-runner-leaks which would make this function return instead of
		1319	/// calling exit.
		1320	fn uncleanExit() error{UncleanExit} {
		1321	std.debug.lockStdErr();
		1322	process.exit(1);
		1323	}
		1324
1228	const Color = std.zig.Color;	1325	const Color = std.zig.Color;
1229	const Summary = enum { all, new, failures, none };	1326	const Summary = enum { all, new, failures, none };
1230		1327
...	@@ -1249,11 +1346,6 @@ fn fatalWithHint(comptime f: []const u8, args: anytype) noreturn {	...	@@ -1249,11 +1346,6 @@ fn fatalWithHint(comptime f: []const u8, args: anytype) noreturn {
1249	process.exit(1);	1346	process.exit(1);
1250	}	1347	}
1251		1348
1252	fn fatal(comptime f: []const u8, args: anytype) noreturn {
1253	std.debug.print(f ++ "\n", args);
1254	process.exit(1);
1255	}
1256
1257	fn validateSystemLibraryOptions(b: *std.Build) void {	1349	fn validateSystemLibraryOptions(b: *std.Build) void {
1258	var bad = false;	1350	var bad = false;
1259	for (b.graph.system_library_options.keys(), b.graph.system_library_options.values()) \|k, v\| {	1351	for (b.graph.system_library_options.keys(), b.graph.system_library_options.values()) \|k, v\| {

lib/compiler/objcopy.zig+2-8

 @@ -198,20 +198,14 @@ fn cmdObjCopy(
                     return std.process.cleanExit();
                 },
                 .update => {
-                    if (seen_update) {
+                    if (seen_update) fatal("zig objcopy only supports 1 update for now", .{});
-                        std.debug.print("zig objcopy only supports 1 update for now\n", .{});
-                        std.process.exit(1);
-                    }
                     seen_update = true;
                     try server.serveEmitBinPath(output, .{
                         .flags = .{ .cache_hit = false },
                     });
                 },
-                else => {
+                else => fatal("unsupported message: {s}", .{@tagName(hdr.tag)}),
-                    std.debug.print("unsupported message: {s}", .{@tagName(hdr.tag)});
-                    std.process.exit(1);
-                },
             }
         }
     }

lib/std/Build.zig+51-61

...	@@ -20,6 +20,7 @@ const Build = @This();	...	@@ -20,6 +20,7 @@ const Build = @This();
20	pub const Cache = @import("Build/Cache.zig");	20	pub const Cache = @import("Build/Cache.zig");
21	pub const Step = @import("Build/Step.zig");	21	pub const Step = @import("Build/Step.zig");
22	pub const Module = @import("Build/Module.zig");	22	pub const Module = @import("Build/Module.zig");
		23	pub const Watch = @import("Build/Watch.zig");
23		24
24	/// Shared state among all Build instances.	25	/// Shared state among all Build instances.
25	graph: *Graph,	26	graph: *Graph,
...	@@ -50,11 +51,9 @@ install_path: []const u8,	...	@@ -50,11 +51,9 @@ install_path: []const u8,
50	sysroot: ?[]const u8 = null,	51	sysroot: ?[]const u8 = null,
51	search_prefixes: std.ArrayListUnmanaged([]const u8),	52	search_prefixes: std.ArrayListUnmanaged([]const u8),
52	libc_file: ?[]const u8 = null,	53	libc_file: ?[]const u8 = null,
53	installed_files: ArrayList(InstalledFile),
54	/// Path to the directory containing build.zig.	54	/// Path to the directory containing build.zig.
55	build_root: Cache.Directory,	55	build_root: Cache.Directory,
56	cache_root: Cache.Directory,	56	cache_root: Cache.Directory,
57	zig_lib_dir: ?LazyPath,
58	pkg_config_pkg_list: ?(PkgConfigError![]const PkgConfigPkg) = null,	57	pkg_config_pkg_list: ?(PkgConfigError![]const PkgConfigPkg) = null,
59	args: ?[]const []const u8 = null,	58	args: ?[]const []const u8 = null,
60	debug_log_scopes: []const []const u8 = &.{},	59	debug_log_scopes: []const []const u8 = &.{},
...	@@ -117,6 +116,7 @@ pub const Graph = struct {	...	@@ -117,6 +116,7 @@ pub const Graph = struct {
117	zig_exe: [:0]const u8,	116	zig_exe: [:0]const u8,
118	env_map: EnvMap,	117	env_map: EnvMap,
119	global_cache_root: Cache.Directory,	118	global_cache_root: Cache.Directory,
		119	zig_lib_directory: Cache.Directory,
120	needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .{},	120	needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .{},
121	/// Information about the native target. Computed before build() is invoked.	121	/// Information about the native target. Computed before build() is invoked.
122	host: ResolvedTarget,	122	host: ResolvedTarget,
...	@@ -276,7 +276,6 @@ pub fn create(	...	@@ -276,7 +276,6 @@ pub fn create(
276	.exe_dir = undefined,	276	.exe_dir = undefined,
277	.h_dir = undefined,	277	.h_dir = undefined,
278	.dest_dir = graph.env_map.get("DESTDIR"),	278	.dest_dir = graph.env_map.get("DESTDIR"),
279	.installed_files = ArrayList(InstalledFile).init(arena),
280	.install_tls = .{	279	.install_tls = .{
281	.step = Step.init(.{	280	.step = Step.init(.{
282	.id = TopLevelStep.base_id,	281	.id = TopLevelStep.base_id,
...	@@ -294,7 +293,6 @@ pub fn create(	...	@@ -294,7 +293,6 @@ pub fn create(
294	}),	293	}),
295	.description = "Remove build artifacts from prefix path",	294	.description = "Remove build artifacts from prefix path",
296	},	295	},
297	.zig_lib_dir = null,
298	.install_path = undefined,	296	.install_path = undefined,
299	.args = null,	297	.args = null,
300	.host = graph.host,	298	.host = graph.host,
...	@@ -378,10 +376,8 @@ fn createChildOnly(	...	@@ -378,10 +376,8 @@ fn createChildOnly(
378	.sysroot = parent.sysroot,	376	.sysroot = parent.sysroot,
379	.search_prefixes = parent.search_prefixes,	377	.search_prefixes = parent.search_prefixes,
380	.libc_file = parent.libc_file,	378	.libc_file = parent.libc_file,
381	.installed_files = ArrayList(InstalledFile).init(allocator),
382	.build_root = build_root,	379	.build_root = build_root,
383	.cache_root = parent.cache_root,	380	.cache_root = parent.cache_root,
384	.zig_lib_dir = parent.zig_lib_dir,
385	.debug_log_scopes = parent.debug_log_scopes,	381	.debug_log_scopes = parent.debug_log_scopes,
386	.debug_compile_errors = parent.debug_compile_errors,	382	.debug_compile_errors = parent.debug_compile_errors,
387	.debug_pkg_config = parent.debug_pkg_config,	383	.debug_pkg_config = parent.debug_pkg_config,
...	@@ -689,7 +685,7 @@ pub fn addExecutable(b: Build, options: ExecutableOptions) Step.Compile {	...	@@ -689,7 +685,7 @@ pub fn addExecutable(b: Build, options: ExecutableOptions) Step.Compile {
689	.max_rss = options.max_rss,	685	.max_rss = options.max_rss,
690	.use_llvm = options.use_llvm,	686	.use_llvm = options.use_llvm,
691	.use_lld = options.use_lld,	687	.use_lld = options.use_lld,
692	.zig_lib_dir = options.zig_lib_dir orelse b.zig_lib_dir,	688	.zig_lib_dir = options.zig_lib_dir,
693	.win32_manifest = options.win32_manifest,	689	.win32_manifest = options.win32_manifest,
694	});	690	});
695	}	691	}
...	@@ -737,7 +733,7 @@ pub fn addObject(b: Build, options: ObjectOptions) Step.Compile {	...	@@ -737,7 +733,7 @@ pub fn addObject(b: Build, options: ObjectOptions) Step.Compile {
737	.max_rss = options.max_rss,	733	.max_rss = options.max_rss,
738	.use_llvm = options.use_llvm,	734	.use_llvm = options.use_llvm,
739	.use_lld = options.use_lld,	735	.use_lld = options.use_lld,
740	.zig_lib_dir = options.zig_lib_dir orelse b.zig_lib_dir,	736	.zig_lib_dir = options.zig_lib_dir,
741	});	737	});
742	}	738	}
743		739
...	@@ -793,7 +789,7 @@ pub fn addSharedLibrary(b: Build, options: SharedLibraryOptions) Step.Compile	...	@@ -793,7 +789,7 @@ pub fn addSharedLibrary(b: Build, options: SharedLibraryOptions) Step.Compile
793	.max_rss = options.max_rss,	789	.max_rss = options.max_rss,
794	.use_llvm = options.use_llvm,	790	.use_llvm = options.use_llvm,
795	.use_lld = options.use_lld,	791	.use_lld = options.use_lld,
796	.zig_lib_dir = options.zig_lib_dir orelse b.zig_lib_dir,	792	.zig_lib_dir = options.zig_lib_dir,
797	.win32_manifest = options.win32_manifest,	793	.win32_manifest = options.win32_manifest,
798	});	794	});
799	}	795	}
...	@@ -844,7 +840,7 @@ pub fn addStaticLibrary(b: Build, options: StaticLibraryOptions) Step.Compile	...	@@ -844,7 +840,7 @@ pub fn addStaticLibrary(b: Build, options: StaticLibraryOptions) Step.Compile
844	.max_rss = options.max_rss,	840	.max_rss = options.max_rss,
845	.use_llvm = options.use_llvm,	841	.use_llvm = options.use_llvm,
846	.use_lld = options.use_lld,	842	.use_lld = options.use_lld,
847	.zig_lib_dir = options.zig_lib_dir orelse b.zig_lib_dir,	843	.zig_lib_dir = options.zig_lib_dir,
848	});	844	});
849	}	845	}
850		846
...	@@ -907,7 +903,7 @@ pub fn addTest(b: Build, options: TestOptions) Step.Compile {	...	@@ -907,7 +903,7 @@ pub fn addTest(b: Build, options: TestOptions) Step.Compile {
907	.test_runner = options.test_runner,	903	.test_runner = options.test_runner,
908	.use_llvm = options.use_llvm,	904	.use_llvm = options.use_llvm,
909	.use_lld = options.use_lld,	905	.use_lld = options.use_lld,
910	.zig_lib_dir = options.zig_lib_dir orelse b.zig_lib_dir,	906	.zig_lib_dir = options.zig_lib_dir,
911	});	907	});
912	}	908	}
913		909
...	@@ -931,7 +927,7 @@ pub fn addAssembly(b: Build, options: AssemblyOptions) Step.Compile {	...	@@ -931,7 +927,7 @@ pub fn addAssembly(b: Build, options: AssemblyOptions) Step.Compile {
931	.optimize = options.optimize,	927	.optimize = options.optimize,
932	},	928	},
933	.max_rss = options.max_rss,	929	.max_rss = options.max_rss,
934	.zig_lib_dir = options.zig_lib_dir orelse b.zig_lib_dir,	930	.zig_lib_dir = options.zig_lib_dir,
935	});	931	});
936	obj_step.addAssemblyFile(options.source_file);	932	obj_step.addAssemblyFile(options.source_file);
937	return obj_step;	933	return obj_step;
...	@@ -1054,7 +1050,11 @@ pub fn addWriteFiles(b: Build) Step.WriteFile {	...	@@ -1054,7 +1050,11 @@ pub fn addWriteFiles(b: Build) Step.WriteFile {
1054	return Step.WriteFile.create(b);	1050	return Step.WriteFile.create(b);
1055	}	1051	}
1056		1052
1057	pub fn addRemoveDirTree(b: Build, dir_path: []const u8) Step.RemoveDir {	1053	pub fn addUpdateSourceFiles(b: Build) Step.UpdateSourceFiles {
		1054	return Step.UpdateSourceFiles.create(b);
		1055	}
		1056
		1057	pub fn addRemoveDirTree(b: Build, dir_path: LazyPath) Step.RemoveDir {
1058	return Step.RemoveDir.create(b, dir_path);	1058	return Step.RemoveDir.create(b, dir_path);
1059	}	1059	}
1060		1060
...	@@ -1083,15 +1083,8 @@ fn makeUninstall(uninstall_step: *Step, prog_node: std.Progress.Node) anyerror!v	...	@@ -1083,15 +1083,8 @@ fn makeUninstall(uninstall_step: *Step, prog_node: std.Progress.Node) anyerror!v
1083	const uninstall_tls: *TopLevelStep = @fieldParentPtr("step", uninstall_step);	1083	const uninstall_tls: *TopLevelStep = @fieldParentPtr("step", uninstall_step);
1084	const b: *Build = @fieldParentPtr("uninstall_tls", uninstall_tls);	1084	const b: *Build = @fieldParentPtr("uninstall_tls", uninstall_tls);
1085		1085
1086	for (b.installed_files.items) \|installed_file\| {	1086	_ = b;
1087	const full_path = b.getInstallPath(installed_file.dir, installed_file.path);	1087	@panic("TODO implement https://github.com/ziglang/zig/issues/14943");
1088	if (b.verbose) {
1089	log.info("rm {s}", .{full_path});
1090	}
1091	fs.cwd().deleteTree(full_path) catch {};
1092	}
1093
1094	// TODO remove empty directories
1095	}	1088	}
1096		1089
1097	/// Creates a configuration option to be passed to the build.zig script.	1090	/// Creates a configuration option to be passed to the build.zig script.
...	@@ -1664,15 +1657,6 @@ pub fn addCheckFile(	...	@@ -1664,15 +1657,6 @@ pub fn addCheckFile(
1664	return Step.CheckFile.create(b, file_source, options);	1657	return Step.CheckFile.create(b, file_source, options);
1665	}	1658	}
1666		1659
1667	/// deprecated: https://github.com/ziglang/zig/issues/14943
1668	pub fn pushInstalledFile(b: *Build, dir: InstallDir, dest_rel_path: []const u8) void {
1669	const file = InstalledFile{
1670	.dir = dir,
1671	.path = dest_rel_path,
1672	};
1673	b.installed_files.append(file.dupe(b)) catch @panic("OOM");
1674	}
1675
1676	pub fn truncateFile(b: *Build, dest_path: []const u8) !void {	1660	pub fn truncateFile(b: *Build, dest_path: []const u8) !void {
1677	if (b.verbose) {	1661	if (b.verbose) {
1678	log.info("truncate {s}", .{dest_path});	1662	log.info("truncate {s}", .{dest_path});
...	@@ -2341,36 +2325,52 @@ pub const LazyPath = union(enum) {	...	@@ -2341,36 +2325,52 @@ pub const LazyPath = union(enum) {
2341	}	2325	}
2342	}	2326	}
2343		2327
2344	/// Returns an absolute path.	2328	/// Deprecated, see `getPath3`.
2345	/// Intended to be used during the make phase only.
2346	pub fn getPath(lazy_path: LazyPath, src_builder: *Build) []const u8 {	2329	pub fn getPath(lazy_path: LazyPath, src_builder: *Build) []const u8 {
2347	return getPath2(lazy_path, src_builder, null);	2330	return getPath2(lazy_path, src_builder, null);
2348	}	2331	}
2349		2332
2350	/// Returns an absolute path.	2333	/// Deprecated, see `getPath3`.
		2334	pub fn getPath2(lazy_path: LazyPath, src_builder: Build, asking_step: ?Step) []const u8 {
		2335	const p = getPath3(lazy_path, src_builder, asking_step);
		2336	return src_builder.pathResolve(&.{ p.root_dir.path orelse ".", p.sub_path });
		2337	}
		2338
2351	/// Intended to be used during the make phase only.	2339	/// Intended to be used during the make phase only.
2352	///	2340	///
2353	/// `asking_step` is only used for debugging purposes; it's the step being	2341	/// `asking_step` is only used for debugging purposes; it's the step being
2354	/// run that is asking for the path.	2342	/// run that is asking for the path.
2355	pub fn getPath2(lazy_path: LazyPath, src_builder: Build, asking_step: ?Step) []const u8 {	2343	pub fn getPath3(lazy_path: LazyPath, src_builder: Build, asking_step: ?Step) Cache.Path {
2356	switch (lazy_path) {	2344	switch (lazy_path) {
2357	.src_path => \|sp\| return sp.owner.pathFromRoot(sp.sub_path),	2345	.src_path => \|sp\| return .{
2358	.cwd_relative => \|p\| return src_builder.pathFromCwd(p),	2346	.root_dir = sp.owner.build_root,
		2347	.sub_path = sp.sub_path,
		2348	},
		2349	.cwd_relative => \|sub_path\| return .{
		2350	.root_dir = Cache.Directory.cwd(),
		2351	.sub_path = sub_path,
		2352	},
2359	.generated => \|gen\| {	2353	.generated => \|gen\| {
2360	var file_path: []const u8 = gen.file.step.owner.pathFromRoot(gen.file.path orelse {	2354	// TODO make gen.file.path not be absolute and use that as the
2361	std.debug.lockStdErr();	2355	// basis for not traversing up too many directories.
2362	const stderr = std.io.getStdErr();	2356
2363	dumpBadGetPathHelp(gen.file.step, stderr, src_builder, asking_step) catch {};	2357	var file_path: Cache.Path = .{
2364	std.debug.unlockStdErr();	2358	.root_dir = gen.file.step.owner.build_root,
2365	@panic("misconfigured build script");	2359	.sub_path = gen.file.path orelse {
2366	});	2360	std.debug.lockStdErr();
		2361	const stderr = std.io.getStdErr();
		2362	dumpBadGetPathHelp(gen.file.step, stderr, src_builder, asking_step) catch {};
		2363	std.debug.unlockStdErr();
		2364	@panic("misconfigured build script");
		2365	},
		2366	};
2367		2367
2368	if (gen.up > 0) {	2368	if (gen.up > 0) {
2369	const cache_root_path = src_builder.cache_root.path orelse	2369	const cache_root_path = src_builder.cache_root.path orelse
2370	(src_builder.cache_root.join(src_builder.allocator, &.{"."}) catch @panic("OOM"));	2370	(src_builder.cache_root.join(src_builder.allocator, &.{"."}) catch @panic("OOM"));
2371		2371
2372	for (0..gen.up) \|_\| {	2372	for (0..gen.up) \|_\| {
2373	if (mem.eql(u8, file_path, cache_root_path)) {	2373	if (mem.eql(u8, file_path.sub_path, cache_root_path)) {
2374	// If we hit the cache root and there's still more to go,	2374	// If we hit the cache root and there's still more to go,
2375	// the script attempted to go too far.	2375	// the script attempted to go too far.
2376	dumpBadDirnameHelp(gen.file.step, asking_step,	2376	dumpBadDirnameHelp(gen.file.step, asking_step,
...	@@ -2384,7 +2384,7 @@ pub const LazyPath = union(enum) {	...	@@ -2384,7 +2384,7 @@ pub const LazyPath = union(enum) {
2384	// path is absolute.	2384	// path is absolute.
2385	// dirname will return null only if we're at root.	2385	// dirname will return null only if we're at root.
2386	// Typically, we'll stop well before that at the cache root.	2386	// Typically, we'll stop well before that at the cache root.
2387	file_path = fs.path.dirname(file_path) orelse {	2387	file_path.sub_path = fs.path.dirname(file_path.sub_path) orelse {
2388	dumpBadDirnameHelp(gen.file.step, asking_step,	2388	dumpBadDirnameHelp(gen.file.step, asking_step,
2389	\\dirname() reached root.	2389	\\dirname() reached root.
2390	\\No more directories left to go up.	2390	\\No more directories left to go up.
...	@@ -2395,9 +2395,12 @@ pub const LazyPath = union(enum) {	...	@@ -2395,9 +2395,12 @@ pub const LazyPath = union(enum) {
2395	}	2395	}
2396	}	2396	}
2397		2397
2398	return src_builder.pathResolve(&.{ file_path, gen.sub_path });	2398	return file_path.join(src_builder.allocator, gen.sub_path) catch @panic("OOM");
		2399	},
		2400	.dependency => \|dep\| return .{
		2401	.root_dir = dep.dependency.builder.build_root,
		2402	.sub_path = dep.sub_path,
2399	},	2403	},
2400	.dependency => \|dep\| return dep.dependency.builder.pathFromRoot(dep.sub_path),
2401	}	2404	}
2402	}	2405	}
2403		2406
...	@@ -2512,19 +2515,6 @@ pub const InstallDir = union(enum) {	...	@@ -2512,19 +2515,6 @@ pub const InstallDir = union(enum) {
2512	}	2515	}
2513	};	2516	};
2514		2517
2515	pub const InstalledFile = struct {
2516	dir: InstallDir,
2517	path: []const u8,
2518
2519	/// Duplicates the installed file path and directory.
2520	pub fn dupe(file: InstalledFile, builder: *Build) InstalledFile {
2521	return .{
2522	.dir = file.dir.dupe(builder),
2523	.path = builder.dupe(file.path),
2524	};
2525	}
2526	};
2527
2528	/// This function is intended to be called in the `configure` phase only.	2518	/// This function is intended to be called in the `configure` phase only.
2529	/// It returns an absolute directory path, which is potentially going to be a	2519	/// It returns an absolute directory path, which is potentially going to be a
2530	/// source of API breakage in the future, so keep that in mind when using this	2520	/// source of API breakage in the future, so keep that in mind when using this

lib/std/Build/Cache.zig+34

...	@@ -354,6 +354,19 @@ pub const Manifest = struct {	...	@@ -354,6 +354,19 @@ pub const Manifest = struct {
354	/// ```	354	/// ```
355	/// var file_contents = cache_hash.files.keys()[file_index].contents.?;	355	/// var file_contents = cache_hash.files.keys()[file_index].contents.?;
356	/// ```	356	/// ```
		357	pub fn addFilePath(m: *Manifest, file_path: Path, max_file_size: ?usize) !usize {
		358	const gpa = m.cache.gpa;
		359	try m.files.ensureUnusedCapacity(gpa, 1);
		360	const resolved_path = try fs.path.resolve(gpa, &.{
		361	file_path.root_dir.path orelse ".",
		362	file_path.subPathOrDot(),
		363	});
		364	errdefer gpa.free(resolved_path);
		365	const prefixed_path = try m.cache.findPrefixResolved(resolved_path);
		366	return addFileInner(m, prefixed_path, max_file_size);
		367	}
		368
		369	/// Deprecated; use `addFilePath`.
357	pub fn addFile(self: *Manifest, file_path: []const u8, max_file_size: ?usize) !usize {	370	pub fn addFile(self: *Manifest, file_path: []const u8, max_file_size: ?usize) !usize {
358	assert(self.manifest_file == null);	371	assert(self.manifest_file == null);
359		372
...	@@ -362,6 +375,10 @@ pub const Manifest = struct {	...	@@ -362,6 +375,10 @@ pub const Manifest = struct {
362	const prefixed_path = try self.cache.findPrefix(file_path);	375	const prefixed_path = try self.cache.findPrefix(file_path);
363	errdefer gpa.free(prefixed_path.sub_path);	376	errdefer gpa.free(prefixed_path.sub_path);
364		377
		378	return addFileInner(self, prefixed_path, max_file_size);
		379	}
		380
		381	fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, max_file_size: ?usize) !usize {
365	const gop = self.files.getOrPutAssumeCapacityAdapted(prefixed_path, FilesAdapter{});	382	const gop = self.files.getOrPutAssumeCapacityAdapted(prefixed_path, FilesAdapter{});
366	if (gop.found_existing) {	383	if (gop.found_existing) {
367	gop.key_ptr.updateMaxSize(max_file_size);	384	gop.key_ptr.updateMaxSize(max_file_size);
...	@@ -990,6 +1007,23 @@ pub const Manifest = struct {	...	@@ -990,6 +1007,23 @@ pub const Manifest = struct {
990	}	1007	}
991	self.files.deinit(self.cache.gpa);	1008	self.files.deinit(self.cache.gpa);
992	}	1009	}
		1010
		1011	pub fn populateFileSystemInputs(man: Manifest, buf: std.ArrayListUnmanaged(u8)) Allocator.Error!void {
		1012	assert(@typeInfo(std.zig.Server.Message.PathPrefix).Enum.fields.len == man.cache.prefixes_len);
		1013	buf.clearRetainingCapacity();
		1014	const gpa = man.cache.gpa;
		1015	const files = man.files.keys();
		1016	if (files.len > 0) {
		1017	for (files) \|file\| {
		1018	try buf.ensureUnusedCapacity(gpa, file.prefixed_path.sub_path.len + 2);
		1019	buf.appendAssumeCapacity(file.prefixed_path.prefix + 1);
		1020	buf.appendSliceAssumeCapacity(file.prefixed_path.sub_path);
		1021	buf.appendAssumeCapacity(0);
		1022	}
		1023	// The null byte is a separator, not a terminator.
		1024	buf.items.len -= 1;
		1025	}
		1026	}
993	};	1027	};
994		1028
995	/// On operating systems that support symlinks, does a readlink. On other operating systems,	1029	/// On operating systems that support symlinks, does a readlink. On other operating systems,

lib/std/Build/Cache/Path.zig+57-2

...	@@ -58,6 +58,20 @@ pub fn openFile(	...	@@ -58,6 +58,20 @@ pub fn openFile(
58	return p.root_dir.handle.openFile(joined_path, flags);	58	return p.root_dir.handle.openFile(joined_path, flags);
59	}	59	}
60		60
		61	pub fn openDir(
		62	p: Path,
		63	sub_path: []const u8,
		64	args: fs.Dir.OpenOptions,
		65	) fs.Dir.OpenError!fs.Dir {
		66	var buf: [fs.max_path_bytes]u8 = undefined;
		67	const joined_path = if (p.sub_path.len == 0) sub_path else p: {
		68	break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
		69	p.sub_path, sub_path,
		70	}) catch return error.NameTooLong;
		71	};
		72	return p.root_dir.handle.openDir(joined_path, args);
		73	}
		74
61	pub fn makeOpenPath(p: Path, sub_path: []const u8, opts: fs.Dir.OpenOptions) !fs.Dir {	75	pub fn makeOpenPath(p: Path, sub_path: []const u8, opts: fs.Dir.OpenOptions) !fs.Dir {
62	var buf: [fs.max_path_bytes]u8 = undefined;	76	var buf: [fs.max_path_bytes]u8 = undefined;
63	const joined_path = if (p.sub_path.len == 0) sub_path else p: {	77	const joined_path = if (p.sub_path.len == 0) sub_path else p: {
...	@@ -137,16 +151,57 @@ pub fn format(	...	@@ -137,16 +151,57 @@ pub fn format(
137	}	151	}
138	if (fmt_string.len > 0)	152	if (fmt_string.len > 0)
139	std.fmt.invalidFmtError(fmt_string, self);	153	std.fmt.invalidFmtError(fmt_string, self);
		154	if (std.fs.path.isAbsolute(self.sub_path)) {
		155	try writer.writeAll(self.sub_path);
		156	return;
		157	}
140	if (self.root_dir.path) \|p\| {	158	if (self.root_dir.path) \|p\| {
141	try writer.writeAll(p);	159	try writer.writeAll(p);
142	try writer.writeAll(fs.path.sep_str);	160	if (self.sub_path.len > 0) {
		161	try writer.writeAll(fs.path.sep_str);
		162	try writer.writeAll(self.sub_path);
		163	}
		164	return;
143	}	165	}
144	if (self.sub_path.len > 0) {	166	if (self.sub_path.len > 0) {
145	try writer.writeAll(self.sub_path);	167	try writer.writeAll(self.sub_path);
146	try writer.writeAll(fs.path.sep_str);	168	return;
147	}	169	}
		170	try writer.writeByte('.');
		171	}
		172
		173	pub fn eql(self: Path, other: Path) bool {
		174	return self.root_dir.eql(other.root_dir) and std.mem.eql(u8, self.sub_path, other.sub_path);
		175	}
		176
		177	pub fn subPathOpt(self: Path) ?[]const u8 {
		178	return if (self.sub_path.len == 0) null else self.sub_path;
148	}	179	}
149		180
		181	pub fn subPathOrDot(self: Path) []const u8 {
		182	return if (self.sub_path.len == 0) "." else self.sub_path;
		183	}
		184
		185	/// Useful to make `Path` a key in `std.ArrayHashMap`.
		186	pub const TableAdapter = struct {
		187	pub const Hash = std.hash.Wyhash;
		188
		189	pub fn hash(self: TableAdapter, a: Cache.Path) u32 {
		190	_ = self;
		191	const seed = switch (@typeInfo(@TypeOf(a.root_dir.handle.fd))) {
		192	.Pointer => @intFromPtr(a.root_dir.handle.fd),
		193	.Int => @as(u32, @bitCast(a.root_dir.handle.fd)),
		194	else => @compileError("unimplemented hash function"),
		195	};
		196	return @truncate(Hash.hash(seed, a.sub_path));
		197	}
		198	pub fn eql(self: TableAdapter, a: Cache.Path, b: Cache.Path, b_index: usize) bool {
		199	_ = self;
		200	_ = b_index;
		201	return a.eql(b);
		202	}
		203	};
		204
150	const Path = @This();	205	const Path = @This();
151	const std = @import("../../std.zig");	206	const std = @import("../../std.zig");
152	const fs = std.fs;	207	const fs = std.fs;

lib/std/Build/Step.zig+235-3

...	@@ -7,6 +7,16 @@ dependencies: std.ArrayList(*Step),	...	@@ -7,6 +7,16 @@ dependencies: std.ArrayList(*Step),
7	/// This field is empty during execution of the user's build script, and	7	/// This field is empty during execution of the user's build script, and
8	/// then populated during dependency loop checking in the build runner.	8	/// then populated during dependency loop checking in the build runner.
9	dependants: std.ArrayListUnmanaged(*Step),	9	dependants: std.ArrayListUnmanaged(*Step),
		10	/// Collects the set of files that retrigger this step to run.
		11	///
		12	/// This is used by the build system's implementation of `--watch` but it can
		13	/// also be potentially useful for IDEs to know what effects editing a
		14	/// particular file has.
		15	///
		16	/// Populated within `make`. Implementation may choose to clear and repopulate,
		17	/// retain previous value, or update.
		18	inputs: Inputs,
		19
10	state: State,	20	state: State,
11	/// Set this field to declare an upper bound on the amount of bytes of memory it will	21	/// Set this field to declare an upper bound on the amount of bytes of memory it will
12	/// take to run the step. Zero means no limit.	22	/// take to run the step. Zero means no limit.
...	@@ -63,6 +73,11 @@ pub const MakeFn = const fn (step: Step, prog_node: std.Progress.Node) anyerro	...	@@ -63,6 +73,11 @@ pub const MakeFn = const fn (step: Step, prog_node: std.Progress.Node) anyerro
63	pub const State = enum {	73	pub const State = enum {
64	precheck_unstarted,	74	precheck_unstarted,
65	precheck_started,	75	precheck_started,
		76	/// This is also used to indicate "dirty" steps that have been modified
		77	/// after a previous build completed, in which case, the step may or may
		78	/// not have been completed before. Either way, one or more of its direct
		79	/// file system inputs have been modified, meaning that the step needs to
		80	/// be re-evaluated.
66	precheck_done,	81	precheck_done,
67	running,	82	running,
68	dependency_failure,	83	dependency_failure,
...	@@ -87,6 +102,7 @@ pub const Id = enum {	...	@@ -87,6 +102,7 @@ pub const Id = enum {
87	fmt,	102	fmt,
88	translate_c,	103	translate_c,
89	write_file,	104	write_file,
		105	update_source_files,
90	run,	106	run,
91	check_file,	107	check_file,
92	check_object,	108	check_object,
...	@@ -107,6 +123,7 @@ pub const Id = enum {	...	@@ -107,6 +123,7 @@ pub const Id = enum {
107	.fmt => Fmt,	123	.fmt => Fmt,
108	.translate_c => TranslateC,	124	.translate_c => TranslateC,
109	.write_file => WriteFile,	125	.write_file => WriteFile,
		126	.update_source_files => UpdateSourceFiles,
110	.run => Run,	127	.run => Run,
111	.check_file => CheckFile,	128	.check_file => CheckFile,
112	.check_object => CheckObject,	129	.check_object => CheckObject,
...	@@ -133,6 +150,28 @@ pub const RemoveDir = @import("Step/RemoveDir.zig");	...	@@ -133,6 +150,28 @@ pub const RemoveDir = @import("Step/RemoveDir.zig");
133	pub const Run = @import("Step/Run.zig");	150	pub const Run = @import("Step/Run.zig");
134	pub const TranslateC = @import("Step/TranslateC.zig");	151	pub const TranslateC = @import("Step/TranslateC.zig");
135	pub const WriteFile = @import("Step/WriteFile.zig");	152	pub const WriteFile = @import("Step/WriteFile.zig");
		153	pub const UpdateSourceFiles = @import("Step/UpdateSourceFiles.zig");
		154
		155	pub const Inputs = struct {
		156	table: Table,
		157
		158	pub const init: Inputs = .{
		159	.table = .{},
		160	};
		161
		162	pub const Table = std.ArrayHashMapUnmanaged(Build.Cache.Path, Files, Build.Cache.Path.TableAdapter, false);
		163	/// The special file name "." means any changes inside the directory.
		164	pub const Files = std.ArrayListUnmanaged([]const u8);
		165
		166	pub fn populated(inputs: *Inputs) bool {
		167	return inputs.table.count() != 0;
		168	}
		169
		170	pub fn clear(inputs: *Inputs, gpa: Allocator) void {
		171	for (inputs.table.values()) \|*files\| files.deinit(gpa);
		172	inputs.table.clearRetainingCapacity();
		173	}
		174	};
136		175
137	pub const StepOptions = struct {	176	pub const StepOptions = struct {
138	id: Id,	177	id: Id,
...	@@ -153,6 +192,7 @@ pub fn init(options: StepOptions) Step {	...	@@ -153,6 +192,7 @@ pub fn init(options: StepOptions) Step {
153	.makeFn = options.makeFn,	192	.makeFn = options.makeFn,
154	.dependencies = std.ArrayList(*Step).init(arena),	193	.dependencies = std.ArrayList(*Step).init(arena),
155	.dependants = .{},	194	.dependants = .{},
		195	.inputs = Inputs.init,
156	.state = .precheck_unstarted,	196	.state = .precheck_unstarted,
157	.max_rss = options.max_rss,	197	.max_rss = options.max_rss,
158	.debug_stack_trace = blk: {	198	.debug_stack_trace = blk: {
...	@@ -395,6 +435,44 @@ pub fn evalZigProcess(	...	@@ -395,6 +435,44 @@ pub fn evalZigProcess(
395	s.result_cached = ebp_hdr.flags.cache_hit;	435	s.result_cached = ebp_hdr.flags.cache_hit;
396	result = try arena.dupe(u8, body[@sizeOf(EbpHdr)..]);	436	result = try arena.dupe(u8, body[@sizeOf(EbpHdr)..]);
397	},	437	},
		438	.file_system_inputs => {
		439	s.clearWatchInputs();
		440	var it = std.mem.splitScalar(u8, body, 0);
		441	while (it.next()) \|prefixed_path\| {
		442	const prefix_index: std.zig.Server.Message.PathPrefix = @enumFromInt(prefixed_path[0] - 1);
		443	const sub_path = try arena.dupe(u8, prefixed_path[1..]);
		444	const sub_path_dirname = std.fs.path.dirname(sub_path) orelse "";
		445	switch (prefix_index) {
		446	.cwd => {
		447	const path: Build.Cache.Path = .{
		448	.root_dir = Build.Cache.Directory.cwd(),
		449	.sub_path = sub_path_dirname,
		450	};
		451	try addWatchInputFromPath(s, path, std.fs.path.basename(sub_path));
		452	},
		453	.zig_lib => zl: {
		454	if (s.cast(Step.Compile)) \|compile\| {
		455	if (compile.zig_lib_dir) \|lp\| {
		456	try addWatchInput(s, lp);
		457	break :zl;
		458	}
		459	}
		460	const path: Build.Cache.Path = .{
		461	.root_dir = s.owner.graph.zig_lib_directory,
		462	.sub_path = sub_path_dirname,
		463	};
		464	try addWatchInputFromPath(s, path, std.fs.path.basename(sub_path));
		465	},
		466	.local_cache => {
		467	const path: Build.Cache.Path = .{
		468	.root_dir = b.cache_root,
		469	.sub_path = sub_path_dirname,
		470	};
		471	try addWatchInputFromPath(s, path, std.fs.path.basename(sub_path));
		472	},
		473	}
		474	}
		475	},
398	else => {}, // ignore other messages	476	else => {}, // ignore other messages
399	}	477	}
400		478
...	@@ -542,19 +620,36 @@ pub fn allocPrintCmd2(	...	@@ -542,19 +620,36 @@ pub fn allocPrintCmd2(
542	return buf.toOwnedSlice(arena);	620	return buf.toOwnedSlice(arena);
543	}	621	}
544		622
545	pub fn cacheHit(s: Step, man: std.Build.Cache.Manifest) !bool {	623	/// Prefer `cacheHitAndWatch` unless you already added watch inputs
		624	/// separately from using the cache system.
		625	pub fn cacheHit(s: Step, man: Build.Cache.Manifest) !bool {
546	s.result_cached = man.hit() catch \|err\| return failWithCacheError(s, man, err);	626	s.result_cached = man.hit() catch \|err\| return failWithCacheError(s, man, err);
547	return s.result_cached;	627	return s.result_cached;
548	}	628	}
549		629
550	fn failWithCacheError(s: Step, man: const std.Build.Cache.Manifest, err: anyerror) anyerror {	630	/// Clears previous watch inputs, if any, and then populates watch inputs from
		631	/// the full set of files picked up by the cache manifest.
		632	///
		633	/// Must be accompanied with `writeManifestAndWatch`.
		634	pub fn cacheHitAndWatch(s: Step, man: Build.Cache.Manifest) !bool {
		635	const is_hit = man.hit() catch \|err\| return failWithCacheError(s, man, err);
		636	s.result_cached = is_hit;
		637	// The above call to hit() populates the manifest with files, so in case of
		638	// a hit, we need to populate watch inputs.
		639	if (is_hit) try setWatchInputsFromManifest(s, man);
		640	return is_hit;
		641	}
		642
		643	fn failWithCacheError(s: Step, man: const Build.Cache.Manifest, err: anyerror) anyerror {
551	const i = man.failed_file_index orelse return err;	644	const i = man.failed_file_index orelse return err;
552	const pp = man.files.keys()[i].prefixed_path;	645	const pp = man.files.keys()[i].prefixed_path;
553	const prefix = man.cache.prefixes()[pp.prefix].path orelse "";	646	const prefix = man.cache.prefixes()[pp.prefix].path orelse "";
554	return s.fail("{s}: {s}/{s}", .{ @errorName(err), prefix, pp.sub_path });	647	return s.fail("{s}: {s}/{s}", .{ @errorName(err), prefix, pp.sub_path });
555	}	648	}
556		649
557	pub fn writeManifest(s: Step, man: std.Build.Cache.Manifest) !void {	650	/// Prefer `writeManifestAndWatch` unless you already added watch inputs
		651	/// separately from using the cache system.
		652	pub fn writeManifest(s: Step, man: Build.Cache.Manifest) !void {
558	if (s.test_results.isSuccess()) {	653	if (s.test_results.isSuccess()) {
559	man.writeManifest() catch \|err\| {	654	man.writeManifest() catch \|err\| {
560	try s.addError("unable to write cache manifest: {s}", .{@errorName(err)});	655	try s.addError("unable to write cache manifest: {s}", .{@errorName(err)});
...	@@ -562,6 +657,142 @@ pub fn writeManifest(s: Step, man: std.Build.Cache.Manifest) !void {	...	@@ -562,6 +657,142 @@ pub fn writeManifest(s: Step, man: std.Build.Cache.Manifest) !void {
562	}	657	}
563	}	658	}
564		659
		660	/// Clears previous watch inputs, if any, and then populates watch inputs from
		661	/// the full set of files picked up by the cache manifest.
		662	///
		663	/// Must be accompanied with `cacheHitAndWatch`.
		664	pub fn writeManifestAndWatch(s: Step, man: Build.Cache.Manifest) !void {
		665	try writeManifest(s, man);
		666	try setWatchInputsFromManifest(s, man);
		667	}
		668
		669	fn setWatchInputsFromManifest(s: Step, man: Build.Cache.Manifest) !void {
		670	const arena = s.owner.allocator;
		671	const prefixes = man.cache.prefixes();
		672	clearWatchInputs(s);
		673	for (man.files.keys()) \|file\| {
		674	// The file path data is freed when the cache manifest is cleaned up at the end of `make`.
		675	const sub_path = try arena.dupe(u8, file.prefixed_path.sub_path);
		676	try addWatchInputFromPath(s, .{
		677	.root_dir = prefixes[file.prefixed_path.prefix],
		678	.sub_path = std.fs.path.dirname(sub_path) orelse "",
		679	}, std.fs.path.basename(sub_path));
		680	}
		681	}
		682
		683	/// For steps that have a single input that never changes when re-running `make`.
		684	pub fn singleUnchangingWatchInput(step: *Step, lazy_path: Build.LazyPath) Allocator.Error!void {
		685	if (!step.inputs.populated()) try step.addWatchInput(lazy_path);
		686	}
		687
		688	pub fn clearWatchInputs(step: *Step) void {
		689	const gpa = step.owner.allocator;
		690	step.inputs.clear(gpa);
		691	}
		692
		693	/// Places a file dependency on the path.
		694	pub fn addWatchInput(step: *Step, lazy_file: Build.LazyPath) Allocator.Error!void {
		695	switch (lazy_file) {
		696	.src_path => \|src_path\| try addWatchInputFromBuilder(step, src_path.owner, src_path.sub_path),
		697	.dependency => \|d\| try addWatchInputFromBuilder(step, d.dependency.builder, d.sub_path),
		698	.cwd_relative => \|path_string\| {
		699	try addWatchInputFromPath(step, .{
		700	.root_dir = .{
		701	.path = null,
		702	.handle = std.fs.cwd(),
		703	},
		704	.sub_path = std.fs.path.dirname(path_string) orelse "",
		705	}, std.fs.path.basename(path_string));
		706	},
		707	// Nothing to watch because this dependency edge is modeled instead via `dependants`.
		708	.generated => {},
		709	}
		710	}
		711
		712	/// Any changes inside the directory will trigger invalidation.
		713	///
		714	/// See also `addDirectoryWatchInputFromPath` which takes a `Build.Cache.Path` instead.
		715	///
		716	/// Paths derived from this directory should also be manually added via
		717	/// `addDirectoryWatchInputFromPath` if and only if this function returns
		718	/// `true`.
		719	pub fn addDirectoryWatchInput(step: *Step, lazy_directory: Build.LazyPath) Allocator.Error!bool {
		720	switch (lazy_directory) {
		721	.src_path => \|src_path\| try addDirectoryWatchInputFromBuilder(step, src_path.owner, src_path.sub_path),
		722	.dependency => \|d\| try addDirectoryWatchInputFromBuilder(step, d.dependency.builder, d.sub_path),
		723	.cwd_relative => \|path_string\| {
		724	try addDirectoryWatchInputFromPath(step, .{
		725	.root_dir = .{
		726	.path = null,
		727	.handle = std.fs.cwd(),
		728	},
		729	.sub_path = path_string,
		730	});
		731	},
		732	// Nothing to watch because this dependency edge is modeled instead via `dependants`.
		733	.generated => return false,
		734	}
		735	return true;
		736	}
		737
		738	/// Any changes inside the directory will trigger invalidation.
		739	///
		740	/// See also `addDirectoryWatchInput` which takes a `Build.LazyPath` instead.
		741	///
		742	/// This function should only be called when it has been verified that the
		743	/// dependency on `path` is not already accounted for by a `Step` dependency.
		744	/// In other words, before calling this function, first check that the
		745	/// `Build.LazyPath` which this `path` is derived from is not `generated`.
		746	pub fn addDirectoryWatchInputFromPath(step: *Step, path: Build.Cache.Path) !void {
		747	return addWatchInputFromPath(step, path, ".");
		748	}
		749
		750	fn addWatchInputFromBuilder(step: Step, builder: Build, sub_path: []const u8) !void {
		751	return addWatchInputFromPath(step, .{
		752	.root_dir = builder.build_root,
		753	.sub_path = std.fs.path.dirname(sub_path) orelse "",
		754	}, std.fs.path.basename(sub_path));
		755	}
		756
		757	fn addDirectoryWatchInputFromBuilder(step: Step, builder: Build, sub_path: []const u8) !void {
		758	return addDirectoryWatchInputFromPath(step, .{
		759	.root_dir = builder.build_root,
		760	.sub_path = sub_path,
		761	});
		762	}
		763
		764	fn addWatchInputFromPath(step: *Step, path: Build.Cache.Path, basename: []const u8) !void {
		765	const gpa = step.owner.allocator;
		766	const gop = try step.inputs.table.getOrPut(gpa, path);
		767	if (!gop.found_existing) gop.value_ptr.* = .{};
		768	try gop.value_ptr.append(gpa, basename);
		769	}
		770
		771	fn reset(step: *Step, gpa: Allocator) void {
		772	assert(step.state == .precheck_done);
		773
		774	step.result_error_msgs.clearRetainingCapacity();
		775	step.result_stderr = "";
		776	step.result_cached = false;
		777	step.result_duration_ns = null;
		778	step.result_peak_rss = 0;
		779	step.test_results = .{};
		780
		781	step.result_error_bundle.deinit(gpa);
		782	step.result_error_bundle = std.zig.ErrorBundle.empty;
		783	}
		784
		785	/// Implementation detail of file watching. Prepares the step for being re-evaluated.
		786	pub fn recursiveReset(step: *Step, gpa: Allocator) void {
		787	assert(step.state != .precheck_done);
		788	step.state = .precheck_done;
		789	step.reset(gpa);
		790	for (step.dependants.items) \|dep\| {
		791	if (dep.state == .precheck_done) continue;
		792	dep.recursiveReset(gpa);
		793	}
		794	}
		795
565	test {	796	test {
566	_ = CheckFile;	797	_ = CheckFile;
567	_ = CheckObject;	798	_ = CheckObject;
...	@@ -577,4 +808,5 @@ test {	...	@@ -577,4 +808,5 @@ test {
577	_ = Run;	808	_ = Run;
578	_ = TranslateC;	809	_ = TranslateC;
579	_ = WriteFile;	810	_ = WriteFile;
		811	_ = UpdateSourceFiles;
580	}	812	}

lib/std/Build/Step/CheckFile.zig+1

...	@@ -50,6 +50,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -50,6 +50,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
50	_ = prog_node;	50	_ = prog_node;
51	const b = step.owner;	51	const b = step.owner;
52	const check_file: *CheckFile = @fieldParentPtr("step", step);	52	const check_file: *CheckFile = @fieldParentPtr("step", step);
		53	try step.singleUnchangingWatchInput(check_file.source);
53		54
54	const src_path = check_file.source.getPath2(b, step);	55	const src_path = check_file.source.getPath2(b, step);
55	const contents = fs.cwd().readFileAlloc(b.allocator, src_path, check_file.max_bytes) catch \|err\| {	56	const contents = fs.cwd().readFileAlloc(b.allocator, src_path, check_file.max_bytes) catch \|err\| {

lib/std/Build/Step/CheckObject.zig+1

...	@@ -555,6 +555,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -555,6 +555,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
555	const b = step.owner;	555	const b = step.owner;
556	const gpa = b.allocator;	556	const gpa = b.allocator;
557	const check_object: *CheckObject = @fieldParentPtr("step", step);	557	const check_object: *CheckObject = @fieldParentPtr("step", step);
		558	try step.singleUnchangingWatchInput(check_object.source);
558		559
559	const src_path = check_object.source.getPath2(b, step);	560	const src_path = check_object.source.getPath2(b, step);
560	const contents = fs.cwd().readFileAllocOptions(	561	const contents = fs.cwd().readFileAllocOptions(

lib/std/Build/Step/ConfigHeader.zig+2

...	@@ -168,6 +168,8 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -168,6 +168,8 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
168	_ = prog_node;	168	_ = prog_node;
169	const b = step.owner;	169	const b = step.owner;
170	const config_header: *ConfigHeader = @fieldParentPtr("step", step);	170	const config_header: *ConfigHeader = @fieldParentPtr("step", step);
		171	if (config_header.style.getPath()) \|lp\| try step.singleUnchangingWatchInput(lp);
		172
171	const gpa = b.allocator;	173	const gpa = b.allocator;
172	const arena = b.allocator;	174	const arena = b.allocator;
173		175

lib/std/Build/Step/InstallDir.zig+16-11

 @@ -41,7 +41,6 @@ pub const Options = struct {
 };
 pub fn create(owner: *std.Build, options: Options) *InstallDir {
-    owner.pushInstalledFile(options.install_dir, options.install_subdir);
     const install_dir = owner.allocator.create(InstallDir) catch @panic("OOM");
     install_dir.* = .{
         .step = Step.init(.{
 @@ -60,12 +59,14 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
     _ = prog_node;
     const b = step.owner;
     const install_dir: *InstallDir = @fieldParentPtr("step", step);
+    step.clearWatchInputs();
     const arena = b.allocator;
     const dest_prefix = b.getInstallPath(install_dir.options.install_dir, install_dir.options.install_subdir);
-    const src_dir_path = install_dir.options.source_dir.getPath2(b, step);
+    const src_dir_path = install_dir.options.source_dir.getPath3(b, step);
-    var src_dir = b.build_root.handle.openDir(src_dir_path, .{ .iterate = true }) catch |err| {
+    const need_derived_inputs = try step.addDirectoryWatchInput(install_dir.options.source_dir);
-        return step.fail("unable to open source directory '{}{s}': {s}", .{
+    var src_dir = src_dir_path.root_dir.handle.openDir(src_dir_path.subPathOrDot(), .{ .iterate = true }) catch |err| {
-            b.build_root, src_dir_path, @errorName(err),
+        return step.fail("unable to open source directory '{}': {s}", .{
+            src_dir_path, @errorName(err),
         });
     };
     defer src_dir.close();
 @@ -89,12 +90,16 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
         }
         // relative to src build root
-        const src_sub_path = b.pathJoin(&.{ src_dir_path, entry.path });
+        const src_sub_path = try src_dir_path.join(arena, entry.path);
         const dest_path = b.pathJoin(&.{ dest_prefix, entry.path });
         const cwd = fs.cwd();
         switch (entry.kind) {
-            .directory => try cwd.makePath(dest_path),
+            .directory => {
+                if (need_derived_inputs) try step.addDirectoryWatchInputFromPath(src_sub_path);
+                try cwd.makePath(dest_path);
+                // TODO: set result_cached=false if the directory did not already exist.
+            },
             .file => {
                 for (install_dir.options.blank_extensions) |ext| {
                     if (mem.endsWith(u8, entry.path, ext)) {
 @@ -104,14 +109,14 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
                 }
                 const prev_status = fs.Dir.updateFile(
-                    b.build_root.handle,
+                    src_sub_path.root_dir.handle,
-                    src_sub_path,
+                    src_sub_path.sub_path,
                     cwd,
                     dest_path,
                     .{},
                 ) catch |err| {
-                    return step.fail("unable to update file from '{}{s}' to '{s}': {s}", .{
+                    return step.fail("unable to update file from '{}' to '{s}': {s}", .{
-                        b.build_root, src_sub_path, dest_path, @errorName(err),
+                        src_sub_path, dest_path, @errorName(err),
                     });
                 };
                 all_cached = all_cached and prev_status == .fresh;

lib/std/Build/Step/InstallFile.zig+2-1

...	@@ -19,7 +19,6 @@ pub fn create(	...	@@ -19,7 +19,6 @@ pub fn create(
19	dest_rel_path: []const u8,	19	dest_rel_path: []const u8,
20	) *InstallFile {	20	) *InstallFile {
21	assert(dest_rel_path.len != 0);	21	assert(dest_rel_path.len != 0);
22	owner.pushInstalledFile(dir, dest_rel_path);
23	const install_file = owner.allocator.create(InstallFile) catch @panic("OOM");	22	const install_file = owner.allocator.create(InstallFile) catch @panic("OOM");
24	install_file.* = .{	23	install_file.* = .{
25	.step = Step.init(.{	24	.step = Step.init(.{
...	@@ -40,6 +39,8 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -40,6 +39,8 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
40	_ = prog_node;	39	_ = prog_node;
41	const b = step.owner;	40	const b = step.owner;
42	const install_file: *InstallFile = @fieldParentPtr("step", step);	41	const install_file: *InstallFile = @fieldParentPtr("step", step);
		42	try step.singleUnchangingWatchInput(install_file.source);
		43
43	const full_src_path = install_file.source.getPath2(b, step);	44	const full_src_path = install_file.source.getPath2(b, step);
44	const full_dest_path = b.getInstallPath(install_file.dir, install_file.dest_rel_path);	45	const full_dest_path = b.getInstallPath(install_file.dir, install_file.dest_rel_path);
45	const cwd = std.fs.cwd();	46	const cwd = std.fs.cwd();

lib/std/Build/Step/ObjCopy.zig+1-4

 @@ -93,14 +93,11 @@ pub fn getOutputSeparatedDebug(objcopy: *const ObjCopy) ?std.Build.LazyPath {
 fn make(step: *Step, prog_node: std.Progress.Node) !void {
     const b = step.owner;
     const objcopy: *ObjCopy = @fieldParentPtr("step", step);
+    try step.singleUnchangingWatchInput(objcopy.input_file);
     var man = b.graph.cache.obtain();
     defer man.deinit();
-    // Random bytes to make ObjCopy unique. Refresh this with new random
-    // bytes when ObjCopy implementation is modified incompatibly.
-    man.hash.add(@as(u32, 0xe18b7baf));
     const full_src_path = objcopy.input_file.getPath2(b, step);
     _ = try man.addFile(full_src_path, null);
     man.hash.addOptionalBytes(objcopy.only_section);

lib/std/Build/Step/Options.zig+4

...	@@ -424,6 +424,9 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -424,6 +424,9 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
424	item.path.getPath2(b, step),	424	item.path.getPath2(b, step),
425	);	425	);
426	}	426	}
		427	if (!step.inputs.populated()) for (options.args.items) \|item\| {
		428	try step.addWatchInput(item.path);
		429	};
427		430
428	const basename = "options.zig";	431	const basename = "options.zig";
429		432
...	@@ -520,6 +523,7 @@ test Options {	...	@@ -520,6 +523,7 @@ test Options {
520	.query = .{},	523	.query = .{},
521	.result = try std.zig.system.resolveTargetQuery(.{}),	524	.result = try std.zig.system.resolveTargetQuery(.{}),
522	},	525	},
		526	.zig_lib_directory = std.Build.Cache.Directory.cwd(),
523	};	527	};
524		528
525	var builder = try std.Build.create(	529	var builder = try std.Build.create(

lib/std/Build/Step/RemoveDir.zig+13-7

 @@ -2,22 +2,23 @@ const std = @import("std");
 const fs = std.fs;
 const Step = std.Build.Step;
 const RemoveDir = @This();
+const LazyPath = std.Build.LazyPath;
 pub const base_id: Step.Id = .remove_dir;
 step: Step,
-dir_path: []const u8,
+doomed_path: LazyPath,
-pub fn create(owner: *std.Build, dir_path: []const u8) *RemoveDir {
+pub fn create(owner: *std.Build, doomed_path: LazyPath) *RemoveDir {
     const remove_dir = owner.allocator.create(RemoveDir) catch @panic("OOM");
     remove_dir.* = .{
         .step = Step.init(.{
             .id = base_id,
-            .name = owner.fmt("RemoveDir {s}", .{dir_path}),
+            .name = owner.fmt("RemoveDir {s}", .{doomed_path.getDisplayName()}),
             .owner = owner,
             .makeFn = make,
         }),
-        .dir_path = owner.dupePath(dir_path),
+        .doomed_path = doomed_path.dupe(owner),
     };
     return remove_dir;
 }
 @@ -30,14 +31,19 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
     const b = step.owner;
     const remove_dir: *RemoveDir = @fieldParentPtr("step", step);
-    b.build_root.handle.deleteTree(remove_dir.dir_path) catch |err| {
+    step.clearWatchInputs();
+    try step.addWatchInput(remove_dir.doomed_path);
+    const full_doomed_path = remove_dir.doomed_path.getPath2(b, step);
+    b.build_root.handle.deleteTree(full_doomed_path) catch |err| {
         if (b.build_root.path) |base| {
             return step.fail("unable to recursively delete path '{s}/{s}': {s}", .{
-                base, remove_dir.dir_path, @errorName(err),
+                base, full_doomed_path, @errorName(err),
             });
         } else {
             return step.fail("unable to recursively delete path '{s}': {s}", .{
-                remove_dir.dir_path, @errorName(err),
+                full_doomed_path, @errorName(err),
             });
         }
     };

lib/std/Build/Step/Run.zig+4-4

lib/std/Build/Step/UpdateSourceFiles.zig created+114

...	@@ -0,0 +1,114 @@
1	//! Writes data to paths relative to the package root, effectively mutating the
2	//! package's source files. Be careful with the latter functionality; it should
3	//! not be used during the normal build process, but as a utility run by a
4	//! developer with intention to update source files, which will then be
5	//! committed to version control.
6	const std = @import("std");
7	const Step = std.Build.Step;
8	const fs = std.fs;
9	const ArrayList = std.ArrayList;
10	const UpdateSourceFiles = @This();
11
12	step: Step,
13	output_source_files: std.ArrayListUnmanaged(OutputSourceFile),
14
15	pub const base_id: Step.Id = .update_source_files;
16
17	pub const OutputSourceFile = struct {
18	contents: Contents,
19	sub_path: []const u8,
20	};
21
22	pub const Contents = union(enum) {
23	bytes: []const u8,
24	copy: std.Build.LazyPath,
25	};
26
27	pub fn create(owner: std.Build) UpdateSourceFiles {
28	const usf = owner.allocator.create(UpdateSourceFiles) catch @panic("OOM");
29	usf.* = .{
30	.step = Step.init(.{
31	.id = base_id,
32	.name = "UpdateSourceFiles",
33	.owner = owner,
34	.makeFn = make,
35	}),
36	.output_source_files = .{},
37	};
38	return usf;
39	}
40
41	/// A path relative to the package root.
42	///
43	/// Be careful with this because it updates source files. This should not be
44	/// used as part of the normal build process, but as a utility occasionally
45	/// run by a developer with intent to modify source files and then commit
46	/// those changes to version control.
47	pub fn addCopyFileToSource(usf: *UpdateSourceFiles, source: std.Build.LazyPath, sub_path: []const u8) void {
48	const b = usf.step.owner;
49	usf.output_source_files.append(b.allocator, .{
50	.contents = .{ .copy = source },
51	.sub_path = sub_path,
52	}) catch @panic("OOM");
53	source.addStepDependencies(&usf.step);
54	}
55
56	/// A path relative to the package root.
57	///
58	/// Be careful with this because it updates source files. This should not be
59	/// used as part of the normal build process, but as a utility occasionally
60	/// run by a developer with intent to modify source files and then commit
61	/// those changes to version control.
62	pub fn addBytesToSource(usf: *UpdateSourceFiles, bytes: []const u8, sub_path: []const u8) void {
63	const b = usf.step.owner;
64	usf.output_source_files.append(b.allocator, .{
65	.contents = .{ .bytes = bytes },
66	.sub_path = sub_path,
67	}) catch @panic("OOM");
68	}
69
70	fn make(step: *Step, prog_node: std.Progress.Node) !void {
71	_ = prog_node;
72	const b = step.owner;
73	const usf: *UpdateSourceFiles = @fieldParentPtr("step", step);
74
75	var any_miss = false;
76	for (usf.output_source_files.items) \|output_source_file\| {
77	if (fs.path.dirname(output_source_file.sub_path)) \|dirname\| {
78	b.build_root.handle.makePath(dirname) catch \|err\| {
79	return step.fail("unable to make path '{}{s}': {s}", .{
80	b.build_root, dirname, @errorName(err),
81	});
82	};
83	}
84	switch (output_source_file.contents) {
85	.bytes => \|bytes\| {
86	b.build_root.handle.writeFile(.{ .sub_path = output_source_file.sub_path, .data = bytes }) catch \|err\| {
87	return step.fail("unable to write file '{}{s}': {s}", .{
88	b.build_root, output_source_file.sub_path, @errorName(err),
89	});
90	};
91	any_miss = true;
92	},
93	.copy => \|file_source\| {
94	if (!step.inputs.populated()) try step.addWatchInput(file_source);
95
96	const source_path = file_source.getPath2(b, step);
97	const prev_status = fs.Dir.updateFile(
98	fs.cwd(),
99	source_path,
100	b.build_root.handle,
101	output_source_file.sub_path,
102	.{},
103	) catch \|err\| {
104	return step.fail("unable to update file from '{s}' to '{}{s}': {s}", .{
105	source_path, b.build_root, output_source_file.sub_path, @errorName(err),
106	});
107	};
108	any_miss = any_miss or prev_status == .stale;
109	},
110	}
111	}
112
113	step.result_cached = !any_miss;
114	}

lib/std/Build/Step/WriteFile.zig+83-126

...	@@ -1,13 +1,6 @@	...	@@ -1,13 +1,6 @@
1	//! WriteFile is primarily used to create a directory in an appropriate	1	//! WriteFile is used to create a directory in an appropriate location inside
2	//! location inside the local cache which has a set of files that have either	2	//! the local cache which has a set of files that have either been generated
3	//! been generated during the build, or are copied from the source package.	3	//! during the build, or are copied from the source package.
4	//!
5	//! However, this step has an additional capability of writing data to paths
6	//! relative to the package root, effectively mutating the package's source
7	//! files. Be careful with the latter functionality; it should not be used
8	//! during the normal build process, but as a utility run by a developer with
9	//! intention to update source files, which will then be committed to version
10	//! control.
11	const std = @import("std");	4	const std = @import("std");
12	const Step = std.Build.Step;	5	const Step = std.Build.Step;
13	const fs = std.fs;	6	const fs = std.fs;
...	@@ -19,8 +12,6 @@ step: Step,	...	@@ -19,8 +12,6 @@ step: Step,
19	// The elements here are pointers because we need stable pointers for the GeneratedFile field.	12	// The elements here are pointers because we need stable pointers for the GeneratedFile field.
20	files: std.ArrayListUnmanaged(File),	13	files: std.ArrayListUnmanaged(File),
21	directories: std.ArrayListUnmanaged(Directory),	14	directories: std.ArrayListUnmanaged(Directory),
22
23	output_source_files: std.ArrayListUnmanaged(OutputSourceFile),
24	generated_directory: std.Build.GeneratedFile,	15	generated_directory: std.Build.GeneratedFile,
25		16
26	pub const base_id: Step.Id = .write_file;	17	pub const base_id: Step.Id = .write_file;
...	@@ -49,12 +40,23 @@ pub const Directory = struct {	...	@@ -49,12 +40,23 @@ pub const Directory = struct {
49	.include_extensions = if (opts.include_extensions) \|incs\| b.dupeStrings(incs) else null,	40	.include_extensions = if (opts.include_extensions) \|incs\| b.dupeStrings(incs) else null,
50	};	41	};
51	}	42	}
52	};
53	};
54		43
55	pub const OutputSourceFile = struct {	44	pub fn pathIncluded(opts: Options, path: []const u8) bool {
56	contents: Contents,	45	for (opts.exclude_extensions) \|ext\| {
57	sub_path: []const u8,	46	if (std.mem.endsWith(u8, path, ext))
		47	return false;
		48	}
		49	if (opts.include_extensions) \|incs\| {
		50	for (incs) \|inc\| {
		51	if (std.mem.endsWith(u8, path, inc))
		52	return true;
		53	} else {
		54	return false;
		55	}
		56	}
		57	return true;
		58	}
		59	};
58	};	60	};
59		61
60	pub const Contents = union(enum) {	62	pub const Contents = union(enum) {
...	@@ -73,7 +75,6 @@ pub fn create(owner: std.Build) WriteFile {	...	@@ -73,7 +75,6 @@ pub fn create(owner: std.Build) WriteFile {
73	}),	75	}),
74	.files = .{},	76	.files = .{},
75	.directories = .{},	77	.directories = .{},
76	.output_source_files = .{},
77	.generated_directory = .{ .step = &write_file.step },	78	.generated_directory = .{ .step = &write_file.step },
78	};	79	};
79	return write_file;	80	return write_file;
...	@@ -150,33 +151,6 @@ pub fn addCopyDirectory(	...	@@ -150,33 +151,6 @@ pub fn addCopyDirectory(
150	};	151	};
151	}	152	}
152		153
153	/// A path relative to the package root.
154	/// Be careful with this because it updates source files. This should not be
155	/// used as part of the normal build process, but as a utility occasionally
156	/// run by a developer with intent to modify source files and then commit
157	/// those changes to version control.
158	pub fn addCopyFileToSource(write_file: *WriteFile, source: std.Build.LazyPath, sub_path: []const u8) void {
159	const b = write_file.step.owner;
160	write_file.output_source_files.append(b.allocator, .{
161	.contents = .{ .copy = source },
162	.sub_path = sub_path,
163	}) catch @panic("OOM");
164	source.addStepDependencies(&write_file.step);
165	}
166
167	/// A path relative to the package root.
168	/// Be careful with this because it updates source files. This should not be
169	/// used as part of the normal build process, but as a utility occasionally
170	/// run by a developer with intent to modify source files and then commit
171	/// those changes to version control.
172	pub fn addBytesToSource(write_file: *WriteFile, bytes: []const u8, sub_path: []const u8) void {
173	const b = write_file.step.owner;
174	write_file.output_source_files.append(b.allocator, .{
175	.contents = .{ .bytes = bytes },
176	.sub_path = sub_path,
177	}) catch @panic("OOM");
178	}
179
180	/// Returns a `LazyPath` representing the base directory that contains all the	154	/// Returns a `LazyPath` representing the base directory that contains all the
181	/// files from this `WriteFile`.	155	/// files from this `WriteFile`.
182	pub fn getDirectory(write_file: *WriteFile) std.Build.LazyPath {	156	pub fn getDirectory(write_file: *WriteFile) std.Build.LazyPath {
...	@@ -200,47 +174,10 @@ fn maybeUpdateName(write_file: *WriteFile) void {	...	@@ -200,47 +174,10 @@ fn maybeUpdateName(write_file: *WriteFile) void {
200	fn make(step: *Step, prog_node: std.Progress.Node) !void {	174	fn make(step: *Step, prog_node: std.Progress.Node) !void {
201	_ = prog_node;	175	_ = prog_node;
202	const b = step.owner;	176	const b = step.owner;
		177	const arena = b.allocator;
		178	const gpa = arena;
203	const write_file: *WriteFile = @fieldParentPtr("step", step);	179	const write_file: *WriteFile = @fieldParentPtr("step", step);
204		180	step.clearWatchInputs();
205	// Writing to source files is kind of an extra capability of this
206	// WriteFile - arguably it should be a different step. But anyway here
207	// it is, it happens unconditionally and does not interact with the other
208	// files here.
209	var any_miss = false;
210	for (write_file.output_source_files.items) \|output_source_file\| {
211	if (fs.path.dirname(output_source_file.sub_path)) \|dirname\| {
212	b.build_root.handle.makePath(dirname) catch \|err\| {
213	return step.fail("unable to make path '{}{s}': {s}", .{
214	b.build_root, dirname, @errorName(err),
215	});
216	};
217	}
218	switch (output_source_file.contents) {
219	.bytes => \|bytes\| {
220	b.build_root.handle.writeFile(.{ .sub_path = output_source_file.sub_path, .data = bytes }) catch \|err\| {
221	return step.fail("unable to write file '{}{s}': {s}", .{
222	b.build_root, output_source_file.sub_path, @errorName(err),
223	});
224	};
225	any_miss = true;
226	},
227	.copy => \|file_source\| {
228	const source_path = file_source.getPath2(b, step);
229	const prev_status = fs.Dir.updateFile(
230	fs.cwd(),
231	source_path,
232	b.build_root.handle,
233	output_source_file.sub_path,
234	.{},
235	) catch \|err\| {
236	return step.fail("unable to update file from '{s}' to '{}{s}': {s}", .{
237	source_path, b.build_root, output_source_file.sub_path, @errorName(err),
238	});
239	};
240	any_miss = any_miss or prev_status == .stale;
241	},
242	}
243	}
244		181
245	// The cache is used here not really as a way to speed things up - because writing	182	// The cache is used here not really as a way to speed things up - because writing
246	// the data to a file would probably be very fast - but as a way to find a canonical	183	// the data to a file would probably be very fast - but as a way to find a canonical
...	@@ -252,39 +189,73 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -252,39 +189,73 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
252	var man = b.graph.cache.obtain();	189	var man = b.graph.cache.obtain();
253	defer man.deinit();	190	defer man.deinit();
254		191
255	// Random bytes to make WriteFile unique. Refresh this with
256	// new random bytes when WriteFile implementation is modified
257	// in a non-backwards-compatible way.
258	man.hash.add(@as(u32, 0xd767ee59));
259
260	for (write_file.files.items) \|file\| {	192	for (write_file.files.items) \|file\| {
261	man.hash.addBytes(file.sub_path);	193	man.hash.addBytes(file.sub_path);
		194
262	switch (file.contents) {	195	switch (file.contents) {
263	.bytes => \|bytes\| {	196	.bytes => \|bytes\| {
264	man.hash.addBytes(bytes);	197	man.hash.addBytes(bytes);
265	},	198	},
266	.copy => \|file_source\| {	199	.copy => \|lazy_path\| {
267	_ = try man.addFile(file_source.getPath2(b, step), null);	200	const path = lazy_path.getPath3(b, step);
		201	_ = try man.addFilePath(path, null);
		202	try step.addWatchInput(lazy_path);
268	},	203	},
269	}	204	}
270	}	205	}
271	for (write_file.directories.items) \|dir\| {	206
272	man.hash.addBytes(dir.source.getPath2(b, step));	207	const open_dir_cache = try arena.alloc(fs.Dir, write_file.directories.items.len);
		208	var open_dirs_count: usize = 0;
		209	defer closeDirs(open_dir_cache[0..open_dirs_count]);
		210
		211	for (write_file.directories.items, open_dir_cache) \|dir, *open_dir_cache_elem\| {
273	man.hash.addBytes(dir.sub_path);	212	man.hash.addBytes(dir.sub_path);
274	for (dir.options.exclude_extensions) \|ext\| man.hash.addBytes(ext);	213	for (dir.options.exclude_extensions) \|ext\| man.hash.addBytes(ext);
275	if (dir.options.include_extensions) \|incs\| for (incs) \|inc\| man.hash.addBytes(inc);	214	if (dir.options.include_extensions) \|incs\| for (incs) \|inc\| man.hash.addBytes(inc);
		215
		216	const need_derived_inputs = try step.addDirectoryWatchInput(dir.source);
		217	const src_dir_path = dir.source.getPath3(b, step);
		218
		219	var src_dir = src_dir_path.root_dir.handle.openDir(src_dir_path.subPathOrDot(), .{ .iterate = true }) catch \|err\| {
		220	return step.fail("unable to open source directory '{}': {s}", .{
		221	src_dir_path, @errorName(err),
		222	});
		223	};
		224	open_dir_cache_elem.* = src_dir;
		225	open_dirs_count += 1;
		226
		227	var it = try src_dir.walk(gpa);
		228	defer it.deinit();
		229	while (try it.next()) \|entry\| {
		230	if (!dir.options.pathIncluded(entry.path)) continue;
		231
		232	switch (entry.kind) {
		233	.directory => {
		234	if (need_derived_inputs) {
		235	const entry_path = try src_dir_path.join(arena, entry.path);
		236	try step.addDirectoryWatchInputFromPath(entry_path);
		237	}
		238	},
		239	.file => {
		240	const entry_path = try src_dir_path.join(arena, entry.path);
		241	_ = try man.addFilePath(entry_path, null);
		242	},
		243	else => continue,
		244	}
		245	}
276	}	246	}
277		247
278	if (try step.cacheHit(&man)) {	248	if (try step.cacheHit(&man)) {
279	const digest = man.final();	249	const digest = man.final();
280	write_file.generated_directory.path = try b.cache_root.join(b.allocator, &.{ "o", &digest });	250	write_file.generated_directory.path = try b.cache_root.join(arena, &.{ "o", &digest });
		251	step.result_cached = true;
281	return;	252	return;
282	}	253	}
283		254
284	const digest = man.final();	255	const digest = man.final();
285	const cache_path = "o" ++ fs.path.sep_str ++ digest;	256	const cache_path = "o" ++ fs.path.sep_str ++ digest;
286		257
287	write_file.generated_directory.path = try b.cache_root.join(b.allocator, &.{ "o", &digest });	258	write_file.generated_directory.path = try b.cache_root.join(arena, &.{ "o", &digest });
288		259
289	var cache_dir = b.cache_root.handle.makeOpenPath(cache_path, .{}) catch \|err\| {	260	var cache_dir = b.cache_root.handle.makeOpenPath(cache_path, .{}) catch \|err\| {
290	return step.fail("unable to make path '{}{s}': {s}", .{	261	return step.fail("unable to make path '{}{s}': {s}", .{
...	@@ -337,8 +308,9 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -337,8 +308,9 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
337	},	308	},
338	}	309	}
339	}	310	}
340	for (write_file.directories.items) \|dir\| {	311
341	const full_src_dir_path = dir.source.getPath2(b, step);	312	for (write_file.directories.items, open_dir_cache) \|dir, already_open_dir\| {
		313	const src_dir_path = dir.source.getPath3(b, step);
342	const dest_dirname = dir.sub_path;	314	const dest_dirname = dir.sub_path;
343		315
344	if (dest_dirname.len != 0) {	316	if (dest_dirname.len != 0) {
...	@@ -349,44 +321,25 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -349,44 +321,25 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
349	};	321	};
350	}	322	}
351		323
352	var src_dir = b.build_root.handle.openDir(full_src_dir_path, .{ .iterate = true }) catch \|err\| {	324	var it = try already_open_dir.walk(gpa);
353	return step.fail("unable to open source directory '{s}': {s}", .{	325	defer it.deinit();
354	full_src_dir_path, @errorName(err),	326	while (try it.next()) \|entry\| {
355	});	327	if (!dir.options.pathIncluded(entry.path)) continue;
356	};
357	defer src_dir.close();
358		328
359	var it = try src_dir.walk(b.allocator);	329	const src_entry_path = try src_dir_path.join(arena, entry.path);
360	next_entry: while (try it.next()) \|entry\| {
361	for (dir.options.exclude_extensions) \|ext\| {
362	if (std.mem.endsWith(u8, entry.path, ext)) continue :next_entry;
363	}
364	if (dir.options.include_extensions) \|incs\| {
365	for (incs) \|inc\| {
366	if (std.mem.endsWith(u8, entry.path, inc)) break;
367	} else {
368	continue :next_entry;
369	}
370	}
371	const full_src_entry_path = b.pathJoin(&.{ full_src_dir_path, entry.path });
372	const dest_path = b.pathJoin(&.{ dest_dirname, entry.path });	330	const dest_path = b.pathJoin(&.{ dest_dirname, entry.path });
373	switch (entry.kind) {	331	switch (entry.kind) {
374	.directory => try cache_dir.makePath(dest_path),	332	.directory => try cache_dir.makePath(dest_path),
375	.file => {	333	.file => {
376	const prev_status = fs.Dir.updateFile(	334	const prev_status = fs.Dir.updateFile(
377	cwd,	335	src_entry_path.root_dir.handle,
378	full_src_entry_path,	336	src_entry_path.sub_path,
379	cache_dir,	337	cache_dir,
380	dest_path,	338	dest_path,
381	.{},	339	.{},
382	) catch \|err\| {	340	) catch \|err\| {
383	return step.fail("unable to update file from '{s}' to '{}{s}{c}{s}': {s}", .{	341	return step.fail("unable to update file from '{}' to '{}{s}{c}{s}': {s}", .{
384	full_src_entry_path,	342	src_entry_path, b.cache_root, cache_path, fs.path.sep, dest_path, @errorName(err),
385	b.cache_root,
386	cache_path,
387	fs.path.sep,
388	dest_path,
389	@errorName(err),
390	});	343	});
391	};	344	};
392	_ = prev_status;	345	_ = prev_status;
...	@@ -398,3 +351,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -398,3 +351,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
398		351
399	try step.writeManifest(&man);	352	try step.writeManifest(&man);
400	}	353	}
		354
		355	fn closeDirs(dirs: []fs.Dir) void {
		356	for (dirs) \|*d\| d.close();
		357	}

lib/std/Build/Watch.zig created+363

...	@@ -0,0 +1,363 @@
1	const builtin = @import("builtin");
2	const std = @import("../std.zig");
3	const Watch = @This();
4	const Step = std.Build.Step;
5	const Allocator = std.mem.Allocator;
6	const assert = std.debug.assert;
7	const fatal = std.zig.fatal;
8
9	dir_table: DirTable,
10	os: Os,
11	generation: Generation,
12
13	/// Key is the directory to watch which contains one or more files we are
14	/// interested in noticing changes to.
15	///
16	/// Value is generation.
17	const DirTable = std.ArrayHashMapUnmanaged(Cache.Path, void, Cache.Path.TableAdapter, false);
18
19	/// Special key of "." means any changes in this directory trigger the steps.
20	const ReactionSet = std.StringArrayHashMapUnmanaged(StepSet);
21	const StepSet = std.AutoArrayHashMapUnmanaged(*Step, Generation);
22
23	const Generation = u8;
24
25	const Hash = std.hash.Wyhash;
26	const Cache = std.Build.Cache;
27
28	const Os = switch (builtin.os.tag) {
29	.linux => struct {
30	const posix = std.posix;
31
32	/// Keyed differently but indexes correspond 1:1 with `dir_table`.
33	handle_table: HandleTable,
34	poll_fds: [1]posix.pollfd,
35
36	const HandleTable = std.ArrayHashMapUnmanaged(FileHandle, ReactionSet, FileHandle.Adapter, false);
37
38	const fan_mask: std.os.linux.fanotify.MarkMask = .{
39	.CLOSE_WRITE = true,
40	.CREATE = true,
41	.DELETE = true,
42	.DELETE_SELF = true,
43	.EVENT_ON_CHILD = true,
44	.MOVED_FROM = true,
45	.MOVED_TO = true,
46	.MOVE_SELF = true,
47	.ONDIR = true,
48	};
49
50	const FileHandle = struct {
51	handle: *align(1) std.os.linux.file_handle,
52
53	fn clone(lfh: FileHandle, gpa: Allocator) Allocator.Error!FileHandle {
54	const bytes = lfh.slice();
55	const new_ptr = try gpa.alignedAlloc(
56	u8,
57	@alignOf(std.os.linux.file_handle),
58	@sizeOf(std.os.linux.file_handle) + bytes.len,
59	);
60	const new_header: *std.os.linux.file_handle = @ptrCast(new_ptr);
61	new_header.* = lfh.handle.*;
62	const new: FileHandle = .{ .handle = new_header };
63	@memcpy(new.slice(), lfh.slice());
64	return new;
65	}
66
67	fn destroy(lfh: FileHandle, gpa: Allocator) void {
68	const ptr: [*]u8 = @ptrCast(lfh.handle);
69	const allocated_slice = ptr[0 .. @sizeOf(std.os.linux.file_handle) + lfh.handle.handle_bytes];
70	return gpa.free(allocated_slice);
71	}
72
73	fn slice(lfh: FileHandle) []u8 {
74	const ptr: [*]u8 = &lfh.handle.f_handle;
75	return ptr[0..lfh.handle.handle_bytes];
76	}
77
78	const Adapter = struct {
79	pub fn hash(self: Adapter, a: FileHandle) u32 {
80	_ = self;
81	const unsigned_type: u32 = @bitCast(a.handle.handle_type);
82	return @truncate(Hash.hash(unsigned_type, a.slice()));
83	}
84	pub fn eql(self: Adapter, a: FileHandle, b: FileHandle, b_index: usize) bool {
85	_ = self;
86	_ = b_index;
87	return a.handle.handle_type == b.handle.handle_type and std.mem.eql(u8, a.slice(), b.slice());
88	}
89	};
90	};
91
92	fn getDirHandle(gpa: Allocator, path: std.Build.Cache.Path) !FileHandle {
93	var file_handle_buffer: [@sizeOf(std.os.linux.file_handle) + 128]u8 align(@alignOf(std.os.linux.file_handle)) = undefined;
94	var mount_id: i32 = undefined;
95	var buf: [std.fs.max_path_bytes]u8 = undefined;
96	const adjusted_path = if (path.sub_path.len == 0) "./" else std.fmt.bufPrint(&buf, "{s}/", .{
97	path.sub_path,
98	}) catch return error.NameTooLong;
99	const stack_ptr: *std.os.linux.file_handle = @ptrCast(&file_handle_buffer);
100	stack_ptr.handle_bytes = file_handle_buffer.len - @sizeOf(std.os.linux.file_handle);
101	try posix.name_to_handle_at(path.root_dir.handle.fd, adjusted_path, stack_ptr, &mount_id, std.os.linux.AT.HANDLE_FID);
102	const stack_lfh: FileHandle = .{ .handle = stack_ptr };
103	return stack_lfh.clone(gpa);
104	}
105
106	fn markDirtySteps(w: *Watch, gpa: Allocator) !bool {
107	const fan_fd = w.os.getFanFd();
108	const fanotify = std.os.linux.fanotify;
109	const M = fanotify.event_metadata;
110	var events_buf: [256 + 4096]u8 = undefined;
111	var any_dirty = false;
112	while (true) {
113	var len = posix.read(fan_fd, &events_buf) catch \|err\| switch (err) {
114	error.WouldBlock => return any_dirty,
115	else => \|e\| return e,
116	};
117	var meta: [*]align(1) M = @ptrCast(&events_buf);
118	while (len >= @sizeOf(M) and meta[0].event_len >= @sizeOf(M) and meta[0].event_len <= len) : ({
119	len -= meta[0].event_len;
120	meta = @ptrCast(@as([*]u8, @ptrCast(meta)) + meta[0].event_len);
121	}) {
122	assert(meta[0].vers == M.VERSION);
123	if (meta[0].mask.Q_OVERFLOW) {
124	any_dirty = true;
125	std.log.warn("file system watch queue overflowed; falling back to fstat", .{});
126	markAllFilesDirty(w, gpa);
127	return true;
128	}
129	const fid: *align(1) fanotify.event_info_fid = @ptrCast(meta + 1);
130	switch (fid.hdr.info_type) {
131	.DFID_NAME => {
132	const file_handle: *align(1) std.os.linux.file_handle = @ptrCast(&fid.handle);
133	const file_name_z: [*:0]u8 = @ptrCast((&file_handle.f_handle).ptr + file_handle.handle_bytes);
134	const file_name = std.mem.span(file_name_z);
135	const lfh: FileHandle = .{ .handle = file_handle };
136	if (w.os.handle_table.getPtr(lfh)) \|reaction_set\| {
137	if (reaction_set.getPtr(".")) \|glob_set\|
138	any_dirty = markStepSetDirty(gpa, glob_set, any_dirty);
139	if (reaction_set.getPtr(file_name)) \|step_set\|
140	any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
141	}
142	},
143	else => \|t\| std.log.warn("unexpected fanotify event '{s}'", .{@tagName(t)}),
144	}
145	}
146	}
147	}
148
149	fn getFanFd(os: *const @This()) posix.fd_t {
150	return os.poll_fds[0].fd;
151	}
152
153	fn update(w: Watch, gpa: Allocator, steps: []const Step) !void {
154	const fan_fd = w.os.getFanFd();
155	// Add missing marks and note persisted ones.
156	for (steps) \|step\| {
157	for (step.inputs.table.keys(), step.inputs.table.values()) \|path, *files\| {
158	const reaction_set = rs: {
159	const gop = try w.dir_table.getOrPut(gpa, path);
160	if (!gop.found_existing) {
161	const dir_handle = try Os.getDirHandle(gpa, path);
162	// `dir_handle` may already be present in the table in
163	// the case that we have multiple Cache.Path instances
164	// that compare inequal but ultimately point to the same
165	// directory on the file system.
166	// In such case, we must revert adding this directory, but keep
167	// the additions to the step set.
168	const dh_gop = try w.os.handle_table.getOrPut(gpa, dir_handle);
169	if (dh_gop.found_existing) {
170	_ = w.dir_table.pop();
171	} else {
172	assert(dh_gop.index == gop.index);
173	dh_gop.value_ptr.* = .{};
174	posix.fanotify_mark(fan_fd, .{
175	.ADD = true,
176	.ONLYDIR = true,
177	}, fan_mask, path.root_dir.handle.fd, path.subPathOrDot()) catch \|err\| {
178	fatal("unable to watch {}: {s}", .{ path, @errorName(err) });
179	};
180	}
181	break :rs dh_gop.value_ptr;
182	}
183	break :rs &w.os.handle_table.values()[gop.index];
184	};
185	for (files.items) \|basename\| {
186	const gop = try reaction_set.getOrPut(gpa, basename);
187	if (!gop.found_existing) gop.value_ptr.* = .{};
188	try gop.value_ptr.put(gpa, step, w.generation);
189	}
190	}
191	}
192
193	{
194	// Remove marks for files that are no longer inputs.
195	var i: usize = 0;
196	while (i < w.os.handle_table.entries.len) {
197	{
198	const reaction_set = &w.os.handle_table.values()[i];
199	var step_set_i: usize = 0;
200	while (step_set_i < reaction_set.entries.len) {
201	const step_set = &reaction_set.values()[step_set_i];
202	var dirent_i: usize = 0;
203	while (dirent_i < step_set.entries.len) {
204	const generations = step_set.values();
205	if (generations[dirent_i] == w.generation) {
206	dirent_i += 1;
207	continue;
208	}
209	step_set.swapRemoveAt(dirent_i);
210	}
211	if (step_set.entries.len > 0) {
212	step_set_i += 1;
213	continue;
214	}
215	reaction_set.swapRemoveAt(step_set_i);
216	}
217	if (reaction_set.entries.len > 0) {
218	i += 1;
219	continue;
220	}
221	}
222
223	const path = w.dir_table.keys()[i];
224
225	posix.fanotify_mark(fan_fd, .{
226	.REMOVE = true,
227	.ONLYDIR = true,
228	}, fan_mask, path.root_dir.handle.fd, path.subPathOrDot()) catch \|err\| switch (err) {
229	error.FileNotFound => {}, // Expected, harmless.
230	else => \|e\| std.log.warn("unable to unwatch '{}': {s}", .{ path, @errorName(e) }),
231	};
232
233	w.dir_table.swapRemoveAt(i);
234	w.os.handle_table.swapRemoveAt(i);
235	}
236	w.generation +%= 1;
237	}
238	}
239	},
240	else => void,
241	};
242
243	pub fn init() !Watch {
244	switch (builtin.os.tag) {
245	.linux => {
246	const fan_fd = try std.posix.fanotify_init(.{
247	.CLASS = .NOTIF,
248	.CLOEXEC = true,
249	.NONBLOCK = true,
250	.REPORT_NAME = true,
251	.REPORT_DIR_FID = true,
252	.REPORT_FID = true,
253	.REPORT_TARGET_FID = true,
254	}, 0);
255	return .{
256	.dir_table = .{},
257	.os = switch (builtin.os.tag) {
258	.linux => .{
259	.handle_table = .{},
260	.poll_fds = .{
261	.{
262	.fd = fan_fd,
263	.events = std.posix.POLL.IN,
264	.revents = undefined,
265	},
266	},
267	},
268	else => {},
269	},
270	.generation = 0,
271	};
272	},
273	else => @panic("unimplemented"),
274	}
275	}
276
277	pub const Match = struct {
278	/// Relative to the watched directory, the file path that triggers this
279	/// match.
280	basename: []const u8,
281	/// The step to re-run when file corresponding to `basename` is changed.
282	step: *Step,
283
284	pub const Context = struct {
285	pub fn hash(self: Context, a: Match) u32 {
286	_ = self;
287	var hasher = Hash.init(0);
288	std.hash.autoHash(&hasher, a.step);
289	hasher.update(a.basename);
290	return @truncate(hasher.final());
291	}
292	pub fn eql(self: Context, a: Match, b: Match, b_index: usize) bool {
293	_ = self;
294	_ = b_index;
295	return a.step == b.step and std.mem.eql(u8, a.basename, b.basename);
296	}
297	};
298	};
299
300	fn markAllFilesDirty(w: *Watch, gpa: Allocator) void {
301	for (w.os.handle_table.values()) \|reaction_set\| {
302	for (reaction_set.values()) \|step_set\| {
303	for (step_set.keys()) \|step\| {
304	step.recursiveReset(gpa);
305	}
306	}
307	}
308	}
309
310	fn markStepSetDirty(gpa: Allocator, step_set: *StepSet, any_dirty: bool) bool {
311	var this_any_dirty = false;
312	for (step_set.keys()) \|step\| {
313	if (step.state != .precheck_done) {
314	step.recursiveReset(gpa);
315	this_any_dirty = true;
316	}
317	}
318	return any_dirty or this_any_dirty;
319	}
320
321	pub fn update(w: Watch, gpa: Allocator, steps: []const Step) !void {
322	switch (builtin.os.tag) {
323	.linux => return Os.update(w, gpa, steps),
324	else => @compileError("unimplemented"),
325	}
326	}
327
328	pub const Timeout = union(enum) {
329	none,
330	ms: u16,
331
332	pub fn to_i32_ms(t: Timeout) i32 {
333	return switch (t) {
334	.none => -1,
335	.ms => \|ms\| ms,
336	};
337	}
338	};
339
340	pub const WaitResult = enum {
341	timeout,
342	/// File system watching triggered on files that were marked as inputs to at least one Step.
343	/// Relevant steps have been marked dirty.
344	dirty,
345	/// File system watching triggered but none of the events were relevant to
346	/// what we are listening to. There is nothing to do.
347	clean,
348	};
349
350	pub fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
351	switch (builtin.os.tag) {
352	.linux => {
353	const events_len = try std.posix.poll(&w.os.poll_fds, timeout.to_i32_ms());
354	return if (events_len == 0)
355	.timeout
356	else if (try Os.markDirtySteps(w, gpa))
357	.dirty
358	else
359	.clean;
360	},
361	else => @compileError("unimplemented"),
362	}
363	}

lib/std/os/linux.zig+182-52

...	@@ -698,12 +698,42 @@ pub fn inotify_rm_watch(fd: i32, wd: i32) usize {	...	@@ -698,12 +698,42 @@ pub fn inotify_rm_watch(fd: i32, wd: i32) usize {
698	return syscall2(.inotify_rm_watch, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, wd))));	698	return syscall2(.inotify_rm_watch, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, wd))));
699	}	699	}
700		700
701	pub fn fanotify_init(flags: u32, event_f_flags: u32) usize {	701	pub fn fanotify_init(flags: fanotify.InitFlags, event_f_flags: u32) usize {
702	return syscall2(.fanotify_init, flags, event_f_flags);	702	return syscall2(.fanotify_init, @as(u32, @bitCast(flags)), event_f_flags);
703	}	703	}
704		704
705	pub fn fanotify_mark(fd: i32, flags: u32, mask: u64, dirfd: i32, pathname: ?[*:0]const u8) usize {	705	pub fn fanotify_mark(
706	return syscall5(.fanotify_mark, @as(usize, @bitCast(@as(isize, fd))), flags, mask, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(pathname));	706	fd: fd_t,
		707	flags: fanotify.MarkFlags,
		708	mask: fanotify.MarkMask,
		709	dirfd: fd_t,
		710	pathname: ?[*:0]const u8,
		711	) usize {
		712	return syscall5(
		713	.fanotify_mark,
		714	@bitCast(@as(isize, fd)),
		715	@as(u32, @bitCast(flags)),
		716	@bitCast(mask),
		717	@bitCast(@as(isize, dirfd)),
		718	@intFromPtr(pathname),
		719	);
		720	}
		721
		722	pub fn name_to_handle_at(
		723	dirfd: fd_t,
		724	pathname: [*:0]const u8,
		725	handle: *std.os.linux.file_handle,
		726	mount_id: *i32,
		727	flags: u32,
		728	) usize {
		729	return syscall5(
		730	.name_to_handle_at,
		731	@as(u32, @bitCast(dirfd)),
		732	@intFromPtr(pathname),
		733	@intFromPtr(handle),
		734	@intFromPtr(mount_id),
		735	flags,
		736	);
707	}	737	}
708		738
709	pub fn readlink(noalias path: [:0]const u8, noalias buf_ptr: []u8, buf_len: usize) usize {	739	pub fn readlink(noalias path: [:0]const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
...	@@ -2916,6 +2946,8 @@ pub const AT = struct {	...	@@ -2916,6 +2946,8 @@ pub const AT = struct {
2916		2946
2917	/// Apply to the entire subtree	2947	/// Apply to the entire subtree
2918	pub const RECURSIVE = 0x8000;	2948	pub const RECURSIVE = 0x8000;
		2949
		2950	pub const HANDLE_FID = REMOVEDIR;
2919	};	2951	};
2920		2952
2921	pub const FALLOC = struct {	2953	pub const FALLOC = struct {
...	@@ -4135,58 +4167,156 @@ pub const IN = struct {	...	@@ -4135,58 +4167,156 @@ pub const IN = struct {
4135	pub const ONESHOT = 0x80000000;	4167	pub const ONESHOT = 0x80000000;
4136	};	4168	};
4137		4169
4138	pub const FAN = struct {	4170	pub const fanotify = struct {
4139	pub const ACCESS = 0x00000001;	4171	pub const InitFlags = packed struct(u32) {
4140	pub const MODIFY = 0x00000002;	4172	CLOEXEC: bool = false,
4141	pub const CLOSE_WRITE = 0x00000008;	4173	NONBLOCK: bool = false,
4142	pub const CLOSE_NOWRITE = 0x00000010;	4174	CLASS: enum(u2) {
4143	pub const OPEN = 0x00000020;	4175	NOTIF = 0,
4144	pub const Q_OVERFLOW = 0x00004000;	4176	CONTENT = 1,
4145	pub const OPEN_PERM = 0x00010000;	4177	PRE_CONTENT = 2,
4146	pub const ACCESS_PERM = 0x00020000;	4178	} = .NOTIF,
4147	pub const ONDIR = 0x40000000;	4179	UNLIMITED_QUEUE: bool = false,
4148	pub const EVENT_ON_CHILD = 0x08000000;	4180	UNLIMITED_MARKS: bool = false,
4149	pub const CLOSE = CLOSE_WRITE \| CLOSE_NOWRITE;	4181	ENABLE_AUDIT: bool = false,
4150	pub const CLOEXEC = 0x00000001;	4182	REPORT_PIDFD: bool = false,
4151	pub const NONBLOCK = 0x00000002;	4183	REPORT_TID: bool = false,
4152	pub const CLASS_NOTIF = 0x00000000;	4184	REPORT_FID: bool = false,
4153	pub const CLASS_CONTENT = 0x00000004;	4185	REPORT_DIR_FID: bool = false,
4154	pub const CLASS_PRE_CONTENT = 0x00000008;	4186	REPORT_NAME: bool = false,
4155	pub const ALL_CLASS_BITS = CLASS_NOTIF \| CLASS_CONTENT \| CLASS_PRE_CONTENT;	4187	REPORT_TARGET_FID: bool = false,
4156	pub const UNLIMITED_QUEUE = 0x00000010;	4188	_: u19 = 0,
4157	pub const UNLIMITED_MARKS = 0x00000020;	4189	};
4158	pub const ALL_INIT_FLAGS = CLOEXEC \| NONBLOCK \| ALL_CLASS_BITS \| UNLIMITED_QUEUE \| UNLIMITED_MARKS;	4190
4159	pub const MARK_ADD = 0x00000001;	4191	pub const MarkFlags = packed struct(u32) {
4160	pub const MARK_REMOVE = 0x00000002;	4192	ADD: bool = false,
4161	pub const MARK_DONT_FOLLOW = 0x00000004;	4193	REMOVE: bool = false,
4162	pub const MARK_ONLYDIR = 0x00000008;	4194	DONT_FOLLOW: bool = false,
4163	pub const MARK_MOUNT = 0x00000010;	4195	ONLYDIR: bool = false,
4164	pub const MARK_IGNORED_MASK = 0x00000020;	4196	MOUNT: bool = false,
4165	pub const MARK_IGNORED_SURV_MODIFY = 0x00000040;	4197	/// Mutually exclusive with `IGNORE`
4166	pub const MARK_FLUSH = 0x00000080;	4198	IGNORED_MASK: bool = false,
4167	pub const ALL_MARK_FLAGS = MARK_ADD \| MARK_REMOVE \| MARK_DONT_FOLLOW \| MARK_ONLYDIR \| MARK_MOUNT \| MARK_IGNORED_MASK \| MARK_IGNORED_SURV_MODIFY \| MARK_FLUSH;	4199	IGNORED_SURV_MODIFY: bool = false,
4168	pub const ALL_EVENTS = ACCESS \| MODIFY \| CLOSE \| OPEN;	4200	FLUSH: bool = false,
4169	pub const ALL_PERM_EVENTS = OPEN_PERM \| ACCESS_PERM;	4201	FILESYSTEM: bool = false,
4170	pub const ALL_OUTGOING_EVENTS = ALL_EVENTS \| ALL_PERM_EVENTS \| Q_OVERFLOW;	4202	EVICTABLE: bool = false,
4171	pub const ALLOW = 0x01;	4203	/// Mutually exclusive with `IGNORED_MASK`
4172	pub const DENY = 0x02;	4204	IGNORE: bool = false,
4173	};	4205	_: u21 = 0,
4174		4206	};
4175	pub const fanotify_event_metadata = extern struct {	4207
4176	event_len: u32,	4208	pub const MarkMask = packed struct(u64) {
4177	vers: u8,	4209	/// File was accessed
4178	reserved: u8,	4210	ACCESS: bool = false,
4179	metadata_len: u16,	4211	/// File was modified
4180	mask: u64 align(8),	4212	MODIFY: bool = false,
4181	fd: i32,	4213	/// Metadata changed
4182	pid: i32,	4214	ATTRIB: bool = false,
		4215	/// Writtable file closed
		4216	CLOSE_WRITE: bool = false,
		4217	/// Unwrittable file closed
		4218	CLOSE_NOWRITE: bool = false,
		4219	/// File was opened
		4220	OPEN: bool = false,
		4221	/// File was moved from X
		4222	MOVED_FROM: bool = false,
		4223	/// File was moved to Y
		4224	MOVED_TO: bool = false,
		4225
		4226	/// Subfile was created
		4227	CREATE: bool = false,
		4228	/// Subfile was deleted
		4229	DELETE: bool = false,
		4230	/// Self was deleted
		4231	DELETE_SELF: bool = false,
		4232	/// Self was moved
		4233	MOVE_SELF: bool = false,
		4234	/// File was opened for exec
		4235	OPEN_EXEC: bool = false,
		4236	reserved13: u1 = 0,
		4237	/// Event queued overflowed
		4238	Q_OVERFLOW: bool = false,
		4239	/// Filesystem error
		4240	FS_ERROR: bool = false,
		4241
		4242	/// File open in perm check
		4243	OPEN_PERM: bool = false,
		4244	/// File accessed in perm check
		4245	ACCESS_PERM: bool = false,
		4246	/// File open/exec in perm check
		4247	OPEN_EXEC_PERM: bool = false,
		4248	reserved19: u8 = 0,
		4249	/// Interested in child events
		4250	EVENT_ON_CHILD: bool = false,
		4251	/// File was renamed
		4252	RENAME: bool = false,
		4253	reserved30: u1 = 0,
		4254	/// Event occurred against dir
		4255	ONDIR: bool = false,
		4256	reserved31: u33 = 0,
		4257	};
		4258
		4259	pub const event_metadata = extern struct {
		4260	event_len: u32,
		4261	vers: u8,
		4262	reserved: u8,
		4263	metadata_len: u16,
		4264	mask: MarkMask align(8),
		4265	fd: i32,
		4266	pid: i32,
		4267
		4268	pub const VERSION = 3;
		4269	};
		4270
		4271	pub const response = extern struct {
		4272	fd: i32,
		4273	response: u32,
		4274	};
		4275
		4276	/// Unique file identifier info record.
		4277	///
		4278	/// This structure is used for records of types `EVENT_INFO_TYPE.FID`.
		4279	/// `EVENT_INFO_TYPE.DFID` and `EVENT_INFO_TYPE.DFID_NAME`.
		4280	///
		4281	/// For `EVENT_INFO_TYPE.DFID_NAME` there is additionally a null terminated
		4282	/// name immediately after the file handle.
		4283	pub const event_info_fid = extern struct {
		4284	hdr: event_info_header,
		4285	fsid: kernel_fsid_t,
		4286	/// Following is an opaque struct file_handle that can be passed as
		4287	/// an argument to open_by_handle_at(2).
		4288	handle: [0]u8,
		4289	};
		4290
		4291	/// Variable length info record following event metadata.
		4292	pub const event_info_header = extern struct {
		4293	info_type: EVENT_INFO_TYPE,
		4294	pad: u8,
		4295	len: u16,
		4296	};
		4297
		4298	pub const EVENT_INFO_TYPE = enum(u8) {
		4299	FID = 1,
		4300	DFID_NAME = 2,
		4301	DFID = 3,
		4302	PIDFD = 4,
		4303	ERROR = 5,
		4304	OLD_DFID_NAME = 10,
		4305	OLD_DFID = 11,
		4306	NEW_DFID_NAME = 12,
		4307	NEW_DFID = 13,
		4308	};
4183	};	4309	};
4184		4310
4185	pub const fanotify_response = extern struct {	4311	pub const file_handle = extern struct {
4186	fd: i32,	4312	handle_bytes: u32,
4187	response: u32,	4313	handle_type: i32,
		4314	f_handle: [0]u8,
4188	};	4315	};
4189		4316
		4317	pub const kernel_fsid_t = fsid_t;
		4318	pub const fsid_t = [2]i32;
		4319
4190	pub const S = struct {	4320	pub const S = struct {
4191	pub const IFMT = 0o170000;	4321	pub const IFMT = 0o170000;
4192		4322

lib/std/posix.zig+55-5

...	@@ -4501,7 +4501,7 @@ pub const FanotifyInitError = error{	...	@@ -4501,7 +4501,7 @@ pub const FanotifyInitError = error{
4501	PermissionDenied,	4501	PermissionDenied,
4502	} \|\| UnexpectedError;	4502	} \|\| UnexpectedError;
4503		4503
4504	pub fn fanotify_init(flags: u32, event_f_flags: u32) FanotifyInitError!i32 {	4504	pub fn fanotify_init(flags: std.os.linux.fanotify.InitFlags, event_f_flags: u32) FanotifyInitError!i32 {
4505	const rc = system.fanotify_init(flags, event_f_flags);	4505	const rc = system.fanotify_init(flags, event_f_flags);
4506	switch (errno(rc)) {	4506	switch (errno(rc)) {
4507	.SUCCESS => return @intCast(rc),	4507	.SUCCESS => return @intCast(rc),
...	@@ -4530,16 +4530,28 @@ pub const FanotifyMarkError = error{	...	@@ -4530,16 +4530,28 @@ pub const FanotifyMarkError = error{
4530	NameTooLong,	4530	NameTooLong,
4531	} \|\| UnexpectedError;	4531	} \|\| UnexpectedError;
4532		4532
4533	pub fn fanotify_mark(fanotify_fd: i32, flags: u32, mask: u64, dirfd: i32, pathname: ?[]const u8) FanotifyMarkError!void {	4533	pub fn fanotify_mark(
		4534	fanotify_fd: fd_t,
		4535	flags: std.os.linux.fanotify.MarkFlags,
		4536	mask: std.os.linux.fanotify.MarkMask,
		4537	dirfd: fd_t,
		4538	pathname: ?[]const u8,
		4539	) FanotifyMarkError!void {
4534	if (pathname) \|path\| {	4540	if (pathname) \|path\| {
4535	const path_c = try toPosixPath(path);	4541	const path_c = try toPosixPath(path);
4536	return fanotify_markZ(fanotify_fd, flags, mask, dirfd, &path_c);	4542	return fanotify_markZ(fanotify_fd, flags, mask, dirfd, &path_c);
		4543	} else {
		4544	return fanotify_markZ(fanotify_fd, flags, mask, dirfd, null);
4537	}	4545	}
4538
4539	return fanotify_markZ(fanotify_fd, flags, mask, dirfd, null);
4540	}	4546	}
4541		4547
4542	pub fn fanotify_markZ(fanotify_fd: i32, flags: u32, mask: u64, dirfd: i32, pathname: ?[*:0]const u8) FanotifyMarkError!void {	4548	pub fn fanotify_markZ(
		4549	fanotify_fd: fd_t,
		4550	flags: std.os.linux.fanotify.MarkFlags,
		4551	mask: std.os.linux.fanotify.MarkMask,
		4552	dirfd: fd_t,
		4553	pathname: ?[*:0]const u8,
		4554	) FanotifyMarkError!void {
4543	const rc = system.fanotify_mark(fanotify_fd, flags, mask, dirfd, pathname);	4555	const rc = system.fanotify_mark(fanotify_fd, flags, mask, dirfd, pathname);
4544	switch (errno(rc)) {	4556	switch (errno(rc)) {
4545	.SUCCESS => return,	4557	.SUCCESS => return,
...	@@ -7274,6 +7286,44 @@ pub fn ptrace(request: u32, pid: pid_t, addr: usize, signal: usize) PtraceError!	...	@@ -7274,6 +7286,44 @@ pub fn ptrace(request: u32, pid: pid_t, addr: usize, signal: usize) PtraceError!
7274	};	7286	};
7275	}	7287	}
7276		7288
		7289	pub const NameToFileHandleAtError = error{
		7290	FileNotFound,
		7291	NotDir,
		7292	OperationNotSupported,
		7293	NameTooLong,
		7294	Unexpected,
		7295	};
		7296
		7297	pub fn name_to_handle_at(
		7298	dirfd: fd_t,
		7299	pathname: []const u8,
		7300	handle: *std.os.linux.file_handle,
		7301	mount_id: *i32,
		7302	flags: u32,
		7303	) NameToFileHandleAtError!void {
		7304	const pathname_c = try toPosixPath(pathname);
		7305	return name_to_handle_atZ(dirfd, &pathname_c, handle, mount_id, flags);
		7306	}
		7307
		7308	pub fn name_to_handle_atZ(
		7309	dirfd: fd_t,
		7310	pathname_z: [*:0]const u8,
		7311	handle: *std.os.linux.file_handle,
		7312	mount_id: *i32,
		7313	flags: u32,
		7314	) NameToFileHandleAtError!void {
		7315	switch (errno(system.name_to_handle_at(dirfd, pathname_z, handle, mount_id, flags))) {
		7316	.SUCCESS => {},
		7317	.FAULT => unreachable, // pathname, mount_id, or handle outside accessible address space
		7318	.INVAL => unreachable, // bad flags, or handle_bytes too big
		7319	.NOENT => return error.FileNotFound,
		7320	.NOTDIR => return error.NotDir,
		7321	.OPNOTSUPP => return error.OperationNotSupported,
		7322	.OVERFLOW => return error.NameTooLong,
		7323	else => \|err\| return unexpectedErrno(err),
		7324	}
		7325	}
		7326
7277	pub const IoCtl_SIOCGIFINDEX_Error = error{	7327	pub const IoCtl_SIOCGIFINDEX_Error = error{
7278	FileSystem,	7328	FileSystem,
7279	InterfaceNotFound,	7329	InterfaceNotFound,

lib/std/zig/Server.zig+15-1

 @@ -20,10 +20,24 @@ pub const Message = struct {
         test_metadata,
         /// Body is a TestResults
         test_results,
+        /// Body is a series of strings, delimited by null bytes.
+        /// Each string is a prefixed file path.
+        /// The first byte indicates the file prefix path (see prefixes fields
+        /// of Cache). This byte is sent over the wire incremented so that null
+        /// bytes are not confused with string terminators.
+        /// The remaining bytes is the file path relative to that prefix.
+        /// The prefixes are hard-coded in Compilation.create (cwd, zig lib dir, local cache dir)
+        file_system_inputs,
         _,
     };
+    pub const PathPrefix = enum(u8) {
+        cwd,
+        zig_lib,
+        local_cache,
+    };
     /// Trailing:
     /// * extra: [extra_len]u32,
     /// * string_bytes: [string_bytes_len]u8,
 @@ -58,7 +72,7 @@ pub const Message = struct {
     };
     /// Trailing:
-    /// * the file system path the emitted binary can be found
+    /// * file system path where the emitted binary can be found
     pub const EmitBinPath = extern struct {
         flags: Flags,

src/Compilation.zig+71-1

 @@ -235,6 +235,8 @@ astgen_wait_group: WaitGroup = .{},
 llvm_opt_bisect_limit: c_int,
+file_system_inputs: ?*std.ArrayListUnmanaged(u8),
 pub const Emit = struct {
     /// Where the output will go.
     directory: Directory,
 @@ -1157,6 +1159,9 @@ pub const CreateOptions = struct {
     error_limit: ?Zcu.ErrorInt = null,
     global_cc_argv: []const []const u8 = &.{},
+    /// Tracks all files that can cause the Compilation to be invalidated and need a rebuild.
+    file_system_inputs: ?*std.ArrayListUnmanaged(u8) = null,
     pub const Entry = link.File.OpenOptions.Entry;
 };
 @@ -1332,6 +1337,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .gpa = gpa,
             .manifest_dir = try options.local_cache_directory.handle.makeOpenPath("h", .{}),
         };
+        // These correspond to std.zig.Server.Message.PathPrefix.
         cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
         cache.addPrefix(options.zig_lib_directory);
         cache.addPrefix(options.local_cache_directory);
 @@ -1508,6 +1514,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .force_undefined_symbols = options.force_undefined_symbols,
             .link_eh_frame_hdr = link_eh_frame_hdr,
             .global_cc_argv = options.global_cc_argv,
+            .file_system_inputs = options.file_system_inputs,
         };
         // Prevent some footguns by making the "any" fields of config reflect
 @@ -2044,6 +2051,9 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
                 );
             };
             if (is_hit) {
+                // In this case the cache hit contains the full set of file system inputs. Nice!
+                if (comp.file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
                 comp.last_update_was_cache_hit = true;
                 log.debug("CacheMode.whole cache hit for {s}", .{comp.root_name});
                 const digest = man.final();
 @@ -2103,12 +2113,24 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
         .incremental => {},
     }
+    // From this point we add a preliminary set of file system inputs that
+    // affects both incremental and whole cache mode. For incremental cache
+    // mode, the long-lived compiler state will track additional file system
+    // inputs discovered after this point. For whole cache mode, we rely on
+    // these inputs to make it past AstGen, and once there, we can rely on
+    // learning file system inputs from the Cache object.
     // For compiling C objects, we rely on the cache hash system to avoid duplicating work.
     // Add a Job for each C object.
     try comp.c_object_work_queue.ensureUnusedCapacity(comp.c_object_table.count());
     for (comp.c_object_table.keys()) |key| {
         comp.c_object_work_queue.writeItemAssumeCapacity(key);
     }
+    if (comp.file_system_inputs) |fsi| {
+        for (comp.c_object_table.keys()) |c_object| {
+            try comp.appendFileSystemInput(fsi, c_object.src.owner.root, c_object.src.src_path);
+        }
+    }
     // For compiling Win32 resources, we rely on the cache hash system to avoid duplicating work.
     // Add a Job for each Win32 resource file.
 @@ -2117,6 +2139,12 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
         for (comp.win32_resource_table.keys()) |key| {
             comp.win32_resource_work_queue.writeItemAssumeCapacity(key);
         }
+        if (comp.file_system_inputs) |fsi| {
+            for (comp.win32_resource_table.keys()) |win32_resource| switch (win32_resource.src) {
+                .rc => |f| try comp.appendFileSystemInput(fsi, f.owner.root, f.src_path),
+                .manifest => continue,
+            };
+        }
     }
     if (comp.module) |zcu| {
 @@ -2151,12 +2179,25 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
             if (zcu.fileByIndex(file_index).mod.isBuiltin()) continue;
             comp.astgen_work_queue.writeItemAssumeCapacity(file_index);
         }
+        if (comp.file_system_inputs) |fsi| {
+            for (zcu.import_table.values()) |file_index| {
+                const file = zcu.fileByIndex(file_index);
+                try comp.appendFileSystemInput(fsi, file.mod.root, file.sub_file_path);
+            }
+        }
         // Put a work item in for checking if any files used with `@embedFile` changed.
         try comp.embed_file_work_queue.ensureUnusedCapacity(zcu.embed_table.count());
         for (zcu.embed_table.values()) |embed_file| {
             comp.embed_file_work_queue.writeItemAssumeCapacity(embed_file);
         }
+        if (comp.file_system_inputs) |fsi| {
+            const ip = &zcu.intern_pool;
+            for (zcu.embed_table.values()) |embed_file| {
+                const sub_file_path = embed_file.sub_file_path.toSlice(ip);
+                try comp.appendFileSystemInput(fsi, embed_file.owner.root, sub_file_path);
+            }
+        }
         try comp.work_queue.writeItem(.{ .analyze_mod = std_mod });
         if (comp.config.is_test) {
 @@ -2210,6 +2251,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
     switch (comp.cache_use) {
         .whole => |whole| {
+            if (comp.file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
             const digest = man.final();
             // Rename the temporary directory into place.
 @@ -2297,6 +2340,30 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
     }
 }
+fn appendFileSystemInput(
+    comp: *Compilation,
+    file_system_inputs: *std.ArrayListUnmanaged(u8),
+    root: Cache.Path,
+    sub_file_path: []const u8,
+) Allocator.Error!void {
+    const gpa = comp.gpa;
+    const prefixes = comp.cache_parent.prefixes();
+    try file_system_inputs.ensureUnusedCapacity(gpa, root.sub_path.len + sub_file_path.len + 3);
+    if (file_system_inputs.items.len > 0) file_system_inputs.appendAssumeCapacity(0);
+    for (prefixes, 1..) |prefix_directory, i| {
+        if (prefix_directory.eql(root.root_dir)) {
+            file_system_inputs.appendAssumeCapacity(@intCast(i));
+            if (root.sub_path.len > 0) {
+                file_system_inputs.appendSliceAssumeCapacity(root.sub_path);
+                file_system_inputs.appendAssumeCapacity(std.fs.path.sep);
+            }
+            file_system_inputs.appendSliceAssumeCapacity(sub_file_path);
+            return;
+        }
+    }
+    std.debug.panic("missing prefix directory: {}, {s}", .{ root, sub_file_path });
+}
 fn flush(comp: *Compilation, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) !void {
     if (comp.bin_file) |lf| {
         // This is needed before reading the error flags.
 @@ -4204,6 +4271,9 @@ fn workerAstGenFile(
                         .token = item.data.token,
                     } }) catch continue;
                 }
+                if (res.is_new) if (comp.file_system_inputs) |fsi| {
+                    comp.appendFileSystemInput(fsi, res.file.mod.root, res.file.sub_file_path) catch continue;
+                };
                 const imported_path_digest = pt.zcu.filePathDigest(res.file_index);
                 const imported_root_decl = pt.zcu.fileRootDecl(res.file_index);
                 break :blk .{ res, imported_path_digest, imported_root_decl };
 @@ -4574,7 +4644,7 @@ fn reportRetryableEmbedFileError(
     const gpa = mod.gpa;
     const src_loc = embed_file.src_loc;
     const ip = &mod.intern_pool;
-    const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
+    const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}/{s}': {s}", .{
         embed_file.owner.root,
         embed_file.sub_file_path.toSlice(ip),
         @errorName(err),

src/Zcu.zig+1-1

...	@@ -728,7 +728,7 @@ pub const File = struct {	...	@@ -728,7 +728,7 @@ pub const File = struct {
728	source_loaded: bool,	728	source_loaded: bool,
729	tree_loaded: bool,	729	tree_loaded: bool,
730	zir_loaded: bool,	730	zir_loaded: bool,
731	/// Relative to the owning package's root_src_dir.	731	/// Relative to the owning package's root source directory.
732	/// Memory is stored in gpa, owned by File.	732	/// Memory is stored in gpa, owned by File.
733	sub_file_path: []const u8,	733	sub_file_path: []const u8,
734	/// Whether this is populated depends on `source_loaded`.	734	/// Whether this is populated depends on `source_loaded`.

src/Zcu/PerThread.zig+1-1

...	@@ -2666,7 +2666,7 @@ pub fn reportRetryableAstGenError(	...	@@ -2666,7 +2666,7 @@ pub fn reportRetryableAstGenError(
2666	},	2666	},
2667	};	2667	};
2668		2668
2669	const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{	2669	const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}/{s}': {s}", .{
2670	file.mod.root, file.sub_file_path, @errorName(err),	2670	file.mod.root, file.sub_file_path, @errorName(err),
2671	});	2671	});
2672	errdefer err_msg.destroy(gpa);	2672	errdefer err_msg.destroy(gpa);

src/main.zig+58-34

 @@ -3227,6 +3227,9 @@ fn buildOutputType(
     process.raiseFileDescriptorLimit();
+    var file_system_inputs: std.ArrayListUnmanaged(u8) = .{};
+    defer file_system_inputs.deinit(gpa);
     const comp = Compilation.create(gpa, arena, .{
         .zig_lib_directory = zig_lib_directory,
         .local_cache_directory = local_cache_directory,
 @@ -3350,6 +3353,7 @@ fn buildOutputType(
         // than to any particular module. This feature can greatly reduce CLI
         // noise when --search-prefix and --mod are combined.
         .global_cc_argv = try cc_argv.toOwnedSlice(arena),
+        .file_system_inputs = &file_system_inputs,
     }) catch |err| switch (err) {
         error.LibCUnavailable => {
             const triple_name = try target.zigTriple(arena);
 @@ -3433,7 +3437,7 @@ fn buildOutputType(
         defer root_prog_node.end();
         if (arg_mode == .translate_c) {
-            return cmdTranslateC(comp, arena, null, root_prog_node);
+            return cmdTranslateC(comp, arena, null, null, root_prog_node);
         }
         updateModule(comp, color, root_prog_node) catch |err| switch (err) {
 @@ -4059,6 +4063,7 @@ fn serve(
     var child_pid: ?std.process.Child.Id = null;
     const main_progress_node = std.Progress.start(.{});
+    const file_system_inputs = comp.file_system_inputs.?;
     while (true) {
         const hdr = try server.receiveMessage();
 @@ -4067,14 +4072,16 @@ fn serve(
             .exit => return cleanExit(),
             .update => {
                 tracy.frameMark();
+                file_system_inputs.clearRetainingCapacity();
                 if (arg_mode == .translate_c) {
                     var arena_instance = std.heap.ArenaAllocator.init(gpa);
                     defer arena_instance.deinit();
                     const arena = arena_instance.allocator();
                     var output: Compilation.CImportResult = undefined;
-                    try cmdTranslateC(comp, arena, &output, main_progress_node);
+                    try cmdTranslateC(comp, arena, &output, file_system_inputs, main_progress_node);
                     defer output.deinit(gpa);
+                    try server.serveStringMessage(.file_system_inputs, file_system_inputs.items);
                     if (output.errors.errorMessageCount() != 0) {
                         try server.serveErrorBundle(output.errors);
                     } else {
 @@ -4116,6 +4123,7 @@ fn serve(
             },
             .hot_update => {
                 tracy.frameMark();
+                file_system_inputs.clearRetainingCapacity();
                 if (child_pid) |pid| {
                     try comp.hotCodeSwap(main_progress_node, pid);
                     try serveUpdateResults(&server, comp);
 @@ -4147,6 +4155,12 @@ fn serve(
 fn serveUpdateResults(s: *Server, comp: *Compilation) !void {
     const gpa = comp.gpa;
+    if (comp.file_system_inputs) |file_system_inputs| {
+        assert(file_system_inputs.items.len > 0);
+        try s.serveStringMessage(.file_system_inputs, file_system_inputs.items);
+    }
     var error_bundle = try comp.getAllErrorsAlloc();
     defer error_bundle.deinit(gpa);
     if (error_bundle.errorMessageCount() > 0) {
 @@ -4434,6 +4448,7 @@ fn cmdTranslateC(
     comp: *Compilation,
     arena: Allocator,
     fancy_output: ?*Compilation.CImportResult,
+    file_system_inputs: ?*std.ArrayListUnmanaged(u8),
     prog_node: std.Progress.Node,
 ) !void {
     if (build_options.only_core_functionality) @panic("@translate-c is not available in a zig2.c build");
 @@ -4454,7 +4469,10 @@ fn cmdTranslateC(
     };
     if (fancy_output) |p| p.cache_hit = true;
-    const digest = if (try man.hit()) man.final() else digest: {
+    const digest = if (try man.hit()) digest: {
+        if (file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
+        break :digest man.final();
+    } else digest: {
         if (fancy_output) |p| p.cache_hit = false;
         var argv = std.ArrayList([]const u8).init(arena);
         switch (comp.config.c_frontend) {
 @@ -4566,6 +4584,8 @@ fn cmdTranslateC(
             @errorName(err),
         });
+        if (file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
         break :digest digest;
     };
 @@ -4649,31 +4669,6 @@ fn cmdInit(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     return cleanExit();
 }
-const usage_build =
-    \\Usage: zig build [steps] [options]
-    \\
-    \\   Build a project from build.zig.
-    \\
-    \\Options:
-    \\  -freference-trace[=num]       How many lines of reference trace should be shown per compile error
-    \\  -fno-reference-trace          Disable reference trace
-    \\  --summary [mode]              Control the printing of the build summary
-    \\    all                         Print the build summary in its entirety
-    \\    failures                    (Default) Only print failed steps
-    \\    none                        Do not print the build summary
-    \\  -j<N>                         Limit concurrent jobs (default is to use all CPU cores)
-    \\  --build-file [file]           Override path to build.zig
-    \\  --cache-dir [path]            Override path to local Zig cache directory
-    \\  --global-cache-dir [path]     Override path to global Zig cache directory
-    \\  --zig-lib-dir [arg]           Override path to Zig lib directory
-    \\  --build-runner [file]         Override path to build runner
-    \\  --prominent-compile-errors    Buffer compile errors and display at end
-    \\  --seed [integer]              For shuffling dependency traversal order (default: random)
-    \\  --fetch                       Exit after fetching dependency tree
-    \\  -h, --help                    Print this help and exit
-    \\
-;
 fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     var build_file: ?[]const u8 = null;
     var override_lib_dir: ?[]const u8 = try EnvVar.ZIG_LIB_DIR.get(arena);
 @@ -4696,6 +4691,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     var verbose_llvm_cpu_features = false;
     var fetch_only = false;
     var system_pkg_dir_path: ?[]const u8 = null;
+    var debug_target: ?[]const u8 = null;
     const argv_index_exe = child_argv.items.len;
     _ = try child_argv.addOne();
 @@ -4703,6 +4699,9 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     const self_exe_path = try introspect.findZigExePath(arena);
     try child_argv.append(self_exe_path);
+    const argv_index_zig_lib_dir = child_argv.items.len;
+    _ = try child_argv.addOne();
     const argv_index_build_file = child_argv.items.len;
     _ = try child_argv.addOne();
 @@ -4752,7 +4751,6 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
                     i += 1;
                     override_lib_dir = args[i];
-                    try child_argv.appendSlice(&.{ arg, args[i] });
                     continue;
                 } else if (mem.eql(u8, arg, "--build-runner")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
 @@ -4802,6 +4800,14 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
                     } else {
                         warn("Zig was compiled without debug extensions. --debug-compile-errors has no effect.", .{});
                     }
+                } else if (mem.eql(u8, arg, "--debug-target")) {
+                    if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
+                    i += 1;
+                    if (build_options.enable_debug_extensions) {
+                        debug_target = args[i];
+                    } else {
+                        warn("Zig was compiled without debug extensions. --debug-target has no effect.", .{});
+                    }
                 } else if (mem.eql(u8, arg, "--verbose-link")) {
                     verbose_link = true;
                 } else if (mem.eql(u8, arg, "--verbose-cc")) {
 @@ -4860,11 +4866,27 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     });
     defer root_prog_node.end();
-    const target_query: std.Target.Query = .{};
+    // Normally the build runner is compiled for the host target but here is
-    const resolved_target: Package.Module.ResolvedTarget = .{
+    // some code to help when debugging edits to the build runner so that you
-        .result = std.zig.resolveTargetQueryOrFatal(target_query),
+    // can make sure it compiles successfully on other targets.
-        .is_native_os = true,
+    const resolved_target: Package.Module.ResolvedTarget = t: {
-        .is_native_abi = true,
+        if (build_options.enable_debug_extensions) {
+            if (debug_target) |triple| {
+                const target_query = try std.Target.Query.parse(.{
+                    .arch_os_abi = triple,
+                });
+                break :t .{
+                    .result = std.zig.resolveTargetQueryOrFatal(target_query),
+                    .is_native_os = false,
+                    .is_native_abi = false,
+                };
+            }
+        }
+        break :t .{
+            .result = std.zig.resolveTargetQueryOrFatal(.{}),
+            .is_native_os = true,
+            .is_native_abi = true,
+        };
     };
     const exe_basename = try std.zig.binNameAlloc(arena, .{
 @@ -4890,6 +4912,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     defer zig_lib_directory.handle.close();
     const cwd_path = try process.getCwdAlloc(arena);
+    child_argv.items[argv_index_zig_lib_dir] = zig_lib_directory.path orelse cwd_path;
     const build_root = try findBuildRoot(arena, .{
         .cwd_path = cwd_path,
         .build_file = build_file,

test/tests.zig+4-4

author	Andrew Kelley <andrew@ziglang.org> 2024-07-12 16:56:17-07:00
committer	GitHub <noreply@github.com> 2024-07-12 16:56:17-07:00
log	1d20ff11d7efc1f07de9a300abc15ad6ae9d6d6f
tree	e72a2989fddfa91571999ade7ef68c87c7c2610f
parent	0d79aa01768d600a19f7a7493afce417da7e3810
parent	5efcc2e9e7c84893b9e418ca82d8d2d4366dde7c
signature	Signed by PGP key B5690EEEBB952194

...	@@ -632,7 +632,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -632,7 +632,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
632	// On Windows we don't have rpaths so we have to add .dll search paths to PATH	632	// On Windows we don't have rpaths so we have to add .dll search paths to PATH
633	run.addPathForDynLibs(artifact);	633	run.addPathForDynLibs(artifact);
634	}	634	}
635	const file_path = artifact.installed_path orelse artifact.generated_bin.?.path.?; // the path is guaranteed to be set	635	const file_path = artifact.installed_path orelse artifact.generated_bin.?.path.?;
636		636
637	try argv_list.append(b.fmt("{s}{s}", .{ pa.prefix, file_path }));	637	try argv_list.append(b.fmt("{s}{s}", .{ pa.prefix, file_path }));
638		638
...	@@ -682,7 +682,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -682,7 +682,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
682	_ = try man.addFile(lazy_path.getPath2(b, step), null);	682	_ = try man.addFile(lazy_path.getPath2(b, step), null);
683	}	683	}
684		684
685	if (!has_side_effects and try step.cacheHit(&man)) {	685	if (!has_side_effects and try step.cacheHitAndWatch(&man)) {
686	// cache hit, skip running command	686	// cache hit, skip running command
687	const digest = man.final();	687	const digest = man.final();
688		688
...	@@ -736,7 +736,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -736,7 +736,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
736	}	736	}
737		737
738	try runCommand(run, argv_list.items, has_side_effects, output_dir_path, prog_node);	738	try runCommand(run, argv_list.items, has_side_effects, output_dir_path, prog_node);
739	if (!has_side_effects) try step.writeManifest(&man);	739	if (!has_side_effects) try step.writeManifestAndWatch(&man);
740	return;	740	return;
741	};	741	};
742		742
...	@@ -812,7 +812,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {	...	@@ -812,7 +812,7 @@ fn make(step: *Step, prog_node: std.Progress.Node) !void {
812	};	812	};
813	}	813	}
814		814
815	if (!has_side_effects) try step.writeManifest(&man);	815	if (!has_side_effects) try step.writeManifestAndWatch(&man);
816		816
817	try populateGeneratedPaths(	817	try populateGeneratedPaths(
818	arena,	818	arena,

...	@@ -771,7 +771,7 @@ pub fn addCliTests(b: std.Build) Step {	...	@@ -771,7 +771,7 @@ pub fn addCliTests(b: std.Build) Step {
771	run_run.expectStdErrEqual("All your codebase are belong to us.\n");	771	run_run.expectStdErrEqual("All your codebase are belong to us.\n");
772	run_run.step.dependOn(&init_exe.step);	772	run_run.step.dependOn(&init_exe.step);
773		773
774	const cleanup = b.addRemoveDirTree(tmp_path);	774	const cleanup = b.addRemoveDirTree(.{ .cwd_relative = tmp_path });
775	cleanup.step.dependOn(&run_test.step);	775	cleanup.step.dependOn(&run_test.step);
776	cleanup.step.dependOn(&run_run.step);	776	cleanup.step.dependOn(&run_run.step);
777	cleanup.step.dependOn(&run_bad.step);	777	cleanup.step.dependOn(&run_bad.step);
...	@@ -816,7 +816,7 @@ pub fn addCliTests(b: std.Build) Step {	...	@@ -816,7 +816,7 @@ pub fn addCliTests(b: std.Build) Step {
816	});	816	});
817	checkfile.setName("check godbolt.org CLI usage generating valid asm");	817	checkfile.setName("check godbolt.org CLI usage generating valid asm");
818		818
819	const cleanup = b.addRemoveDirTree(tmp_path);	819	const cleanup = b.addRemoveDirTree(.{ .cwd_relative = tmp_path });
820	cleanup.step.dependOn(&checkfile.step);	820	cleanup.step.dependOn(&checkfile.step);
821		821
822	step.dependOn(&cleanup.step);	822	step.dependOn(&cleanup.step);
...	@@ -882,7 +882,7 @@ pub fn addCliTests(b: std.Build) Step {	...	@@ -882,7 +882,7 @@ pub fn addCliTests(b: std.Build) Step {
882		882
883	const unformatted_code_utf16 = "\xff\xfe \x00 \x00 \x00 \x00/\x00/\x00 \x00n\x00o\x00 \x00r\x00e\x00a\x00s\x00o\x00n\x00";	883	const unformatted_code_utf16 = "\xff\xfe \x00 \x00 \x00 \x00/\x00/\x00 \x00n\x00o\x00 \x00r\x00e\x00a\x00s\x00o\x00n\x00";
884	const fmt6_path = std.fs.path.join(b.allocator, &.{ tmp_path, "fmt6.zig" }) catch @panic("OOM");	884	const fmt6_path = std.fs.path.join(b.allocator, &.{ tmp_path, "fmt6.zig" }) catch @panic("OOM");
885	const write6 = b.addWriteFiles();	885	const write6 = b.addUpdateSourceFiles();
886	write6.addBytesToSource(unformatted_code_utf16, fmt6_path);	886	write6.addBytesToSource(unformatted_code_utf16, fmt6_path);
887	write6.step.dependOn(&run5.step);	887	write6.step.dependOn(&run5.step);
888		888
...	@@ -902,7 +902,7 @@ pub fn addCliTests(b: std.Build) Step {	...	@@ -902,7 +902,7 @@ pub fn addCliTests(b: std.Build) Step {
902	});	902	});
903	check6.step.dependOn(&run6.step);	903	check6.step.dependOn(&run6.step);
904		904
905	const cleanup = b.addRemoveDirTree(tmp_path);	905	const cleanup = b.addRemoveDirTree(.{ .cwd_relative = tmp_path });
906	cleanup.step.dependOn(&check6.step);	906	cleanup.step.dependOn(&check6.step);
907		907
908	step.dependOn(&cleanup.step);	908	step.dependOn(&cleanup.step);

Merge pull request #20580 from ziglang/watch