Commit 58edefc6d1716c0731ee2fe672ec8d073651aafb | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-03-01 22:56:37-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-03-15 10:48:13-07:00
log	58edefc6d1716c0731ee2fe672ec8d073651aafb
tree	9de4d030be9f44d3bc953d114eaef0812bd11cf4
parent	d0f675827c28b1d50e8aea6a7d29cb45ad8d4e67

zig build: many enhancements related to parallel building

Rework std.Build.Step to have an `owner: *Build` field. This
simplified the implementation of installation steps, as well as provided
some much-needed common API for the new parallelized build system.

--verbose is now defined very concretely: it prints to stderr just
before spawning a child process.

Child process execution is updated to conform to the new
parallel-friendly make() function semantics.

DRY up the failWithCacheError handling code. It now integrates properly
with the step graph instead of incorrectly dumping to stderr and calling
process exit.

In the main CLI, fix `zig fmt` crash when there are no errors and stdin
is used.

Deleted steps:
 * EmulatableRunStep - this entire thing can be removed in favor of a
   flag added to std.Build.RunStep called `skip_foreign_checks`.
 * LogStep - this doesn't really fit with a multi-threaded build runner
   and is effectively superseded by the new build summary output.

build runner:
 * add -fsummary and -fno-summary to override the default behavior,
   which is to print a summary if any of the build steps fail.
 * print the dep prefix when emitting error messages for steps.

std.Build.FmtStep:
 * This step now supports exclude paths as well as a check flag.
 * The check flag decides between two modes, modify mode, and check
   mode. These can be used to update source files in place, or to fail
   the build, respectively.

Zig's own build.zig:
 * The `test-fmt` step will do all the `zig fmt` checking that we expect
   to be done. Since the `test` step depends on this one, we can simply
   remove the explicit call to `zig fmt` in the CI.
 * The new `fmt` step will actually perform `zig fmt` and update source
   files in place.

std.Build.RunStep:
 * expose max_stdio_size is a field (previously an unchangeable
   hard-coded value).
 * rework the API. Instead of configuring each stream independently,
   there is a `stdio` field where you can choose between
   `infer_from_args`, `inherit`, or `check`. These determine whether the
   RunStep is considered to have side-effects or not. The previous
   field, `condition` is gone.
 * when stdio mode is set to `check` there is a slice of any number of
   checks to make, which include things like exit code, stderr matching,
   or stdout matching.
 * remove the ill-defined `print` field.
 * when adding an output arg, it takes the opportunity to give itself a
   better name.
 * The flag `skip_foreign_checks` is added. If this is true, a RunStep
   which is configured to check the output of the executed binary will
   not fail the build if the binary cannot be executed due to being for
   a foreign binary to the host system which is running the build graph.
   Command-line arguments such as -fqemu and -fwasmtime may affect
   whether a binary is detected as foreign, as well as system
   configuration such as Rosetta (macOS) and binfmt_misc (Linux).
   - This makes EmulatableRunStep no longer needed.
 * Fix the child process handling to properly integrate with the new
   bulid API and to avoid deadlocks in stdout/stderr streams by polling
   if necessary.

std.Build.RemoveDirStep now uses the open build_root directory handle
instead of an absolute path.

23 files changed, 1113 insertions(+), 1167 deletions(-)

