fix more fallout from locking stderr

4 files changed, 36 insertions, 30 deletions

diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index 4770e03a0c..d308efdf70 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -158,7 +158,8 @@ fn rebuildTestsWorkerRun(run: *Step.Run, gpa: Allocator, parent_prog_node: std.P
 }
 
 fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, parent_prog_node: std.Progress.Node) !void {
-    const io = run.step.owner.graph.io;
+    const graph = run.step.owner.graph;
+    const io = graph.io;
     const compile = run.producer.?;
     const prog_node = parent_prog_node.start(compile.step.name, 0);
     defer prog_node.end();
@@ -171,9 +172,9 @@ fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, parent_prog_nod
 
     if (show_error_msgs or show_compile_errors or show_stderr) {
         var buf: [256]u8 = undefined;
-        const stderr = try io.lockStderrWriter(&buf);
-        defer io.unlockStderrWriter();
-        build_runner.printErrorMessages(gpa, &compile.step, .{}, &stderr.interface, stderr.mode, .verbose, .indent) catch {};
+        const stderr = try io.lockStderr(&buf, graph.stderr_mode);
+        defer io.unlockStderr();
+        build_runner.printErrorMessages(gpa, &compile.step, .{}, stderr.terminal(), .verbose, .indent) catch {};
     }
 
     const rebuilt_bin_path = result catch |err| switch (err) {
@@ -186,7 +187,8 @@ fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, parent_prog_nod
 fn fuzzWorkerRun(fuzz: *Fuzz, run: *Step.Run, unit_test_index: u32) void {
     const owner = run.step.owner;
     const gpa = owner.allocator;
-    const io = owner.graph.io;
+    const graph = owner.graph;
+    const io = graph.io;
     const test_name = run.cached_test_metadata.?.testName(unit_test_index);
 
     const prog_node = fuzz.prog_node.start(test_name, 0);
@@ -195,11 +197,11 @@ fn fuzzWorkerRun(fuzz: *Fuzz, run: *Step.Run, unit_test_index: u32) void {
     run.rerunInFuzzMode(fuzz, unit_test_index, prog_node) catch |err| switch (err) {
         error.MakeFailed => {
             var buf: [256]u8 = undefined;
-            const stderr = io.lockStderrWriter(&buf) catch |e| switch (e) {
+            const stderr = io.lockStderr(&buf, graph.stderr_mode) catch |e| switch (e) {
                 error.Canceled => return,
             };
-            defer io.unlockStderrWriter();
-            build_runner.printErrorMessages(gpa, &run.step, .{}, &stderr.interface, stderr.mode, .verbose, .indent) catch {};
+            defer io.unlockStderr();
+            build_runner.printErrorMessages(gpa, &run.step, .{}, stderr.terminal(), .verbose, .indent) catch {};
             return;
         },
         else => {
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 0df58b24b7..74b41634a7 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -328,16 +328,17 @@ pub fn cast(step: *Step, comptime T: type) ?*T {
 }
 
 /// For debugging purposes, prints identifying information about this Step.
-pub fn dump(step: *Step, w: *Io.Writer, fwm: Io.File.Writer.Mode) void {
+pub fn dump(step: *Step, t: Io.Terminal) void {
+    const w = t.writer;
     if (step.debug_stack_trace.instruction_addresses.len > 0) {
         w.print("name: '{s}'. creation stack trace:\n", .{step.name}) catch {};
-        std.debug.writeStackTrace(&step.debug_stack_trace, w, fwm) catch {};
+        std.debug.writeStackTrace(&step.debug_stack_trace, t) catch {};
     } else {
         const field = "debug_stack_frames_count";
         comptime assert(@hasField(Build, field));
-        fwm.setColor(w, .yellow) catch {};
+        t.setColor(.yellow) catch {};
         w.print("name: '{s}'. no stack trace collected for this step, see std.Build." ++ field ++ "\n", .{step.name}) catch {};
-        fwm.setColor(w, .reset) catch {};
+        t.setColor(.reset) catch {};
     }
 }
 
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index 888775884d..4752046089 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -925,20 +925,21 @@ const CliNamedModules = struct {
 fn getGeneratedFilePath(compile: *Compile, comptime tag_name: []const u8, asking_step: ?*Step) ![]const u8 {
     const step = &compile.step;
     const b = step.owner;
-    const io = b.graph.io;
+    const graph = b.graph;
+    const io = graph.io;
     const maybe_path: ?*GeneratedFile = @field(compile, tag_name);
 
     const generated_file = maybe_path orelse {
-        const stderr = try io.lockStderrWriter(&.{});
-        std.Build.dumpBadGetPathHelp(&compile.step, &stderr.interface, stderr.mode, compile.step.owner, asking_step) catch {};
-        io.unlockStderrWriter();
+        const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
+        std.Build.dumpBadGetPathHelp(&compile.step, stderr.terminal(), compile.step.owner, asking_step) catch {};
+        io.unlockStderr();
         @panic("missing emit option for " ++ tag_name);
     };
 
     const path = generated_file.path orelse {
-        const stderr = try io.lockStderrWriter(&.{});
-        std.Build.dumpBadGetPathHelp(&compile.step, &stderr.interface, stderr.mode, compile.step.owner, asking_step) catch {};
-        io.unlockStderrWriter();
+        const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
+        std.Build.dumpBadGetPathHelp(&compile.step, stderr.terminal(), compile.step.owner, asking_step) catch {};
+        io.unlockStderr();
         @panic(tag_name ++ " is null. Is there a missing step dependency?");
     };
 
@@ -1907,7 +1908,7 @@ fn checkCompileErrors(compile: *Compile) !void {
         try actual_eb.renderToWriter(.{
             .include_reference_trace = false,
             .include_source_line = false,
-        }, &aw.writer, .streaming);
+        }, &aw.writer);
         break :ae try aw.toOwnedSlice();
     };
 
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index 67cf201374..157a0292e7 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1559,7 +1559,8 @@ fn spawnChildAndCollect(
 ) !?EvalGenericResult {
     const b = run.step.owner;
     const arena = b.allocator;
-    const io = b.graph.io;
+    const graph = b.graph;
+    const io = graph.io;
 
     if (fuzz_context != null) {
         assert(!has_side_effects);
@@ -1625,11 +1626,12 @@ fn spawnChildAndCollect(
         if (!run.disable_zig_progress and !inherit) {
             child.progress_node = options.progress_node;
         }
-        if (inherit) {
-            const stderr = try io.lockStderrWriter(&.{});
-            try setColorEnvironmentVariables(run, env_map, stderr.mode);
-        }
-        defer if (inherit) io.unlockStderrWriter();
+        const terminal_mode: Io.Terminal.Mode = if (inherit) m: {
+            const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
+            break :m stderr.terminal_mode;
+        } else .no_color;
+        defer if (inherit) io.unlockStderr();
+        try setColorEnvironmentVariables(run, env_map, terminal_mode);
         var timer = try std.time.Timer.start();
         const res = try evalGeneric(run, &child);
         run.step.result_duration_ns = timer.read();
@@ -1637,7 +1639,7 @@ fn spawnChildAndCollect(
     }
 }
 
-fn setColorEnvironmentVariables(run: *Run, env_map: *EnvMap, fwm: Io.File.Writer.Mode) !void {
+fn setColorEnvironmentVariables(run: *Run, env_map: *EnvMap, terminal_mode: Io.Terminal.Mode) !void {
     color: switch (run.color) {
         .manual => {},
         .enable => {
@@ -1648,9 +1650,9 @@ fn setColorEnvironmentVariables(run: *Run, env_map: *EnvMap, fwm: Io.File.Writer
             try env_map.put("NO_COLOR", "1");
             env_map.remove("CLICOLOR_FORCE");
         },
-        .inherit => switch (fwm) {
-            .terminal_escaped => continue :color .enable,
-            else => continue :color .disable,
+        .inherit => switch (terminal_mode) {
+            .no_color, .windows_api => continue :color .disable,
+            .escape_codes => continue :color .enable,
         },
         .auto => {
             const capture_stderr = run.captured_stderr != null or switch (run.stdio) {