update lockStderrWriter sites

use the application's Io implementation where possible. This correctly
makes writing to stderr cancelable, fallible, and participate in the
application's event loop. It also removes one more hard-coded
dependency on a secondary Io implementation.

12 files changed, 91 insertions, 54 deletions

diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index b7300cb5df..de2985d2b5 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -2238,7 +2238,7 @@ pub const GeneratedFile = struct {
     /// This value must be set in the `fn make()` of the `step` and must not be `null` afterwards.
     path: ?[]const u8 = null,
 
-    /// Deprecated, see `getPath2`.
+    /// Deprecated, see `getPath3`.
     pub fn getPath(gen: GeneratedFile) []const u8 {
         return gen.step.owner.pathFromCwd(gen.path orelse std.debug.panic(
             "getPath() was called on a GeneratedFile that wasn't built yet. Is there a missing Step dependency on step '{s}'?",
@@ -2246,11 +2246,18 @@ pub const GeneratedFile = struct {
         ));
     }
 
+    /// Deprecated, see `getPath3`.
     pub fn getPath2(gen: GeneratedFile, src_builder: *Build, asking_step: ?*Step) []const u8 {
+        return getPath3(gen, src_builder, asking_step) catch |err| switch (err) {
+            error.Canceled => std.process.exit(1),
+        };
+    }
+
+    pub fn getPath3(gen: GeneratedFile, src_builder: *Build, asking_step: ?*Step) Io.Cancelable![]const u8 {
         return gen.path orelse {
-            const stderr = std.debug.lockStderrWriter(&.{});
+            const io = gen.step.owner.graph.io;
+            const stderr = try io.lockStderrWriter(&.{});
             dumpBadGetPathHelp(gen.step, &stderr.interface, stderr.mode, src_builder, asking_step) catch {};
-            std.debug.unlockStderrWriter();
             @panic("misconfigured build script");
         };
     }
@@ -2425,22 +2432,29 @@ pub const LazyPath = union(enum) {
         }
     }
 
-    /// Deprecated, see `getPath3`.
+    /// Deprecated, see `getPath4`.
     pub fn getPath(lazy_path: LazyPath, src_builder: *Build) []const u8 {
         return getPath2(lazy_path, src_builder, null);
     }
 
-    /// Deprecated, see `getPath3`.
+    /// Deprecated, see `getPath4`.
     pub fn getPath2(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) []const u8 {
         const p = getPath3(lazy_path, src_builder, asking_step);
         return src_builder.pathResolve(&.{ p.root_dir.path orelse ".", p.sub_path });
     }
 
+    /// Deprecated, see `getPath4`.
+    pub fn getPath3(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) Cache.Path {
+        return getPath4(lazy_path, src_builder, asking_step) catch |err| switch (err) {
+            error.Canceled => std.process.exit(1),
+        };
+    }
+
     /// Intended to be used during the make phase only.
     ///
     /// `asking_step` is only used for debugging purposes; it's the step being
     /// run that is asking for the path.
-    pub fn getPath3(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) Cache.Path {
+    pub fn getPath4(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) Io.Cancelable!Cache.Path {
         switch (lazy_path) {
             .src_path => |sp| return .{
                 .root_dir = sp.owner.build_root,
@@ -2457,9 +2471,10 @@ pub const LazyPath = union(enum) {
                 var file_path: Cache.Path = .{
                     .root_dir = Cache.Directory.cwd(),
                     .sub_path = gen.file.path orelse {
-                        const stderr = std.debug.lockStderrWriter(&.{});
+                        const io = src_builder.graph.io;
+                        const stderr = try io.lockStderrWriter(&.{});
                         dumpBadGetPathHelp(gen.file.step, &stderr.interface, stderr.mode, src_builder, asking_step) catch {};
-                        std.debug.unlockStderrWriter();
+                        io.unlockStderrWriter();
                         @panic("misconfigured build script");
                     },
                 };
diff --git a/lib/std/Build/Fuzz.zig b/lib/std/Build/Fuzz.zig
index c2b7d1e9e9..4770e03a0c 100644
--- a/lib/std/Build/Fuzz.zig
+++ b/lib/std/Build/Fuzz.zig
@@ -158,6 +158,7 @@ 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 compile = run.producer.?;
     const prog_node = parent_prog_node.start(compile.step.name, 0);
     defer prog_node.end();
@@ -170,8 +171,8 @@ 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 = std.debug.lockStderrWriter(&buf);
-        defer std.debug.unlockStderrWriter();
+        const stderr = try io.lockStderrWriter(&buf);
+        defer io.unlockStderrWriter();
         build_runner.printErrorMessages(gpa, &compile.step, .{}, &stderr.interface, stderr.mode, .verbose, .indent) catch {};
     }
 
@@ -182,12 +183,10 @@ fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, parent_prog_nod
     run.rebuilt_executable = try rebuilt_bin_path.join(gpa, compile.out_filename);
 }
 
-fn fuzzWorkerRun(
-    fuzz: *Fuzz,
-    run: *Step.Run,
-    unit_test_index: u32,
-) void {
-    const gpa = run.step.owner.allocator;
+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 test_name = run.cached_test_metadata.?.testName(unit_test_index);
 
     const prog_node = fuzz.prog_node.start(test_name, 0);
@@ -196,8 +195,10 @@ fn fuzzWorkerRun(
     run.rerunInFuzzMode(fuzz, unit_test_index, prog_node) catch |err| switch (err) {
         error.MakeFailed => {
             var buf: [256]u8 = undefined;
-            const stderr = std.debug.lockStderrWriter(&buf);
-            defer std.debug.unlockStderrWriter();
+            const stderr = io.lockStderrWriter(&buf) catch |e| switch (e) {
+                error.Canceled => return,
+            };
+            defer io.unlockStderrWriter();
             build_runner.printErrorMessages(gpa, &run.step, .{}, &stderr.interface, stderr.mode, .verbose, .indent) catch {};
             return;
         },
diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig
index d703e55b87..888775884d 100644
--- a/lib/std/Build/Step/Compile.zig
+++ b/lib/std/Build/Step/Compile.zig
@@ -922,20 +922,23 @@ const CliNamedModules = struct {
     }
 };
 
-fn getGeneratedFilePath(compile: *Compile, comptime tag_name: []const u8, asking_step: ?*Step) []const u8 {
+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 maybe_path: ?*GeneratedFile = @field(compile, tag_name);
 
     const generated_file = maybe_path orelse {
-        const stderr = std.debug.lockStderrWriter(&.{});
+        const stderr = try io.lockStderrWriter(&.{});
         std.Build.dumpBadGetPathHelp(&compile.step, &stderr.interface, stderr.mode, compile.step.owner, asking_step) catch {};
-        std.debug.unlockStderrWriter();
+        io.unlockStderrWriter();
         @panic("missing emit option for " ++ tag_name);
     };
 
     const path = generated_file.path orelse {
-        const stderr = std.debug.lockStderrWriter(&.{});
+        const stderr = try io.lockStderrWriter(&.{});
         std.Build.dumpBadGetPathHelp(&compile.step, &stderr.interface, stderr.mode, compile.step.owner, asking_step) catch {};
-        std.debug.unlockStderrWriter();
+        io.unlockStderrWriter();
         @panic(tag_name ++ " is null. Is there a missing step dependency?");
     };
 
@@ -1149,9 +1152,9 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
                                     // For everything else, we directly link
                                     // against the library file.
                                     const full_path_lib = if (other_produces_implib)
-                                        other.getGeneratedFilePath("generated_implib", &compile.step)
+                                        try other.getGeneratedFilePath("generated_implib", &compile.step)
                                     else
-                                        other.getGeneratedFilePath("generated_bin", &compile.step);
+                                        try other.getGeneratedFilePath("generated_bin", &compile.step);
 
                                     try zig_args.append(full_path_lib);
                                     total_linker_objects += 1;
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index f1e5313905..67cf201374 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1559,6 +1559,7 @@ fn spawnChildAndCollect(
 ) !?EvalGenericResult {
     const b = run.step.owner;
     const arena = b.allocator;
+    const io = b.graph.io;
 
     if (fuzz_context != null) {
         assert(!has_side_effects);
@@ -1625,10 +1626,10 @@ fn spawnChildAndCollect(
             child.progress_node = options.progress_node;
         }
         if (inherit) {
-            const stderr = std.debug.lockStderrWriter(&.{});
+            const stderr = try io.lockStderrWriter(&.{});
             try setColorEnvironmentVariables(run, env_map, stderr.mode);
         }
-        defer if (inherit) std.debug.unlockStderrWriter();
+        defer if (inherit) io.unlockStderrWriter();
         var timer = try std.time.Timer.start();
         const res = try evalGeneric(run, &child);
         run.step.result_duration_ns = timer.read();
diff --git a/lib/std/Build/WebServer.zig b/lib/std/Build/WebServer.zig
index ccb7159192..a2b35e3522 100644
--- a/lib/std/Build/WebServer.zig
+++ b/lib/std/Build/WebServer.zig
@@ -655,7 +655,7 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
     }
 
     if (result_error_bundle.errorMessageCount() > 0) {
-        result_error_bundle.renderToStdErr(.{}, .auto);
+        try result_error_bundle.renderToStderr(io, .{}, .auto);
         log.err("the following command failed with {d} compilation errors:\n{s}", .{
             result_error_bundle.errorMessageCount(),
             try Build.Step.allocPrintCmd(arena, null, argv.items),
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 603f53091e..6edbf9e471 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -764,7 +764,7 @@ fn appendTreeSymbol(symbol: TreeSymbol, buf: []u8, start_i: usize) usize {
     }
 }
 
-pub fn clearWrittenWithEscapeCodes(file_writer: *Io.File.Writer) anyerror!void {
+pub fn clearWrittenWithEscapeCodes(file_writer: *Io.File.Writer) Io.Writer.Error!void {
     if (noop_impl or !global_progress.need_clear) return;
     try file_writer.writeAllUnescaped(clear ++ progress_remove);
     global_progress.need_clear = false;
diff --git a/lib/std/json/dynamic.zig b/lib/std/json/dynamic.zig
index c3cccd1a91..f85916670b 100644
--- a/lib/std/json/dynamic.zig
+++ b/lib/std/json/dynamic.zig
@@ -47,10 +47,9 @@ pub const Value = union(enum) {
     }
 
     pub fn dump(v: Value) void {
-        const w, _ = std.debug.lockStderrWriter(&.{});
+        const stderr = std.debug.lockStderrWriter(&.{});
         defer std.debug.unlockStderrWriter();
-
-        json.Stringify.value(v, .{}, w) catch return;
+        json.Stringify.value(v, .{}, &stderr.interface) catch return;
     }
 
     pub fn jsonStringify(value: @This(), jws: anytype) !void {
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 216e793cbe..4b4c27fe20 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -1849,7 +1849,7 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
 /// and does not return.
 pub fn cleanExit(io: Io) void {
     if (builtin.mode == .Debug) return;
-    _ = io.lockStderrWriter(&.{});
+    _ = io.lockStderrWriter(&.{}) catch {};
     exit(0);
 }
 
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
index 092b65d71a..64ea3d1a4d 100644
--- a/lib/std/testing.zig
+++ b/lib/std/testing.zig
@@ -368,13 +368,21 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
         break :diff_index if (expected.len == actual.len) return else shortest;
     };
     if (!backend_can_print) return error.TestExpectedEqual;
-    const stderr = std.debug.lockStderrWriter(&.{});
-    defer std.debug.unlockStderrWriter();
-    failEqualSlices(T, expected, actual, diff_index, &stderr.interface, stderr.mode) catch {};
+    if (io.lockStderrWriter(&.{})) |stderr| {
+        defer io.unlockStderrWriter();
+        failEqualSlices(T, expected, actual, diff_index, &stderr.interface, stderr.mode) catch {};
+    } else |_| {}
     return error.TestExpectedEqual;
 }
 
-fn failEqualSlices(comptime T: type, expected: []const T, actual: []const T, diff_index: usize, w: *Io.Writer, fwm: Io.File.Writer.Mode) !void {
+fn failEqualSlices(
+    comptime T: type,
+    expected: []const T,
+    actual: []const T,
+    diff_index: usize,
+    w: *Io.Writer,
+    fwm: Io.File.Writer.Mode,
+) !void {
     try w.print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
 
     // TODO: Should this be configurable by the caller?
diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index b6203326f2..a094dee83f 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -639,7 +639,7 @@ pub fn readSourceFileToEndAlloc(gpa: Allocator, file_reader: *Io.File.Reader) ![
     return buffer.toOwnedSliceSentinel(gpa, 0);
 }
 
-pub fn printAstErrorsToStderr(gpa: Allocator, tree: Ast, path: []const u8, color: Color) !void {
+pub fn printAstErrorsToStderr(gpa: Allocator, io: Io, tree: Ast, path: []const u8, color: Color) !void {
     var wip_errors: std.zig.ErrorBundle.Wip = undefined;
     try wip_errors.init(gpa);
     defer wip_errors.deinit();
@@ -648,7 +648,7 @@ pub fn printAstErrorsToStderr(gpa: Allocator, tree: Ast, path: []const u8, color
 
     var error_bundle = try wip_errors.toOwnedBundle("");
     defer error_bundle.deinit(gpa);
-    error_bundle.renderToStdErr(.{}, color);
+    error_bundle.renderToStderr(io, .{}, color);
 }
 
 pub fn putAstErrorsIntoBundle(
diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig
index cc6182c8aa..0342874cf9 100644
--- a/lib/std/zig/ErrorBundle.zig
+++ b/lib/std/zig/ErrorBundle.zig
@@ -162,11 +162,13 @@ pub const RenderOptions = struct {
     include_log_text: bool = true,
 };
 
-pub fn renderToStdErr(eb: ErrorBundle, options: RenderOptions, color: std.zig.Color) void {
+pub const RenderToStderrError = Io.Cancelable || Io.File.Writer.Mode.SetColorError;
+
+pub fn renderToStderr(eb: ErrorBundle, io: Io, options: RenderOptions, color: std.zig.Color) RenderToStderrError!void {
     var buffer: [256]u8 = undefined;
-    const stderr = std.debug.lockStderrWriter(&buffer);
-    defer std.debug.unlockStderrWriter();
-    renderToWriter(eb, options, &stderr.interface, color.getTtyConf(stderr.mode)) catch return;
+    const stderr = try io.lockStderrWriter(&buffer);
+    defer io.unlockStderrWriter();
+    try renderToWriter(eb, options, &stderr.interface, color.getTtyConf(stderr.mode));
 }
 
 pub fn renderToWriter(
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index 9d9a6a48ce..5318eab2df 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -1,7 +1,6 @@
 const std = @import("std");
-const mem = std.mem;
-const print = std.debug.print;
-const maxInt = std.math.maxInt;
+const Io = std.Io;
+const Allocator = std.mem.Allocator;
 
 test "zig fmt: remove extra whitespace at start and end of file with comment between" {
     try testTransform(
@@ -6332,10 +6331,10 @@ test "ampersand" {
 
 var fixed_buffer_mem: [100 * 1024]u8 = undefined;
 
-fn testParse(source: [:0]const u8, allocator: mem.Allocator, anything_changed: *bool) ![]u8 {
+fn testParse(io: Io, source: [:0]const u8, allocator: Allocator, anything_changed: *bool) ![]u8 {
     var buffer: [64]u8 = undefined;
-    const stderr = std.debug.lockStderrWriter(&buffer);
-    defer std.debug.unlockStderrWriter();
+    const stderr = try io.lockStderrWriter(&buffer);
+    defer io.unlockStderrWriter();
 
     var tree = try std.zig.Ast.parse(allocator, source, .zig);
     defer tree.deinit(allocator);
@@ -6359,27 +6358,36 @@ fn testParse(source: [:0]const u8, allocator: mem.Allocator, anything_changed: *
     }
 
     const formatted = try tree.renderAlloc(allocator);
-    anything_changed.* = !mem.eql(u8, formatted, source);
+    anything_changed.* = !std.mem.eql(u8, formatted, source);
     return formatted;
 }
-fn testTransformImpl(allocator: mem.Allocator, fba: *std.heap.FixedBufferAllocator, source: [:0]const u8, expected_source: []const u8) !void {
+fn testTransformImpl(
+    io: Io,
+    allocator: Allocator,
+    fba: *std.heap.FixedBufferAllocator,
+    source: [:0]const u8,
+    expected_source: []const u8,
+) !void {
     // reset the fixed buffer allocator each run so that it can be re-used for each
     // iteration of the failing index
     fba.reset();
     var anything_changed: bool = undefined;
-    const result_source = try testParse(source, allocator, &anything_changed);
+    const result_source = try testParse(io, source, allocator, &anything_changed);
     try std.testing.expectEqualStrings(expected_source, result_source);
     const changes_expected = source.ptr != expected_source.ptr;
     if (anything_changed != changes_expected) {
-        print("std.zig.render returned {} instead of {}\n", .{ anything_changed, changes_expected });
+        std.debug.print("std.zig.render returned {} instead of {}\n", .{ anything_changed, changes_expected });
         return error.TestFailed;
     }
     try std.testing.expect(anything_changed == changes_expected);
     allocator.free(result_source);
 }
 fn testTransform(source: [:0]const u8, expected_source: []const u8) !void {
+    const io = std.testing.io;
     var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
-    return std.testing.checkAllAllocationFailures(fixed_allocator.allocator(), testTransformImpl, .{ &fixed_allocator, source, expected_source });
+    return std.testing.checkAllAllocationFailures(fixed_allocator.allocator(), testTransformImpl, .{
+        io, &fixed_allocator, source, expected_source,
+    });
 }
 fn testCanonical(source: [:0]const u8) !void {
     return testTransform(source, source);