build.zig+18-6

 @@ -61,8 +61,6 @@ pub fn build(b: *std.Build) !void {
     test_cases.stack_size = stack_size;
     test_cases.single_threaded = single_threaded;
-    const fmt_build_zig = b.addFmt(&[_][]const u8{"build.zig"});
     const skip_debug = b.option(bool, "skip-debug", "Main test suite skips debug builds") orelse false;
     const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse false;
     const skip_release_small = b.option(bool, "skip-release-small", "Main test suite skips release-small builds") orelse skip_release;
 @@ -386,10 +384,24 @@ pub fn build(b: *std.Build) !void {
     }
     const optimization_modes = chosen_opt_modes_buf[0..chosen_mode_index];
-    // run stage1 `zig fmt` on this build.zig file just to make sure it works
+    const fmt_include_paths = &.{ "doc", "lib", "src", "test", "tools", "build.zig" };
-    test_step.dependOn(&fmt_build_zig.step);
+    const fmt_exclude_paths = &.{ "test/cases" };
-    const fmt_step = b.step("test-fmt", "Run zig fmt against build.zig to make sure it works");
+    const check_fmt = b.addFmt(.{
-    fmt_step.dependOn(&fmt_build_zig.step);
+        .paths = fmt_include_paths,
+        .exclude_paths = fmt_exclude_paths,
+        .check = true,
+    });
+    const do_fmt = b.addFmt(.{
+        .paths = fmt_include_paths,
+        .exclude_paths = fmt_exclude_paths,
+    });
+    const test_fmt_step = b.step("test-fmt", "Check whether source files have conforming formatting");
+    test_fmt_step.dependOn(&check_fmt.step);
+    const do_fmt_step = b.step("fmt", "Modify source files in place to have conforming formatting");
+    do_fmt_step.dependOn(&do_fmt.step);
     test_step.dependOn(tests.addPkgTests(
         b,

lib/build_runner.zig+46-25

...	@@ -93,6 +93,7 @@ pub fn main() !void {	...	@@ -93,6 +93,7 @@ pub fn main() !void {
93		93
94	var install_prefix: ?[]const u8 = null;	94	var install_prefix: ?[]const u8 = null;
95	var dir_list = std.Build.DirList{};	95	var dir_list = std.Build.DirList{};
		96	var enable_summary: ?bool = null;
96		97
97	const Color = enum { auto, off, on };	98	const Color = enum { auto, off, on };
98	var color: Color = .auto;	99	var color: Color = .auto;
...	@@ -217,6 +218,10 @@ pub fn main() !void {	...	@@ -217,6 +218,10 @@ pub fn main() !void {
217	builder.enable_darling = true;	218	builder.enable_darling = true;
218	} else if (mem.eql(u8, arg, "-fno-darling")) {	219	} else if (mem.eql(u8, arg, "-fno-darling")) {
219	builder.enable_darling = false;	220	builder.enable_darling = false;
		221	} else if (mem.eql(u8, arg, "-fsummary")) {
		222	enable_summary = true;
		223	} else if (mem.eql(u8, arg, "-fno-summary")) {
		224	enable_summary = false;
220	} else if (mem.eql(u8, arg, "-freference-trace")) {	225	} else if (mem.eql(u8, arg, "-freference-trace")) {
221	builder.reference_trace = 256;	226	builder.reference_trace = 256;
222	} else if (mem.startsWith(u8, arg, "-freference-trace=")) {	227	} else if (mem.startsWith(u8, arg, "-freference-trace=")) {
...	@@ -252,8 +257,9 @@ pub fn main() !void {	...	@@ -252,8 +257,9 @@ pub fn main() !void {
252	}	257	}
253	}	258	}
254		259
		260	const stderr = std.io.getStdErr();
255	const ttyconf: std.debug.TTY.Config = switch (color) {	261	const ttyconf: std.debug.TTY.Config = switch (color) {
256	.auto => std.debug.detectTTYConfig(std.io.getStdErr()),	262	.auto => std.debug.detectTTYConfig(stderr),
257	.on => .escape_codes,	263	.on => .escape_codes,
258	.off => .no_color,	264	.off => .no_color,
259	};	265	};
...	@@ -279,6 +285,8 @@ pub fn main() !void {	...	@@ -279,6 +285,8 @@ pub fn main() !void {
279	main_progress_node,	285	main_progress_node,
280	thread_pool_options,	286	thread_pool_options,
281	ttyconf,	287	ttyconf,
		288	stderr,
		289	enable_summary,
282	) catch \|err\| switch (err) {	290	) catch \|err\| switch (err) {
283	error.UncleanExit => process.exit(1),	291	error.UncleanExit => process.exit(1),
284	else => return err,	292	else => return err,
...	@@ -292,6 +300,8 @@ fn runStepNames(	...	@@ -292,6 +300,8 @@ fn runStepNames(
292	parent_prog_node: *std.Progress.Node,	300	parent_prog_node: *std.Progress.Node,
293	thread_pool_options: std.Thread.Pool.Options,	301	thread_pool_options: std.Thread.Pool.Options,
294	ttyconf: std.debug.TTY.Config,	302	ttyconf: std.debug.TTY.Config,
		303	stderr: std.fs.File,
		304	enable_summary: ?bool,
295	) !void {	305	) !void {
296	const gpa = b.allocator;	306	const gpa = b.allocator;
297	var step_stack: std.AutoArrayHashMapUnmanaged(*Step, void) = .{};	307	var step_stack: std.AutoArrayHashMapUnmanaged(*Step, void) = .{};
...	@@ -382,28 +392,35 @@ fn runStepNames(	...	@@ -382,28 +392,35 @@ fn runStepNames(
382		392
383	// A proper command line application defaults to silently succeeding.	393	// A proper command line application defaults to silently succeeding.
384	// The user may request verbose mode if they have a different preference.	394	// The user may request verbose mode if they have a different preference.
385	if (failure_count == 0 and !b.verbose) return cleanExit();	395	if (failure_count == 0 and enable_summary != true) return cleanExit();
386		396
387	const stderr = std.io.getStdErr();	397	if (enable_summary != false) {
388		398	const total_count = success_count + failure_count + pending_count;
389	const total_count = success_count + failure_count + pending_count;	399	ttyconf.setColor(stderr, .Cyan) catch {};
390	ttyconf.setColor(stderr, .Cyan) catch {};	400	stderr.writeAll("Build Summary:") catch {};
391	stderr.writeAll("Build Summary: ") catch {};	401	ttyconf.setColor(stderr, .Reset) catch {};
392	ttyconf.setColor(stderr, .Reset) catch {};	402	stderr.writer().print(" {d}/{d} steps succeeded; {d} failed", .{
393	stderr.writer().print("{d}/{d} steps succeeded; {d} failed; {d} total compile errors\n", .{	403	success_count, total_count, failure_count,
394	success_count, total_count, failure_count, total_compile_errors,	404	}) catch {};
395	}) catch {};	405
		406	if (enable_summary == null) {
		407	ttyconf.setColor(stderr, .Dim) catch {};
		408	stderr.writeAll(" (disable with -fno-summary)") catch {};
		409	ttyconf.setColor(stderr, .Reset) catch {};
		410	}
		411	stderr.writeAll("\n") catch {};
396		412
397	// Print a fancy tree with build results.	413	// Print a fancy tree with build results.
398	var print_node: PrintNode = .{ .parent = null };	414	var print_node: PrintNode = .{ .parent = null };
399	if (step_names.len == 0) {	415	if (step_names.len == 0) {
400	print_node.last = true;	416	print_node.last = true;
401	printTreeStep(b, b.default_step, stderr, ttyconf, &print_node, &step_stack) catch {};	417	printTreeStep(b, b.default_step, stderr, ttyconf, &print_node, &step_stack) catch {};
402	} else {	418	} else {
403	for (step_names, 0..) \|step_name, i\| {	419	for (step_names, 0..) \|step_name, i\| {
404	const tls = b.top_level_steps.get(step_name).?;	420	const tls = b.top_level_steps.get(step_name).?;
405	print_node.last = i + 1 == b.top_level_steps.count();	421	print_node.last = i + 1 == b.top_level_steps.count();
406	printTreeStep(b, &tls.step, stderr, ttyconf, &print_node, &step_stack) catch {};	422	printTreeStep(b, &tls.step, stderr, ttyconf, &print_node, &step_stack) catch {};
		423	}
407	}	424	}
408	}	425	}
409		426
...	@@ -453,9 +470,9 @@ fn printTreeStep(	...	@@ -453,9 +470,9 @@ fn printTreeStep(
453	step_stack: std.AutoArrayHashMapUnmanaged(Step, void),	470	step_stack: std.AutoArrayHashMapUnmanaged(Step, void),
454	) !void {	471	) !void {
455	const first = step_stack.swapRemove(s);	472	const first = step_stack.swapRemove(s);
456	if (!first) try ttyconf.setColor(stderr, .Dim);
457	try printPrefix(parent_node, stderr);	473	try printPrefix(parent_node, stderr);
458		474
		475	if (!first) try ttyconf.setColor(stderr, .Dim);
459	if (parent_node.parent != null) {	476	if (parent_node.parent != null) {
460	if (parent_node.last) {	477	if (parent_node.last) {
461	try stderr.writeAll("└─ ");	478	try stderr.writeAll("└─ ");
...	@@ -464,7 +481,7 @@ fn printTreeStep(	...	@@ -464,7 +481,7 @@ fn printTreeStep(
464	}	481	}
465	}	482	}
466		483
467	// TODO print the dep prefix too?	484	// dep_prefix omitted here because it is redundant with the tree.
468	try stderr.writeAll(s.name);	485	try stderr.writeAll(s.name);
469		486
470	if (first) {	487	if (first) {
...	@@ -608,8 +625,10 @@ fn workerMakeOneStep(	...	@@ -608,8 +625,10 @@ fn workerMakeOneStep(
608	const stderr = std.io.getStdErr();	625	const stderr = std.io.getStdErr();
609		626
610	for (s.result_error_msgs.items) \|msg\| {	627	for (s.result_error_msgs.items) \|msg\| {
611	// TODO print the dep prefix too	628	// Sometimes it feels like you just can't catch a break. Finally,
		629	// with Zig, you can.
612	ttyconf.setColor(stderr, .Bold) catch break;	630	ttyconf.setColor(stderr, .Bold) catch break;
		631	stderr.writeAll(s.owner.dep_prefix) catch break;
613	stderr.writeAll(s.name) catch break;	632	stderr.writeAll(s.name) catch break;
614	stderr.writeAll(": ") catch break;	633	stderr.writeAll(": ") catch break;
615	ttyconf.setColor(stderr, .Red) catch break;	634	ttyconf.setColor(stderr, .Red) catch break;
...	@@ -735,6 +754,8 @@ fn usage(builder: *std.Build, already_ran_build: bool, out_stream: anytype) !voi	...	@@ -735,6 +754,8 @@ fn usage(builder: *std.Build, already_ran_build: bool, out_stream: anytype) !voi
735	\\Advanced Options:	754	\\Advanced Options:
736	\\ -freference-trace[=num] How many lines of reference trace should be shown per compile error	755	\\ -freference-trace[=num] How many lines of reference trace should be shown per compile error
737	\\ -fno-reference-trace Disable reference trace	756	\\ -fno-reference-trace Disable reference trace
		757	\\ -fsummary Print the build summary, even on success
		758	\\ -fno-summary Omit the build summary, even on failure
738	\\ --build-file [file] Override path to build.zig	759	\\ --build-file [file] Override path to build.zig
739	\\ --cache-dir [path] Override path to local Zig cache directory	760	\\ --cache-dir [path] Override path to local Zig cache directory
740	\\ --global-cache-dir [path] Override path to global Zig cache directory	761	\\ --global-cache-dir [path] Override path to global Zig cache directory

lib/std/Build.zig+14-212

...	@@ -32,14 +32,12 @@ pub const Step = @import("Build/Step.zig");	...	@@ -32,14 +32,12 @@ pub const Step = @import("Build/Step.zig");
32	pub const CheckFileStep = @import("Build/CheckFileStep.zig");	32	pub const CheckFileStep = @import("Build/CheckFileStep.zig");
33	pub const CheckObjectStep = @import("Build/CheckObjectStep.zig");	33	pub const CheckObjectStep = @import("Build/CheckObjectStep.zig");
34	pub const ConfigHeaderStep = @import("Build/ConfigHeaderStep.zig");	34	pub const ConfigHeaderStep = @import("Build/ConfigHeaderStep.zig");
35	pub const EmulatableRunStep = @import("Build/EmulatableRunStep.zig");
36	pub const FmtStep = @import("Build/FmtStep.zig");	35	pub const FmtStep = @import("Build/FmtStep.zig");
37	pub const InstallArtifactStep = @import("Build/InstallArtifactStep.zig");	36	pub const InstallArtifactStep = @import("Build/InstallArtifactStep.zig");
38	pub const InstallDirStep = @import("Build/InstallDirStep.zig");	37	pub const InstallDirStep = @import("Build/InstallDirStep.zig");
39	pub const InstallFileStep = @import("Build/InstallFileStep.zig");	38	pub const InstallFileStep = @import("Build/InstallFileStep.zig");
40	pub const ObjCopyStep = @import("Build/ObjCopyStep.zig");	39	pub const ObjCopyStep = @import("Build/ObjCopyStep.zig");
41	pub const CompileStep = @import("Build/CompileStep.zig");	40	pub const CompileStep = @import("Build/CompileStep.zig");
42	pub const LogStep = @import("Build/LogStep.zig");
43	pub const OptionsStep = @import("Build/OptionsStep.zig");	41	pub const OptionsStep = @import("Build/OptionsStep.zig");
44	pub const RemoveDirStep = @import("Build/RemoveDirStep.zig");	42	pub const RemoveDirStep = @import("Build/RemoveDirStep.zig");
45	pub const RunStep = @import("Build/RunStep.zig");	43	pub const RunStep = @import("Build/RunStep.zig");
...	@@ -195,7 +193,7 @@ pub fn create(	...	@@ -195,7 +193,7 @@ pub fn create(
195	env_map.* = try process.getEnvMap(allocator);	193	env_map.* = try process.getEnvMap(allocator);
196		194
197	const self = try allocator.create(Build);	195	const self = try allocator.create(Build);
198	self.* = Build{	196	self.* = .{
199	.zig_exe = zig_exe,	197	.zig_exe = zig_exe,
200	.build_root = build_root,	198	.build_root = build_root,
201	.cache_root = cache_root,	199	.cache_root = cache_root,
...	@@ -224,16 +222,18 @@ pub fn create(	...	@@ -224,16 +222,18 @@ pub fn create(
224	.dest_dir = env_map.get("DESTDIR"),	222	.dest_dir = env_map.get("DESTDIR"),
225	.installed_files = ArrayList(InstalledFile).init(allocator),	223	.installed_files = ArrayList(InstalledFile).init(allocator),
226	.install_tls = .{	224	.install_tls = .{
227	.step = Step.init(allocator, .{	225	.step = Step.init(.{
228	.id = .top_level,	226	.id = .top_level,
229	.name = "install",	227	.name = "install",
		228	.owner = self,
230	}),	229	}),
231	.description = "Copy build artifacts to prefix path",	230	.description = "Copy build artifacts to prefix path",
232	},	231	},
233	.uninstall_tls = .{	232	.uninstall_tls = .{
234	.step = Step.init(allocator, .{	233	.step = Step.init(.{
235	.id = .top_level,	234	.id = .top_level,
236	.name = "uninstall",	235	.name = "uninstall",
		236	.owner = self,
237	.makeFn = makeUninstall,	237	.makeFn = makeUninstall,
238	}),	238	}),
239	.description = "Remove build artifacts from prefix path",	239	.description = "Remove build artifacts from prefix path",
...	@@ -267,16 +267,18 @@ fn createChildOnly(parent: *Build, dep_name: []const u8, build_root: Cache.Direc	...	@@ -267,16 +267,18 @@ fn createChildOnly(parent: *Build, dep_name: []const u8, build_root: Cache.Direc
267	child.* = .{	267	child.* = .{
268	.allocator = allocator,	268	.allocator = allocator,
269	.install_tls = .{	269	.install_tls = .{
270	.step = Step.init(allocator, .{	270	.step = Step.init(.{
271	.id = .top_level,	271	.id = .top_level,
272	.name = "install",	272	.name = "install",
		273	.owner = child,
273	}),	274	}),
274	.description = "Copy build artifacts to prefix path",	275	.description = "Copy build artifacts to prefix path",
275	},	276	},
276	.uninstall_tls = .{	277	.uninstall_tls = .{
277	.step = Step.init(allocator, .{	278	.step = Step.init(.{
278	.id = .top_level,	279	.id = .top_level,
279	.name = "uninstall",	280	.name = "uninstall",
		281	.owner = child,
280	.makeFn = makeUninstall,	282	.makeFn = makeUninstall,
281	}),	283	}),
282	.description = "Remove build artifacts from prefix path",	284	.description = "Remove build artifacts from prefix path",
...	@@ -689,21 +691,14 @@ pub fn addWriteFiles(self: Build) WriteFileStep {	...	@@ -689,21 +691,14 @@ pub fn addWriteFiles(self: Build) WriteFileStep {
689	return write_file_step;	691	return write_file_step;
690	}	692	}
691		693
692	pub fn addLog(self: Build, comptime format: []const u8, args: anytype) LogStep {
693	const data = self.fmt(format, args);
694	const log_step = self.allocator.create(LogStep) catch @panic("OOM");
695	log_step.* = LogStep.init(self, data);
696	return log_step;
697	}
698
699	pub fn addRemoveDirTree(self: Build, dir_path: []const u8) RemoveDirStep {	694	pub fn addRemoveDirTree(self: Build, dir_path: []const u8) RemoveDirStep {
700	const remove_dir_step = self.allocator.create(RemoveDirStep) catch @panic("OOM");	695	const remove_dir_step = self.allocator.create(RemoveDirStep) catch @panic("OOM");
701	remove_dir_step.* = RemoveDirStep.init(self, dir_path);	696	remove_dir_step.* = RemoveDirStep.init(self, dir_path);
702	return remove_dir_step;	697	return remove_dir_step;
703	}	698	}
704		699
705	pub fn addFmt(self: Build, paths: []const []const u8) FmtStep {	700	pub fn addFmt(b: Build, options: FmtStep.Options) FmtStep {
706	return FmtStep.create(self, paths);	701	return FmtStep.create(b, options);
707	}	702	}
708		703
709	pub fn addTranslateC(self: Build, options: TranslateCStep.Options) TranslateCStep {	704	pub fn addTranslateC(self: Build, options: TranslateCStep.Options) TranslateCStep {
...	@@ -870,10 +865,11 @@ pub fn option(self: *Build, comptime T: type, name_raw: []const u8, description_	...	@@ -870,10 +865,11 @@ pub fn option(self: *Build, comptime T: type, name_raw: []const u8, description_
870		865
871	pub fn step(self: Build, name: []const u8, description: []const u8) Step {	866	pub fn step(self: Build, name: []const u8, description: []const u8) Step {
872	const step_info = self.allocator.create(TopLevelStep) catch @panic("OOM");	867	const step_info = self.allocator.create(TopLevelStep) catch @panic("OOM");
873	step_info.* = TopLevelStep{	868	step_info.* = .{
874	.step = Step.init(self.allocator, .{	869	.step = Step.init(.{
875	.id = .top_level,	870	.id = .top_level,
876	.name = name,	871	.name = name,
		872	.owner = self,
877	}),	873	}),
878	.description = self.dupe(description),	874	.description = self.dupe(description),
879	};	875	};
...	@@ -1145,10 +1141,6 @@ pub fn validateUserInputDidItFail(self: *Build) bool {	...	@@ -1145,10 +1141,6 @@ pub fn validateUserInputDidItFail(self: *Build) bool {
1145	return self.invalid_user_input;	1141	return self.invalid_user_input;
1146	}	1142	}
1147		1143
1148	pub fn spawnChild(self: *Build, argv: []const []const u8) !void {
1149	return self.spawnChildEnvMap(null, self.env_map, argv);
1150	}
1151
1152	fn allocPrintCmd(ally: Allocator, opt_cwd: ?[]const u8, argv: []const []const u8) ![]u8 {	1144	fn allocPrintCmd(ally: Allocator, opt_cwd: ?[]const u8, argv: []const []const u8) ![]u8 {
1153	var buf = ArrayList(u8).init(ally);	1145	var buf = ArrayList(u8).init(ally);
1154	if (opt_cwd) \|cwd\| try buf.writer().print("cd {s} && ", .{cwd});	1146	if (opt_cwd) \|cwd\| try buf.writer().print("cd {s} && ", .{cwd});
...	@@ -1163,40 +1155,6 @@ fn printCmd(ally: Allocator, cwd: ?[]const u8, argv: []const []const u8) void {	...	@@ -1163,40 +1155,6 @@ fn printCmd(ally: Allocator, cwd: ?[]const u8, argv: []const []const u8) void {
1163	std.debug.print("{s}\n", .{text});	1155	std.debug.print("{s}\n", .{text});
1164	}	1156	}
1165		1157
1166	pub fn spawnChildEnvMap(self: Build, cwd: ?[]const u8, env_map: const EnvMap, argv: []const []const u8) !void {
1167	if (self.verbose) {
1168	printCmd(self.allocator, cwd, argv);
1169	}
1170
1171	if (!process.can_spawn)
1172	return error.ExecNotSupported;
1173
1174	var child = std.ChildProcess.init(argv, self.allocator);
1175	child.cwd = cwd;
1176	child.env_map = env_map;
1177
1178	const term = child.spawnAndWait() catch \|err\| {
1179	log.err("Unable to spawn {s}: {s}", .{ argv[0], @errorName(err) });
1180	return err;
1181	};
1182
1183	switch (term) {
1184	.Exited => \|code\| {
1185	if (code != 0) {
1186	log.err("The following command exited with error code {}:", .{code});
1187	printCmd(self.allocator, cwd, argv);
1188	return error.UncleanExit;
1189	}
1190	},
1191	else => {
1192	log.err("The following command terminated unexpectedly:", .{});
1193	printCmd(self.allocator, cwd, argv);
1194
1195	return error.UncleanExit;
1196	},
1197	}
1198	}
1199
1200	pub fn installArtifact(self: Build, artifact: CompileStep) void {	1158	pub fn installArtifact(self: Build, artifact: CompileStep) void {
1201	self.getInstallStep().dependOn(&self.addInstallArtifact(artifact).step);	1159	self.getInstallStep().dependOn(&self.addInstallArtifact(artifact).step);
1202	}	1160	}
...	@@ -1403,160 +1361,6 @@ pub fn execAllowFail(	...	@@ -1403,160 +1361,6 @@ pub fn execAllowFail(
1403	}	1361	}
1404	}	1362	}
1405		1363
1406	/// This function is used exclusively for spawning and communicating with the zig compiler.
1407	/// TODO: move to build_runner.zig
1408	pub fn execFromStep(b: Build, argv: []const []const u8, s: Step, prog_node: *std.Progress.Node) ![]const u8 {
1409	assert(argv.len != 0);
1410
1411	if (b.verbose) {
1412	const text = try allocPrintCmd(b.allocator, null, argv);
1413	try s.result_error_msgs.append(b.allocator, text);
1414	}
1415
1416	if (!process.can_spawn) {
1417	try s.result_error_msgs.append(b.allocator, b.fmt("Unable to spawn the following command: cannot spawn child processes\n{s}", .{
1418	try allocPrintCmd(b.allocator, null, argv),
1419	}));
1420	return error.MakeFailed;
1421	}
1422
1423	var child = std.ChildProcess.init(argv, b.allocator);
1424	child.env_map = b.env_map;
1425	child.stdin_behavior = .Pipe;
1426	child.stdout_behavior = .Pipe;
1427	child.stderr_behavior = .Pipe;
1428
1429	try child.spawn();
1430
1431	var poller = std.io.poll(b.allocator, enum { stdout, stderr }, .{
1432	.stdout = child.stdout.?,
1433	.stderr = child.stderr.?,
1434	});
1435	defer poller.deinit();
1436
1437	try sendMessage(child.stdin.?, .update);
1438	try sendMessage(child.stdin.?, .exit);
1439
1440	const Header = std.zig.Server.Message.Header;
1441	var result: ?[]const u8 = null;
1442
1443	var node_name: std.ArrayListUnmanaged(u8) = .{};
1444	defer node_name.deinit(b.allocator);
1445	var sub_prog_node: ?std.Progress.Node = null;
1446	defer if (sub_prog_node) \|*n\| n.end();
1447
1448	while (try poller.poll()) {
1449	const stdout = poller.fifo(.stdout);
1450	const buf = stdout.readableSlice(0);
1451	assert(stdout.readableLength() == buf.len);
1452	if (buf.len >= @sizeOf(Header)) {
1453	const header = @ptrCast(*align(1) const Header, buf[0..@sizeOf(Header)]);
1454	const header_and_msg_len = header.bytes_len + @sizeOf(Header);
1455	if (buf.len >= header_and_msg_len) {
1456	const body = buf[@sizeOf(Header)..][0..header.bytes_len];
1457	switch (header.tag) {
1458	.zig_version => {
1459	if (!mem.eql(u8, builtin.zig_version_string, body)) {
1460	try s.result_error_msgs.append(
1461	b.allocator,
1462	b.fmt("zig version mismatch build runner vs compiler: '{s}' vs '{s}'", .{
1463	builtin.zig_version_string, body,
1464	}),
1465	);
1466	return error.MakeFailed;
1467	}
1468	},
1469	.error_bundle => {
1470	const EbHdr = std.zig.Server.Message.ErrorBundle;
1471	const eb_hdr = @ptrCast(*align(1) const EbHdr, body);
1472	const extra_bytes =
1473	body[@sizeOf(EbHdr)..][0 .. @sizeOf(u32) * eb_hdr.extra_len];
1474	const string_bytes =
1475	body[@sizeOf(EbHdr) + extra_bytes.len ..][0..eb_hdr.string_bytes_len];
1476	// TODO: use @ptrCast when the compiler supports it
1477	const unaligned_extra = mem.bytesAsSlice(u32, extra_bytes);
1478	const extra_array = try b.allocator.alloc(u32, unaligned_extra.len);
1479	// TODO: use @memcpy when it supports slices
1480	for (extra_array, unaligned_extra) \|dst, src\| dst. = src;
1481	s.result_error_bundle = .{
1482	.string_bytes = try b.allocator.dupe(u8, string_bytes),
1483	.extra = extra_array,
1484	};
1485	},
1486	.progress => {
1487	if (sub_prog_node) \|*n\| n.end();
1488	node_name.clearRetainingCapacity();
1489	try node_name.appendSlice(b.allocator, body);
1490	sub_prog_node = prog_node.start(node_name.items, 0);
1491	sub_prog_node.?.activate();
1492	},
1493	.emit_bin_path => {
1494	result = try b.allocator.dupe(u8, body);
1495	},
1496	_ => {
1497	// Unrecognized message.
1498	},
1499	}
1500	stdout.discard(header_and_msg_len);
1501	}
1502	}
1503	}
1504
1505	const stderr = poller.fifo(.stderr);
1506	if (stderr.readableLength() > 0) {
1507	try s.result_error_msgs.append(b.allocator, try stderr.toOwnedSlice());
1508	}
1509
1510	// Send EOF to stdin.
1511	child.stdin.?.close();
1512	child.stdin = null;
1513
1514	const term = try child.wait();
1515	switch (term) {
1516	.Exited => \|code\| {
1517	if (code != 0) {
1518	try s.result_error_msgs.append(b.allocator, b.fmt("the following command exited with error code {d}:\n{s}", .{
1519	code, try allocPrintCmd(b.allocator, null, argv),
1520	}));
1521	return error.MakeFailed;
1522	}
1523	},
1524	.Signal, .Stopped, .Unknown => \|code\| {
1525	_ = code;
1526	try s.result_error_msgs.append(b.allocator, b.fmt("the following command terminated unexpectedly:\n{s}", .{
1527	try allocPrintCmd(b.allocator, null, argv),
1528	}));
1529	return error.MakeFailed;
1530	},
1531	}
1532
1533	if (s.result_error_bundle.errorMessageCount() > 0) {
1534	try s.result_error_msgs.append(
1535	b.allocator,
1536	b.fmt("the following command failed with {d} compilation errors:\n{s}", .{
1537	s.result_error_bundle.errorMessageCount(),
1538	try allocPrintCmd(b.allocator, null, argv),
1539	}),
1540	);
1541	return error.MakeFailed;
1542	}
1543
1544	return result orelse {
1545	try s.result_error_msgs.append(b.allocator, b.fmt("the following command failed to communicate the compilation result:\n{s}", .{
1546	try allocPrintCmd(b.allocator, null, argv),
1547	}));
1548	return error.MakeFailed;
1549	};
1550	}
1551
1552	fn sendMessage(file: fs.File, tag: std.zig.Client.Message.Tag) !void {
1553	const header: std.zig.Client.Message.Header = .{
1554	.tag = tag,
1555	.bytes_len = 0,
1556	};
1557	try file.writeAll(std.mem.asBytes(&header));
1558	}
1559
1560	/// This is a helper function to be called from build.zig scripts, not from	1364	/// This is a helper function to be called from build.zig scripts, not from
1561	/// inside step make() functions. If any errors occur, it fails the build with	1365	/// inside step make() functions. If any errors occur, it fails the build with
1562	/// a helpful message.	1366	/// a helpful message.
...	@@ -1910,14 +1714,12 @@ pub fn serializeCpu(allocator: Allocator, cpu: std.Target.Cpu) ![]const u8 {	...	@@ -1910,14 +1714,12 @@ pub fn serializeCpu(allocator: Allocator, cpu: std.Target.Cpu) ![]const u8 {
1910	test {	1714	test {
1911	_ = CheckFileStep;	1715	_ = CheckFileStep;
1912	_ = CheckObjectStep;	1716	_ = CheckObjectStep;
1913	_ = EmulatableRunStep;
1914	_ = FmtStep;	1717	_ = FmtStep;
1915	_ = InstallArtifactStep;	1718	_ = InstallArtifactStep;
1916	_ = InstallDirStep;	1719	_ = InstallDirStep;
1917	_ = InstallFileStep;	1720	_ = InstallFileStep;
1918	_ = ObjCopyStep;	1721	_ = ObjCopyStep;
1919	_ = CompileStep;	1722	_ = CompileStep;
1920	_ = LogStep;
1921	_ = OptionsStep;	1723	_ = OptionsStep;
1922	_ = RemoveDirStep;	1724	_ = RemoveDirStep;
1923	_ = RunStep;	1725	_ = RunStep;

lib/std/Build/CheckFileStep.zig+9-9

 @@ -8,26 +8,25 @@ const CheckFileStep = @This();
 pub const base_id = .check_file;
 step: Step,
-builder: *std.Build,
 expected_matches: []const []const u8,
 source: std.Build.FileSource,
 max_bytes: usize = 20 * 1024 * 1024,
 pub fn create(
-    builder: *std.Build,
+    owner: *std.Build,
     source: std.Build.FileSource,
     expected_matches: []const []const u8,
 ) *CheckFileStep {
-    const self = builder.allocator.create(CheckFileStep) catch @panic("OOM");
+    const self = owner.allocator.create(CheckFileStep) catch @panic("OOM");
     self.* = CheckFileStep{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = .check_file,
             .name = "CheckFile",
+            .owner = owner,
             .makeFn = make,
         }),
-        .source = source.dupe(builder),
+        .source = source.dupe(owner),
-        .expected_matches = builder.dupeStrings(expected_matches),
+        .expected_matches = owner.dupeStrings(expected_matches),
     };
     self.source.addStepDependencies(&self.step);
     return self;
 @@ -35,10 +34,11 @@ pub fn create(
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
+    const b = step.owner;
     const self = @fieldParentPtr(CheckFileStep, "step", step);
-    const src_path = self.source.getPath(self.builder);
+    const src_path = self.source.getPath(b);
-    const contents = try fs.cwd().readFileAlloc(self.builder.allocator, src_path, self.max_bytes);
+    const contents = try fs.cwd().readFileAlloc(b.allocator, src_path, self.max_bytes);
     for (self.expected_matches) |expected_match| {
         if (mem.indexOf(u8, contents, expected_match) == null) {

lib/std/Build/CheckObjectStep.zig+22-15

 @@ -10,29 +10,31 @@ const CheckObjectStep = @This();
 const Allocator = mem.Allocator;
 const Step = std.Build.Step;
-const EmulatableRunStep = std.Build.EmulatableRunStep;
 pub const base_id = .check_object;
 step: Step,
-builder: *std.Build,
 source: std.Build.FileSource,
 max_bytes: usize = 20 * 1024 * 1024,
 checks: std.ArrayList(Check),
 dump_symtab: bool = false,
 obj_format: std.Target.ObjectFormat,
-pub fn create(builder: *std.Build, source: std.Build.FileSource, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
+pub fn create(
-    const gpa = builder.allocator;
+    owner: *std.Build,
+    source: std.Build.FileSource,
+    obj_format: std.Target.ObjectFormat,
+) *CheckObjectStep {
+    const gpa = owner.allocator;
     const self = gpa.create(CheckObjectStep) catch @panic("OOM");
     self.* = .{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(gpa, .{
             .id = .check_file,
             .name = "CheckObject",
+            .owner = owner,
             .makeFn = make,
         }),
-        .source = source.dupe(builder),
+        .source = source.dupe(owner),
         .checks = std.ArrayList(Check).init(gpa),
         .obj_format = obj_format,
     };
 @@ -42,14 +44,18 @@ pub fn create(builder: *std.Build, source: std.Build.FileSource, obj_format: std
 /// Runs and (optionally) compares the output of a binary.
 /// Asserts `self` was generated from an executable step.
-pub fn runAndCompare(self: *CheckObjectStep) *EmulatableRunStep {
+/// TODO this doesn't actually compare, and there's no apparent reason for it
+/// to depend on the check object step. I don't see why this function should exist,
+/// the caller could just add the run step directly.
+pub fn runAndCompare(self: *CheckObjectStep) *std.Build.RunStep {
     const dependencies_len = self.step.dependencies.items.len;
     assert(dependencies_len > 0);
     const exe_step = self.step.dependencies.items[dependencies_len - 1];
     const exe = exe_step.cast(std.Build.CompileStep).?;
-    const emulatable_step = EmulatableRunStep.create(self.builder, "EmulatableRun", exe);
+    const run = self.step.owner.addRunArtifact(exe);
-    emulatable_step.step.dependOn(&self.step);
+    run.skip_foreign_checks = true;
-    return emulatable_step;
+    run.step.dependOn(&self.step);
+    return run;
 }
 /// There two types of actions currently suported:
 @@ -253,7 +259,7 @@ const Check = struct {
 /// Creates a new sequence of actions with `phrase` as the first anchor searched phrase.
 pub fn checkStart(self: *CheckObjectStep, phrase: []const u8) void {
-    var new_check = Check.create(self.builder);
+    var new_check = Check.create(self.step.owner);
     new_check.match(phrase);
     self.checks.append(new_check) catch @panic("OOM");
 }
 @@ -295,17 +301,18 @@ pub fn checkComputeCompare(
     program: []const u8,
     expected: ComputeCompareExpected,
 ) void {
-    var new_check = Check.create(self.builder);
+    var new_check = Check.create(self.step.owner);
     new_check.computeCmp(program, expected);
     self.checks.append(new_check) catch @panic("OOM");
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
+    const b = step.owner;
+    const gpa = b.allocator;
     const self = @fieldParentPtr(CheckObjectStep, "step", step);
-    const gpa = self.builder.allocator;
+    const src_path = self.source.getPath(b);
-    const src_path = self.source.getPath(self.builder);
     const contents = try fs.cwd().readFileAllocOptions(
         gpa,
         src_path,

lib/std/Build/CompileStep.zig+241-215

 @@ -22,7 +22,6 @@ const InstallDir = std.Build.InstallDir;
 const InstallArtifactStep = std.Build.InstallArtifactStep;
 const GeneratedFile = std.Build.GeneratedFile;
 const ObjCopyStep = std.Build.ObjCopyStep;
-const EmulatableRunStep = std.Build.EmulatableRunStep;
 const CheckObjectStep = std.Build.CheckObjectStep;
 const RunStep = std.Build.RunStep;
 const OptionsStep = std.Build.OptionsStep;
 @@ -32,7 +31,6 @@ const CompileStep = @This();
 pub const base_id: Step.Id = .compile;
 step: Step,
-builder: *std.Build,
 name: []const u8,
 target: CrossTarget,
 target_info: NativeTargetInfo,
 @@ -305,24 +303,23 @@ pub const EmitOption = union(enum) {
     }
 };
-pub fn create(builder: *std.Build, options: Options) *CompileStep {
+pub fn create(owner: *std.Build, options: Options) *CompileStep {
-    const name = builder.dupe(options.name);
+    const name = owner.dupe(options.name);
-    const root_src: ?FileSource = if (options.root_source_file) |rsrc| rsrc.dupe(builder) else null;
+    const root_src: ?FileSource = if (options.root_source_file) |rsrc| rsrc.dupe(owner) else null;
     if (mem.indexOf(u8, name, "/") != null or mem.indexOf(u8, name, "\\") != null) {
         panic("invalid name: '{s}'. It looks like a file path, but it is supposed to be the library or application name.", .{name});
     }
-    const step_name = builder.fmt("compile {s} {s} {s}", .{
+    const step_name = owner.fmt("compile {s} {s} {s}", .{
         name,
         @tagName(options.optimize),
-        options.target.zigTriple(builder.allocator) catch @panic("OOM"),
+        options.target.zigTriple(owner.allocator) catch @panic("OOM"),
     });
-    const self = builder.allocator.create(CompileStep) catch @panic("OOM");
+    const self = owner.allocator.create(CompileStep) catch @panic("OOM");
     self.* = CompileStep{
         .strip = null,
         .unwind_tables = null,
-        .builder = builder,
         .verbose_link = false,
         .verbose_cc = false,
         .optimize = options.optimize,
 @@ -331,27 +328,28 @@ pub fn create(builder: *std.Build, options: Options) *CompileStep {
         .kind = options.kind,
         .root_src = root_src,
         .name = name,
-        .frameworks = StringHashMap(FrameworkLinkInfo).init(builder.allocator),
+        .frameworks = StringHashMap(FrameworkLinkInfo).init(owner.allocator),
-        .step = Step.init(builder.allocator, .{
+        .step = Step.init(.{
             .id = base_id,
             .name = step_name,
+            .owner = owner,
             .makeFn = make,
         }),
         .version = options.version,
         .out_filename = undefined,
-        .out_h_filename = builder.fmt("{s}.h", .{name}),
+        .out_h_filename = owner.fmt("{s}.h", .{name}),
         .out_lib_filename = undefined,
-        .out_pdb_filename = builder.fmt("{s}.pdb", .{name}),
+        .out_pdb_filename = owner.fmt("{s}.pdb", .{name}),
         .major_only_filename = null,
         .name_only_filename = null,
-        .modules = std.StringArrayHashMap(*Module).init(builder.allocator),
+        .modules = std.StringArrayHashMap(*Module).init(owner.allocator),
-        .include_dirs = ArrayList(IncludeDir).init(builder.allocator),
+        .include_dirs = ArrayList(IncludeDir).init(owner.allocator),
-        .link_objects = ArrayList(LinkObject).init(builder.allocator),
+        .link_objects = ArrayList(LinkObject).init(owner.allocator),
-        .c_macros = ArrayList([]const u8).init(builder.allocator),
+        .c_macros = ArrayList([]const u8).init(owner.allocator),
-        .lib_paths = ArrayList([]const u8).init(builder.allocator),
+        .lib_paths = ArrayList([]const u8).init(owner.allocator),
-        .rpaths = ArrayList([]const u8).init(builder.allocator),
+        .rpaths = ArrayList([]const u8).init(owner.allocator),
-        .framework_dirs = ArrayList([]const u8).init(builder.allocator),
+        .framework_dirs = ArrayList([]const u8).init(owner.allocator),
-        .installed_headers = ArrayList(*Step).init(builder.allocator),
+        .installed_headers = ArrayList(*Step).init(owner.allocator),
         .object_src = undefined,
         .c_std = std.Build.CStd.C99,
         .zig_lib_dir = null,
 @@ -382,9 +380,10 @@ pub fn create(builder: *std.Build, options: Options) *CompileStep {
 }
 fn computeOutFileNames(self: *CompileStep) void {
+    const b = self.step.owner;
     const target = self.target_info.target;
-    self.out_filename = std.zig.binNameAlloc(self.builder.allocator, .{
+    self.out_filename = std.zig.binNameAlloc(b.allocator, .{
         .root_name = self.name,
         .target = target,
         .output_mode = switch (self.kind) {
 @@ -404,30 +403,30 @@ fn computeOutFileNames(self: *CompileStep) void {
             self.out_lib_filename = self.out_filename;
         } else if (self.version) |version| {
             if (target.isDarwin()) {
-                self.major_only_filename = self.builder.fmt("lib{s}.{d}.dylib", .{
+                self.major_only_filename = b.fmt("lib{s}.{d}.dylib", .{
                     self.name,
                     version.major,
                 });
-                self.name_only_filename = self.builder.fmt("lib{s}.dylib", .{self.name});
+                self.name_only_filename = b.fmt("lib{s}.dylib", .{self.name});
                 self.out_lib_filename = self.out_filename;
             } else if (target.os.tag == .windows) {
-                self.out_lib_filename = self.builder.fmt("{s}.lib", .{self.name});
+                self.out_lib_filename = b.fmt("{s}.lib", .{self.name});
             } else {
-                self.major_only_filename = self.builder.fmt("lib{s}.so.{d}", .{ self.name, version.major });
+                self.major_only_filename = b.fmt("lib{s}.so.{d}", .{ self.name, version.major });
-                self.name_only_filename = self.builder.fmt("lib{s}.so", .{self.name});
+                self.name_only_filename = b.fmt("lib{s}.so", .{self.name});
                 self.out_lib_filename = self.out_filename;
             }
         } else {
             if (target.isDarwin()) {
                 self.out_lib_filename = self.out_filename;
             } else if (target.os.tag == .windows) {
-                self.out_lib_filename = self.builder.fmt("{s}.lib", .{self.name});
+                self.out_lib_filename = b.fmt("{s}.lib", .{self.name});
             } else {
                 self.out_lib_filename = self.out_filename;
             }
         }
         if (self.output_dir != null) {
-            self.output_lib_path_source.path = self.builder.pathJoin(
+            self.output_lib_path_source.path = b.pathJoin(
                 &.{ self.output_dir.?, self.out_lib_filename },
             );
         }
 @@ -435,17 +434,20 @@ fn computeOutFileNames(self: *CompileStep) void {
 }
 pub fn setOutputDir(self: *CompileStep, dir: []const u8) void {
-    self.output_dir = self.builder.dupePath(dir);
+    const b = self.step.owner;
+    self.output_dir = b.dupePath(dir);
 }
 pub fn install(self: *CompileStep) void {
-    self.builder.installArtifact(self);
+    const b = self.step.owner;
+    b.installArtifact(self);
 }
-pub fn installHeader(a: *CompileStep, src_path: []const u8, dest_rel_path: []const u8) void {
+pub fn installHeader(cs: *CompileStep, src_path: []const u8, dest_rel_path: []const u8) void {
-    const install_file = a.builder.addInstallHeaderFile(src_path, dest_rel_path);
+    const b = cs.step.owner;
-    a.builder.getInstallStep().dependOn(&install_file.step);
+    const install_file = b.addInstallHeaderFile(src_path, dest_rel_path);
-    a.installed_headers.append(&install_file.step) catch @panic("OOM");
+    b.getInstallStep().dependOn(&install_file.step);
+    cs.installed_headers.append(&install_file.step) catch @panic("OOM");
 }
 pub const InstallConfigHeaderOptions = struct {
 @@ -459,13 +461,14 @@ pub fn installConfigHeader(
     options: InstallConfigHeaderOptions,
 ) void {
     const dest_rel_path = options.dest_rel_path orelse config_header.include_path;
-    const install_file = cs.builder.addInstallFileWithDir(
+    const b = cs.step.owner;
+    const install_file = b.addInstallFileWithDir(
         .{ .generated = &config_header.output_file },
         options.install_dir,
         dest_rel_path,
     );
     install_file.step.dependOn(&config_header.step);
-    cs.builder.getInstallStep().dependOn(&install_file.step);
+    b.getInstallStep().dependOn(&install_file.step);
     cs.installed_headers.append(&install_file.step) catch @panic("OOM");
 }
 @@ -482,91 +485,84 @@ pub fn installHeadersDirectory(
 }
 pub fn installHeadersDirectoryOptions(
-    a: *CompileStep,
+    cs: *CompileStep,
     options: std.Build.InstallDirStep.Options,
 ) void {
-    const install_dir = a.builder.addInstallDirectory(options);
+    const b = cs.step.owner;
-    a.builder.getInstallStep().dependOn(&install_dir.step);
+    const install_dir = b.addInstallDirectory(options);
-    a.installed_headers.append(&install_dir.step) catch @panic("OOM");
+    b.getInstallStep().dependOn(&install_dir.step);
+    cs.installed_headers.append(&install_dir.step) catch @panic("OOM");
 }
-pub fn installLibraryHeaders(a: *CompileStep, l: *CompileStep) void {
+pub fn installLibraryHeaders(cs: *CompileStep, l: *CompileStep) void {
     assert(l.kind == .lib);
-    const install_step = a.builder.getInstallStep();
+    const b = cs.step.owner;
+    const install_step = b.getInstallStep();
     // Copy each element from installed_headers, modifying the builder
     // to be the new parent's builder.
     for (l.installed_headers.items) |step| {
         const step_copy = switch (step.id) {
             inline .install_file, .install_dir => |id| blk: {
                 const T = id.Type();
-                const ptr = a.builder.allocator.create(T) catch @panic("OOM");
+                const ptr = b.allocator.create(T) catch @panic("OOM");
                 ptr.* = step.cast(T).?.*;
-                ptr.override_source_builder = ptr.builder;
+                ptr.dest_builder = b;
-                ptr.builder = a.builder;
                 break :blk &ptr.step;
             },
             else => unreachable,
         };
-        a.installed_headers.append(step_copy) catch @panic("OOM");
+        cs.installed_headers.append(step_copy) catch @panic("OOM");
         install_step.dependOn(step_copy);
     }
-    a.installed_headers.appendSlice(l.installed_headers.items) catch @panic("OOM");
+    cs.installed_headers.appendSlice(l.installed_headers.items) catch @panic("OOM");
 }
 pub fn addObjCopy(cs: *CompileStep, options: ObjCopyStep.Options) *ObjCopyStep {
+    const b = cs.step.owner;
     var copy = options;
     if (copy.basename == null) {
         if (options.format) |f| {
-            copy.basename = cs.builder.fmt("{s}.{s}", .{ cs.name, @tagName(f) });
+            copy.basename = b.fmt("{s}.{s}", .{ cs.name, @tagName(f) });
         } else {
             copy.basename = cs.name;
         }
     }
-    return cs.builder.addObjCopy(cs.getOutputSource(), copy);
+    return b.addObjCopy(cs.getOutputSource(), copy);
 }
 /// Deprecated: use `std.Build.addRunArtifact`
 /// This function will run in the context of the package that created the executable,
 /// which is undesirable when running an executable provided by a dependency package.
-pub fn run(exe: *CompileStep) *RunStep {
+pub fn run(cs: *CompileStep) *RunStep {
-    return exe.builder.addRunArtifact(exe);
+    return cs.step.owner.addRunArtifact(cs);
-}
-/// Creates an `EmulatableRunStep` with an executable built with `addExecutable`.
-/// Allows running foreign binaries through emulation platforms such as Qemu or Rosetta.
-/// When a binary cannot be ran through emulation or the option is disabled, a warning
-/// will be printed and the binary will *NOT* be ran.
-pub fn runEmulatable(exe: *CompileStep) *EmulatableRunStep {
-    assert(exe.kind == .exe or exe.kind == .test_exe);
-    const run_step = EmulatableRunStep.create(exe.builder, exe.builder.fmt("run {s}", .{exe.step.name}), exe);
-    if (exe.vcpkg_bin_path) |path| {
-        RunStep.addPathDirInternal(&run_step.step, exe.builder, path);
-    }
-    return run_step;
 }
 pub fn checkObject(self: *CompileStep, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
-    return CheckObjectStep.create(self.builder, self.getOutputSource(), obj_format);
+    const b = self.step.owner;
+    return CheckObjectStep.create(b, self.getOutputSource(), obj_format);
 }
 pub fn setLinkerScriptPath(self: *CompileStep, source: FileSource) void {
-    self.linker_script = source.dupe(self.builder);
+    const b = self.step.owner;
+    self.linker_script = source.dupe(b);
     source.addStepDependencies(&self.step);
 }
 pub fn linkFramework(self: *CompileStep, framework_name: []const u8) void {
-    self.frameworks.put(self.builder.dupe(framework_name), .{}) catch @panic("OOM");
+    const b = self.step.owner;
+    self.frameworks.put(b.dupe(framework_name), .{}) catch @panic("OOM");
 }
 pub fn linkFrameworkNeeded(self: *CompileStep, framework_name: []const u8) void {
-    self.frameworks.put(self.builder.dupe(framework_name), .{
+    const b = self.step.owner;
+    self.frameworks.put(b.dupe(framework_name), .{
         .needed = true,
     }) catch @panic("OOM");
 }
 pub fn linkFrameworkWeak(self: *CompileStep, framework_name: []const u8) void {
-    self.frameworks.put(self.builder.dupe(framework_name), .{
+    const b = self.step.owner;
+    self.frameworks.put(b.dupe(framework_name), .{
         .weak = true,
     }) catch @panic("OOM");
 }
 @@ -619,21 +615,24 @@ pub fn linkLibCpp(self: *CompileStep) void {
 /// If the value is omitted, it is set to 1.
 /// `name` and `value` need not live longer than the function call.
 pub fn defineCMacro(self: *CompileStep, name: []const u8, value: ?[]const u8) void {
-    const macro = std.Build.constructCMacro(self.builder.allocator, name, value);
+    const b = self.step.owner;
+    const macro = std.Build.constructCMacro(b.allocator, name, value);
     self.c_macros.append(macro) catch @panic("OOM");
 }
 /// name_and_value looks like [name]=[value]. If the value is omitted, it is set to 1.
 pub fn defineCMacroRaw(self: *CompileStep, name_and_value: []const u8) void {
-    self.c_macros.append(self.builder.dupe(name_and_value)) catch @panic("OOM");
+    const b = self.step.owner;
+    self.c_macros.append(b.dupe(name_and_value)) catch @panic("OOM");
 }
 /// This one has no integration with anything, it just puts -lname on the command line.
 /// Prefer to use `linkSystemLibrary` instead.
 pub fn linkSystemLibraryName(self: *CompileStep, name: []const u8) void {
+    const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
-            .name = self.builder.dupe(name),
+            .name = b.dupe(name),
             .needed = false,
             .weak = false,
             .use_pkg_config = .no,
 @@ -644,9 +643,10 @@ pub fn linkSystemLibraryName(self: *CompileStep, name: []const u8) void {
 /// This one has no integration with anything, it just puts -needed-lname on the command line.
 /// Prefer to use `linkSystemLibraryNeeded` instead.
 pub fn linkSystemLibraryNeededName(self: *CompileStep, name: []const u8) void {
+    const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
-            .name = self.builder.dupe(name),
+            .name = b.dupe(name),
             .needed = true,
             .weak = false,
             .use_pkg_config = .no,
 @@ -657,9 +657,10 @@ pub fn linkSystemLibraryNeededName(self: *CompileStep, name: []const u8) void {
 /// Darwin-only. This one has no integration with anything, it just puts -weak-lname on the
 /// command line. Prefer to use `linkSystemLibraryWeak` instead.
 pub fn linkSystemLibraryWeakName(self: *CompileStep, name: []const u8) void {
+    const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
-            .name = self.builder.dupe(name),
+            .name = b.dupe(name),
             .needed = false,
             .weak = true,
             .use_pkg_config = .no,
 @@ -670,9 +671,10 @@ pub fn linkSystemLibraryWeakName(self: *CompileStep, name: []const u8) void {
 /// This links against a system library, exclusively using pkg-config to find the library.
 /// Prefer to use `linkSystemLibrary` instead.
 pub fn linkSystemLibraryPkgConfigOnly(self: *CompileStep, lib_name: []const u8) void {
+    const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
-            .name = self.builder.dupe(lib_name),
+            .name = b.dupe(lib_name),
             .needed = false,
             .weak = false,
             .use_pkg_config = .force,
 @@ -683,9 +685,10 @@ pub fn linkSystemLibraryPkgConfigOnly(self: *CompileStep, lib_name: []const u8)
 /// This links against a system library, exclusively using pkg-config to find the library.
 /// Prefer to use `linkSystemLibraryNeeded` instead.
 pub fn linkSystemLibraryNeededPkgConfigOnly(self: *CompileStep, lib_name: []const u8) void {
+    const b = self.step.owner;
     self.link_objects.append(.{
         .system_lib = .{
-            .name = self.builder.dupe(lib_name),
+            .name = b.dupe(lib_name),
             .needed = true,
             .weak = false,
             .use_pkg_config = .force,
 @@ -696,13 +699,14 @@ pub fn linkSystemLibraryNeededPkgConfigOnly(self: *CompileStep, lib_name: []cons
 /// Run pkg-config for the given library name and parse the output, returning the arguments
 /// that should be passed to zig to link the given library.
 pub fn runPkgConfig(self: *CompileStep, lib_name: []const u8) ![]const []const u8 {
+    const b = self.step.owner;
     const pkg_name = match: {
         // First we have to map the library name to pkg config name. Unfortunately,
         // there are several examples where this is not straightforward:
         // -lSDL2 -> pkg-config sdl2
         // -lgdk-3 -> pkg-config gdk-3.0
         // -latk-1.0 -> pkg-config atk
-        const pkgs = try getPkgConfigList(self.builder);
+        const pkgs = try getPkgConfigList(b);
         // Exact match means instant winner.
         for (pkgs) |pkg| {
 @@ -742,7 +746,7 @@ pub fn runPkgConfig(self: *CompileStep, lib_name: []const u8) ![]const []const u
     };
     var code: u8 = undefined;
-    const stdout = if (self.builder.execAllowFail(&[_][]const u8{
+    const stdout = if (b.execAllowFail(&[_][]const u8{
         "pkg-config",
         pkg_name,
         "--cflags",
 @@ -755,7 +759,7 @@ pub fn runPkgConfig(self: *CompileStep, lib_name: []const u8) ![]const []const u
         else => return err,
     };
-    var zig_args = ArrayList([]const u8).init(self.builder.allocator);
+    var zig_args = ArrayList([]const u8).init(b.allocator);
     defer zig_args.deinit();
     var it = mem.tokenize(u8, stdout, " \r\n\t");
 @@ -780,7 +784,7 @@ pub fn runPkgConfig(self: *CompileStep, lib_name: []const u8) ![]const []const u
             try zig_args.appendSlice(&[_][]const u8{ "-D", macro });
         } else if (mem.startsWith(u8, tok, "-D")) {
             try zig_args.append(tok);
-        } else if (self.builder.verbose) {
+        } else if (b.verbose) {
             log.warn("Ignoring pkg-config flag '{s}'", .{tok});
         }
     }
 @@ -804,6 +808,7 @@ fn linkSystemLibraryInner(self: *CompileStep, name: []const u8, opts: struct {
     needed: bool = false,
     weak: bool = false,
 }) void {
+    const b = self.step.owner;
     if (isLibCLibrary(name)) {
         self.linkLibC();
         return;
 @@ -815,7 +820,7 @@ fn linkSystemLibraryInner(self: *CompileStep, name: []const u8, opts: struct {
     self.link_objects.append(.{
         .system_lib = .{
-            .name = self.builder.dupe(name),
+            .name = b.dupe(name),
             .needed = opts.needed,
             .weak = opts.weak,
             .use_pkg_config = .yes,
 @@ -824,26 +829,30 @@ fn linkSystemLibraryInner(self: *CompileStep, name: []const u8, opts: struct {
 }
 pub fn setNamePrefix(self: *CompileStep, text: []const u8) void {
+    const b = self.step.owner;
     assert(self.kind == .@"test" or self.kind == .test_exe);
-    self.name_prefix = self.builder.dupe(text);
+    self.name_prefix = b.dupe(text);
 }
 pub fn setFilter(self: *CompileStep, text: ?[]const u8) void {
+    const b = self.step.owner;
     assert(self.kind == .@"test" or self.kind == .test_exe);
-    self.filter = if (text) |t| self.builder.dupe(t) else null;
+    self.filter = if (text) |t| b.dupe(t) else null;
 }
 pub fn setTestRunner(self: *CompileStep, path: ?[]const u8) void {
+    const b = self.step.owner;
     assert(self.kind == .@"test" or self.kind == .test_exe);
-    self.test_runner = if (path) |p| self.builder.dupePath(p) else null;
+    self.test_runner = if (path) |p| b.dupePath(p) else null;
 }
 /// Handy when you have many C/C++ source files and want them all to have the same flags.
 pub fn addCSourceFiles(self: *CompileStep, files: []const []const u8, flags: []const []const u8) void {
-    const c_source_files = self.builder.allocator.create(CSourceFiles) catch @panic("OOM");
+    const b = self.step.owner;
+    const c_source_files = b.allocator.create(CSourceFiles) catch @panic("OOM");
-    const files_copy = self.builder.dupeStrings(files);
+    const files_copy = b.dupeStrings(files);
-    const flags_copy = self.builder.dupeStrings(flags);
+    const flags_copy = b.dupeStrings(flags);
     c_source_files.* = .{
         .files = files_copy,
 @@ -860,8 +869,9 @@ pub fn addCSourceFile(self: *CompileStep, file: []const u8, flags: []const []con
 }
 pub fn addCSourceFileSource(self: *CompileStep, source: CSourceFile) void {
-    const c_source_file = self.builder.allocator.create(CSourceFile) catch @panic("OOM");
+    const b = self.step.owner;
-    c_source_file.* = source.dupe(self.builder);
+    const c_source_file = b.allocator.create(CSourceFile) catch @panic("OOM");
+    c_source_file.* = source.dupe(b);
     self.link_objects.append(.{ .c_source_file = c_source_file }) catch @panic("OOM");
     source.source.addStepDependencies(&self.step);
 }
 @@ -875,15 +885,18 @@ pub fn setVerboseCC(self: *CompileStep, value: bool) void {
 }
 pub fn overrideZigLibDir(self: *CompileStep, dir_path: []const u8) void {
-    self.zig_lib_dir = self.builder.dupePath(dir_path);
+    const b = self.step.owner;
+    self.zig_lib_dir = b.dupePath(dir_path);
 }
 pub fn setMainPkgPath(self: *CompileStep, dir_path: []const u8) void {
-    self.main_pkg_path = self.builder.dupePath(dir_path);
+    const b = self.step.owner;
+    self.main_pkg_path = b.dupePath(dir_path);
 }
 pub fn setLibCFile(self: *CompileStep, libc_file: ?FileSource) void {
-    self.libc_file = if (libc_file) |f| f.dupe(self.builder) else null;
+    const b = self.step.owner;
+    self.libc_file = if (libc_file) |f| f.dupe(b) else null;
 }
 /// Returns the generated executable, library or object file.
 @@ -914,13 +927,15 @@ pub fn getOutputPdbSource(self: *CompileStep) FileSource {
 }
 pub fn addAssemblyFile(self: *CompileStep, path: []const u8) void {
+    const b = self.step.owner;
     self.link_objects.append(.{
-        .assembly_file = .{ .path = self.builder.dupe(path) },
+        .assembly_file = .{ .path = b.dupe(path) },
     }) catch @panic("OOM");
 }
 pub fn addAssemblyFileSource(self: *CompileStep, source: FileSource) void {
-    const source_duped = source.dupe(self.builder);
+    const b = self.step.owner;
+    const source_duped = source.dupe(b);
     self.link_objects.append(.{ .assembly_file = source_duped }) catch @panic("OOM");
     source_duped.addStepDependencies(&self.step);
 }
 @@ -930,7 +945,8 @@ pub fn addObjectFile(self: *CompileStep, source_file: []const u8) void {
 }
 pub fn addObjectFileSource(self: *CompileStep, source: FileSource) void {
-    self.link_objects.append(.{ .static_path = source.dupe(self.builder) }) catch @panic("OOM");
+    const b = self.step.owner;
+    self.link_objects.append(.{ .static_path = source.dupe(b) }) catch @panic("OOM");
     source.addStepDependencies(&self.step);
 }
 @@ -945,11 +961,13 @@ pub const addLibPath = @compileError("deprecated, use addLibraryPath");
 pub const addFrameworkDir = @compileError("deprecated, use addFrameworkPath");
 pub fn addSystemIncludePath(self: *CompileStep, path: []const u8) void {
-    self.include_dirs.append(IncludeDir{ .raw_path_system = self.builder.dupe(path) }) catch @panic("OOM");
+    const b = self.step.owner;
+    self.include_dirs.append(IncludeDir{ .raw_path_system = b.dupe(path) }) catch @panic("OOM");
 }
 pub fn addIncludePath(self: *CompileStep, path: []const u8) void {
-    self.include_dirs.append(IncludeDir{ .raw_path = self.builder.dupe(path) }) catch @panic("OOM");
+    const b = self.step.owner;
+    self.include_dirs.append(IncludeDir{ .raw_path = b.dupe(path) }) catch @panic("OOM");
 }
 pub fn addConfigHeader(self: *CompileStep, config_header: *ConfigHeaderStep) void {
 @@ -958,23 +976,27 @@ pub fn addConfigHeader(self: *CompileStep, config_header: *ConfigHeaderStep) voi
 }
 pub fn addLibraryPath(self: *CompileStep, path: []const u8) void {
-    self.lib_paths.append(self.builder.dupe(path)) catch @panic("OOM");
+    const b = self.step.owner;
+    self.lib_paths.append(b.dupe(path)) catch @panic("OOM");
 }
 pub fn addRPath(self: *CompileStep, path: []const u8) void {
-    self.rpaths.append(self.builder.dupe(path)) catch @panic("OOM");
+    const b = self.step.owner;
+    self.rpaths.append(b.dupe(path)) catch @panic("OOM");
 }
 pub fn addFrameworkPath(self: *CompileStep, dir_path: []const u8) void {
-    self.framework_dirs.append(self.builder.dupe(dir_path)) catch @panic("OOM");
+    const b = self.step.owner;
+    self.framework_dirs.append(b.dupe(dir_path)) catch @panic("OOM");
 }
 /// Adds a module to be used with `@import` and exposing it in the current
 /// package's module table using `name`.
 pub fn addModule(cs: *CompileStep, name: []const u8, module: *Module) void {
-    cs.modules.put(cs.builder.dupe(name), module) catch @panic("OOM");
+    const b = cs.step.owner;
+    cs.modules.put(b.dupe(name), module) catch @panic("OOM");
-    var done = std.AutoHashMap(*Module, void).init(cs.builder.allocator);
+    var done = std.AutoHashMap(*Module, void).init(b.allocator);
     defer done.deinit();
     cs.addRecursiveBuildDeps(module, &done) catch @panic("OOM");
 }
 @@ -982,7 +1004,8 @@ pub fn addModule(cs: *CompileStep, name: []const u8, module: *Module) void {
 /// Adds a module to be used with `@import` without exposing it in the current
 /// package's module table.
 pub fn addAnonymousModule(cs: *CompileStep, name: []const u8, options: std.Build.CreateModuleOptions) void {
-    const module = cs.builder.createModule(options);
+    const b = cs.step.owner;
+    const module = b.createModule(options);
     return addModule(cs, name, module);
 }
 @@ -1002,12 +1025,13 @@ fn addRecursiveBuildDeps(cs: *CompileStep, module: *Module, done: *std.AutoHashM
 /// If Vcpkg was found on the system, it will be added to include and lib
 /// paths for the specified target.
 pub fn addVcpkgPaths(self: *CompileStep, linkage: CompileStep.Linkage) !void {
+    const b = self.step.owner;
     // Ideally in the Unattempted case we would call the function recursively
     // after findVcpkgRoot and have only one switch statement, but the compiler
     // cannot resolve the error set.
-    switch (self.builder.vcpkg_root) {
+    switch (b.vcpkg_root) {
         .unattempted => {
-            self.builder.vcpkg_root = if (try findVcpkgRoot(self.builder.allocator)) |root|
+            b.vcpkg_root = if (try findVcpkgRoot(b.allocator)) |root|
                 VcpkgRoot{ .found = root }
             else
                 .not_found;
 @@ -1016,31 +1040,32 @@ pub fn addVcpkgPaths(self: *CompileStep, linkage: CompileStep.Linkage) !void {
         .found => {},
     }
-    switch (self.builder.vcpkg_root) {
+    switch (b.vcpkg_root) {
         .unattempted => unreachable,
         .not_found => return error.VcpkgNotFound,
         .found => |root| {
-            const allocator = self.builder.allocator;
+            const allocator = b.allocator;
             const triplet = try self.target.vcpkgTriplet(allocator, if (linkage == .static) .Static else .Dynamic);
-            defer self.builder.allocator.free(triplet);
+            defer b.allocator.free(triplet);
-            const include_path = self.builder.pathJoin(&.{ root, "installed", triplet, "include" });
+            const include_path = b.pathJoin(&.{ root, "installed", triplet, "include" });
             errdefer allocator.free(include_path);
             try self.include_dirs.append(IncludeDir{ .raw_path = include_path });
-            const lib_path = self.builder.pathJoin(&.{ root, "installed", triplet, "lib" });
+            const lib_path = b.pathJoin(&.{ root, "installed", triplet, "lib" });
             try self.lib_paths.append(lib_path);
-            self.vcpkg_bin_path = self.builder.pathJoin(&.{ root, "installed", triplet, "bin" });
+            self.vcpkg_bin_path = b.pathJoin(&.{ root, "installed", triplet, "bin" });
         },
     }
 }
 pub fn setExecCmd(self: *CompileStep, args: []const ?[]const u8) void {
+    const b = self.step.owner;
     assert(self.kind == .@"test");
-    const duped_args = self.builder.allocator.alloc(?[]u8, args.len) catch @panic("OOM");
+    const duped_args = b.allocator.alloc(?[]u8, args.len) catch @panic("OOM");
     for (args, 0..) |arg, i| {
-        duped_args[i] = if (arg) |a| self.builder.dupe(a) else null;
+        duped_args[i] = if (arg) |a| b.dupe(a) else null;
     }
     self.exec_cmd_args = duped_args;
 }
 @@ -1055,16 +1080,17 @@ fn appendModuleArgs(
     cs: *CompileStep,
     zig_args: *ArrayList([]const u8),
 ) error{OutOfMemory}!void {
+    const b = cs.step.owner;
     // First, traverse the whole dependency graph and give every module a unique name, ideally one
     // named after what it's called somewhere in the graph. It will help here to have both a mapping
     // from module to name and a set of all the currently-used names.
-    var mod_names = std.AutoHashMap(*Module, []const u8).init(cs.builder.allocator);
+    var mod_names = std.AutoHashMap(*Module, []const u8).init(b.allocator);
-    var names = std.StringHashMap(void).init(cs.builder.allocator);
+    var names = std.StringHashMap(void).init(b.allocator);
     var to_name = std.ArrayList(struct {
         name: []const u8,
         mod: *Module,
-    }).init(cs.builder.allocator);
+    }).init(b.allocator);
     {
         var it = cs.modules.iterator();
         while (it.next()) |kv| {
 @@ -1085,7 +1111,7 @@ fn appendModuleArgs(
         if (mod_names.contains(dep.mod)) continue;
         // We'll use this buffer to store the name we decide on
-        var buf = try cs.builder.allocator.alloc(u8, dep.name.len + 32);
+        var buf = try b.allocator.alloc(u8, dep.name.len + 32);
         // First, try just the exposed dependency name
         std.mem.copy(u8, buf, dep.name);
         var name = buf[0..dep.name.len];
 @@ -1122,15 +1148,15 @@ fn appendModuleArgs(
             const mod = kv.key_ptr.*;
             const name = kv.value_ptr.*;
-            const deps_str = try constructDepString(cs.builder.allocator, mod_names, mod.dependencies);
+            const deps_str = try constructDepString(b.allocator, mod_names, mod.dependencies);
             const src = mod.builder.pathFromRoot(mod.source_file.getPath(mod.builder));
             try zig_args.append("--mod");
-            try zig_args.append(try std.fmt.allocPrint(cs.builder.allocator, "{s}:{s}:{s}", .{ name, deps_str, src }));
+            try zig_args.append(try std.fmt.allocPrint(b.allocator, "{s}:{s}:{s}", .{ name, deps_str, src }));
         }
     }
     // Lastly, output the root dependencies
-    const deps_str = try constructDepString(cs.builder.allocator, mod_names, cs.modules);
+    const deps_str = try constructDepString(b.allocator, mod_names, cs.modules);
     if (deps_str.len > 0) {
         try zig_args.append("--deps");
         try zig_args.append(deps_str);
 @@ -1161,18 +1187,18 @@ fn constructDepString(
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
+    const b = step.owner;
     const self = @fieldParentPtr(CompileStep, "step", step);
-    const builder = self.builder;
     if (self.root_src == null and self.link_objects.items.len == 0) {
         log.err("{s}: linker needs 1 or more objects to link", .{self.step.name});
         return error.NeedAnObject;
     }
-    var zig_args = ArrayList([]const u8).init(builder.allocator);
+    var zig_args = ArrayList([]const u8).init(b.allocator);
     defer zig_args.deinit();
-    try zig_args.append(builder.zig_exe);
+    try zig_args.append(b.zig_exe);
     const cmd = switch (self.kind) {
         .lib => "build-lib",
 @@ -1183,15 +1209,15 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     };
     try zig_args.append(cmd);
-    if (builder.reference_trace) |some| {
+    if (b.reference_trace) |some| {
-        try zig_args.append(try std.fmt.allocPrint(builder.allocator, "-freference-trace={d}", .{some}));
+        try zig_args.append(try std.fmt.allocPrint(b.allocator, "-freference-trace={d}", .{some}));
     }
     try addFlag(&zig_args, "LLVM", self.use_llvm);
     try addFlag(&zig_args, "LLD", self.use_lld);
     if (self.target.ofmt) |ofmt| {
-        try zig_args.append(try std.fmt.allocPrint(builder.allocator, "-ofmt={s}", .{@tagName(ofmt)}));
+        try zig_args.append(try std.fmt.allocPrint(b.allocator, "-ofmt={s}", .{@tagName(ofmt)}));
     }
     if (self.entry_symbol_name) |entry| {
 @@ -1201,18 +1227,18 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.stack_size) |stack_size| {
         try zig_args.append("--stack");
-        try zig_args.append(try std.fmt.allocPrint(builder.allocator, "{}", .{stack_size}));
+        try zig_args.append(try std.fmt.allocPrint(b.allocator, "{}", .{stack_size}));
     }
-    if (self.root_src) |root_src| try zig_args.append(root_src.getPath(builder));
+    if (self.root_src) |root_src| try zig_args.append(root_src.getPath(b));
     // We will add link objects from transitive dependencies, but we want to keep
     // all link objects in the same order provided.
     // This array is used to keep self.link_objects immutable.
     var transitive_deps: TransitiveDeps = .{
-        .link_objects = ArrayList(LinkObject).init(builder.allocator),
+        .link_objects = ArrayList(LinkObject).init(b.allocator),
-        .seen_system_libs = StringHashMap(void).init(builder.allocator),
+        .seen_system_libs = StringHashMap(void).init(b.allocator),
-        .seen_steps = std.AutoHashMap(*const Step, void).init(builder.allocator),
+        .seen_steps = std.AutoHashMap(*const Step, void).init(b.allocator),
         .is_linking_libcpp = self.is_linking_libcpp,
         .is_linking_libc = self.is_linking_libc,
         .frameworks = &self.frameworks,
 @@ -1225,14 +1251,14 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     for (transitive_deps.link_objects.items) |link_object| {
         switch (link_object) {
-            .static_path => |static_path| try zig_args.append(static_path.getPath(builder)),
+            .static_path => |static_path| try zig_args.append(static_path.getPath(b)),
             .other_step => |other| switch (other.kind) {
                 .exe => @panic("Cannot link with an executable build artifact"),
                 .test_exe => @panic("Cannot link with an executable build artifact"),
                 .@"test" => @panic("Cannot link with a test"),
                 .obj => {
-                    try zig_args.append(other.getOutputSource().getPath(builder));
+                    try zig_args.append(other.getOutputSource().getPath(b));
                 },
                 .lib => l: {
                     if (self.isStaticLibrary() and other.isStaticLibrary()) {
 @@ -1240,7 +1266,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                         break :l;
                     }
-                    const full_path_lib = other.getOutputLibSource().getPath(builder);
+                    const full_path_lib = other.getOutputLibSource().getPath(b);
                     try zig_args.append(full_path_lib);
                     if (other.linkage == Linkage.dynamic and !self.target.isWindows()) {
 @@ -1262,7 +1288,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                     break :prefix "-l";
                 };
                 switch (system_lib.use_pkg_config) {
-                    .no => try zig_args.append(builder.fmt("{s}{s}", .{ prefix, system_lib.name })),
+                    .no => try zig_args.append(b.fmt("{s}{s}", .{ prefix, system_lib.name })),
                     .yes, .force => {
                         if (self.runPkgConfig(system_lib.name)) |args| {
                             try zig_args.appendSlice(args);
 @@ -1276,7 +1302,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                                 .yes => {
                                     // pkg-config failed, so fall back to linking the library
                                     // by name directly.
-                                    try zig_args.append(builder.fmt("{s}{s}", .{
+                                    try zig_args.append(b.fmt("{s}{s}", .{
                                         prefix,
                                         system_lib.name,
                                     }));
 @@ -1299,7 +1325,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                     try zig_args.append("--");
                     prev_has_extra_flags = false;
                 }
-                try zig_args.append(asm_file.getPath(builder));
+                try zig_args.append(asm_file.getPath(b));
             },
             .c_source_file => |c_source_file| {
 @@ -1316,7 +1342,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                     }
                     try zig_args.append("--");
                 }
-                try zig_args.append(c_source_file.source.getPath(builder));
+                try zig_args.append(c_source_file.source.getPath(b));
             },
             .c_source_files => |c_source_files| {
 @@ -1334,7 +1360,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                     try zig_args.append("--");
                 }
                 for (c_source_files.files) |file| {
-                    try zig_args.append(builder.pathFromRoot(file));
+                    try zig_args.append(b.pathFromRoot(file));
                 }
             },
         }
 @@ -1350,7 +1376,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.image_base) |image_base| {
         try zig_args.append("--image-base");
-        try zig_args.append(builder.fmt("0x{x}", .{image_base}));
+        try zig_args.append(b.fmt("0x{x}", .{image_base}));
     }
     if (self.filter) |filter| {
 @@ -1369,32 +1395,32 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.test_runner) |test_runner| {
         try zig_args.append("--test-runner");
-        try zig_args.append(builder.pathFromRoot(test_runner));
+        try zig_args.append(b.pathFromRoot(test_runner));
     }
-    for (builder.debug_log_scopes) |log_scope| {
+    for (b.debug_log_scopes) |log_scope| {
         try zig_args.append("--debug-log");
         try zig_args.append(log_scope);
     }
-    if (builder.debug_compile_errors) {
+    if (b.debug_compile_errors) {
         try zig_args.append("--debug-compile-errors");
     }
-    if (builder.verbose_cimport) try zig_args.append("--verbose-cimport");
+    if (b.verbose_cimport) try zig_args.append("--verbose-cimport");
-    if (builder.verbose_air) try zig_args.append("--verbose-air");
+    if (b.verbose_air) try zig_args.append("--verbose-air");
-    if (builder.verbose_llvm_ir) try zig_args.append("--verbose-llvm-ir");
+    if (b.verbose_llvm_ir) try zig_args.append("--verbose-llvm-ir");
-    if (builder.verbose_link or self.verbose_link) try zig_args.append("--verbose-link");
+    if (b.verbose_link or self.verbose_link) try zig_args.append("--verbose-link");
-    if (builder.verbose_cc or self.verbose_cc) try zig_args.append("--verbose-cc");
+    if (b.verbose_cc or self.verbose_cc) try zig_args.append("--verbose-cc");
-    if (builder.verbose_llvm_cpu_features) try zig_args.append("--verbose-llvm-cpu-features");
+    if (b.verbose_llvm_cpu_features) try zig_args.append("--verbose-llvm-cpu-features");
-    if (self.emit_analysis.getArg(builder, "emit-analysis")) |arg| try zig_args.append(arg);
+    if (self.emit_analysis.getArg(b, "emit-analysis")) |arg| try zig_args.append(arg);
-    if (self.emit_asm.getArg(builder, "emit-asm")) |arg| try zig_args.append(arg);
+    if (self.emit_asm.getArg(b, "emit-asm")) |arg| try zig_args.append(arg);
-    if (self.emit_bin.getArg(builder, "emit-bin")) |arg| try zig_args.append(arg);
+    if (self.emit_bin.getArg(b, "emit-bin")) |arg| try zig_args.append(arg);
-    if (self.emit_docs.getArg(builder, "emit-docs")) |arg| try zig_args.append(arg);
+    if (self.emit_docs.getArg(b, "emit-docs")) |arg| try zig_args.append(arg);
-    if (self.emit_implib.getArg(builder, "emit-implib")) |arg| try zig_args.append(arg);
+    if (self.emit_implib.getArg(b, "emit-implib")) |arg| try zig_args.append(arg);
-    if (self.emit_llvm_bc.getArg(builder, "emit-llvm-bc")) |arg| try zig_args.append(arg);
+    if (self.emit_llvm_bc.getArg(b, "emit-llvm-bc")) |arg| try zig_args.append(arg);
-    if (self.emit_llvm_ir.getArg(builder, "emit-llvm-ir")) |arg| try zig_args.append(arg);
+    if (self.emit_llvm_ir.getArg(b, "emit-llvm-ir")) |arg| try zig_args.append(arg);
     if (self.emit_h) try zig_args.append("-femit-h");
 @@ -1435,31 +1461,31 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     }
     if (self.link_z_common_page_size) |size| {
         try zig_args.append("-z");
-        try zig_args.append(builder.fmt("common-page-size={d}", .{size}));
+        try zig_args.append(b.fmt("common-page-size={d}", .{size}));
     }
     if (self.link_z_max_page_size) |size| {
         try zig_args.append("-z");
-        try zig_args.append(builder.fmt("max-page-size={d}", .{size}));
+        try zig_args.append(b.fmt("max-page-size={d}", .{size}));
     }
     if (self.libc_file) |libc_file| {
         try zig_args.append("--libc");
-        try zig_args.append(libc_file.getPath(builder));
+        try zig_args.append(libc_file.getPath(b));
-    } else if (builder.libc_file) |libc_file| {
+    } else if (b.libc_file) |libc_file| {
         try zig_args.append("--libc");
         try zig_args.append(libc_file);
     }
     switch (self.optimize) {
         .Debug => {}, // Skip since it's the default.
-        else => try zig_args.append(builder.fmt("-O{s}", .{@tagName(self.optimize)})),
+        else => try zig_args.append(b.fmt("-O{s}", .{@tagName(self.optimize)})),
     }
     try zig_args.append("--cache-dir");
-    try zig_args.append(builder.cache_root.path orelse ".");
+    try zig_args.append(b.cache_root.path orelse ".");
     try zig_args.append("--global-cache-dir");
-    try zig_args.append(builder.global_cache_root.path orelse ".");
+    try zig_args.append(b.global_cache_root.path orelse ".");
     try zig_args.append("--name");
     try zig_args.append(self.name);
 @@ -1471,11 +1497,11 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.kind == .lib and self.linkage != null and self.linkage.? == .dynamic) {
         if (self.version) |version| {
             try zig_args.append("--version");
-            try zig_args.append(builder.fmt("{}", .{version}));
+            try zig_args.append(b.fmt("{}", .{version}));
         }
         if (self.target.isDarwin()) {
-            const install_name = self.install_name orelse builder.fmt("@rpath/{s}{s}{s}", .{
+            const install_name = self.install_name orelse b.fmt("@rpath/{s}{s}{s}", .{
                 self.target.libPrefix(),
                 self.name,
                 self.target.dynamicLibSuffix(),
 @@ -1489,7 +1515,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         try zig_args.appendSlice(&[_][]const u8{ "--entitlements", entitlements });
     }
     if (self.pagezero_size) |pagezero_size| {
-        const size = try std.fmt.allocPrint(builder.allocator, "{x}", .{pagezero_size});
+        const size = try std.fmt.allocPrint(b.allocator, "{x}", .{pagezero_size});
         try zig_args.appendSlice(&[_][]const u8{ "-pagezero_size", size });
     }
     if (self.search_strategy) |strat| switch (strat) {
 @@ -1497,7 +1523,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         .dylibs_first => try zig_args.append("-search_dylibs_first"),
     };
     if (self.headerpad_size) |headerpad_size| {
-        const size = try std.fmt.allocPrint(builder.allocator, "{x}", .{headerpad_size});
+        const size = try std.fmt.allocPrint(b.allocator, "{x}", .{headerpad_size});
         try zig_args.appendSlice(&[_][]const u8{ "-headerpad", size });
     }
     if (self.headerpad_max_install_names) {
 @@ -1545,16 +1571,16 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         try zig_args.append("--export-table");
     }
     if (self.initial_memory) |initial_memory| {
-        try zig_args.append(builder.fmt("--initial-memory={d}", .{initial_memory}));
+        try zig_args.append(b.fmt("--initial-memory={d}", .{initial_memory}));
     }
     if (self.max_memory) |max_memory| {
-        try zig_args.append(builder.fmt("--max-memory={d}", .{max_memory}));
+        try zig_args.append(b.fmt("--max-memory={d}", .{max_memory}));
     }
     if (self.shared_memory) {
         try zig_args.append("--shared-memory");
     }
     if (self.global_base) |global_base| {
-        try zig_args.append(builder.fmt("--global-base={d}", .{global_base}));
+        try zig_args.append(b.fmt("--global-base={d}", .{global_base}));
     }
     if (self.code_model != .default) {
 @@ -1562,16 +1588,16 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         try zig_args.append(@tagName(self.code_model));
     }
     if (self.wasi_exec_model) |model| {
-        try zig_args.append(builder.fmt("-mexec-model={s}", .{@tagName(model)}));
+        try zig_args.append(b.fmt("-mexec-model={s}", .{@tagName(model)}));
     }
     for (self.export_symbol_names) |symbol_name| {
-        try zig_args.append(builder.fmt("--export={s}", .{symbol_name}));
+        try zig_args.append(b.fmt("--export={s}", .{symbol_name}));
     }
     if (!self.target.isNative()) {
         try zig_args.appendSlice(&.{
-            "-target", try self.target.zigTriple(builder.allocator),
+            "-target", try self.target.zigTriple(b.allocator),
-            "-mcpu",   try std.Build.serializeCpu(builder.allocator, self.target.getCpu()),
+            "-mcpu",   try std.Build.serializeCpu(b.allocator, self.target.getCpu()),
         });
         if (self.target.dynamic_linker.get()) |dynamic_linker| {
 @@ -1582,12 +1608,12 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.linker_script) |linker_script| {
         try zig_args.append("--script");
-        try zig_args.append(linker_script.getPath(builder));
+        try zig_args.append(linker_script.getPath(b));
     }
     if (self.version_script) |version_script| {
         try zig_args.append("--version-script");
-        try zig_args.append(builder.pathFromRoot(version_script));
+        try zig_args.append(b.pathFromRoot(version_script));
     }
     if (self.kind == .@"test") {
 @@ -1603,23 +1629,23 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         } else {
             const need_cross_glibc = self.target.isGnuLibC() and transitive_deps.is_linking_libc;
-            switch (builder.host.getExternalExecutor(self.target_info, .{
+            switch (b.host.getExternalExecutor(self.target_info, .{
-                .qemu_fixes_dl = need_cross_glibc and builder.glibc_runtimes_dir != null,
+                .qemu_fixes_dl = need_cross_glibc and b.glibc_runtimes_dir != null,
                 .link_libc = transitive_deps.is_linking_libc,
             })) {
                 .native => {},
                 .bad_dl, .bad_os_or_cpu => {
                     try zig_args.append("--test-no-exec");
                 },
-                .rosetta => if (builder.enable_rosetta) {
+                .rosetta => if (b.enable_rosetta) {
                     try zig_args.append("--test-cmd-bin");
                 } else {
                     try zig_args.append("--test-no-exec");
                 },
                 .qemu => |bin_name| ok: {
-                    if (builder.enable_qemu) qemu: {
+                    if (b.enable_qemu) qemu: {
                         const glibc_dir_arg = if (need_cross_glibc)
-                            builder.glibc_runtimes_dir orelse break :qemu
+                            b.glibc_runtimes_dir orelse break :qemu
                         else
                             null;
                         try zig_args.append("--test-cmd");
 @@ -1636,7 +1662,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                                 "i686"
                             else
                                 @tagName(cpu_arch);
-                            const full_dir = try std.fmt.allocPrint(builder.allocator, fmt_str, .{
+                            const full_dir = try std.fmt.allocPrint(b.allocator, fmt_str, .{
                                 dir, cpu_arch_name, @tagName(os_tag), @tagName(abi),
                             });
 @@ -1650,14 +1676,14 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                     }
                     try zig_args.append("--test-no-exec");
                 },
-                .wine => |bin_name| if (builder.enable_wine) {
+                .wine => |bin_name| if (b.enable_wine) {
                     try zig_args.append("--test-cmd");
                     try zig_args.append(bin_name);
                     try zig_args.append("--test-cmd-bin");
                 } else {
                     try zig_args.append("--test-no-exec");
                 },
-                .wasmtime => |bin_name| if (builder.enable_wasmtime) {
+                .wasmtime => |bin_name| if (b.enable_wasmtime) {
                     try zig_args.append("--test-cmd");
                     try zig_args.append(bin_name);
                     try zig_args.append("--test-cmd");
 @@ -1666,7 +1692,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                 } else {
                     try zig_args.append("--test-no-exec");
                 },
-                .darling => |bin_name| if (builder.enable_darling) {
+                .darling => |bin_name| if (b.enable_darling) {
                     try zig_args.append("--test-cmd");
                     try zig_args.append(bin_name);
                     try zig_args.append("--test-cmd-bin");
 @@ -1685,18 +1711,18 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         switch (include_dir) {
             .raw_path => |include_path| {
                 try zig_args.append("-I");
-                try zig_args.append(builder.pathFromRoot(include_path));
+                try zig_args.append(b.pathFromRoot(include_path));
             },
             .raw_path_system => |include_path| {
-                if (builder.sysroot != null) {
+                if (b.sysroot != null) {
                     try zig_args.append("-iwithsysroot");
                 } else {
                     try zig_args.append("-isystem");
                 }
-                const resolved_include_path = builder.pathFromRoot(include_path);
+                const resolved_include_path = b.pathFromRoot(include_path);
-                const common_include_path = if (builtin.os.tag == .windows and builder.sysroot != null and fs.path.isAbsolute(resolved_include_path)) blk: {
+                const common_include_path = if (builtin.os.tag == .windows and b.sysroot != null and fs.path.isAbsolute(resolved_include_path)) blk: {
                     // We need to check for disk designator and strip it out from dir path so
                     // that zig/clang can concat resolved_include_path with sysroot.
                     const disk_designator = fs.path.diskDesignatorWindows(resolved_include_path);
 @@ -1712,7 +1738,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
             },
             .other_step => |other| {
                 if (other.emit_h) {
-                    const h_path = other.getOutputHSource().getPath(builder);
+                    const h_path = other.getOutputHSource().getPath(b);
                     try zig_args.append("-isystem");
                     try zig_args.append(fs.path.dirname(h_path).?);
                 }
 @@ -1721,8 +1747,8 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                         try install_step.make(prog_node);
                     }
                     try zig_args.append("-I");
-                    try zig_args.append(builder.pathJoin(&.{
+                    try zig_args.append(b.pathJoin(&.{
-                        other.builder.install_prefix, "include",
+                        other.step.owner.install_prefix, "include",
                     }));
                 }
             },
 @@ -1751,7 +1777,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.target.isDarwin()) {
         for (self.framework_dirs.items) |dir| {
-            if (builder.sysroot != null) {
+            if (b.sysroot != null) {
                 try zig_args.append("-iframeworkwithsysroot");
             } else {
                 try zig_args.append("-iframework");
 @@ -1784,17 +1810,17 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         }
     }
-    if (builder.sysroot) |sysroot| {
+    if (b.sysroot) |sysroot| {
         try zig_args.appendSlice(&[_][]const u8{ "--sysroot", sysroot });
     }
-    for (builder.search_prefixes.items) |search_prefix| {
+    for (b.search_prefixes.items) |search_prefix| {
         try zig_args.append("-L");
-        try zig_args.append(builder.pathJoin(&.{
+        try zig_args.append(b.pathJoin(&.{
             search_prefix, "lib",
         }));
         try zig_args.append("-I");
-        try zig_args.append(builder.pathJoin(&.{
+        try zig_args.append(b.pathJoin(&.{
             search_prefix, "include",
         }));
     }
 @@ -1805,15 +1831,15 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (self.zig_lib_dir) |dir| {
         try zig_args.append("--zig-lib-dir");
-        try zig_args.append(builder.pathFromRoot(dir));
+        try zig_args.append(b.pathFromRoot(dir));
-    } else if (builder.zig_lib_dir) |dir| {
+    } else if (b.zig_lib_dir) |dir| {
         try zig_args.append("--zig-lib-dir");
         try zig_args.append(dir);
     }
     if (self.main_pkg_path) |dir| {
         try zig_args.append("--main-pkg-path");
-        try zig_args.append(builder.pathFromRoot(dir));
+        try zig_args.append(b.pathFromRoot(dir));
     }
     try addFlag(&zig_args, "PIC", self.force_pic);
 @@ -1846,15 +1872,15 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         args_length += arg.len + 1; // +1 to account for null terminator
     }
     if (args_length >= 30 * 1024) {
-        try builder.cache_root.handle.makePath("args");
+        try b.cache_root.handle.makePath("args");
         const args_to_escape = zig_args.items[2..];
-        var escaped_args = try ArrayList([]const u8).initCapacity(builder.allocator, args_to_escape.len);
+        var escaped_args = try ArrayList([]const u8).initCapacity(b.allocator, args_to_escape.len);
         arg_blk: for (args_to_escape) |arg| {
             for (arg, 0..) |c, arg_idx| {
                 if (c == '\\' or c == '"') {
                     // Slow path for arguments that need to be escaped. We'll need to allocate and copy
-                    var escaped = try ArrayList(u8).initCapacity(builder.allocator, arg.len + 1);
+                    var escaped = try ArrayList(u8).initCapacity(b.allocator, arg.len + 1);
                     const writer = escaped.writer();
                     try writer.writeAll(arg[0..arg_idx]);
                     for (arg[arg_idx..]) |to_escape| {
 @@ -1870,8 +1896,8 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         // Write the args to zig-cache/args/<SHA256 hash of args> to avoid conflicts with
         // other zig build commands running in parallel.
-        const partially_quoted = try std.mem.join(builder.allocator, "\" \"", escaped_args.items);
+        const partially_quoted = try std.mem.join(b.allocator, "\" \"", escaped_args.items);
-        const args = try std.mem.concat(builder.allocator, u8, &[_][]const u8{ "\"", partially_quoted, "\"" });
+        const args = try std.mem.concat(b.allocator, u8, &[_][]const u8{ "\"", partially_quoted, "\"" });
         var args_hash: [Sha256.digest_length]u8 = undefined;
         Sha256.hash(args, &args_hash, .{});
 @@ -1883,18 +1909,18 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         );
         const args_file = "args" ++ fs.path.sep_str ++ args_hex_hash;
-        try builder.cache_root.handle.writeFile(args_file, args);
+        try b.cache_root.handle.writeFile(args_file, args);
-        const resolved_args_file = try mem.concat(builder.allocator, u8, &.{
+        const resolved_args_file = try mem.concat(b.allocator, u8, &.{
             "@",
-            try builder.cache_root.join(builder.allocator, &.{args_file}),
+            try b.cache_root.join(b.allocator, &.{args_file}),
         });
         zig_args.shrinkRetainingCapacity(2);
         try zig_args.append(resolved_args_file);
     }
-    const output_bin_path = try builder.execFromStep(zig_args.items, &self.step, prog_node);
+    const output_bin_path = try step.evalZigProcess(zig_args.items, prog_node);
     const build_output_dir = fs.path.dirname(output_bin_path).?;
     if (self.output_dir) |output_dir| {
 @@ -1928,25 +1954,25 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     // Update generated files
     if (self.output_dir != null) {
-        self.output_path_source.path = builder.pathJoin(
+        self.output_path_source.path = b.pathJoin(
             &.{ self.output_dir.?, self.out_filename },
         );
         if (self.emit_h) {
-            self.output_h_path_source.path = builder.pathJoin(
+            self.output_h_path_source.path = b.pathJoin(
                 &.{ self.output_dir.?, self.out_h_filename },
             );
         }
         if (self.target.isWindows() or self.target.isUefi()) {
-            self.output_pdb_path_source.path = builder.pathJoin(
+            self.output_pdb_path_source.path = b.pathJoin(
                 &.{ self.output_dir.?, self.out_pdb_filename },
             );
         }
     }
     if (self.kind == .lib and self.linkage != null and self.linkage.? == .dynamic and self.version != null and self.target.wantSharedLibSymLinks()) {
-        try doAtomicSymLinks(builder.allocator, self.getOutputSource().getPath(builder), self.major_only_filename.?, self.name_only_filename.?);
+        try doAtomicSymLinks(b.allocator, self.getOutputSource().getPath(b), self.major_only_filename.?, self.name_only_filename.?);
     }
 }

lib/std/Build/ConfigHeaderStep.zig+13-14

 @@ -34,7 +34,6 @@ pub const Value = union(enum) {
 };
 step: Step,
-builder: *std.Build,
 values: std.StringArrayHashMap(Value),
 output_file: std.Build.GeneratedFile,
 @@ -49,8 +48,8 @@ pub const Options = struct {
     first_ret_addr: ?usize = null,
 };
-pub fn create(builder: *std.Build, options: Options) *ConfigHeaderStep {
+pub fn create(owner: *std.Build, options: Options) *ConfigHeaderStep {
-    const self = builder.allocator.create(ConfigHeaderStep) catch @panic("OOM");
+    const self = owner.allocator.create(ConfigHeaderStep) catch @panic("OOM");
     var include_path: []const u8 = "config.h";
 @@ -69,29 +68,28 @@ pub fn create(builder: *std.Build, options: Options) *ConfigHeaderStep {
     }
     const name = if (options.style.getFileSource()) |s|
-        builder.fmt("configure {s} header {s} to {s}", .{
+        owner.fmt("configure {s} header {s} to {s}", .{
             @tagName(options.style), s.getDisplayName(), include_path,
         })
     else
-        builder.fmt("configure {s} header to {s}", .{@tagName(options.style), include_path});
+        owner.fmt("configure {s} header to {s}", .{ @tagName(options.style), include_path });
     self.* = .{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = base_id,
             .name = name,
+            .owner = owner,
             .makeFn = make,
             .first_ret_addr = options.first_ret_addr orelse @returnAddress(),
         }),
         .style = options.style,
-        .values = std.StringArrayHashMap(Value).init(builder.allocator),
+        .values = std.StringArrayHashMap(Value).init(owner.allocator),
         .max_bytes = options.max_bytes,
         .include_path = include_path,
         .output_file = .{ .step = &self.step },
     };
     return self;
 }
 @@ -161,8 +159,9 @@ fn putValue(self: *ConfigHeaderStep, field_name: []const u8, comptime T: type, v
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
+    const b = step.owner;
     const self = @fieldParentPtr(ConfigHeaderStep, "step", step);
-    const gpa = self.builder.allocator;
+    const gpa = b.allocator;
     // The cache is used here not really as a way to speed things up - because writing
     // the data to a file would probably be very fast - but as a way to find a canonical
 @@ -191,13 +190,13 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     switch (self.style) {
         .autoconf => |file_source| {
             try output.appendSlice(c_generated_line);
-            const src_path = file_source.getPath(self.builder);
+            const src_path = file_source.getPath(b);
             const contents = try std.fs.cwd().readFileAlloc(gpa, src_path, self.max_bytes);
             try render_autoconf(contents, &output, self.values, src_path);
         },
         .cmake => |file_source| {
             try output.appendSlice(c_generated_line);
-            const src_path = file_source.getPath(self.builder);
+            const src_path = file_source.getPath(b);
             const contents = try std.fs.cwd().readFileAlloc(gpa, src_path, self.max_bytes);
             try render_cmake(contents, &output, self.values, src_path);
         },
 @@ -222,7 +221,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         .{std.fmt.fmtSliceHexLower(&digest)},
     ) catch unreachable;
-    const output_dir = try self.builder.cache_root.join(gpa, &.{ "o", &hash_basename });
+    const output_dir = try b.cache_root.join(gpa, &.{ "o", &hash_basename });
     // If output_path has directory parts, deal with them.  Example:
     // output_dir is zig-cache/o/HASH
 @@ -242,7 +241,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     try dir.writeFile(std.fs.path.basename(self.include_path), output.items);
-    self.output_file.path = try std.fs.path.join(self.builder.allocator, &.{
+    self.output_file.path = try std.fs.path.join(b.allocator, &.{
         output_dir, self.include_path,
     });
 }

lib/std/Build/EmulatableRunStep.zig deleted-218

...	@@ -1,218 +0,0 @@
1	//! Unlike `RunStep` this step will provide emulation, when enabled, to run foreign binaries.
2	//! When a binary is foreign, but emulation for the target is disabled, the specified binary
3	//! will not be run and therefore also not validated against its output.
4	//! This step can be useful when wishing to run a built binary on multiple platforms,
5	//! without having to verify if it's possible to be ran against.
6
7	const std = @import("../std.zig");
8	const Step = std.Build.Step;
9	const CompileStep = std.Build.CompileStep;
10	const RunStep = std.Build.RunStep;
11
12	const fs = std.fs;
13	const process = std.process;
14	const EnvMap = process.EnvMap;
15
16	const EmulatableRunStep = @This();
17
18	pub const base_id = .emulatable_run;
19
20	const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
21
22	step: Step,
23	builder: *std.Build,
24
25	/// The artifact (executable) to be run by this step
26	exe: *CompileStep,
27
28	/// Set this to `null` to ignore the exit code for the purpose of determining a successful execution
29	expected_term: ?std.ChildProcess.Term = .{ .Exited = 0 },
30
31	/// Override this field to modify the environment
32	env_map: ?*EnvMap,
33
34	/// Set this to modify the current working directory
35	cwd: ?[]const u8,
36
37	stdout_action: RunStep.StdIoAction = .inherit,
38	stderr_action: RunStep.StdIoAction = .inherit,
39
40	/// When set to true, hides the warning of skipping a foreign binary which cannot be run on the host
41	/// or through emulation.
42	hide_foreign_binaries_warning: bool,
43
44	/// Creates a step that will execute the given artifact. This step will allow running the
45	/// binary through emulation when any of the emulation options such as `enable_rosetta` are set to true.
46	/// When set to false, and the binary is foreign, running the executable is skipped.
47	/// Asserts given artifact is an executable.
48	pub fn create(builder: std.Build, name: []const u8, artifact: CompileStep) *EmulatableRunStep {
49	std.debug.assert(artifact.kind == .exe or artifact.kind == .test_exe);
50	const self = builder.allocator.create(EmulatableRunStep) catch @panic("OOM");
51
52	const option_name = "hide-foreign-warnings";
53	const hide_warnings = if (builder.available_options_map.get(option_name) == null) warn: {
54	break :warn builder.option(bool, option_name, "Hide the warning when a foreign binary which is incompatible is skipped") orelse false;
55	} else false;
56
57	self.* = .{
58	.builder = builder,
59	.step = Step.init(builder.allocator, .{
60	.id = .emulatable_run,
61	.name = name,
62	.makeFn = make,
63	}),
64	.exe = artifact,
65	.env_map = null,
66	.cwd = null,
67	.hide_foreign_binaries_warning = hide_warnings,
68	};
69	self.step.dependOn(&artifact.step);
70
71	return self;
72	}
73
74	fn make(step: Step, prog_node: std.Progress.Node) !void {
75	_ = prog_node;
76	const self = @fieldParentPtr(EmulatableRunStep, "step", step);
77	const host_info = self.builder.host;
78
79	var argv_list = std.ArrayList([]const u8).init(self.builder.allocator);
80	defer argv_list.deinit();
81
82	const need_cross_glibc = self.exe.target.isGnuLibC() and self.exe.is_linking_libc;
83	switch (host_info.getExternalExecutor(self.exe.target_info, .{
84	.qemu_fixes_dl = need_cross_glibc and self.builder.glibc_runtimes_dir != null,
85	.link_libc = self.exe.is_linking_libc,
86	})) {
87	.native => {},
88	.rosetta => if (!self.builder.enable_rosetta) return warnAboutForeignBinaries(self),
89	.wine => \|bin_name\| if (self.builder.enable_wine) {
90	try argv_list.append(bin_name);
91	} else return,
92	.qemu => \|bin_name\| if (self.builder.enable_qemu) {
93	const glibc_dir_arg = if (need_cross_glibc)
94	self.builder.glibc_runtimes_dir orelse return
95	else
96	null;
97	try argv_list.append(bin_name);
98	if (glibc_dir_arg) \|dir\| {
99	// TODO look into making this a call to `linuxTriple`. This
100	// needs the directory to be called "i686" rather than
101	// "x86" which is why we do it manually here.
102	const fmt_str = "{s}" ++ fs.path.sep_str ++ "{s}-{s}-{s}";
103	const cpu_arch = self.exe.target.getCpuArch();
104	const os_tag = self.exe.target.getOsTag();
105	const abi = self.exe.target.getAbi();
106	const cpu_arch_name: []const u8 = if (cpu_arch == .x86)
107	"i686"
108	else
109	@tagName(cpu_arch);
110	const full_dir = try std.fmt.allocPrint(self.builder.allocator, fmt_str, .{
111	dir, cpu_arch_name, @tagName(os_tag), @tagName(abi),
112	});
113
114	try argv_list.append("-L");
115	try argv_list.append(full_dir);
116	}
117	} else return warnAboutForeignBinaries(self),
118	.darling => \|bin_name\| if (self.builder.enable_darling) {
119	try argv_list.append(bin_name);
120	} else return warnAboutForeignBinaries(self),
121	.wasmtime => \|bin_name\| if (self.builder.enable_wasmtime) {
122	try argv_list.append(bin_name);
123	try argv_list.append("--dir=.");
124	} else return warnAboutForeignBinaries(self),
125	else => return warnAboutForeignBinaries(self),
126	}
127
128	if (self.exe.target.isWindows()) {
129	// On Windows we don't have rpaths so we have to add .dll search paths to PATH
130	RunStep.addPathForDynLibsInternal(&self.step, self.builder, self.exe);
131	}
132
133	const executable_path = self.exe.installed_path orelse self.exe.getOutputSource().getPath(self.builder);
134	try argv_list.append(executable_path);
135
136	try RunStep.runCommand(
137	argv_list.items,
138	self.builder,
139	self.expected_term,
140	self.stdout_action,
141	self.stderr_action,
142	.Inherit,
143	self.env_map,
144	self.cwd,
145	false,
146	);
147	}
148
149	pub fn expectStdErrEqual(self: *EmulatableRunStep, bytes: []const u8) void {
150	self.stderr_action = .{ .expect_exact = self.builder.dupe(bytes) };
151	}
152
153	pub fn expectStdOutEqual(self: *EmulatableRunStep, bytes: []const u8) void {
154	self.stdout_action = .{ .expect_exact = self.builder.dupe(bytes) };
155	}
156
157	fn warnAboutForeignBinaries(step: *EmulatableRunStep) void {
158	if (step.hide_foreign_binaries_warning) return;
159	const builder = step.builder;
160	const artifact = step.exe;
161
162	const host_name = builder.host.target.zigTriple(builder.allocator) catch @panic("unhandled error");
163	const foreign_name = artifact.target.zigTriple(builder.allocator) catch @panic("unhandled error");
164	const target_info = std.zig.system.NativeTargetInfo.detect(artifact.target) catch @panic("unhandled error");
165	const need_cross_glibc = artifact.target.isGnuLibC() and artifact.is_linking_libc;
166	switch (builder.host.getExternalExecutor(target_info, .{
167	.qemu_fixes_dl = need_cross_glibc and builder.glibc_runtimes_dir != null,
168	.link_libc = artifact.is_linking_libc,
169	})) {
170	.native => unreachable,
171	.bad_dl => \|foreign_dl\| {
172	const host_dl = builder.host.dynamic_linker.get() orelse "(none)";
173	std.debug.print("the host system does not appear to be capable of executing binaries from the target because the host dynamic linker is '{s}', while the target dynamic linker is '{s}'. Consider setting the dynamic linker as '{s}'.\n", .{
174	host_dl, foreign_dl, host_dl,
175	});
176	},
177	.bad_os_or_cpu => {
178	std.debug.print("the host system ({s}) does not appear to be capable of executing binaries from the target ({s}).\n", .{
179	host_name, foreign_name,
180	});
181	},
182	.darling => if (!builder.enable_darling) {
183	std.debug.print(
184	"the host system ({s}) does not appear to be capable of executing binaries " ++
185	"from the target ({s}). Consider enabling darling.\n",
186	.{ host_name, foreign_name },
187	);
188	},
189	.rosetta => if (!builder.enable_rosetta) {
190	std.debug.print(
191	"the host system ({s}) does not appear to be capable of executing binaries " ++
192	"from the target ({s}). Consider enabling rosetta.\n",
193	.{ host_name, foreign_name },
194	);
195	},
196	.wine => if (!builder.enable_wine) {
197	std.debug.print(
198	"the host system ({s}) does not appear to be capable of executing binaries " ++
199	"from the target ({s}). Consider enabling wine.\n",
200	.{ host_name, foreign_name },
201	);
202	},
203	.qemu => if (!builder.enable_qemu) {
204	std.debug.print(
205	"the host system ({s}) does not appear to be capable of executing binaries " ++
206	"from the target ({s}). Consider enabling qemu.\n",
207	.{ host_name, foreign_name },
208	);
209	},
210	.wasmtime => {
211	std.debug.print(
212	"the host system ({s}) does not appear to be capable of executing binaries " ++
213	"from the target ({s}). Consider enabling wasmtime.\n",
214	.{ host_name, foreign_name },
215	);
216	},
217	}
218	}

lib/std/Build/FmtStep.zig+58-22

...	@@ -1,37 +1,73 @@	...	@@ -1,37 +1,73 @@
1	const std = @import("../std.zig");	1	//! This step has two modes:
2	const Step = std.Build.Step;	2	//! * Modify mode: directly modify source files, formatting them in place.
3	const FmtStep = @This();	3	//! * Check mode: fail the step if a non-conforming file is found.
		4
		5	step: Step,
		6	paths: []const []const u8,
		7	exclude_paths: []const []const u8,
		8	check: bool,
4		9
5	pub const base_id = .fmt;	10	pub const base_id = .fmt;
6		11
7	step: Step,	12	pub const Options = struct {
8	builder: *std.Build,	13	paths: []const []const u8 = &.{},
9	argv: [][]const u8,	14	exclude_paths: []const []const u8 = &.{},
10		15	/// If true, fails the build step when any non-conforming files are encountered.
11	pub fn create(builder: std.Build, paths: []const []const u8) FmtStep {	16	check: bool = false,
12	const self = builder.allocator.create(FmtStep) catch @panic("OOM");	17	};
13	const name = "zig fmt";	18
14	self.* = FmtStep{	19	pub fn create(owner: std.Build, options: Options) FmtStep {
15	.step = Step.init(builder.allocator, .{	20	const self = owner.allocator.create(FmtStep) catch @panic("OOM");
16	.id = .fmt,	21	const name = if (options.check) "zig fmt --check" else "zig fmt";
		22	self.* = .{
		23	.step = Step.init(.{
		24	.id = base_id,
17	.name = name,	25	.name = name,
		26	.owner = owner,
18	.makeFn = make,	27	.makeFn = make,
19	}),	28	}),
20	.builder = builder,	29	.paths = options.paths,
21	.argv = builder.allocator.alloc([]u8, paths.len + 2) catch @panic("OOM"),	30	.exclude_paths = options.exclude_paths,
		31	.check = options.check,
22	};	32	};
23
24	self.argv[0] = builder.zig_exe;
25	self.argv[1] = "fmt";
26	for (paths, 0..) \|path, i\| {
27	self.argv[2 + i] = builder.pathFromRoot(path);
28	}
29	return self;	33	return self;
30	}	34	}
31		35
32	fn make(step: Step, prog_node: std.Progress.Node) !void {	36	fn make(step: Step, prog_node: std.Progress.Node) !void {
		37	// zig fmt is fast enough that no progress is needed.
33	_ = prog_node;	38	_ = prog_node;
		39
		40	// TODO: if check=false, this means we are modifying source files in place, which
		41	// is an operation that could race against other operations also modifying source files
		42	// in place. In this case, this step should obtain a write lock while making those
		43	// modifications.
		44
		45	const b = step.owner;
		46	const arena = b.allocator;
34	const self = @fieldParentPtr(FmtStep, "step", step);	47	const self = @fieldParentPtr(FmtStep, "step", step);
35		48
36	return self.builder.spawnChild(self.argv);	49	var argv: std.ArrayListUnmanaged([]const u8) = .{};
		50	try argv.ensureUnusedCapacity(arena, 2 + 1 + self.paths.len + 2 * self.exclude_paths.len);
		51
		52	argv.appendAssumeCapacity(b.zig_exe);
		53	argv.appendAssumeCapacity("fmt");
		54
		55	if (self.check) {
		56	argv.appendAssumeCapacity("--check");
		57	}
		58
		59	for (self.paths) \|p\| {
		60	argv.appendAssumeCapacity(b.pathFromRoot(p));
		61	}
		62
		63	for (self.exclude_paths) \|p\| {
		64	argv.appendAssumeCapacity("--exclude");
		65	argv.appendAssumeCapacity(b.pathFromRoot(p));
		66	}
		67
		68	return step.evalChildProcess(argv.items);
37	}	69	}
		70
		71	const std = @import("../std.zig");
		72	const Step = std.Build.Step;
		73	const FmtStep = @This();

lib/std/Build/InstallArtifactStep.zig+27-22

 @@ -7,23 +7,24 @@ const InstallArtifactStep = @This();
 pub const base_id = .install_artifact;
 step: Step,
-builder: *std.Build,
+dest_builder: *std.Build,
 artifact: *CompileStep,
 dest_dir: InstallDir,
 pdb_dir: ?InstallDir,
 h_dir: ?InstallDir,
-pub fn create(builder: *std.Build, artifact: *CompileStep) *InstallArtifactStep {
+pub fn create(owner: *std.Build, artifact: *CompileStep) *InstallArtifactStep {
     if (artifact.install_step) |s| return s;
-    const self = builder.allocator.create(InstallArtifactStep) catch @panic("OOM");
+    const self = owner.allocator.create(InstallArtifactStep) catch @panic("OOM");
     self.* = InstallArtifactStep{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = base_id,
-            .name = builder.fmt("install {s}", .{artifact.name}),
+            .name = owner.fmt("install {s}", .{artifact.name}),
+            .owner = owner,
             .makeFn = make,
         }),
+        .dest_builder = owner,
         .artifact = artifact,
         .dest_dir = artifact.override_dest_dir orelse switch (artifact.kind) {
             .obj => @panic("Cannot install a .obj build artifact."),
 @@ -43,48 +44,52 @@ pub fn create(builder: *std.Build, artifact: *CompileStep) *InstallArtifactStep
     self.step.dependOn(&artifact.step);
     artifact.install_step = self;
-    builder.pushInstalledFile(self.dest_dir, artifact.out_filename);
+    owner.pushInstalledFile(self.dest_dir, artifact.out_filename);
     if (self.artifact.isDynamicLibrary()) {
         if (artifact.major_only_filename) |name| {
-            builder.pushInstalledFile(.lib, name);
+            owner.pushInstalledFile(.lib, name);
         }
         if (artifact.name_only_filename) |name| {
-            builder.pushInstalledFile(.lib, name);
+            owner.pushInstalledFile(.lib, name);
         }
         if (self.artifact.target.isWindows()) {
-            builder.pushInstalledFile(.lib, artifact.out_lib_filename);
+            owner.pushInstalledFile(.lib, artifact.out_lib_filename);
         }
     }
     if (self.pdb_dir) |pdb_dir| {
-        builder.pushInstalledFile(pdb_dir, artifact.out_pdb_filename);
+        owner.pushInstalledFile(pdb_dir, artifact.out_pdb_filename);
     }
     if (self.h_dir) |h_dir| {
-        builder.pushInstalledFile(h_dir, artifact.out_h_filename);
+        owner.pushInstalledFile(h_dir, artifact.out_h_filename);
     }
     return self;
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
+    const src_builder = step.owner;
     const self = @fieldParentPtr(InstallArtifactStep, "step", step);
-    const builder = self.builder;
+    const dest_builder = self.dest_builder;
-    const full_dest_path = builder.getInstallPath(self.dest_dir, self.artifact.out_filename);
+    const full_dest_path = dest_builder.getInstallPath(self.dest_dir, self.artifact.out_filename);
-    try builder.updateFile(self.artifact.getOutputSource().getPath(builder), full_dest_path);
+    try src_builder.updateFile(
+        self.artifact.getOutputSource().getPath(src_builder),
+        full_dest_path,
+    );
     if (self.artifact.isDynamicLibrary() and self.artifact.version != null and self.artifact.target.wantSharedLibSymLinks()) {
-        try CompileStep.doAtomicSymLinks(builder.allocator, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);
+        try CompileStep.doAtomicSymLinks(src_builder.allocator, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);
     }
     if (self.artifact.isDynamicLibrary() and self.artifact.target.isWindows() and self.artifact.emit_implib != .no_emit) {
-        const full_implib_path = builder.getInstallPath(self.dest_dir, self.artifact.out_lib_filename);
+        const full_implib_path = dest_builder.getInstallPath(self.dest_dir, self.artifact.out_lib_filename);
-        try builder.updateFile(self.artifact.getOutputLibSource().getPath(builder), full_implib_path);
+        try src_builder.updateFile(self.artifact.getOutputLibSource().getPath(src_builder), full_implib_path);
     }
     if (self.pdb_dir) |pdb_dir| {
-        const full_pdb_path = builder.getInstallPath(pdb_dir, self.artifact.out_pdb_filename);
+        const full_pdb_path = dest_builder.getInstallPath(pdb_dir, self.artifact.out_pdb_filename);
-        try builder.updateFile(self.artifact.getOutputPdbSource().getPath(builder), full_pdb_path);
+        try src_builder.updateFile(self.artifact.getOutputPdbSource().getPath(src_builder), full_pdb_path);
     }
     if (self.h_dir) |h_dir| {
-        const full_h_path = builder.getInstallPath(h_dir, self.artifact.out_h_filename);
+        const full_h_path = dest_builder.getInstallPath(h_dir, self.artifact.out_h_filename);
-        try builder.updateFile(self.artifact.getOutputHSource().getPath(builder), full_h_path);
+        try src_builder.updateFile(self.artifact.getOutputHSource().getPath(src_builder), full_h_path);
     }
     self.artifact.installed_path = full_dest_path;
 }

lib/std/Build/InstallDirStep.zig+16-18

 @@ -7,11 +7,10 @@ const InstallDirStep = @This();
 const log = std.log;
 step: Step,
-builder: *std.Build,
 options: Options,
 /// This is used by the build system when a file being installed comes from one
 /// package but is being installed by another.
-override_source_builder: ?*std.Build = null,
+dest_builder: *std.Build,
 pub const base_id = .install_dir;
 @@ -40,27 +39,26 @@ pub const Options = struct {
     }
 };
-pub fn init(
+pub fn init(owner: *std.Build, options: Options) InstallDirStep {
-    builder: *std.Build,
+    owner.pushInstalledFile(options.install_dir, options.install_subdir);
-    options: Options,
-) InstallDirStep {
-    builder.pushInstalledFile(options.install_dir, options.install_subdir);
     return .{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = .install_dir,
-            .name = builder.fmt("install {s}/", .{options.source_dir}),
+            .name = owner.fmt("install {s}/", .{options.source_dir}),
+            .owner = owner,
             .makeFn = make,
         }),
-        .options = options.dupe(builder),
+        .options = options.dupe(owner),
+        .dest_builder = owner,
     };
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
     const self = @fieldParentPtr(InstallDirStep, "step", step);
-    const dest_prefix = self.builder.getInstallPath(self.options.install_dir, self.options.install_subdir);
+    const dest_builder = self.dest_builder;
-    const src_builder = self.override_source_builder orelse self.builder;
+    const dest_prefix = dest_builder.getInstallPath(self.options.install_dir, self.options.install_subdir);
+    const src_builder = self.step.owner;
     const full_src_dir = src_builder.pathFromRoot(self.options.source_dir);
     var src_dir = std.fs.cwd().openIterableDir(full_src_dir, .{}) catch |err| {
         log.err("InstallDirStep: unable to open source directory '{s}': {s}", .{
 @@ -69,7 +67,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         return error.StepFailed;
     };
     defer src_dir.close();
-    var it = try src_dir.walk(self.builder.allocator);
+    var it = try src_dir.walk(dest_builder.allocator);
     next_entry: while (try it.next()) |entry| {
         for (self.options.exclude_extensions) |ext| {
             if (mem.endsWith(u8, entry.path, ext)) {
 @@ -77,20 +75,20 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
             }
         }
-        const full_path = self.builder.pathJoin(&.{ full_src_dir, entry.path });
+        const full_path = dest_builder.pathJoin(&.{ full_src_dir, entry.path });
-        const dest_path = self.builder.pathJoin(&.{ dest_prefix, entry.path });
+        const dest_path = dest_builder.pathJoin(&.{ dest_prefix, entry.path });
         switch (entry.kind) {
             .Directory => try fs.cwd().makePath(dest_path),
             .File => {
                 for (self.options.blank_extensions) |ext| {
                     if (mem.endsWith(u8, entry.path, ext)) {
-                        try self.builder.truncateFile(dest_path);
+                        try dest_builder.truncateFile(dest_path);
                         continue :next_entry;
                     }
                 }
-                try self.builder.updateFile(full_path, dest_path);
+                try dest_builder.updateFile(full_path, dest_path);
             },
             else => continue,
         }

lib/std/Build/InstallFileStep.zig+15-14

 @@ -7,39 +7,40 @@ const InstallFileStep = @This();
 pub const base_id = .install_file;
 step: Step,
-builder: *std.Build,
 source: FileSource,
 dir: InstallDir,
 dest_rel_path: []const u8,
 /// This is used by the build system when a file being installed comes from one
 /// package but is being installed by another.
-override_source_builder: ?*std.Build = null,
+dest_builder: *std.Build,
 pub fn init(
-    builder: *std.Build,
+    owner: *std.Build,
     source: FileSource,
     dir: InstallDir,
     dest_rel_path: []const u8,
 ) InstallFileStep {
-    builder.pushInstalledFile(dir, dest_rel_path);
+    owner.pushInstalledFile(dir, dest_rel_path);
     return InstallFileStep{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
+            .id = base_id,
-            .id = .install_file,
+            .name = owner.fmt("install {s} to {s}", .{ source.getDisplayName(), dest_rel_path }),
-            .name = builder.fmt("install {s} to {s}", .{ source.getDisplayName(), dest_rel_path }),
+            .owner = owner,
             .makeFn = make,
         }),
-        .source = source.dupe(builder),
+        .source = source.dupe(owner),
-        .dir = dir.dupe(builder),
+        .dir = dir.dupe(owner),
-        .dest_rel_path = builder.dupePath(dest_rel_path),
+        .dest_rel_path = owner.dupePath(dest_rel_path),
+        .dest_builder = owner,
     };
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
+    const src_builder = step.owner;
     const self = @fieldParentPtr(InstallFileStep, "step", step);
-    const src_builder = self.override_source_builder orelse self.builder;
+    const dest_builder = self.dest_builder;
     const full_src_path = self.source.getPath2(src_builder, step);
-    const full_dest_path = self.builder.getInstallPath(self.dir, self.dest_rel_path);
+    const full_dest_path = dest_builder.getInstallPath(self.dir, self.dest_rel_path);
-    try self.builder.updateFile(full_src_path, full_dest_path);
+    try dest_builder.updateFile(full_src_path, full_dest_path);
 }

lib/std/Build/LogStep.zig deleted-28

...	@@ -1,28 +0,0 @@
1	const std = @import("../std.zig");
2	const log = std.log;
3	const Step = std.Build.Step;
4	const LogStep = @This();
5
6	pub const base_id = .log;
7
8	step: Step,
9	builder: *std.Build,
10	data: []const u8,
11
12	pub fn init(builder: *std.Build, data: []const u8) LogStep {
13	return LogStep{
14	.builder = builder,
15	.step = Step.init(builder.allocator, .{
16	.id = .log,
17	.name = builder.fmt("log {s}", .{data}),
18	.makeFn = make,
19	}),
20	.data = builder.dupe(data),
21	};
22	}
23
24	fn make(step: Step, prog_node: std.Progress.Node) anyerror!void {
25	_ = prog_node;
26	const self = @fieldParentPtr(LogStep, "step", step);
27	log.info("{s}", .{self.data});
28	}

lib/std/Build/ObjCopyStep.zig+8-25

 @@ -21,7 +21,6 @@ pub const RawFormat = enum {
 };
 step: Step,
-builder: *std.Build,
 file_source: std.Build.FileSource,
 basename: []const u8,
 output_file: std.Build.GeneratedFile,
 @@ -38,18 +37,18 @@ pub const Options = struct {
 };
 pub fn create(
-    builder: *std.Build,
+    owner: *std.Build,
     file_source: std.Build.FileSource,
     options: Options,
 ) *ObjCopyStep {
-    const self = builder.allocator.create(ObjCopyStep) catch @panic("OOM");
+    const self = owner.allocator.create(ObjCopyStep) catch @panic("OOM");
     self.* = ObjCopyStep{
-        .step = Step.init(builder.allocator, .{
+        .step = Step.init(.{
             .id = base_id,
-            .name = builder.fmt("objcopy {s}", .{file_source.getDisplayName()}),
+            .name = owner.fmt("objcopy {s}", .{file_source.getDisplayName()}),
+            .owner = owner,
             .makeFn = make,
         }),
-        .builder = builder,
         .file_source = file_source,
         .basename = options.basename orelse file_source.getDisplayName(),
         .output_file = std.Build.GeneratedFile{ .step = &self.step },
 @@ -67,9 +66,8 @@ pub fn getOutputSource(self: *const ObjCopyStep) std.Build.FileSource {
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
-    _ = prog_node;
+    const b = step.owner;
     const self = @fieldParentPtr(ObjCopyStep, "step", step);
-    const b = self.builder;
     var man = b.cache.obtain();
     defer man.deinit();
 @@ -84,7 +82,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     man.hash.addOptional(self.pad_to);
     man.hash.addOptional(self.format);
-    if (man.hit() catch |err| failWithCacheError(man, err)) {
+    if (try step.cacheHit(&man)) {
         // Cache hit, skip subprocess execution.
         const digest = man.final();
         self.output_file.path = try b.cache_root.join(b.allocator, &.{
 @@ -116,23 +114,8 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     };
     try argv.appendSlice(&.{ full_src_path, full_dest_path });
-    _ = try self.builder.execFromStep(argv.items, &self.step);
+    _ = try step.spawnZigProcess(argv.items, prog_node);
     self.output_file.path = full_dest_path;
     try man.writeManifest();
 }
-/// TODO consolidate this with the same function in RunStep?
-/// Also properly deal with concurrency (see open PR)
-fn failWithCacheError(man: std.Build.Cache.Manifest, err: anyerror) noreturn {
-    const i = man.failed_file_index orelse failWithSimpleError(err);
-    const pp = man.files.items[i].prefixed_path orelse failWithSimpleError(err);
-    const prefix = man.cache.prefixes()[pp.prefix].path orelse "";
-    std.debug.print("{s}: {s}/{s}\n", .{ @errorName(err), prefix, pp.sub_path });
-    std.process.exit(1);
-}
-fn failWithSimpleError(err: anyerror) noreturn {
-    std.debug.print("{s}\n", .{@errorName(err)});
-    std.process.exit(1);
-}

lib/std/Build/OptionsStep.zig+17-17

 @@ -12,25 +12,24 @@ pub const base_id = .options;
 step: Step,
 generated_file: GeneratedFile,
-builder: *std.Build,
 contents: std.ArrayList(u8),
 artifact_args: std.ArrayList(OptionArtifactArg),
 file_source_args: std.ArrayList(OptionFileSourceArg),
-pub fn create(builder: *std.Build) *OptionsStep {
+pub fn create(owner: *std.Build) *OptionsStep {
-    const self = builder.allocator.create(OptionsStep) catch @panic("OOM");
+    const self = owner.allocator.create(OptionsStep) catch @panic("OOM");
     self.* = .{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = base_id,
             .name = "options",
+            .owner = owner,
             .makeFn = make,
         }),
         .generated_file = undefined,
-        .contents = std.ArrayList(u8).init(builder.allocator),
+        .contents = std.ArrayList(u8).init(owner.allocator),
-        .artifact_args = std.ArrayList(OptionArtifactArg).init(builder.allocator),
+        .artifact_args = std.ArrayList(OptionArtifactArg).init(owner.allocator),
-        .file_source_args = std.ArrayList(OptionFileSourceArg).init(builder.allocator),
+        .file_source_args = std.ArrayList(OptionFileSourceArg).init(owner.allocator),
     };
     self.generated_file = .{ .step = &self.step };
 @@ -196,7 +195,7 @@ pub fn addOptionFileSource(
 ) void {
     self.file_source_args.append(.{
         .name = name,
-        .source = source.dupe(self.builder),
+        .source = source.dupe(self.step.owner),
     }) catch @panic("OOM");
     source.addStepDependencies(&self.step);
 }
 @@ -204,12 +203,12 @@ pub fn addOptionFileSource(
 /// The value is the path in the cache dir.
 /// Adds a dependency automatically.
 pub fn addOptionArtifact(self: *OptionsStep, name: []const u8, artifact: *CompileStep) void {
-    self.artifact_args.append(.{ .name = self.builder.dupe(name), .artifact = artifact }) catch @panic("OOM");
+    self.artifact_args.append(.{ .name = self.step.owner.dupe(name), .artifact = artifact }) catch @panic("OOM");
     self.step.dependOn(&artifact.step);
 }
 pub fn createModule(self: *OptionsStep) *std.Build.Module {
-    return self.builder.createModule(.{
+    return self.step.owner.createModule(.{
         .source_file = self.getSource(),
         .dependencies = &.{},
     });
 @@ -220,14 +219,17 @@ pub fn getSource(self: *OptionsStep) FileSource {
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
+    // This step completes so quickly that no progress is necessary.
     _ = prog_node;
+    const b = step.owner;
     const self = @fieldParentPtr(OptionsStep, "step", step);
     for (self.artifact_args.items) |item| {
         self.addOption(
             []const u8,
             item.name,
-            self.builder.pathFromRoot(item.artifact.getOutputSource().getPath(self.builder)),
+            b.pathFromRoot(item.artifact.getOutputSource().getPath(b)),
         );
     }
 @@ -235,20 +237,18 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         self.addOption(
             []const u8,
             item.name,
-            item.source.getPath(self.builder),
+            item.source.getPath(b),
         );
     }
-    var options_dir = try self.builder.cache_root.handle.makeOpenPath("options", .{});
+    var options_dir = try b.cache_root.handle.makeOpenPath("options", .{});
     defer options_dir.close();
     const basename = self.hashContentsToFileName();
     try options_dir.writeFile(&basename, self.contents.items);
-    self.generated_file.path = try self.builder.cache_root.join(self.builder.allocator, &.{
+    self.generated_file.path = try b.cache_root.join(b.allocator, &.{ "options", &basename });
-        "options", &basename,
-    });
 }
 fn hashContentsToFileName(self: *OptionsStep) [64]u8 {

lib/std/Build/RemoveDirStep.zig+19-10

 @@ -7,28 +7,37 @@ const RemoveDirStep = @This();
 pub const base_id = .remove_dir;
 step: Step,
-builder: *std.Build,
 dir_path: []const u8,
-pub fn init(builder: *std.Build, dir_path: []const u8) RemoveDirStep {
+pub fn init(owner: *std.Build, dir_path: []const u8) RemoveDirStep {
     return RemoveDirStep{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = .remove_dir,
-            .name = builder.fmt("RemoveDir {s}", .{dir_path}),
+            .name = owner.fmt("RemoveDir {s}", .{dir_path}),
+            .owner = owner,
             .makeFn = make,
         }),
-        .dir_path = builder.dupePath(dir_path),
+        .dir_path = owner.dupePath(dir_path),
     };
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
+    // TODO update progress node while walking file system.
+    // Should the standard library support this use case??
     _ = prog_node;
+    const b = step.owner;
     const self = @fieldParentPtr(RemoveDirStep, "step", step);
-    const full_path = self.builder.pathFromRoot(self.dir_path);
+    b.build_root.handle.deleteTree(self.dir_path) catch |err| {
-    fs.cwd().deleteTree(full_path) catch |err| {
+        if (b.build_root.path) |base| {
-        log.err("Unable to remove {s}: {s}", .{ full_path, @errorName(err) });
+            return step.fail("unable to recursively delete path '{s}/{s}': {s}", .{
-        return err;
+                base, self.dir_path, @errorName(err),
+            });
+        } else {
+            return step.fail("unable to recursively delete path '{s}': {s}", .{
+                self.dir_path, @errorName(err),
+            });
+        }
     };
 }

lib/std/Build/RunStep.zig+295-216

...	@@ -11,14 +11,11 @@ const EnvMap = process.EnvMap;	...	@@ -11,14 +11,11 @@ const EnvMap = process.EnvMap;
11	const Allocator = mem.Allocator;	11	const Allocator = mem.Allocator;
12	const ExecError = std.Build.ExecError;	12	const ExecError = std.Build.ExecError;
13		13
14	const max_stdout_size = 1 * 1024 * 1024; // 1 MiB
15
16	const RunStep = @This();	14	const RunStep = @This();
17		15
18	pub const base_id: Step.Id = .run;	16	pub const base_id: Step.Id = .run;
19		17
20	step: Step,	18	step: Step,
21	builder: *std.Build,
22		19
23	/// See also addArg and addArgs to modifying this directly	20	/// See also addArg and addArgs to modifying this directly
24	argv: ArrayList(Arg),	21	argv: ArrayList(Arg),
...	@@ -29,35 +26,68 @@ cwd: ?[]const u8,	...	@@ -29,35 +26,68 @@ cwd: ?[]const u8,
29	/// Override this field to modify the environment, or use setEnvironmentVariable	26	/// Override this field to modify the environment, or use setEnvironmentVariable
30	env_map: ?*EnvMap,	27	env_map: ?*EnvMap,
31		28
32	stdout_action: StdIoAction = .inherit,	29	/// Configures whether the RunStep is considered to have side-effects, and also
33	stderr_action: StdIoAction = .inherit,	30	/// whether the RunStep will inherit stdio streams, forwarding them to the
34		31	/// parent process, in which case will require a global lock to prevent other
35	stdin_behavior: std.ChildProcess.StdIo = .Inherit,	32	/// steps from interfering with stdio while the subprocess associated with this
36		33	/// RunStep is running.
37	/// Set this to `null` to ignore the exit code for the purpose of determining a successful execution	34	/// If the RunStep is determined to not have side-effects, then execution will
38	expected_term: ?std.ChildProcess.Term = .{ .Exited = 0 },	35	/// be skipped if all output files are up-to-date and input files are
39		36	/// unchanged.
40	/// Print the command before running it	37	stdio: StdIo = .infer_from_args,
41	print: bool,
42	/// Controls whether execution is skipped if the output file is up-to-date.
43	/// The default is to always run if there is no output file, and to skip
44	/// running if all output files are up-to-date.
45	condition: enum { output_outdated, always } = .output_outdated,
46		38
47	/// Additional file paths relative to build.zig that, when modified, indicate	39	/// Additional file paths relative to build.zig that, when modified, indicate
48	/// that the RunStep should be re-executed.	40	/// that the RunStep should be re-executed.
		41	/// If the RunStep is determined to have side-effects, this field is ignored
		42	/// and the RunStep is always executed when it appears in the build graph.
49	extra_file_dependencies: []const []const u8 = &.{},	43	extra_file_dependencies: []const []const u8 = &.{},
50		44
51	/// After adding an output argument, this step will by default rename itself	45	/// After adding an output argument, this step will by default rename itself
52	/// for a better display name in the build summary.	46	/// for a better display name in the build summary.
53	/// This can be disabled by setting this to false.	47	/// This can be disabled by setting this to false.
54	rename_step_with_output_arg: bool,	48	rename_step_with_output_arg: bool = true,
55		49
56	pub const StdIoAction = union(enum) {	50	/// If this is true, a RunStep which is configured to check the output of the
		51	/// executed binary will not fail the build if the binary cannot be executed
		52	/// due to being for a foreign binary to the host system which is running the
		53	/// build graph.
		54	/// Command-line arguments such as -fqemu and -fwasmtime may affect whether a
		55	/// binary is detected as foreign, as well as system configuration such as
		56	/// Rosetta (macOS) and binfmt_misc (Linux).
		57	skip_foreign_checks: bool = false,
		58
		59	/// If stderr or stdout exceeds this amount, the child process is killed and
		60	/// the step fails.
		61	max_stdio_size: usize = 10 * 1024 * 1024,
		62
		63	pub const StdIo = union(enum) {
		64	/// Whether the RunStep has side-effects will be determined by whether or not one
		65	/// of the args is an output file (added with `addOutputFileArg`).
		66	/// If the RunStep is determined to have side-effects, this is the same as `inherit`.
		67	/// The step will fail if the subprocess crashes or returns a non-zero exit code.
		68	infer_from_args,
		69	/// Causes the RunStep to be considered to have side-effects, and therefore
		70	/// always execute when it appears in the build graph.
		71	/// It also means that this step will obtain a global lock to prevent other
		72	/// steps from running in the meantime.
		73	/// The step will fail if the subprocess crashes or returns a non-zero exit code.
57	inherit,	74	inherit,
58	ignore,	75	/// Causes the RunStep to be considered to not have side-effects. The
59	expect_exact: []const u8,	76	/// process will be re-executed if any of the input dependencies are
60	expect_matches: []const []const u8,	77	/// modified. The exit code and standard I/O streams will be checked for
		78	/// certain conditions, and the step will succeed or fail based on these
		79	/// conditions.
		80	/// Note that an explicit check for exit code 0 needs to be added to this
		81	/// list if such a check is desireable.
		82	check: []const Check,
		83
		84	pub const Check = union(enum) {
		85	expect_stderr_exact: []const u8,
		86	expect_stderr_match: []const u8,
		87	expect_stdout_exact: []const u8,
		88	expect_stdout_match: []const u8,
		89	expect_term: std.ChildProcess.Term,
		90	};
61	};	91	};
62		92
63	pub const Arg = union(enum) {	93	pub const Arg = union(enum) {
...	@@ -72,20 +102,20 @@ pub const Arg = union(enum) {	...	@@ -72,20 +102,20 @@ pub const Arg = union(enum) {
72	};	102	};
73	};	103	};
74		104
75	pub fn create(builder: std.Build, name: []const u8) RunStep {	105	pub fn create(owner: std.Build, name: []const u8) RunStep {
76	const self = builder.allocator.create(RunStep) catch @panic("OOM");	106	const self = owner.allocator.create(RunStep) catch @panic("OOM");
77	self.* = .{	107	self.* = .{
78	.builder = builder,	108	.step = Step.init(.{
79	.step = Step.init(builder.allocator, .{
80	.id = base_id,	109	.id = base_id,
81	.name = name,	110	.name = name,
		111	.owner = owner,
82	.makeFn = make,	112	.makeFn = make,
83	}),	113	}),
84	.argv = ArrayList(Arg).init(builder.allocator),	114	.argv = ArrayList(Arg).init(owner.allocator),
85	.cwd = null,	115	.cwd = null,
86	.env_map = null,	116	.env_map = null,
87	.print = builder.verbose,
88	.rename_step_with_output_arg = true,	117	.rename_step_with_output_arg = true,
		118	.max_stdio_size = 10 * 1024 * 1024,
89	};	119	};
90	return self;	120	return self;
91	}	121	}
...	@@ -99,16 +129,17 @@ pub fn addArtifactArg(self: RunStep, artifact: CompileStep) void {	...	@@ -99,16 +129,17 @@ pub fn addArtifactArg(self: RunStep, artifact: CompileStep) void {
99	/// run, and returns a FileSource which can be used as inputs to other APIs	129	/// run, and returns a FileSource which can be used as inputs to other APIs
100	/// throughout the build system.	130	/// throughout the build system.
101	pub fn addOutputFileArg(rs: *RunStep, basename: []const u8) std.Build.FileSource {	131	pub fn addOutputFileArg(rs: *RunStep, basename: []const u8) std.Build.FileSource {
102	const generated_file = rs.builder.allocator.create(std.Build.GeneratedFile) catch @panic("OOM");	132	const b = rs.step.owner;
		133	const generated_file = b.allocator.create(std.Build.GeneratedFile) catch @panic("OOM");
103	generated_file.* = .{ .step = &rs.step };	134	generated_file.* = .{ .step = &rs.step };
104	rs.argv.append(.{ .output = .{	135	rs.argv.append(.{ .output = .{
105	.generated_file = generated_file,	136	.generated_file = generated_file,
106	.basename = rs.builder.dupe(basename),	137	.basename = b.dupe(basename),
107	} }) catch @panic("OOM");	138	} }) catch @panic("OOM");
108		139
109	if (rs.rename_step_with_output_arg) {	140	if (rs.rename_step_with_output_arg) {
110	rs.rename_step_with_output_arg = false;	141	rs.rename_step_with_output_arg = false;
111	rs.step.name = rs.builder.fmt("{s} ({s})", .{ rs.step.name, basename });	142	rs.step.name = b.fmt("{s} ({s})", .{ rs.step.name, basename });
112	}	143	}
113		144
114	return .{ .generated = generated_file };	145	return .{ .generated = generated_file };
...	@@ -116,13 +147,13 @@ pub fn addOutputFileArg(rs: *RunStep, basename: []const u8) std.Build.FileSource	...	@@ -116,13 +147,13 @@ pub fn addOutputFileArg(rs: *RunStep, basename: []const u8) std.Build.FileSource
116		147
117	pub fn addFileSourceArg(self: *RunStep, file_source: std.Build.FileSource) void {	148	pub fn addFileSourceArg(self: *RunStep, file_source: std.Build.FileSource) void {
118	self.argv.append(Arg{	149	self.argv.append(Arg{
119	.file_source = file_source.dupe(self.builder),	150	.file_source = file_source.dupe(self.step.owner),
120	}) catch @panic("OOM");	151	}) catch @panic("OOM");
121	file_source.addStepDependencies(&self.step);	152	file_source.addStepDependencies(&self.step);
122	}	153	}
123		154
124	pub fn addArg(self: *RunStep, arg: []const u8) void {	155	pub fn addArg(self: *RunStep, arg: []const u8) void {
125	self.argv.append(Arg{ .bytes = self.builder.dupe(arg) }) catch @panic("OOM");	156	self.argv.append(Arg{ .bytes = self.step.owner.dupe(arg) }) catch @panic("OOM");
126	}	157	}
127		158
128	pub fn addArgs(self: *RunStep, args: []const []const u8) void {	159	pub fn addArgs(self: *RunStep, args: []const []const u8) void {
...	@@ -132,13 +163,14 @@ pub fn addArgs(self: *RunStep, args: []const []const u8) void {	...	@@ -132,13 +163,14 @@ pub fn addArgs(self: *RunStep, args: []const []const u8) void {
132	}	163	}
133		164
134	pub fn clearEnvironment(self: *RunStep) void {	165	pub fn clearEnvironment(self: *RunStep) void {
135	const new_env_map = self.builder.allocator.create(EnvMap) catch @panic("OOM");	166	const b = self.step.owner;
136	new_env_map.* = EnvMap.init(self.builder.allocator);	167	const new_env_map = b.allocator.create(EnvMap) catch @panic("OOM");
		168	new_env_map.* = EnvMap.init(b.allocator);
137	self.env_map = new_env_map;	169	self.env_map = new_env_map;
138	}	170	}
139		171
140	pub fn addPathDir(self: *RunStep, search_path: []const u8) void {	172	pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
141	addPathDirInternal(&self.step, self.builder, search_path);	173	addPathDirInternal(&self.step, self.step.owner, search_path);
142	}	174	}
143		175
144	/// For internal use only, users of `RunStep` should use `addPathDir` directly.	176	/// For internal use only, users of `RunStep` should use `addPathDir` directly.
...	@@ -157,13 +189,12 @@ pub fn addPathDirInternal(step: Step, builder: std.Build, search_path: []const	...	@@ -157,13 +189,12 @@ pub fn addPathDirInternal(step: Step, builder: std.Build, search_path: []const
157	}	189	}
158		190
159	pub fn getEnvMap(self: RunStep) EnvMap {	191	pub fn getEnvMap(self: RunStep) EnvMap {
160	return getEnvMapInternal(&self.step, self.builder.allocator);	192	return getEnvMapInternal(&self.step, self.step.owner.allocator);
161	}	193	}
162		194
163	fn getEnvMapInternal(step: Step, allocator: Allocator) EnvMap {	195	fn getEnvMapInternal(step: Step, allocator: Allocator) EnvMap {
164	const maybe_env_map = switch (step.id) {	196	const maybe_env_map = switch (step.id) {
165	.run => step.cast(RunStep).?.env_map,	197	.run => step.cast(RunStep).?.env_map,
166	.emulatable_run => step.cast(std.Build.EmulatableRunStep).?.env_map,
167	else => unreachable,	198	else => unreachable,
168	};	199	};
169	return maybe_env_map orelse {	200	return maybe_env_map orelse {
...	@@ -171,7 +202,6 @@ fn getEnvMapInternal(step: Step, allocator: Allocator) EnvMap {	...	@@ -171,7 +202,6 @@ fn getEnvMapInternal(step: Step, allocator: Allocator) EnvMap {
171	env_map.* = process.getEnvMap(allocator) catch @panic("unhandled error");	202	env_map.* = process.getEnvMap(allocator) catch @panic("unhandled error");
172	switch (step.id) {	203	switch (step.id) {
173	.run => step.cast(RunStep).?.env_map = env_map,	204	.run => step.cast(RunStep).?.env_map = env_map,
174	.emulatable_run => step.cast(RunStep).?.env_map = env_map,
175	else => unreachable,	205	else => unreachable,
176	}	206	}
177	return env_map;	207	return env_map;
...	@@ -179,41 +209,85 @@ fn getEnvMapInternal(step: Step, allocator: Allocator) EnvMap {	...	@@ -179,41 +209,85 @@ fn getEnvMapInternal(step: Step, allocator: Allocator) EnvMap {
179	}	209	}
180		210
181	pub fn setEnvironmentVariable(self: *RunStep, key: []const u8, value: []const u8) void {	211	pub fn setEnvironmentVariable(self: *RunStep, key: []const u8, value: []const u8) void {
		212	const b = self.step.owner;
182	const env_map = self.getEnvMap();	213	const env_map = self.getEnvMap();
183	env_map.put(	214	env_map.put(b.dupe(key), b.dupe(value)) catch @panic("unhandled error");
184	self.builder.dupe(key),
185	self.builder.dupe(value),
186	) catch @panic("unhandled error");
187	}	215	}
188		216
189	pub fn expectStdErrEqual(self: *RunStep, bytes: []const u8) void {	217	pub fn expectStdErrEqual(self: *RunStep, bytes: []const u8) void {
190	self.stderr_action = .{ .expect_exact = self.builder.dupe(bytes) };	218	const new_check: StdIo.Check = .{ .expect_stderr_exact = self.step.owner.dupe(bytes) };
		219	self.addCheck(new_check);
191	}	220	}
192		221
193	pub fn expectStdOutEqual(self: *RunStep, bytes: []const u8) void {	222	pub fn expectStdOutEqual(self: *RunStep, bytes: []const u8) void {
194	self.stdout_action = .{ .expect_exact = self.builder.dupe(bytes) };	223	const new_check: StdIo.Check = .{ .expect_stdout_exact = self.step.owner.dupe(bytes) };
		224	self.addCheck(new_check);
195	}	225	}
196		226
197	fn stdIoActionToBehavior(action: StdIoAction) std.ChildProcess.StdIo {	227	pub fn expectExitCode(self: *RunStep, code: u8) void {
198	return switch (action) {	228	const new_check: StdIo.Check = .{ .expect_term = .{ .Exited = code } };
199	.ignore => .Ignore,	229	self.addCheck(new_check);
200	.inherit => .Inherit,
201	.expect_exact, .expect_matches => .Pipe,
202	};
203	}	230	}
204		231
205	fn needOutputCheck(self: RunStep) bool {	232	pub fn addCheck(self: *RunStep, new_check: StdIo.Check) void {
206	switch (self.condition) {	233	const arena = self.step.owner.allocator;
207	.always => return false,	234	switch (self.stdio) {
208	.output_outdated => {},	235	.infer_from_args => {
		236	const list = arena.create([1]StdIo.Check) catch @panic("OOM");
		237	list.* = .{new_check};
		238	self.stdio = .{ .check = list };
		239	},
		240	.check => \|checks\| {
		241	const new_list = arena.alloc(StdIo.Check, checks.len + 1) catch @panic("OOM");
		242	std.mem.copy(StdIo.Check, new_list, checks);
		243	new_list[checks.len] = new_check;
		244	},
		245	else => @panic("illegal call to addCheck: conflicting helper method calls. Suggest to directly set stdio field of RunStep instead"),
209	}	246	}
210	if (self.extra_file_dependencies.len > 0) return true;	247	}
		248
		249	/// Returns whether the RunStep has side effects other than updating the output arguments.
		250	fn hasSideEffects(self: RunStep) bool {
		251	return switch (self.stdio) {
		252	.infer_from_args => !self.hasAnyOutputArgs(),
		253	.inherit => true,
		254	.check => false,
		255	};
		256	}
211		257
		258	fn hasAnyOutputArgs(self: RunStep) bool {
212	for (self.argv.items) \|arg\| switch (arg) {	259	for (self.argv.items) \|arg\| switch (arg) {
213	.output => return true,	260	.output => return true,
214	else => continue,	261	else => continue,
215	};	262	};
		263	return false;
		264	}
216		265
		266	fn checksContainStdout(checks: []const StdIo.Check) bool {
		267	for (checks) \|check\| switch (check) {
		268	.expect_stderr_exact,
		269	.expect_stderr_match,
		270	.expect_term,
		271	=> continue,
		272
		273	.expect_stdout_exact,
		274	.expect_stdout_match,
		275	=> return true,
		276	};
		277	return false;
		278	}
		279
		280	fn checksContainStderr(checks: []const StdIo.Check) bool {
		281	for (checks) \|check\| switch (check) {
		282	.expect_stdout_exact,
		283	.expect_stdout_match,
		284	.expect_term,
		285	=> continue,
		286
		287	.expect_stderr_exact,
		288	.expect_stderr_match,
		289	=> return true,
		290	};
217	return false;	291	return false;
218	}	292	}
219		293
...	@@ -223,16 +297,17 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -223,16 +297,17 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
223	// processes could use to supply progress updates.	297	// processes could use to supply progress updates.
224	_ = prog_node;	298	_ = prog_node;
225		299
		300	const b = step.owner;
226	const self = @fieldParentPtr(RunStep, "step", step);	301	const self = @fieldParentPtr(RunStep, "step", step);
227	const need_output_check = self.needOutputCheck();	302	const has_side_effects = self.hasSideEffects();
228		303
229	var argv_list = ArrayList([]const u8).init(self.builder.allocator);	304	var argv_list = ArrayList([]const u8).init(b.allocator);
230	var output_placeholders = ArrayList(struct {	305	var output_placeholders = ArrayList(struct {
231	index: usize,	306	index: usize,
232	output: Arg.Output,	307	output: Arg.Output,
233	}).init(self.builder.allocator);	308	}).init(b.allocator);
234		309
235	var man = self.builder.cache.obtain();	310	var man = b.cache.obtain();
236	defer man.deinit();	311	defer man.deinit();
237		312
238	for (self.argv.items) \|arg\| {	313	for (self.argv.items) \|arg\| {
...	@@ -242,7 +317,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -242,7 +317,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
242	man.hash.addBytes(bytes);	317	man.hash.addBytes(bytes);
243	},	318	},
244	.file_source => \|file\| {	319	.file_source => \|file\| {
245	const file_path = file.getPath(self.builder);	320	const file_path = file.getPath(b);
246	try argv_list.append(file_path);	321	try argv_list.append(file_path);
247	_ = try man.addFile(file_path, null);	322	_ = try man.addFile(file_path, null);
248	},	323	},
...	@@ -252,7 +327,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -252,7 +327,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
252	self.addPathForDynLibs(artifact);	327	self.addPathForDynLibs(artifact);
253	}	328	}
254	const file_path = artifact.installed_path orelse	329	const file_path = artifact.installed_path orelse
255	artifact.getOutputSource().getPath(self.builder);	330	artifact.getOutputSource().getPath(b);
256		331
257	try argv_list.append(file_path);	332	try argv_list.append(file_path);
258		333
...	@@ -272,17 +347,17 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -272,17 +347,17 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
272	}	347	}
273	}	348	}
274		349
275	if (need_output_check) {	350	if (!has_side_effects) {
276	for (self.extra_file_dependencies) \|file_path\| {	351	for (self.extra_file_dependencies) \|file_path\| {
277	_ = try man.addFile(self.builder.pathFromRoot(file_path), null);	352	_ = try man.addFile(b.pathFromRoot(file_path), null);
278	}	353	}
279		354
280	if (man.hit() catch \|err\| failWithCacheError(man, err)) {	355	if (try step.cacheHit(&man)) {
281	// cache hit, skip running command	356	// cache hit, skip running command
282	const digest = man.final();	357	const digest = man.final();
283	for (output_placeholders.items) \|placeholder\| {	358	for (output_placeholders.items) \|placeholder\| {
284	placeholder.output.generated_file.path = try self.builder.cache_root.join(	359	placeholder.output.generated_file.path = try b.cache_root.join(
285	self.builder.allocator,	360	b.allocator,
286	&.{ "o", &digest, placeholder.output.basename },	361	&.{ "o", &digest, placeholder.output.basename },
287	);	362	);
288	}	363	}
...	@@ -292,8 +367,8 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -292,8 +367,8 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
292	const digest = man.final();	367	const digest = man.final();
293		368
294	for (output_placeholders.items) \|placeholder\| {	369	for (output_placeholders.items) \|placeholder\| {
295	const output_path = try self.builder.cache_root.join(	370	const output_path = try b.cache_root.join(
296	self.builder.allocator,	371	b.allocator,
297	&.{ "o", &digest, placeholder.output.basename },	372	&.{ "o", &digest, placeholder.output.basename },
298	);	373	);
299	const output_dir = fs.path.dirname(output_path).?;	374	const output_dir = fs.path.dirname(output_path).?;
...	@@ -308,18 +383,16 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -308,18 +383,16 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
308	}	383	}
309		384
310	try runCommand(	385	try runCommand(
		386	step,
		387	self.cwd,
311	argv_list.items,	388	argv_list.items,
312	self.builder,
313	self.expected_term,
314	self.stdout_action,
315	self.stderr_action,
316	self.stdin_behavior,
317	self.env_map,	389	self.env_map,
318	self.cwd,	390	self.stdio,
319	self.print,	391	has_side_effects,
		392	self.max_stdio_size,
320	);	393	);
321		394
322	if (need_output_check) {	395	if (!has_side_effects) {
323	try man.writeManifest();	396	try man.writeManifest();
324	}	397	}
325	}	398	}
...	@@ -369,165 +442,171 @@ fn termMatches(expected: ?std.ChildProcess.Term, actual: std.ChildProcess.Term)	...	@@ -369,165 +442,171 @@ fn termMatches(expected: ?std.ChildProcess.Term, actual: std.ChildProcess.Term)
369	};	442	};
370	}	443	}
371		444
372	pub fn runCommand(	445	fn runCommand(
		446	step: *Step,
		447	opt_cwd: ?[]const u8,
373	argv: []const []const u8,	448	argv: []const []const u8,
374	builder: *std.Build,
375	expected_term: ?std.ChildProcess.Term,
376	stdout_action: StdIoAction,
377	stderr_action: StdIoAction,
378	stdin_behavior: std.ChildProcess.StdIo,
379	env_map: ?*EnvMap,	449	env_map: ?*EnvMap,
380	maybe_cwd: ?[]const u8,	450	stdio: StdIo,
381	print: bool,	451	has_side_effects: bool,
		452	max_stdio_size: usize,
382	) !void {	453	) !void {
383	const cwd = if (maybe_cwd) \|cwd\| builder.pathFromRoot(cwd) else builder.build_root.path;	454	const b = step.owner;
384		455	const arena = b.allocator;
385	if (!std.process.can_spawn) {	456	const cwd = if (opt_cwd) \|cwd\| b.pathFromRoot(cwd) else b.build_root.path;
386	const cmd = try std.mem.join(builder.allocator, " ", argv);
387	std.debug.print("the following command cannot be executed ({s} does not support spawning a child process):\n{s}", .{
388	@tagName(builtin.os.tag), cmd,
389	});
390	builder.allocator.free(cmd);
391	return ExecError.ExecNotSupported;
392	}
393		457
394	var child = std.ChildProcess.init(argv, builder.allocator);	458	try step.handleChildProcUnsupported(opt_cwd, argv);
395	child.cwd = cwd;	459	try Step.handleVerbose(step.owner, opt_cwd, argv);
396	child.env_map = env_map orelse builder.env_map;
397		460
398	child.stdin_behavior = stdin_behavior;	461	var child = std.ChildProcess.init(argv, arena);
399	child.stdout_behavior = stdIoActionToBehavior(stdout_action);	462	child.cwd = cwd;
400	child.stderr_behavior = stdIoActionToBehavior(stderr_action);	463	child.env_map = env_map orelse b.env_map;
401
402	if (print)
403	printCmd(cwd, argv);
404		464
405	child.spawn() catch \|err\| {	465	child.stdin_behavior = switch (stdio) {
406	std.debug.print("Unable to spawn {s}: {s}\n", .{ argv[0], @errorName(err) });	466	.infer_from_args => if (has_side_effects) .Inherit else .Ignore,
407	return err;	467	.inherit => .Inherit,
		468	.check => .Close,
		469	};
		470	child.stdout_behavior = switch (stdio) {
		471	.infer_from_args => if (has_side_effects) .Inherit else .Ignore,
		472	.inherit => .Inherit,
		473	.check => \|checks\| if (checksContainStdout(checks)) .Pipe else .Ignore,
		474	};
		475	child.stderr_behavior = switch (stdio) {
		476	.infer_from_args => if (has_side_effects) .Inherit else .Pipe,
		477	.inherit => .Inherit,
		478	.check => .Pipe,
408	};	479	};
409		480
410	// TODO need to poll to read these streams to prevent a deadlock (or rely on evented I/O).	481	child.spawn() catch \|err\| return step.fail("unable to spawn {s}: {s}", .{
411		482	argv[0], @errorName(err),
412	var stdout: ?[]const u8 = null;	483	});
413	defer if (stdout) \|s\| builder.allocator.free(s);	484
		485	var stdout_bytes: ?[]const u8 = null;
		486	var stderr_bytes: ?[]const u8 = null;
		487
		488	if (child.stdout) \|stdout\| {
		489	if (child.stderr) \|stderr\| {
		490	var poller = std.io.poll(arena, enum { stdout, stderr }, .{
		491	.stdout = stdout,
		492	.stderr = stderr,
		493	});
		494	defer poller.deinit();
		495
		496	while (try poller.poll()) {
		497	if (poller.fifo(.stdout).count > max_stdio_size)
		498	return error.StdoutStreamTooLong;
		499	if (poller.fifo(.stderr).count > max_stdio_size)
		500	return error.StderrStreamTooLong;
		501	}
414		502
415	switch (stdout_action) {	503	stdout_bytes = try poller.fifo(.stdout).toOwnedSlice();
416	.expect_exact, .expect_matches => {	504	stderr_bytes = try poller.fifo(.stderr).toOwnedSlice();
417	stdout = try child.stdout.?.reader().readAllAlloc(builder.allocator, max_stdout_size);	505	} else {
418	},	506	stdout_bytes = try stdout.reader().readAllAlloc(arena, max_stdio_size);
419	.inherit, .ignore => {},	507	}
		508	} else if (child.stderr) \|stderr\| {
		509	stderr_bytes = try stderr.reader().readAllAlloc(arena, max_stdio_size);
420	}	510	}
421		511
422	var stderr: ?[]const u8 = null;	512	if (stderr_bytes) \|stderr\| if (stderr.len > 0) {
423	defer if (stderr) \|s\| builder.allocator.free(s);	513	const stderr_is_diagnostic = switch (stdio) {
424		514	.check => \|checks\| !checksContainStderr(checks),
425	switch (stderr_action) {	515	else => true,
426	.expect_exact, .expect_matches => {	516	};
427	stderr = try child.stderr.?.reader().readAllAlloc(builder.allocator, max_stdout_size);	517	if (stderr_is_diagnostic) {
428	},	518	try step.result_error_msgs.append(arena, stderr);
429	.inherit, .ignore => {},	519	}
430	}	520	};
431		521
432	const term = child.wait() catch \|err\| {	522	const term = child.wait() catch \|err\| {
433	std.debug.print("Unable to spawn {s}: {s}\n", .{ argv[0], @errorName(err) });	523	return step.fail("unable to wait for {s}: {s}", .{ argv[0], @errorName(err) });
434	return err;
435	};	524	};
436		525
437	if (!termMatches(expected_term, term)) {	526	switch (stdio) {
438	std.debug.print("The following command {} (expected {}):\n", .{ fmtTerm(term), fmtTerm(expected_term) });	527	.check => \|checks\| for (checks) \|check\| switch (check) {
439	printCmd(cwd, argv);	528	.expect_stderr_exact => \|expected_bytes\| {
440	return error.UnexpectedExit;	529	if (!mem.eql(u8, expected_bytes, stderr_bytes.?)) {
441	}	530	return step.fail(
442		531	\\========= expected this stderr: =========
443	switch (stderr_action) {	532	\\{s}
444	.inherit, .ignore => {},	533	\\========= but found: ====================
445	.expect_exact => \|expected_bytes\| {	534	\\{s}
446	if (!mem.eql(u8, expected_bytes, stderr.?)) {	535	\\========= from the following command: ===
447	std.debug.print(	536	\\{s}
448	\\	537	, .{
449	\\========= Expected this stderr: =========	538	expected_bytes,
450	\\{s}	539	stderr_bytes.?,
451	\\========= But found: ====================	540	try Step.allocPrintCmd(arena, opt_cwd, argv),
452	\\{s}	541	});
453	\\	542	}
454	, .{ expected_bytes, stderr.? });	543	},
455	printCmd(cwd, argv);	544	.expect_stderr_match => \|match\| {
456	return error.TestFailed;	545	if (mem.indexOf(u8, stderr_bytes.?, match) == null) {
457	}	546	return step.fail(
458	},	547	\\========= expected to find in stderr: =========
459	.expect_matches => \|matches\| for (matches) \|match\| {	548	\\{s}
460	if (mem.indexOf(u8, stderr.?, match) == null) {	549	\\========= but stderr does not contain it: =====
461	std.debug.print(	550	\\{s}
462	\\	551	\\========= from the following command: =========
463	\\========= Expected to find in stderr: =========	552	\\{s}
464	\\{s}	553	, .{
465	\\========= But stderr does not contain it: =====	554	match,
466	\\{s}	555	stderr_bytes.?,
467	\\	556	try Step.allocPrintCmd(arena, opt_cwd, argv),
468	, .{ match, stderr.? });	557	});
469	printCmd(cwd, argv);	558	}
470	return error.TestFailed;	559	},
471	}	560	.expect_stdout_exact => \|expected_bytes\| {
472	},	561	if (!mem.eql(u8, expected_bytes, stdout_bytes.?)) {
473	}	562	return step.fail(
474		563	\\========= expected this stdout: =========
475	switch (stdout_action) {	564	\\{s}
476	.inherit, .ignore => {},	565	\\========= but found: ====================
477	.expect_exact => \|expected_bytes\| {	566	\\{s}
478	if (!mem.eql(u8, expected_bytes, stdout.?)) {	567	\\========= from the following command: ===
479	std.debug.print(	568	\\{s}
480	\\	569	, .{
481	\\========= Expected this stdout: =========	570	expected_bytes,
482	\\{s}	571	stdout_bytes.?,
483	\\========= But found: ====================	572	try Step.allocPrintCmd(arena, opt_cwd, argv),
484	\\{s}	573	});
485	\\	574	}
486	, .{ expected_bytes, stdout.? });	575	},
487	printCmd(cwd, argv);	576	.expect_stdout_match => \|match\| {
488	return error.TestFailed;	577	if (mem.indexOf(u8, stdout_bytes.?, match) == null) {
489	}	578	return step.fail(
		579	\\========= expected to find in stdout: =========
		580	\\{s}
		581	\\========= but stdout does not contain it: =====
		582	\\{s}
		583	\\========= from the following command: =========
		584	\\{s}
		585	, .{
		586	match,
		587	stdout_bytes.?,
		588	try Step.allocPrintCmd(arena, opt_cwd, argv),
		589	});
		590	}
		591	},
		592	.expect_term => \|expected_term\| {
		593	if (!termMatches(expected_term, term)) {
		594	return step.fail("the following command {} (expected {}):\n{s}", .{
		595	fmtTerm(term),
		596	fmtTerm(expected_term),
		597	try Step.allocPrintCmd(arena, opt_cwd, argv),
		598	});
		599	}
		600	},
490	},	601	},
491	.expect_matches => \|matches\| for (matches) \|match\| {	602	else => {
492	if (mem.indexOf(u8, stdout.?, match) == null) {	603	try step.handleChildProcessTerm(term, opt_cwd, argv);
493	std.debug.print(
494	\\
495	\\========= Expected to find in stdout: =========
496	\\{s}
497	\\========= But stdout does not contain it: =====
498	\\{s}
499	\\
500	, .{ match, stdout.? });
501	printCmd(cwd, argv);
502	return error.TestFailed;
503	}
504	},	604	},
505	}	605	}
506	}	606	}
507		607
508	fn failWithCacheError(man: std.Build.Cache.Manifest, err: anyerror) noreturn {
509	const i = man.failed_file_index orelse failWithSimpleError(err);
510	const pp = man.files.items[i].prefixed_path orelse failWithSimpleError(err);
511	const prefix = man.cache.prefixes()[pp.prefix].path orelse "";
512	std.debug.print("{s}: {s}/{s}\n", .{ @errorName(err), prefix, pp.sub_path });
513	std.process.exit(1);
514	}
515
516	fn failWithSimpleError(err: anyerror) noreturn {
517	std.debug.print("{s}\n", .{@errorName(err)});
518	std.process.exit(1);
519	}
520
521	fn printCmd(cwd: ?[]const u8, argv: []const []const u8) void {
522	if (cwd) \|yes_cwd\| std.debug.print("cd {s} && ", .{yes_cwd});
523	for (argv) \|arg\| {
524	std.debug.print("{s} ", .{arg});
525	}
526	std.debug.print("\n", .{});
527	}
528
529	fn addPathForDynLibs(self: RunStep, artifact: CompileStep) void {	608	fn addPathForDynLibs(self: RunStep, artifact: CompileStep) void {
530	addPathForDynLibsInternal(&self.step, self.builder, artifact);	609	addPathForDynLibsInternal(&self.step, self.step.owner, artifact);
531	}	610	}
532		611
533	/// This should only be used for internal usage, this is called automatically	612	/// This should only be used for internal usage, this is called automatically

lib/std/Build/Step.zig+236-5

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	id: Id,	1	id: Id,
2	name: []const u8,	2	name: []const u8,
		3	owner: *Build,
3	makeFn: MakeFn,	4	makeFn: MakeFn,
4	dependencies: std.ArrayList(*Step),	5	dependencies: std.ArrayList(*Step),
5	/// This field is empty during execution of the user's build script, and	6	/// This field is empty during execution of the user's build script, and
...	@@ -39,7 +40,6 @@ pub const Id = enum {	...	@@ -39,7 +40,6 @@ pub const Id = enum {
39	translate_c,	40	translate_c,
40	write_file,	41	write_file,
41	run,	42	run,
42	emulatable_run,
43	check_file,	43	check_file,
44	check_object,	44	check_object,
45	config_header,	45	config_header,
...	@@ -60,7 +60,6 @@ pub const Id = enum {	...	@@ -60,7 +60,6 @@ pub const Id = enum {
60	.translate_c => Build.TranslateCStep,	60	.translate_c => Build.TranslateCStep,
61	.write_file => Build.WriteFileStep,	61	.write_file => Build.WriteFileStep,
62	.run => Build.RunStep,	62	.run => Build.RunStep,
63	.emulatable_run => Build.EmulatableRunStep,
64	.check_file => Build.CheckFileStep,	63	.check_file => Build.CheckFileStep,
65	.check_object => Build.CheckObjectStep,	64	.check_object => Build.CheckObjectStep,
66	.config_header => Build.ConfigHeaderStep,	65	.config_header => Build.ConfigHeaderStep,
...	@@ -74,11 +73,14 @@ pub const Id = enum {	...	@@ -74,11 +73,14 @@ pub const Id = enum {
74	pub const Options = struct {	73	pub const Options = struct {
75	id: Id,	74	id: Id,
76	name: []const u8,	75	name: []const u8,
		76	owner: *Build,
77	makeFn: MakeFn = makeNoOp,	77	makeFn: MakeFn = makeNoOp,
78	first_ret_addr: ?usize = null,	78	first_ret_addr: ?usize = null,
79	};	79	};
80		80
81	pub fn init(allocator: Allocator, options: Options) Step {	81	pub fn init(options: Options) Step {
		82	const arena = options.owner.allocator;
		83
82	var addresses = [1]usize{0} ** n_debug_stack_frames;	84	var addresses = [1]usize{0} ** n_debug_stack_frames;
83	const first_ret_addr = options.first_ret_addr orelse @returnAddress();	85	const first_ret_addr = options.first_ret_addr orelse @returnAddress();
84	var stack_trace = std.builtin.StackTrace{	86	var stack_trace = std.builtin.StackTrace{
...	@@ -89,9 +91,10 @@ pub fn init(allocator: Allocator, options: Options) Step {	...	@@ -89,9 +91,10 @@ pub fn init(allocator: Allocator, options: Options) Step {
89		91
90	return .{	92	return .{
91	.id = options.id,	93	.id = options.id,
92	.name = allocator.dupe(u8, options.name) catch @panic("OOM"),	94	.name = arena.dupe(u8, options.name) catch @panic("OOM"),
		95	.owner = options.owner,
93	.makeFn = options.makeFn,	96	.makeFn = options.makeFn,
94	.dependencies = std.ArrayList(*Step).init(allocator),	97	.dependencies = std.ArrayList(*Step).init(arena),
95	.dependants = .{},	98	.dependants = .{},
96	.state = .precheck_unstarted,	99	.state = .precheck_unstarted,
97	.debug_stack_trace = addresses,	100	.debug_stack_trace = addresses,
...	@@ -168,3 +171,231 @@ const std = @import("../std.zig");	...	@@ -168,3 +171,231 @@ const std = @import("../std.zig");
168	const Build = std.Build;	171	const Build = std.Build;
169	const Allocator = std.mem.Allocator;	172	const Allocator = std.mem.Allocator;
170	const assert = std.debug.assert;	173	const assert = std.debug.assert;
		174	const builtin = @import("builtin");
		175
		176	pub fn evalChildProcess(s: *Step, argv: []const []const u8) !void {
		177	const arena = s.owner.allocator;
		178
		179	try handleChildProcUnsupported(s, null, argv);
		180	try handleVerbose(s.owner, null, argv);
		181
		182	const result = std.ChildProcess.exec(.{
		183	.allocator = arena,
		184	.argv = argv,
		185	}) catch \|err\| return s.fail("unable to spawn {s}: {s}", .{ argv[0], @errorName(err) });
		186
		187	if (result.stderr.len > 0) {
		188	try s.result_error_msgs.append(arena, result.stderr);
		189	}
		190
		191	try handleChildProcessTerm(s, result.term, null, argv);
		192	}
		193
		194	pub fn fail(step: *Step, comptime fmt: []const u8, args: anytype) error{ OutOfMemory, MakeFailed } {
		195	const arena = step.owner.allocator;
		196	const msg = try std.fmt.allocPrint(arena, fmt, args);
		197	try step.result_error_msgs.append(arena, msg);
		198	return error.MakeFailed;
		199	}
		200
		201	/// Assumes that argv contains `--listen=-` and that the process being spawned
		202	/// is the zig compiler - the same version that compiled the build runner.
		203	pub fn evalZigProcess(
		204	s: *Step,
		205	argv: []const []const u8,
		206	prog_node: *std.Progress.Node,
		207	) ![]const u8 {
		208	assert(argv.len != 0);
		209	const b = s.owner;
		210	const arena = b.allocator;
		211	const gpa = arena;
		212
		213	try handleChildProcUnsupported(s, null, argv);
		214	try handleVerbose(s.owner, null, argv);
		215
		216	var child = std.ChildProcess.init(argv, arena);
		217	child.env_map = b.env_map;
		218	child.stdin_behavior = .Pipe;
		219	child.stdout_behavior = .Pipe;
		220	child.stderr_behavior = .Pipe;
		221
		222	child.spawn() catch \|err\| return s.fail("unable to spawn {s}: {s}", .{
		223	argv[0], @errorName(err),
		224	});
		225
		226	var poller = std.io.poll(gpa, enum { stdout, stderr }, .{
		227	.stdout = child.stdout.?,
		228	.stderr = child.stderr.?,
		229	});
		230	defer poller.deinit();
		231
		232	try sendMessage(child.stdin.?, .update);
		233	try sendMessage(child.stdin.?, .exit);
		234
		235	const Header = std.zig.Server.Message.Header;
		236	var result: ?[]const u8 = null;
		237
		238	var node_name: std.ArrayListUnmanaged(u8) = .{};
		239	defer node_name.deinit(gpa);
		240	var sub_prog_node: ?std.Progress.Node = null;
		241	defer if (sub_prog_node) \|*n\| n.end();
		242
		243	while (try poller.poll()) {
		244	const stdout = poller.fifo(.stdout);
		245	const buf = stdout.readableSlice(0);
		246	assert(stdout.readableLength() == buf.len);
		247	if (buf.len >= @sizeOf(Header)) {
		248	const header = @ptrCast(*align(1) const Header, buf[0..@sizeOf(Header)]);
		249	const header_and_msg_len = header.bytes_len + @sizeOf(Header);
		250	if (buf.len >= header_and_msg_len) {
		251	const body = buf[@sizeOf(Header)..][0..header.bytes_len];
		252	switch (header.tag) {
		253	.zig_version => {
		254	if (!std.mem.eql(u8, builtin.zig_version_string, body)) {
		255	return s.fail(
		256	"zig version mismatch build runner vs compiler: '{s}' vs '{s}'",
		257	.{ builtin.zig_version_string, body },
		258	);
		259	}
		260	},
		261	.error_bundle => {
		262	const EbHdr = std.zig.Server.Message.ErrorBundle;
		263	const eb_hdr = @ptrCast(*align(1) const EbHdr, body);
		264	const extra_bytes =
		265	body[@sizeOf(EbHdr)..][0 .. @sizeOf(u32) * eb_hdr.extra_len];
		266	const string_bytes =
		267	body[@sizeOf(EbHdr) + extra_bytes.len ..][0..eb_hdr.string_bytes_len];
		268	// TODO: use @ptrCast when the compiler supports it
		269	const unaligned_extra = std.mem.bytesAsSlice(u32, extra_bytes);
		270	const extra_array = try arena.alloc(u32, unaligned_extra.len);
		271	// TODO: use @memcpy when it supports slices
		272	for (extra_array, unaligned_extra) \|dst, src\| dst. = src;
		273	s.result_error_bundle = .{
		274	.string_bytes = try arena.dupe(u8, string_bytes),
		275	.extra = extra_array,
		276	};
		277	},
		278	.progress => {
		279	if (sub_prog_node) \|*n\| n.end();
		280	node_name.clearRetainingCapacity();
		281	try node_name.appendSlice(gpa, body);
		282	sub_prog_node = prog_node.start(node_name.items, 0);
		283	sub_prog_node.?.activate();
		284	},
		285	.emit_bin_path => {
		286	result = try arena.dupe(u8, body);
		287	},
		288	_ => {
		289	// Unrecognized message.
		290	},
		291	}
		292	stdout.discard(header_and_msg_len);
		293	}
		294	}
		295	}
		296
		297	const stderr = poller.fifo(.stderr);
		298	if (stderr.readableLength() > 0) {
		299	try s.result_error_msgs.append(arena, try stderr.toOwnedSlice());
		300	}
		301
		302	// Send EOF to stdin.
		303	child.stdin.?.close();
		304	child.stdin = null;
		305
		306	const term = child.wait() catch \|err\| {
		307	return s.fail("unable to wait for {s}: {s}", .{ argv[0], @errorName(err) });
		308	};
		309	try handleChildProcessTerm(s, term, null, argv);
		310
		311	if (s.result_error_bundle.errorMessageCount() > 0) {
		312	return s.fail("the following command failed with {d} compilation errors:\n{s}", .{
		313	s.result_error_bundle.errorMessageCount(),
		314	try allocPrintCmd(arena, null, argv),
		315	});
		316	}
		317
		318	return result orelse return s.fail(
		319	"the following command failed to communicate the compilation result:\n{s}",
		320	.{try allocPrintCmd(arena, null, argv)},
		321	);
		322	}
		323
		324	fn sendMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag) !void {
		325	const header: std.zig.Client.Message.Header = .{
		326	.tag = tag,
		327	.bytes_len = 0,
		328	};
		329	try file.writeAll(std.mem.asBytes(&header));
		330	}
		331
		332	pub fn handleVerbose(
		333	b: *Build,
		334	opt_cwd: ?[]const u8,
		335	argv: []const []const u8,
		336	) error{OutOfMemory}!void {
		337	if (b.verbose) {
		338	// Intention of verbose is to print all sub-process command lines to
		339	// stderr before spawning them.
		340	const text = try allocPrintCmd(b.allocator, opt_cwd, argv);
		341	std.debug.print("{s}\n", .{text});
		342	}
		343	}
		344
		345	pub inline fn handleChildProcUnsupported(
		346	s: *Step,
		347	opt_cwd: ?[]const u8,
		348	argv: []const []const u8,
		349	) error{ OutOfMemory, MakeFailed }!void {
		350	if (!std.process.can_spawn) {
		351	return s.fail(
		352	"unable to execute the following command: host cannot spawn child processes\n{s}",
		353	.{try allocPrintCmd(s.owner.allocator, opt_cwd, argv)},
		354	);
		355	}
		356	}
		357
		358	pub fn handleChildProcessTerm(
		359	s: *Step,
		360	term: std.ChildProcess.Term,
		361	opt_cwd: ?[]const u8,
		362	argv: []const []const u8,
		363	) error{ MakeFailed, OutOfMemory }!void {
		364	const arena = s.owner.allocator;
		365	switch (term) {
		366	.Exited => \|code\| {
		367	if (code != 0) {
		368	return s.fail(
		369	"the following command exited with error code {d}:\n{s}",
		370	.{ code, try allocPrintCmd(arena, opt_cwd, argv) },
		371	);
		372	}
		373	},
		374	.Signal, .Stopped, .Unknown => {
		375	return s.fail(
		376	"the following command terminated unexpectedly:\n{s}",
		377	.{try allocPrintCmd(arena, opt_cwd, argv)},
		378	);
		379	},
		380	}
		381	}
		382
		383	pub fn allocPrintCmd(arena: Allocator, opt_cwd: ?[]const u8, argv: []const []const u8) ![]u8 {
		384	var buf: std.ArrayListUnmanaged(u8) = .{};
		385	if (opt_cwd) \|cwd\| try buf.writer(arena).print("cd {s} && ", .{cwd});
		386	for (argv) \|arg\| {
		387	try buf.writer(arena).print("{s} ", .{arg});
		388	}
		389	return buf.toOwnedSlice(arena);
		390	}
		391
		392	pub fn cacheHit(s: Step, man: std.Build.Cache.Manifest) !bool {
		393	return man.hit() catch \|err\| return failWithCacheError(s, man, err);
		394	}
		395
		396	fn failWithCacheError(s: Step, man: const std.Build.Cache.Manifest, err: anyerror) anyerror {
		397	const i = man.failed_file_index orelse return err;
		398	const pp = man.files.items[i].prefixed_path orelse return err;
		399	const prefix = man.cache.prefixes()[pp.prefix].path orelse "";
		400	return s.fail("{s}: {s}/{s}\n", .{ @errorName(err), prefix, pp.sub_path });
		401	}

lib/std/Build/TranslateCStep.zig+20-20

 @@ -11,7 +11,6 @@ const TranslateCStep = @This();
 pub const base_id = .translate_c;
 step: Step,
-builder: *std.Build,
 source: std.Build.FileSource,
 include_dirs: std.ArrayList([]const u8),
 c_macros: std.ArrayList([]const u8),
 @@ -26,19 +25,19 @@ pub const Options = struct {
     optimize: std.builtin.OptimizeMode,
 };
-pub fn create(builder: *std.Build, options: Options) *TranslateCStep {
+pub fn create(owner: *std.Build, options: Options) *TranslateCStep {
-    const self = builder.allocator.create(TranslateCStep) catch @panic("OOM");
+    const self = owner.allocator.create(TranslateCStep) catch @panic("OOM");
-    const source = options.source_file.dupe(builder);
+    const source = options.source_file.dupe(owner);
     self.* = TranslateCStep{
-        .step = Step.init(builder.allocator, .{
+        .step = Step.init(.{
             .id = .translate_c,
             .name = "translate-c",
+            .owner = owner,
             .makeFn = make,
         }),
-        .builder = builder,
         .source = source,
-        .include_dirs = std.ArrayList([]const u8).init(builder.allocator),
+        .include_dirs = std.ArrayList([]const u8).init(owner.allocator),
-        .c_macros = std.ArrayList([]const u8).init(builder.allocator),
+        .c_macros = std.ArrayList([]const u8).init(owner.allocator),
         .out_basename = undefined,
         .target = options.target,
         .optimize = options.optimize,
 @@ -58,7 +57,7 @@ pub const AddExecutableOptions = struct {
 /// Creates a step to build an executable from the translated source.
 pub fn addExecutable(self: *TranslateCStep, options: AddExecutableOptions) *CompileStep {
-    return self.builder.addExecutable(.{
+    return self.step.owner.addExecutable(.{
         .root_source_file = .{ .generated = &self.output_file },
         .name = options.name orelse "translated_c",
         .version = options.version,
 @@ -69,30 +68,31 @@ pub fn addExecutable(self: *TranslateCStep, options: AddExecutableOptions) *Comp
 }
 pub fn addIncludeDir(self: *TranslateCStep, include_dir: []const u8) void {
-    self.include_dirs.append(self.builder.dupePath(include_dir)) catch @panic("OOM");
+    self.include_dirs.append(self.step.owner.dupePath(include_dir)) catch @panic("OOM");
 }
 pub fn addCheckFile(self: *TranslateCStep, expected_matches: []const []const u8) *CheckFileStep {
-    return CheckFileStep.create(self.builder, .{ .generated = &self.output_file }, self.builder.dupeStrings(expected_matches));
+    return CheckFileStep.create(self.step.owner, .{ .generated = &self.output_file }, self.step.owner.dupeStrings(expected_matches));
 }
 /// If the value is omitted, it is set to 1.
 /// `name` and `value` need not live longer than the function call.
 pub fn defineCMacro(self: *TranslateCStep, name: []const u8, value: ?[]const u8) void {
-    const macro = std.Build.constructCMacro(self.builder.allocator, name, value);
+    const macro = std.Build.constructCMacro(self.step.owner.allocator, name, value);
     self.c_macros.append(macro) catch @panic("OOM");
 }
 /// name_and_value looks like [name]=[value]. If the value is omitted, it is set to 1.
 pub fn defineCMacroRaw(self: *TranslateCStep, name_and_value: []const u8) void {
-    self.c_macros.append(self.builder.dupe(name_and_value)) catch @panic("OOM");
+    self.c_macros.append(self.step.owner.dupe(name_and_value)) catch @panic("OOM");
 }
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
+    const b = step.owner;
     const self = @fieldParentPtr(TranslateCStep, "step", step);
-    var argv_list = std.ArrayList([]const u8).init(self.builder.allocator);
+    var argv_list = std.ArrayList([]const u8).init(b.allocator);
-    try argv_list.append(self.builder.zig_exe);
+    try argv_list.append(b.zig_exe);
     try argv_list.append("translate-c");
     try argv_list.append("-lc");
 @@ -101,12 +101,12 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     if (!self.target.isNative()) {
         try argv_list.append("-target");
-        try argv_list.append(try self.target.zigTriple(self.builder.allocator));
+        try argv_list.append(try self.target.zigTriple(b.allocator));
     }
     switch (self.optimize) {
         .Debug => {}, // Skip since it's the default.
-        else => try argv_list.append(self.builder.fmt("-O{s}", .{@tagName(self.optimize)})),
+        else => try argv_list.append(b.fmt("-O{s}", .{@tagName(self.optimize)})),
     }
     for (self.include_dirs.items) |include_dir| {
 @@ -119,15 +119,15 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
         try argv_list.append(c_macro);
     }
-    try argv_list.append(self.source.getPath(self.builder));
+    try argv_list.append(self.source.getPath(b));
-    const output_path = try self.builder.execFromStep(argv_list.items, &self.step, prog_node);
+    const output_path = try step.evalZigProcess(argv_list.items, prog_node);
     self.out_basename = fs.path.basename(output_path);
     const output_dir = fs.path.dirname(output_path).?;
     self.output_file.path = try fs.path.join(
-        self.builder.allocator,
+        b.allocator,
         &[_][]const u8{ output_dir, self.out_basename },
     );
 }

lib/std/Build/WriteFileStep.zig+26-37

 @@ -10,7 +10,6 @@
 //! control.
 step: Step,
-builder: *std.Build,
 /// The elements here are pointers because we need stable pointers for the
 /// GeneratedFile field.
 files: std.ArrayListUnmanaged(*File),
 @@ -34,12 +33,12 @@ pub const Contents = union(enum) {
     copy: std.Build.FileSource,
 };
-pub fn init(builder: *std.Build) WriteFileStep {
+pub fn init(owner: *std.Build) WriteFileStep {
     return .{
-        .builder = builder,
+        .step = Step.init(.{
-        .step = Step.init(builder.allocator, .{
             .id = .write_file,
             .name = "writefile",
+            .owner = owner,
             .makeFn = make,
         }),
         .files = .{},
 @@ -48,12 +47,13 @@ pub fn init(builder: *std.Build) WriteFileStep {
 }
 pub fn add(wf: *WriteFileStep, sub_path: []const u8, bytes: []const u8) void {
-    const gpa = wf.builder.allocator;
+    const b = wf.step.owner;
+    const gpa = b.allocator;
     const file = gpa.create(File) catch @panic("OOM");
     file.* = .{
         .generated_file = .{ .step = &wf.step },
-        .sub_path = wf.builder.dupePath(sub_path),
+        .sub_path = b.dupePath(sub_path),
-        .contents = .{ .bytes = wf.builder.dupe(bytes) },
+        .contents = .{ .bytes = b.dupe(bytes) },
     };
     wf.files.append(gpa, file) catch @panic("OOM");
 }
 @@ -66,11 +66,12 @@ pub fn add(wf: *WriteFileStep, sub_path: []const u8, bytes: []const u8) void {
 /// required sub-path exists.
 /// This is the option expected to be used most commonly with `addCopyFile`.
 pub fn addCopyFile(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: []const u8) void {
-    const gpa = wf.builder.allocator;
+    const b = wf.step.owner;
+    const gpa = b.allocator;
     const file = gpa.create(File) catch @panic("OOM");
     file.* = .{
         .generated_file = .{ .step = &wf.step },
-        .sub_path = wf.builder.dupePath(sub_path),
+        .sub_path = b.dupePath(sub_path),
         .contents = .{ .copy = source },
     };
     wf.files.append(gpa, file) catch @panic("OOM");
 @@ -83,7 +84,8 @@ pub fn addCopyFile(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: [
 /// those changes to version control.
 /// A file added this way is not available with `getFileSource`.
 pub fn addCopyFileToSource(wf: *WriteFileStep, source: std.Build.FileSource, sub_path: []const u8) void {
-    wf.output_source_files.append(wf.builder.allocator, .{
+    const b = wf.step.owner;
+    wf.output_source_files.append(b.allocator, .{
         .contents = .{ .copy = source },
         .sub_path = sub_path,
     }) catch @panic("OOM");
 @@ -101,6 +103,7 @@ pub fn getFileSource(wf: *WriteFileStep, sub_path: []const u8) ?std.Build.FileSo
 fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     _ = prog_node;
+    const b = step.owner;
     const wf = @fieldParentPtr(WriteFileStep, "step", step);
     // Writing to source files is kind of an extra capability of this
 @@ -110,11 +113,11 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     for (wf.output_source_files.items) |output_source_file| {
         const basename = fs.path.basename(output_source_file.sub_path);
         if (fs.path.dirname(output_source_file.sub_path)) |dirname| {
-            var dir = try wf.builder.build_root.handle.makeOpenPath(dirname, .{});
+            var dir = try b.build_root.handle.makeOpenPath(dirname, .{});
             defer dir.close();
             try writeFile(wf, dir, output_source_file.contents, basename);
         } else {
-            try writeFile(wf, wf.builder.build_root.handle, output_source_file.contents, basename);
+            try writeFile(wf, b.build_root.handle, output_source_file.contents, basename);
         }
     }
 @@ -125,7 +128,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     // If, for example, a hard-coded path was used as the location to put WriteFileStep
     // files, then two WriteFileSteps executing in parallel might clobber each other.
-    var man = wf.builder.cache.obtain();
+    var man = b.cache.obtain();
     defer man.deinit();
     // Random bytes to make WriteFileStep unique. Refresh this with
 @@ -140,17 +143,17 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
                 man.hash.addBytes(bytes);
             },
             .copy => |file_source| {
-                _ = try man.addFile(file_source.getPath(wf.builder), null);
+                _ = try man.addFile(file_source.getPath(b), null);
             },
         }
     }
-    if (man.hit() catch |err| failWithCacheError(man, err)) {
+    if (try step.cacheHit(&man)) {
         // Cache hit, skip writing file data.
         const digest = man.final();
         for (wf.files.items) |file| {
-            file.generated_file.path = try wf.builder.cache_root.join(
+            file.generated_file.path = try b.cache_root.join(
-                wf.builder.allocator,
+                b.allocator,
                 &.{ "o", &digest, file.sub_path },
             );
         }
 @@ -160,7 +163,7 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     const digest = man.final();
     const cache_path = "o" ++ fs.path.sep_str ++ digest;
-    var cache_dir = wf.builder.cache_root.handle.makeOpenPath(cache_path, .{}) catch |err| {
+    var cache_dir = b.cache_root.handle.makeOpenPath(cache_path, .{}) catch |err| {
         std.debug.print("unable to make path {s}: {s}\n", .{ cache_path, @errorName(err) });
         return err;
     };
 @@ -169,15 +172,15 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
     for (wf.files.items) |file| {
         const basename = fs.path.basename(file.sub_path);
         if (fs.path.dirname(file.sub_path)) |dirname| {
-            var dir = try wf.builder.cache_root.handle.makeOpenPath(dirname, .{});
+            var dir = try b.cache_root.handle.makeOpenPath(dirname, .{});
             defer dir.close();
             try writeFile(wf, dir, file.contents, basename);
         } else {
             try writeFile(wf, cache_dir, file.contents, basename);
         }
-        file.generated_file.path = try wf.builder.cache_root.join(
+        file.generated_file.path = try b.cache_root.join(
-            wf.builder.allocator,
+            b.allocator,
             &.{ cache_path, file.sub_path },
         );
     }
 @@ -186,32 +189,18 @@ fn make(step: *Step, prog_node: *std.Progress.Node) !void {
 }
 fn writeFile(wf: *WriteFileStep, dir: fs.Dir, contents: Contents, basename: []const u8) !void {
+    const b = wf.step.owner;
     // TODO after landing concurrency PR, improve error reporting here
     switch (contents) {
         .bytes => |bytes| return dir.writeFile(basename, bytes),
         .copy => |file_source| {
-            const source_path = file_source.getPath(wf.builder);
+            const source_path = file_source.getPath(b);
             const prev_status = try fs.Dir.updateFile(fs.cwd(), source_path, dir, basename, .{});
             _ = prev_status; // TODO logging (affected by open PR regarding concurrency)
         },
     }
 }
-/// TODO consolidate this with the same function in RunStep?
-/// Also properly deal with concurrency (see open PR)
-fn failWithCacheError(man: std.Build.Cache.Manifest, err: anyerror) noreturn {
-    const i = man.failed_file_index orelse failWithSimpleError(err);
-    const pp = man.files.items[i].prefixed_path orelse failWithSimpleError(err);
-    const prefix = man.cache.prefixes()[pp.prefix].path orelse "";
-    std.debug.print("{s}: {s}/{s}\n", .{ @errorName(err), prefix, pp.sub_path });
-    std.process.exit(1);
-}
-fn failWithSimpleError(err: anyerror) noreturn {
-    std.debug.print("{s}\n", .{@errorName(err)});
-    std.process.exit(1);
-}
 const std = @import("../std.zig");
 const Step = std.Build.Step;
 const fs = std.fs;

src/main.zig+6-6

 @@ -4419,6 +4419,8 @@ pub const usage_build =
     \\Options:
     \\   -freference-trace[=num]       How many lines of reference trace should be shown per compile error
     \\   -fno-reference-trace          Disable reference trace
+    \\   -fsummary                     Print the build summary, even on success
+    \\   -fno-summary                  Omit the build summary, even on failure
     \\   --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
 @@ -4920,8 +4922,6 @@ pub fn cmdFmt(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
         };
         defer tree.deinit(gpa);
-        try printAstErrorsToStderr(gpa, tree, "<stdin>", color);
-        var has_ast_error = false;
         if (check_ast_flag) {
             var file: Module.File = .{
                 .status = .never_loaded,
 @@ -4957,11 +4957,11 @@ pub fn cmdFmt(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
                 var error_bundle = try wip_errors.toOwnedBundle();
                 defer error_bundle.deinit(gpa);
                 error_bundle.renderToStdErr(ttyconf);
-                has_ast_error = true;
+                process.exit(2);
             }
-        }
+        } else if (tree.errors.len != 0) {
-        if (tree.errors.len != 0 or has_ast_error) {
+            try printAstErrorsToStderr(gpa, tree, "<stdin>", color);
-            process.exit(1);
+            process.exit(2);
         }
         const formatted = try tree.render(gpa);
         defer gpa.free(formatted);

test/src/compare_output.zig+1-3

 @@ -166,9 +166,7 @@ pub const CompareOutputContext = struct {
                 const run = exe.run();
                 run.addArgs(case.cli_args);
-                run.stderr_action = .ignore;
+                run.expectExitCode(126);
-                run.stdout_action = .ignore;
-                run.expected_term = .{ .Exited = 126 };
                 self.step.dependOn(&run.step);
             },

test/tests.zig+6-10

 @@ -858,10 +858,11 @@ pub const StackTracesContext = struct {
             const allocator = context.b.allocator;
             const ptr = allocator.create(RunAndCompareStep) catch unreachable;
             ptr.* = RunAndCompareStep{
-                .step = Step.init(allocator, .{
+                .step = Step.init(.{
                     .id = .custom,
                     .name = "StackTraceCompareOutputStep",
                     .makeFn = make,
+                    .owner = context.b,
                 }),
                 .context = context,
                 .exe = exe,
 @@ -1121,10 +1122,7 @@ pub const StandaloneContext = struct {
             defer zig_args.resize(zig_args_base_len) catch unreachable;
             const run_cmd = b.addSystemCommand(zig_args.items);
-            const log_step = b.addLog("PASS {s} ({s})", .{ annotated_case_name, @tagName(optimize_mode) });
+            self.step.dependOn(&run_cmd.step);
-            log_step.step.dependOn(&run_cmd.step);
-            self.step.dependOn(&log_step.step);
         }
     }
 @@ -1150,10 +1148,7 @@ pub const StandaloneContext = struct {
                 exe.linkSystemLibrary("c");
             }
-            const log_step = b.addLog("PASS {s}", .{annotated_case_name});
+            self.step.dependOn(&exe.step);
-            log_step.step.dependOn(&exe.step);
-            self.step.dependOn(&log_step.step);
         }
     }
 };
 @@ -1203,9 +1198,10 @@ pub const GenHContext = struct {
             const allocator = context.b.allocator;
             const ptr = allocator.create(GenHCmpOutputStep) catch unreachable;
             ptr.* = GenHCmpOutputStep{
-                .step = Step.init(allocator, .{
+                .step = Step.init(.{
                     .id = .custom,
                     .name = "ParseCCmpOutput",
+                    .owner = context.b,
                     .makeFn = make,
                 }),
                 .context = context,