process.Child.collectOutput: Take an allocator instead of array list pointers

Author: squeek502

lib/std/process/Child.zig

@@ -344,39 +344,36 @@ pub const RunResult = struct {
     stderr: []u8,
 };
 
-fn fifoToOwnedArrayList(fifo: *std.io.PollFifo) std.ArrayList(u8) {
+fn fifoToOwnedSlice(fifo: *std.io.PollFifo) ![]u8 {
     if (fifo.head != 0) fifo.realign();
-    const result = std.ArrayList(u8){
+    var result = std.ArrayListUnmanaged(u8){
         .items = fifo.buf[0..fifo.count],
         .capacity = fifo.buf.len,
-        .allocator = fifo.allocator,
     };
     fifo.* = std.io.PollFifo.init(fifo.allocator);
-    return result;
+    return result.toOwnedSlice(fifo.allocator);
 }
 
+pub const Output = struct {
+    stdout: []u8,
+    stderr: []u8,
+};
+
 /// Collect the output from the process's stdout and stderr. Will return once all output
 /// has been collected. This does not mean that the process has ended. `wait` should still
 /// be called to wait for and clean up the process.
 ///
 /// The process must be started with stdout_behavior and stderr_behavior == .Pipe
 pub fn collectOutput(
     child: ChildProcess,
-    stdout: *std.ArrayList(u8),
-    stderr: *std.ArrayList(u8),
+    /// Used for `stdout` and `stderr`.
+    allocator: Allocator,
     max_output_bytes: usize,
-) !void {
+) !Output {
     assert(child.stdout_behavior == .Pipe);
     assert(child.stderr_behavior == .Pipe);
 
-    // we could make this work with multiple allocators but YAGNI
-    if (stdout.allocator.ptr != stderr.allocator.ptr or
-        stdout.allocator.vtable != stderr.allocator.vtable)
-    {
-        unreachable; // ChildProcess.collectOutput only supports 1 allocator
-    }
-
-    var poller = std.io.poll(stdout.allocator, enum { stdout, stderr }, .{
+    var poller = std.io.poll(allocator, enum { stdout, stderr }, .{
         .stdout = child.stdout.?,
         .stderr = child.stderr.?,
     });
@@ -389,8 +386,15 @@ pub fn collectOutput(
             return error.StderrStreamTooLong;
     }
 
-    stdout.* = fifoToOwnedArrayList(poller.fifo(.stdout));
-    stderr.* = fifoToOwnedArrayList(poller.fifo(.stderr));
+    const stdout = try fifoToOwnedSlice(poller.fifo(.stdout));
+    errdefer allocator.free(stdout);
+    const stderr = try fifoToOwnedSlice(poller.fifo(.stderr));
+    errdefer allocator.free(stderr);
+
+    return .{
+        .stdout = stdout,
+        .stderr = stderr,
+    };
 }
 
 pub const RunError = posix.GetCwdError || posix.ReadError || SpawnError || posix.PollError || error{
@@ -420,20 +424,13 @@ pub fn run(args: struct {
     child.expand_arg0 = args.expand_arg0;
     child.progress_node = args.progress_node;
 
-    var stdout = std.ArrayList(u8).init(args.allocator);
-    var stderr = std.ArrayList(u8).init(args.allocator);
-    errdefer {
-        stdout.deinit();
-        stderr.deinit();
-    }
-
     try child.spawn();
-    try child.collectOutput(&stdout, &stderr, args.max_output_bytes);
+    const output = try child.collectOutput(args.allocator, args.max_output_bytes);
 
     return RunResult{
         .term = try child.wait(),
-        .stdout = try stdout.toOwnedSlice(),
-        .stderr = try stderr.toOwnedSlice(),
+        .stdout = output.stdout,
+        .stderr = output.stderr,
     };
 }