@zigc/lib 0.17.0-dev.607 → 0.17.0-dev.644

package/compiler/Maker/PkgConfig.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const Io = std.Io;
 const mem = std.mem;
 const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;
 
 const Maker = @import("../Maker.zig");
 const Step = @import("Step.zig");
@@ -23,6 +24,7 @@ pub const Result = std.zig.PkgConfig.Parsed;
 pub fn run(
     maker: *Maker,
     step: *Step,
+    arena: Allocator,
     progress_node: std.Progress.Node,
     lib_name: []const u8,
     /// If true, reports failure error messages on step rather than returning
@@ -31,7 +33,6 @@ pub fn run(
 ) RunError!Result {
     const pc = &maker.pkg_config;
     const graph = maker.graph;
-    const arena = graph.arena; // TODO don't leak into process arena
 
     const pkg_config_exe = getExe(graph);
     const pkgs = try getPkgs(maker, step, progress_node, force);
@@ -41,7 +42,7 @@ pub fn run(
     };
     const pkg = pkgs.all[found_index];
 
-    const stdout = try captureChildProcess(maker, step, .{
+    const stdout = try captureChildProcess(maker, step, arena, .{
         .argv = &.{ pkg_config_exe, pkg.name, "--cflags", "--libs" },
         .progress_node = progress_node,
         .allow_failure = !force,
@@ -69,11 +70,16 @@ fn getExe(graph: *const Graph) []const u8 {
     return std.zig.PkgConfig.exe(&graph.environ_map);
 }
 
-fn getPkgs(maker: *Maker, step: *Step, progress_node: std.Progress.Node, force: bool) RunError!std.zig.PkgConfig {
+fn getPkgs(
+    maker: *Maker,
+    step: *Step,
+    progress_node: std.Progress.Node,
+    force: bool,
+) RunError!std.zig.PkgConfig {
     const graph = maker.graph;
-    const arena = graph.arena; // TODO don't leak into process arena
     const io = graph.io;
     const pc = &maker.pkg_config;
+    const arena = graph.arena;
 
     try pc.mutex.lock(io);
     defer pc.mutex.unlock(io);
@@ -81,7 +87,7 @@ fn getPkgs(maker: *Maker, step: *Step, progress_node: std.Progress.Node, force:
     if (pc.pkgs) |pkgs| return pkgs;
 
     const pkg_config_exe = getExe(graph);
-    const stdout = try captureChildProcess(maker, step, .{
+    const stdout = try captureChildProcess(maker, step, arena, .{
         .argv = &.{ pkg_config_exe, "--list-all" },
         .progress_node = progress_node,
         .allow_failure = !force,
@@ -98,15 +104,17 @@ fn getPkgs(maker: *Maker, step: *Step, progress_node: std.Progress.Node, force:
         else => |e| return e,
     };
 
+    step.clearFailedCommand(maker.gpa);
     pc.pkgs = result;
     return result;
 }
 
-fn captureChildProcess(maker: *Maker, step: *Step, options: Step.CaptureChildProcessOptions) ![]const u8 {
-    const captured = step.captureChildProcess(maker, options) catch |err| switch (err) {
+fn captureChildProcess(maker: *Maker, step: *Step, arena: Allocator, options: Step.CaptureChildProcessOptions) ![]const u8 {
+    const captured = step.captureChildProcess(maker, arena, options) catch |err| switch (err) {
         error.FileNotFound => return error.PkgConfigUnavailable,
         else => |e| return e,
     };
+    if (captured.stderr.len != 0) try step.setResultStderr(maker.gpa, captured.stderr);
     assert(step.result_failed_command != null);
     if (captured.term.success()) return captured.stdout;
     if (!options.allow_failure) return step.fail(maker, "{s} {f}", .{ options.argv[0], captured.term });

package/compiler/Maker/Step/Compile.zig

@@ -328,10 +328,10 @@ fn lowerZigArgs(
                                 const pkg_conf_node = progress_node.start("pkg-config", 0);
                                 defer pkg_conf_node.end();
 
-                                if (PkgConfig.run(maker, step, pkg_conf_node, system_lib_name, force)) |result| {
-                                    try zig_args.appendSlice(gpa, result.cflags);
-                                    try zig_args.appendSlice(gpa, result.libs);
-                                    try seen_system_libs.put(arena, system_lib.name, result.cflags);
+                                if (PkgConfig.run(maker, step, arena, pkg_conf_node, system_lib_name, force)) |pc| {
+                                    try zig_args.appendSlice(gpa, pc.cflags);
+                                    try zig_args.appendSlice(gpa, pc.libs);
+                                    try seen_system_libs.put(arena, system_lib.name, pc.cflags);
                                     break :l;
                                 } else |err| switch (err) {
                                     error.PkgConfigUnavailable,
@@ -960,8 +960,8 @@ pub fn rebuildInFuzzMode(
     const arena = arena_allocator.allocator();
 
     step.result_error_msgs.clearRetainingCapacity();
-    step.result_stderr = "";
-
+    step.clearResultStderr(gpa);
+    step.clearErrorBundle(gpa);
     step.result_error_bundle.deinit(gpa);
     step.result_error_bundle = std.zig.ErrorBundle.empty;
 
@@ -1291,11 +1291,9 @@ fn appendModuleFlags(
 
     if (m.resolved_target.get(conf)) |resolved_target| {
         // Communicate the query via CLI since it's more compact.
-        if (resolved_target.query.get(conf)) |compact_query| {
+        if (resolved_target.unwrapQuery(conf)) |query| {
             try zig_args.ensureUnusedCapacity(gpa, 6);
 
-            const query = compact_query.unwrap(conf);
-
             zig_args.appendAssumeCapacity("-target");
             zig_args.appendAssumeCapacity(try query.zigTriple(arena));
 

package/compiler/Maker/Step/Fmt.zig

@@ -43,7 +43,7 @@ pub fn make(
         argv.appendAssumeCapacity(try maker.resolveLazyPathIndexAbs(arena, lp, step_index));
     }
 
-    const run_result = step.captureChildProcess(maker, .{
+    const run_result = step.captureChildProcess(maker, arena, .{
         .progress_node = progress_node,
         .argv = argv.items,
         .allow_failure = false,

package/compiler/Maker/Step/Run.zig

@@ -332,6 +332,12 @@ pub fn make(
 
     try populateGeneratedStdIo(maker, &conf_run, cache_root, &digest);
     try populateGeneratedPaths(maker, output_placeholders.items, cache_root, &digest);
+
+    // The utility functions that spawn the child process must unconditionally allocate
+    // the failed command because at that point it is not known whether the step will
+    // pass or fail based on the process termination. Here we free the memory since
+    // the step has succeeded.
+    step.clearFailedCommand(gpa);
 }
 
 /// Reads stdout of a Zig test process until a termination condition is reached:
@@ -713,7 +719,7 @@ const FuzzTestRunner = struct {
         }
     }
 
-    fn listen(f: *FuzzTestRunner, arena: Allocator) !void {
+    fn listen(f: *FuzzTestRunner) !void {
         const maker = f.ctx.fuzz.maker;
         const graph = maker.graph;
         const io = graph.io;
@@ -737,7 +743,7 @@ const FuzzTestRunner = struct {
                         else => |read_e| return read_e,
                     }),
                     2 => try f.completeStderrRead(id, result.file_read_streaming catch |e| switch (e) {
-                        error.EndOfStream => return f.instanceEos(arena, id),
+                        error.EndOfStream => return f.instanceEos(id),
                         else => |read_e| return read_e,
                     }),
                     else => unreachable,
@@ -899,8 +905,9 @@ const FuzzTestRunner = struct {
         } });
     }
 
-    fn instanceEos(f: *FuzzTestRunner, arena: Allocator, id: u32) !void {
+    fn instanceEos(f: *FuzzTestRunner, id: u32) !void {
         const maker = f.ctx.fuzz.maker;
+        const gpa = maker.gpa;
         const instance = &f.instances[id];
         const run_index = f.run_index;
 
@@ -912,7 +919,7 @@ const FuzzTestRunner = struct {
         instance.child.stdin = null;
         const term = try instance.child.wait(io);
         if (!termMatches(.{ .exited = 0 }, term)) {
-            step.result_stderr = try f.mergedStderr(arena);
+            step.takeResultStderr(gpa, try f.mergedStderr(gpa));
             try f.saveCrash(id, term);
             return step.fail(maker, "test process unexpectedly {f}", .{fmtTerm(term)});
         }
@@ -1055,7 +1062,7 @@ const FuzzTestRunner = struct {
         }
     }
 
-    fn mergedStderr(f: *FuzzTestRunner, arena: Allocator) Allocator.Error![]const u8 {
+    fn mergedStderr(f: *FuzzTestRunner, gpa: Allocator) Allocator.Error![]const u8 {
         // Collect any available stderr
         while (f.batch.next()) |completion| {
             if (completion.index % 3 != 2) continue;
@@ -1065,7 +1072,7 @@ const FuzzTestRunner = struct {
 
         var stderr_len: usize = 0;
         for (f.instances) |*instance| stderr_len += instance.stderr.items.len;
-        const stderr = try arena.alloc(u8, stderr_len);
+        const stderr = try gpa.alloc(u8, stderr_len);
 
         stderr_len = 0;
         for (f.instances) |*instance| {
@@ -1086,13 +1093,12 @@ fn evalFuzzTest(
     var f: FuzzTestRunner = try .init(run, run_index, fuzz_context, progress_node, spawn_options);
     defer f.deinit();
     try f.startInstances();
-    try f.listen(fuzz_context.fuzz.maker.graph.arena);
+    try f.listen();
 }
 
 const StdioPollEnum = enum { stdout, stderr };
 
 fn evalZigTest(
-    arena: Allocator,
     run: *Run,
     run_index: Configuration.Step.Index,
     maker: *Maker,
@@ -1140,7 +1146,7 @@ fn evalZigTest(
         };
 
         switch (try waitZigTest(
-            arena,
+            graph.arena,
             run,
             run_index,
             maker,
@@ -1158,7 +1164,7 @@ fn evalZigTest(
                     error.ReadFailed => return stderr_fr.err.?,
                     error.EndOfStream => {},
                 }
-                step.result_stderr = try arena.dupe(u8, stderr_fr.interface.buffered());
+                step.takeResultStderr(gpa, try multi_reader.toOwnedSlice(1));
 
                 // Clean up everything and wait for the child to exit.
                 child.stdin.?.close(io);
@@ -1180,8 +1186,9 @@ fn evalZigTest(
             .no_poll => |no_poll| {
                 // This might be a success (we requested exit and the child dutifully closed stdout) or
                 // a crash of some kind. Either way, the child will terminate by itself -- wait for it.
-                const stderr_reader = multi_reader.reader(1);
-                const stderr_owned = try arena.dupe(u8, stderr_reader.buffered());
+                const stderr_owned = try multi_reader.toOwnedSlice(1);
+                var keep_stderr_owned = false;
+                defer if (!keep_stderr_owned) gpa.free(stderr_owned);
 
                 // Clean up everything and wait for the child to exit.
                 child.stdin.?.close(io);
@@ -1209,7 +1216,9 @@ fn evalZigTest(
                 }
 
                 // Report an error if the child terminated uncleanly or if we were still trying to run more tests.
-                step.result_stderr = stderr_owned;
+                step.takeResultStderr(gpa, stderr_owned);
+                keep_stderr_owned = true;
+
                 const tests_done = test_metadata != null and test_metadata.?.next_index == std.math.maxInt(u32);
                 if (!tests_done or !termMatches(.{ .exited = 0 }, term)) {
                     // The individual unit test results are irrelevant: the test runner itself broke!
@@ -1234,9 +1243,10 @@ fn evalZigTest(
                 return;
             },
             .timeout => |timeout| {
-                const stderr_reader = multi_reader.reader(1);
-                const stderr = stderr_reader.buffered();
-                stderr_reader.tossBuffered();
+                const stderr_owned = try multi_reader.toOwnedSlice(1);
+                var keep_stderr_owned = false;
+                defer if (!keep_stderr_owned) gpa.free(stderr_owned);
+
                 if (timeout.active_test_index) |test_index| {
                     // A test was running. Report the timeout against that test, and continue on to
                     // the next test.
@@ -1245,16 +1255,20 @@ fn evalZigTest(
                     try step.addError(maker, "'{s}' timed out after {f}{s}{s}", .{
                         test_metadata.?.testName(test_index),
                         Io.Duration{ .nanoseconds = timeout.ns_elapsed },
-                        if (stderr.len != 0) " with stderr:\n" else "",
-                        std.mem.trim(u8, stderr, "\n"),
+                        if (stderr_owned.len != 0) " with stderr:\n" else "",
+                        std.mem.trim(u8, stderr_owned, "\n"),
                     });
                     continue;
                 }
                 // Just log an error and let the child be killed.
-                step.result_stderr = try arena.dupe(u8, stderr);
+                step.takeResultStderr(gpa, stderr_owned);
+                keep_stderr_owned = true;
+
                 // The individual unit test results in `results` are irrelevant: the test runner
                 // is broken! Fail immediately without populating `s.test_results`.
-                return step.fail(maker, "test runner failed to respond for {f}", .{Io.Duration{ .nanoseconds = timeout.ns_elapsed }});
+                return step.fail(maker, "test runner failed to respond for {f}", .{
+                    Io.Duration{ .nanoseconds = timeout.ns_elapsed },
+                });
             },
         }
         comptime unreachable;
@@ -1456,8 +1470,8 @@ fn evalGeneric(
 
             try multi_reader.checkAnyError();
 
-            stdout_bytes = try multi_reader.toOwnedSlice(0);
-            stderr_bytes = try multi_reader.toOwnedSlice(1);
+            stdout_bytes = multi_reader.reader(0).buffered();
+            stderr_bytes = multi_reader.reader(1).buffered();
         } else {
             var stdout_reader = stdout.readerStreaming(io, &.{});
             const stdio_limit: Io.Limit = if (conf_run.stdio_limit.value) |x| .limited64(x) else .unlimited;
@@ -1484,7 +1498,7 @@ fn evalGeneric(
             else => true,
         };
         if (stderr_is_diagnostic) {
-            step.result_stderr = bytes;
+            try step.setResultStderr(maker.gpa, bytes);
         }
     };
 
@@ -1815,8 +1829,7 @@ fn runCommand(
                 }
                 const root_module = producer.root_module.get(conf);
                 const root_module_target = root_module.resolved_target.get(conf).?.result.get(conf);
-                const other_target_query = root_module_target.unwrap(conf);
-                const root_target = std.zig.system.resolveTargetQuery(io, other_target_query) catch unreachable;
+                const root_target = root_module_target.unwrapTarget(conf);
                 const link_libc = maker.stepByIndex(producer_index).extended.compile.is_linking_libc;
 
                 const host: std.Target = std.zig.system.resolveTargetQuery(io, .{}) catch |he| switch (he) {
@@ -1900,6 +1913,12 @@ fn runCommand(
                             // by default. '-S inherit-env' was added in Wasmtime version 20.
                             interp_argv.appendAssumeCapacity("-Sinherit-env");
                             interp_argv.appendSliceAssumeCapacity(argv);
+
+                            // Enable more detailed backtraces by default, but allow the user to override this (e.g.
+                            // with `WASMTIME_BACKTRACE_DETAILS=0`) if desired.
+                            if (environ_map.get("WASMTIME_BACKTRACE_DETAILS") == null) {
+                                try environ_map.put("WASMTIME_BACKTRACE_DETAILS", "1");
+                            }
                         } else {
                             return failForeign(arena, &conf_run, maker, run_index, "-fwasmtime", argv[0], &root_target, &host);
                         }
@@ -2084,16 +2103,11 @@ fn runCommand(
         },
         else => {
             // On failure, report captured stderr like normal standard error output.
-            const bad_exit = switch (generic_result.term) {
-                .exited => |code| code != 0,
-                .signal, .stopped, .unknown => true,
-            };
-            if (bad_exit) {
+            if (!generic_result.term.success()) {
                 if (generic_result.stderr) |bytes| {
-                    step.result_stderr = bytes;
+                    try step.setResultStderr(gpa, bytes);
                 }
             }
-
             try step.handleChildProcessTerm(maker, generic_result.term);
         },
     }
@@ -2135,13 +2149,17 @@ fn spawnChildAndCollect(
         .inherit;
 
     // If an error occurs, it's caused by this command:
-    step.clearFailedCommand(gpa);
-    step.result_failed_command = try std.zig.allocPrintCmd(gpa, argv, .{
-        .cwd = switch (child_cwd) {
-            .path => |p| p,
-            .dir => unreachable,
-            .inherit => null,
-        },
+    const cwd_string = switch (child_cwd) {
+        .path => |p| p,
+        .dir => unreachable,
+        .inherit => null,
+    };
+    // We have to set the failed command here regardless of whether this
+    // function returns an error because only after this function returns
+    // does the logic determine whether the child process termination was
+    // success or failure.
+    step.setFailedCommand(gpa, argv, .{
+        .cwd = cwd_string,
         .child_env = environ_map,
         .parent_env = &graph.environ_map,
     });
@@ -2178,7 +2196,7 @@ fn spawnChildAndCollect(
 
     if (conf_run.flags.stdio == .zig_test) {
         const started: Io.Clock.Timestamp = .now(io, .awake);
-        const result = evalZigTest(graph.arena, run, run_index, maker, progress_node, spawn_options, fuzz_context) catch |err| switch (err) {
+        const result = evalZigTest(run, run_index, maker, progress_node, spawn_options, fuzz_context) catch |err| switch (err) {
             error.Canceled => |e| return e,
             else => |e| e,
         };
@@ -2198,7 +2216,7 @@ fn spawnChildAndCollect(
         try setColorEnvironmentVariables(&conf_run, environ_map, terminal_mode);
 
         const started: Io.Clock.Timestamp = .now(io, .awake);
-        const result = evalGeneric(graph.arena, run_index, maker, spawn_options) catch |err| switch (err) {
+        const result = evalGeneric(arena, run_index, maker, spawn_options) catch |err| switch (err) {
             error.Canceled => |e| return e,
             else => |e| e,
         };

package/compiler/Maker/Step/TranslateC.zig

@@ -40,10 +40,11 @@ pub fn make(
     argv.appendAssumeCapacity("--global-cache-dir");
     argv.appendAssumeCapacity(graph.global_cache_root.path orelse ".");
 
-    if (conf_tc.target.get(conf).?.query.unwrap()) |compact_query| {
-        const query = compact_query.get(conf).unwrap(conf);
-        argv.appendAssumeCapacity("-target");
-        argv.appendAssumeCapacity(try query.zigTriple(arena));
+    if (conf_tc.target.get(conf)) |resolved_target| {
+        if (resolved_target.unwrapQuery(conf)) |query| {
+            argv.appendAssumeCapacity("-target");
+            argv.appendAssumeCapacity(try query.zigTriple(arena));
+        }
     }
 
     switch (conf_tc.flags.optimize) {
@@ -112,7 +113,7 @@ pub fn make(
                 const pkg_conf_node = progress_node.start("pkg-config", 0);
                 defer pkg_conf_node.end();
 
-                if (PkgConfig.run(maker, step, pkg_conf_node, system_lib_name, force)) |result| {
+                if (PkgConfig.run(maker, step, arena, pkg_conf_node, system_lib_name, force)) |result| {
                     try argv.appendSlice(arena, result.cflags);
                     try argv.appendSlice(arena, result.libs);
                     try seen_system_libs.put(arena, system_lib.name, result.cflags);

package/compiler/Maker/Step.zig

@@ -54,8 +54,10 @@ dependants: std.ArrayList(Configuration.Step.Index) = .empty,
 inputs: Inputs = .init,
 pending_deps: u32 = undefined,
 
+/// Array list and internal memory owned by process arena.
 result_error_msgs: std.ArrayList([]const u8) = .empty,
 result_error_bundle: std.zig.ErrorBundle = .empty,
+/// Owned by `Maker.gpa`.
 result_stderr: []const u8 = "",
 result_cached: bool = false,
 /// Indicates error information is missing due to allocation failure.
@@ -310,9 +312,8 @@ pub fn reset(step: *Step, maker: *Maker) void {
     const gpa = maker.gpa;
 
     clearFailedCommand(step, gpa);
-
+    clearResultStderr(step, gpa);
     step.result_error_msgs.clearRetainingCapacity();
-    step.result_stderr = "";
     step.result_cached = false;
     step.result_duration_ns = null;
     step.result_peak_rss = 0;
@@ -332,20 +333,23 @@ pub const CaptureChildProcessOptions = struct {
     allow_failure: bool = false,
 };
 
-/// Populates `s.result_failed_command`.
-pub fn captureChildProcess(s: *Step, maker: *Maker, options: CaptureChildProcessOptions) !std.process.RunResult {
+/// Populates `s.result_failed_command` unconditionally.
+pub fn captureChildProcess(
+    s: *Step,
+    maker: *Maker,
+    allocator: Allocator,
+    options: CaptureChildProcessOptions,
+) !std.process.RunResult {
     const gpa = maker.gpa;
     const graph = maker.graph;
-    const arena = graph.arena; // TODO stop leaking into process arena
     const io = graph.io;
 
-    clearFailedCommand(s, gpa);
-    s.result_failed_command = try std.zig.allocPrintCmd(gpa, options.argv, .{});
+    s.setFailedCommand(gpa, options.argv, .{});
 
     try handleChildProcUnsupported(s, maker);
     try graph.handleVerbose(null, null, options.argv);
 
-    const result = std.process.run(arena, io, .{
+    const result = std.process.run(allocator, io, .{
         .argv = options.argv,
         .environ_map = options.environ_map orelse &graph.environ_map,
         .progress_node = options.progress_node,
@@ -358,7 +362,7 @@ pub fn captureChildProcess(s: *Step, maker: *Maker, options: CaptureChildProcess
         return s.fail(maker, "failed to run {s}: {t}", .{ options.argv[0], err });
     };
 
-    if (result.stderr.len > 0) try s.result_error_msgs.append(arena, result.stderr);
+    if (result.stderr.len > 0) try s.result_error_msgs.append(graph.arena, result.stderr);
 
     return result;
 }
@@ -375,6 +379,21 @@ pub fn clearFailedCommand(s: *Step, gpa: Allocator) void {
     }
 }
 
+pub fn setFailedCommand(
+    s: *Step,
+    gpa: Allocator,
+    argv: []const []const u8,
+    options: std.zig.AllocPrintCmdOptions,
+) void {
+    s.clearFailedCommand(gpa);
+    s.result_failed_command = std.zig.allocPrintCmd(gpa, argv, options) catch |err| switch (err) {
+        error.OutOfMemory => {
+            s.result_oom = true;
+            return;
+        },
+    };
+}
+
 pub const FailError = error{ OutOfMemory, MakeFailed };
 
 pub fn fail(step: *Step, maker: *const Maker, comptime fmt: []const u8, args: anytype) FailError {
@@ -410,7 +429,8 @@ pub const ZigProcess = struct {
 
 /// Assumes that argv contains `--listen=-` and that the process being spawned
 /// is the zig compiler - the same version that compiled the build runner.
-/// Populates `s.result_failed_command`.
+///
+/// Populates `s.result_failed_command` on failure.
 pub fn evalZigProcess(
     step_index: Configuration.Step.Index,
     maker: *Maker,
@@ -424,8 +444,7 @@ pub fn evalZigProcess(
     const io = graph.io;
 
     // If an error occurs, it's happened in this command:
-    clearFailedCommand(s, gpa);
-    s.result_failed_command = try std.zig.allocPrintCmd(gpa, argv, .{});
+    errdefer s.setFailedCommand(gpa, argv, .{});
 
     if (s.getZigProcess()) |zp| update: {
         assert(watch);
@@ -683,16 +702,12 @@ fn sendMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag) !void {
     };
 }
 
-/// Asserts that the caller has already populated `s.result_failed_command`.
 pub inline fn handleChildProcUnsupported(s: *Step, maker: *Maker) FailError!void {
-    assert(s.result_failed_command != null);
     if (!std.process.can_spawn)
         return s.fail(maker, "unable to spawn process: host cannot spawn child processes", .{});
 }
 
-/// Asserts that the caller has already populated `s.result_failed_command`.
 pub fn handleChildProcessTerm(s: *Step, maker: *Maker, term: std.process.Child.Term) FailError!void {
-    assert(s.result_failed_command != null);
     if (!term.success()) return s.fail(maker, "process {f}", .{term});
 }
 
@@ -861,3 +876,19 @@ fn oomWrap(s: *Step, result: error{OutOfMemory}!void) void {
         s.result_oom = true;
     };
 }
+
+pub fn clearResultStderr(step: *Step, gpa: Allocator) void {
+    if (step.result_stderr.len != 0) {
+        gpa.free(step.result_stderr);
+        step.result_stderr = "";
+    }
+}
+
+pub fn setResultStderr(step: *Step, gpa: Allocator, bytes: []const u8) Allocator.Error!void {
+    takeResultStderr(step, gpa, try gpa.dupe(u8, bytes));
+}
+
+pub fn takeResultStderr(step: *Step, gpa: Allocator, owned: []const u8) void {
+    clearResultStderr(step, gpa);
+    step.result_stderr = owned;
+}