Commit 608145c2f07d90c46cdaa8bc2013f31b965a5b8b | zig

lib/compiler/aro/aro/Diagnostics.zig+13-15

 @@ -24,20 +24,21 @@ pub const Message = struct {
         @"fatal error",
     };
-    pub fn write(msg: Message, w: *std.Io.Writer, config: std.Io.File.Writer.Mode, details: bool) std.Io.tty.Config.SetColorError!void {
+    pub fn write(msg: Message, t: std.Io.Terminal, details: bool) std.Io.Terminal.SetColorError!void {
-        try config.setColor(w, .bold);
+        const w = t.writer;
+        try t.setColor(.bold);
         if (msg.location) |loc| {
             try w.print("{s}:{d}:{d}: ", .{ loc.path, loc.line_no, loc.col });
         }
         switch (msg.effective_kind) {
-            .@"fatal error", .@"error" => try config.setColor(w, .bright_red),
+            .@"fatal error", .@"error" => try t.setColor(.bright_red),
-            .note => try config.setColor(w, .bright_cyan),
+            .note => try t.setColor(.bright_cyan),
-            .warning => try config.setColor(w, .bright_magenta),
+            .warning => try t.setColor(.bright_magenta),
             .off => unreachable,
         }
         try w.print("{s}: ", .{@tagName(msg.effective_kind)});
-        try config.setColor(w, .white);
+        try t.setColor(.white);
         try w.writeAll(msg.text);
         if (msg.opt) |some| {
             if (msg.effective_kind == .@"error" and msg.kind != .@"error") {
 @@ -55,17 +56,17 @@ pub const Message = struct {
         if (!details or msg.location == null) {
             try w.writeAll("\n");
-            try config.setColor(w, .reset);
+            try t.setColor(.reset);
         } else {
             const loc = msg.location.?;
             const trailer = if (loc.end_with_splice) "\\ " else "";
-            try config.setColor(w, .reset);
+            try t.setColor(.reset);
             try w.print("\n{s}{s}\n", .{ loc.line, trailer });
             try w.splatByteAll(' ', loc.width);
-            try config.setColor(w, .bold);
+            try t.setColor(.bold);
-            try config.setColor(w, .bright_green);
+            try t.setColor(.bright_green);
             try w.writeAll("^\n");
-            try config.setColor(w, .reset);
+            try t.setColor(.reset);
         }
         try w.flush();
     }
 @@ -290,10 +291,7 @@ pub const State = struct {
 const Diagnostics = @This();
 output: union(enum) {
-    to_writer: struct {
+    to_writer: std.Io.Terminal,
-        writer: *std.Io.Writer,
-        color: std.Io.File.Writer.Mode,
-    },
     to_list: struct {
         messages: std.ArrayList(Message) = .empty,
         arena: std.heap.ArenaAllocator,

lib/compiler/build_runner.zig+169-169

...	@@ -286,8 +286,8 @@ pub fn main() !void {	...	@@ -286,8 +286,8 @@ pub fn main() !void {
286	const next_arg = nextArg(args, &arg_idx) orelse	286	const next_arg = nextArg(args, &arg_idx) orelse
287	fatalWithHint("expected u16 after '{s}'", .{arg});	287	fatalWithHint("expected u16 after '{s}'", .{arg});
288	debounce_interval_ms = std.fmt.parseUnsigned(u16, next_arg, 0) catch \|err\| {	288	debounce_interval_ms = std.fmt.parseUnsigned(u16, next_arg, 0) catch \|err\| {
289	fatal("unable to parse debounce interval '{s}' as unsigned 16-bit integer: {s}\n", .{	289	fatal("unable to parse debounce interval '{s}' as unsigned 16-bit integer: {t}\n", .{
290	next_arg, @errorName(err),	290	next_arg, err,
291	});	291	});
292	};	292	};
293	} else if (mem.eql(u8, arg, "--webui")) {	293	} else if (mem.eql(u8, arg, "--webui")) {
...	@@ -429,6 +429,12 @@ pub fn main() !void {	...	@@ -429,6 +429,12 @@ pub fn main() !void {
429	}	429	}
430	}	430	}
431		431
		432	graph.stderr_mode = switch (color) {
		433	.auto => try .detect(io, .stderr()),
		434	.on => .escape_codes,
		435	.off => .no_color,
		436	};
		437
432	if (webui_listen != null) {	438	if (webui_listen != null) {
433	if (watch) fatal("using '--webui' and '--watch' together is not yet supported; consider omitting '--watch' in favour of the web UI \"Rebuild\" button", .{});	439	if (watch) fatal("using '--webui' and '--watch' together is not yet supported; consider omitting '--watch' in favour of the web UI \"Rebuild\" button", .{});
434	if (builtin.single_threaded) fatal("'--webui' is not yet supported on single-threaded hosts", .{});	440	if (builtin.single_threaded) fatal("'--webui' is not yet supported on single-threaded hosts", .{});
...	@@ -522,7 +528,7 @@ pub fn main() !void {	...	@@ -522,7 +528,7 @@ pub fn main() !void {
522	// Perhaps in the future there could be an Advanced Options flag	528	// Perhaps in the future there could be an Advanced Options flag
523	// such as --debug-build-runner-leaks which would make this code	529	// such as --debug-build-runner-leaks which would make this code
524	// return instead of calling exit.	530	// return instead of calling exit.
525	_ = io.lockStderrWriter(&.{}) catch {};	531	_ = io.lockStderr(&.{}, graph.stderr_mode) catch {};
526	process.exit(1);	532	process.exit(1);
527	},	533	},
528	else => \|e\| return e,	534	else => \|e\| return e,
...	@@ -554,9 +560,9 @@ pub fn main() !void {	...	@@ -554,9 +560,9 @@ pub fn main() !void {
554	}	560	}
555		561
556	rebuild: while (true) : (if (run.error_style.clearOnUpdate()) {	562	rebuild: while (true) : (if (run.error_style.clearOnUpdate()) {
557	const stderr = try io.lockStderrWriter(&stdio_buffer_allocation);	563	const stderr = try io.lockStderr(&stdio_buffer_allocation, graph.stderr_mode);
558	defer io.unlockStderrWriter();	564	defer io.unlockStderr();
559	try stderr.writeAllUnescaped("\x1B[2J\x1B[3J\x1B[H");	565	try stderr.file_writer.interface.writeAll("\x1B[2J\x1B[3J\x1B[H");
560	}) {	566	}) {
561	if (run.web_server) \|*ws\| ws.startBuild();	567	if (run.web_server) \|*ws\| ws.startBuild();
562		568
...	@@ -730,7 +736,8 @@ fn runStepNames(	...	@@ -730,7 +736,8 @@ fn runStepNames(
730	fuzz: ?std.Build.Fuzz.Mode,	736	fuzz: ?std.Build.Fuzz.Mode,
731	) !void {	737	) !void {
732	const gpa = run.gpa;	738	const gpa = run.gpa;
733	const io = b.graph.io;	739	const graph = b.graph;
		740	const io = graph.io;
734	const step_stack = &run.step_stack;	741	const step_stack = &run.step_stack;
735		742
736	{	743	{
...	@@ -856,20 +863,19 @@ fn runStepNames(	...	@@ -856,20 +863,19 @@ fn runStepNames(
856	.none => break :summary,	863	.none => break :summary,
857	}	864	}
858		865
859	const stderr = try io.lockStderrWriter(&stdio_buffer_allocation);	866	const stderr = try io.lockStderr(&stdio_buffer_allocation, graph.stderr_mode);
860	defer io.unlockStderrWriter();	867	defer io.unlockStderr();
861		868	const t = stderr.terminal();
862	const w = &stderr.interface;	869	const w = &stderr.file_writer.interface;
863	const fwm = stderr.mode;
864		870
865	const total_count = success_count + failure_count + pending_count + skipped_count;	871	const total_count = success_count + failure_count + pending_count + skipped_count;
866	fwm.setColor(w, .cyan) catch {};	872	t.setColor(.cyan) catch {};
867	fwm.setColor(w, .bold) catch {};	873	t.setColor(.bold) catch {};
868	w.writeAll("Build Summary: ") catch {};	874	w.writeAll("Build Summary: ") catch {};
869	fwm.setColor(w, .reset) catch {};	875	t.setColor(.reset) catch {};
870	w.print("{d}/{d} steps succeeded", .{ success_count, total_count }) catch {};	876	w.print("{d}/{d} steps succeeded", .{ success_count, total_count }) catch {};
871	{	877	{
872	fwm.setColor(w, .dim) catch {};	878	t.setColor(.dim) catch {};
873	var first = true;	879	var first = true;
874	if (skipped_count > 0) {	880	if (skipped_count > 0) {
875	w.print("{s}{d} skipped", .{ if (first) " (" else ", ", skipped_count }) catch {};	881	w.print("{s}{d} skipped", .{ if (first) " (" else ", ", skipped_count }) catch {};
...	@@ -880,12 +886,12 @@ fn runStepNames(	...	@@ -880,12 +886,12 @@ fn runStepNames(
880	first = false;	886	first = false;
881	}	887	}
882	if (!first) w.writeByte(')') catch {};	888	if (!first) w.writeByte(')') catch {};
883	fwm.setColor(w, .reset) catch {};	889	t.setColor(.reset) catch {};
884	}	890	}
885		891
886	if (test_count > 0) {	892	if (test_count > 0) {
887	w.print("; {d}/{d} tests passed", .{ test_pass_count, test_count }) catch {};	893	w.print("; {d}/{d} tests passed", .{ test_pass_count, test_count }) catch {};
888	fwm.setColor(w, .dim) catch {};	894	t.setColor(.dim) catch {};
889	var first = true;	895	var first = true;
890	if (test_skip_count > 0) {	896	if (test_skip_count > 0) {
891	w.print("{s}{d} skipped", .{ if (first) " (" else ", ", test_skip_count }) catch {};	897	w.print("{s}{d} skipped", .{ if (first) " (" else ", ", test_skip_count }) catch {};
...	@@ -904,7 +910,7 @@ fn runStepNames(	...	@@ -904,7 +910,7 @@ fn runStepNames(
904	first = false;	910	first = false;
905	}	911	}
906	if (!first) w.writeByte(')') catch {};	912	if (!first) w.writeByte(')') catch {};
907	fwm.setColor(w, .reset) catch {};	913	t.setColor(.reset) catch {};
908	}	914	}
909		915
910	w.writeAll("\n") catch {};	916	w.writeAll("\n") catch {};
...	@@ -918,7 +924,7 @@ fn runStepNames(	...	@@ -918,7 +924,7 @@ fn runStepNames(
918	var print_node: PrintNode = .{ .parent = null };	924	var print_node: PrintNode = .{ .parent = null };
919	if (step_names.len == 0) {	925	if (step_names.len == 0) {
920	print_node.last = true;	926	print_node.last = true;
921	printTreeStep(b, b.default_step, run, w, fwm, &print_node, &step_stack_copy) catch {};	927	printTreeStep(b, b.default_step, run, t, &print_node, &step_stack_copy) catch {};
922	} else {	928	} else {
923	const last_index = if (run.summary == .all) b.top_level_steps.count() else blk: {	929	const last_index = if (run.summary == .all) b.top_level_steps.count() else blk: {
924	var i: usize = step_names.len;	930	var i: usize = step_names.len;
...	@@ -937,7 +943,7 @@ fn runStepNames(	...	@@ -937,7 +943,7 @@ fn runStepNames(
937	for (step_names, 0..) \|step_name, i\| {	943	for (step_names, 0..) \|step_name, i\| {
938	const tls = b.top_level_steps.get(step_name).?;	944	const tls = b.top_level_steps.get(step_name).?;
939	print_node.last = i + 1 == last_index;	945	print_node.last = i + 1 == last_index;
940	printTreeStep(b, &tls.step, run, w, fwm, &print_node, &step_stack_copy) catch {};	946	printTreeStep(b, &tls.step, run, t, &print_node, &step_stack_copy) catch {};
941	}	947	}
942	}	948	}
943	w.writeByte('\n') catch {};	949	w.writeByte('\n') catch {};
...	@@ -954,7 +960,7 @@ fn runStepNames(	...	@@ -954,7 +960,7 @@ fn runStepNames(
954	if (run.error_style.verboseContext()) break :code 1; // failure; print build command	960	if (run.error_style.verboseContext()) break :code 1; // failure; print build command
955	break :code 2; // failure; do not print build command	961	break :code 2; // failure; do not print build command
956	};	962	};
957	_ = io.lockStderrWriter(&.{}) catch {};	963	_ = io.lockStderr(&.{}, graph.stderr_mode) catch {};
958	process.exit(code);	964	process.exit(code);
959	}	965	}
960		966
...	@@ -963,33 +969,30 @@ const PrintNode = struct {	...	@@ -963,33 +969,30 @@ const PrintNode = struct {
963	last: bool = false,	969	last: bool = false,
964	};	970	};
965		971
966	fn printPrefix(node: PrintNode, w: Writer, fwm: File.Writer.Mode) !void {	972	fn printPrefix(node: *PrintNode, stderr: Io.Terminal) !void {
967	const parent = node.parent orelse return;	973	const parent = node.parent orelse return;
		974	const writer = stderr.writer;
968	if (parent.parent == null) return;	975	if (parent.parent == null) return;
969	try printPrefix(parent, w, fwm);	976	try printPrefix(parent, stderr);
970	if (parent.last) {	977	if (parent.last) {
971	try w.writeAll(" ");	978	try writer.writeAll(" ");
972	} else {	979	} else {
973	try w.writeAll(switch (fwm) {	980	try writer.writeAll(switch (stderr.mode) {
974	.terminal_escaped => "\x1B\x28\x30\x78\x1B\x28\x42 ", // │	981	.escape_codes => "\x1B\x28\x30\x78\x1B\x28\x42 ", // │
975	else => "\| ",	982	else => "\| ",
976	});	983	});
977	}	984	}
978	}	985	}
979		986
980	fn printChildNodePrefix(w: *Writer, fwm: File.Writer.Mode) !void {	987	fn printChildNodePrefix(stderr: Io.Terminal) !void {
981	try w.writeAll(switch (fwm) {	988	try stderr.writer.writeAll(switch (stderr.mode) {
982	.terminal_escaped => "\x1B\x28\x30\x6d\x71\x1B\x28\x42 ", // └─	989	.escape_codes => "\x1B\x28\x30\x6d\x71\x1B\x28\x42 ", // └─
983	else => "+- ",	990	else => "+- ",
984	});	991	});
985	}	992	}
986		993
987	fn printStepStatus(	994	fn printStepStatus(s: Step, stderr: Io.Terminal, run: const Run) !void {
988	s: *Step,	995	const writer = stderr.writer;
989	stderr: *Writer,
990	fwm: File.Writer.Mode,
991	run: *const Run,
992	) !void {
993	switch (s.state) {	996	switch (s.state) {
994	.precheck_unstarted => unreachable,	997	.precheck_unstarted => unreachable,
995	.precheck_started => unreachable,	998	.precheck_started => unreachable,
...	@@ -997,139 +1000,135 @@ fn printStepStatus(	...	@@ -997,139 +1000,135 @@ fn printStepStatus(
997	.running => unreachable,	1000	.running => unreachable,
998		1001
999	.dependency_failure => {	1002	.dependency_failure => {
1000	try fwm.setColor(stderr, .dim);	1003	try stderr.setColor(.dim);
1001	try stderr.writeAll(" transitive failure\n");	1004	try writer.writeAll(" transitive failure\n");
1002	try fwm.setColor(stderr, .reset);	1005	try stderr.setColor(.reset);
1003	},	1006	},
1004		1007
1005	.success => {	1008	.success => {
1006	try fwm.setColor(stderr, .green);	1009	try stderr.setColor(.green);
1007	if (s.result_cached) {	1010	if (s.result_cached) {
1008	try stderr.writeAll(" cached");	1011	try writer.writeAll(" cached");
1009	} else if (s.test_results.test_count > 0) {	1012	} else if (s.test_results.test_count > 0) {
1010	const pass_count = s.test_results.passCount();	1013	const pass_count = s.test_results.passCount();
1011	assert(s.test_results.test_count == pass_count + s.test_results.skip_count);	1014	assert(s.test_results.test_count == pass_count + s.test_results.skip_count);
1012	try stderr.print(" {d} pass", .{pass_count});	1015	try writer.print(" {d} pass", .{pass_count});
1013	if (s.test_results.skip_count > 0) {	1016	if (s.test_results.skip_count > 0) {
1014	try fwm.setColor(stderr, .reset);	1017	try stderr.setColor(.reset);
1015	try stderr.writeAll(", ");	1018	try writer.writeAll(", ");
1016	try fwm.setColor(stderr, .yellow);	1019	try stderr.setColor(.yellow);
1017	try stderr.print("{d} skip", .{s.test_results.skip_count});	1020	try writer.print("{d} skip", .{s.test_results.skip_count});
1018	}	1021	}
1019	try fwm.setColor(stderr, .reset);	1022	try stderr.setColor(.reset);
1020	try stderr.print(" ({d} total)", .{s.test_results.test_count});	1023	try writer.print(" ({d} total)", .{s.test_results.test_count});
1021	} else {	1024	} else {
1022	try stderr.writeAll(" success");	1025	try writer.writeAll(" success");
1023	}	1026	}
1024	try fwm.setColor(stderr, .reset);	1027	try stderr.setColor(.reset);
1025	if (s.result_duration_ns) \|ns\| {	1028	if (s.result_duration_ns) \|ns\| {
1026	try fwm.setColor(stderr, .dim);	1029	try stderr.setColor(.dim);
1027	if (ns >= std.time.ns_per_min) {	1030	if (ns >= std.time.ns_per_min) {
1028	try stderr.print(" {d}m", .{ns / std.time.ns_per_min});	1031	try writer.print(" {d}m", .{ns / std.time.ns_per_min});
1029	} else if (ns >= std.time.ns_per_s) {	1032	} else if (ns >= std.time.ns_per_s) {
1030	try stderr.print(" {d}s", .{ns / std.time.ns_per_s});	1033	try writer.print(" {d}s", .{ns / std.time.ns_per_s});
1031	} else if (ns >= std.time.ns_per_ms) {	1034	} else if (ns >= std.time.ns_per_ms) {
1032	try stderr.print(" {d}ms", .{ns / std.time.ns_per_ms});	1035	try writer.print(" {d}ms", .{ns / std.time.ns_per_ms});
1033	} else if (ns >= std.time.ns_per_us) {	1036	} else if (ns >= std.time.ns_per_us) {
1034	try stderr.print(" {d}us", .{ns / std.time.ns_per_us});	1037	try writer.print(" {d}us", .{ns / std.time.ns_per_us});
1035	} else {	1038	} else {
1036	try stderr.print(" {d}ns", .{ns});	1039	try writer.print(" {d}ns", .{ns});
1037	}	1040	}
1038	try fwm.setColor(stderr, .reset);	1041	try stderr.setColor(.reset);
1039	}	1042	}
1040	if (s.result_peak_rss != 0) {	1043	if (s.result_peak_rss != 0) {
1041	const rss = s.result_peak_rss;	1044	const rss = s.result_peak_rss;
1042	try fwm.setColor(stderr, .dim);	1045	try stderr.setColor(.dim);
1043	if (rss >= 1000_000_000) {	1046	if (rss >= 1000_000_000) {
1044	try stderr.print(" MaxRSS:{d}G", .{rss / 1000_000_000});	1047	try writer.print(" MaxRSS:{d}G", .{rss / 1000_000_000});
1045	} else if (rss >= 1000_000) {	1048	} else if (rss >= 1000_000) {
1046	try stderr.print(" MaxRSS:{d}M", .{rss / 1000_000});	1049	try writer.print(" MaxRSS:{d}M", .{rss / 1000_000});
1047	} else if (rss >= 1000) {	1050	} else if (rss >= 1000) {
1048	try stderr.print(" MaxRSS:{d}K", .{rss / 1000});	1051	try writer.print(" MaxRSS:{d}K", .{rss / 1000});
1049	} else {	1052	} else {
1050	try stderr.print(" MaxRSS:{d}B", .{rss});	1053	try writer.print(" MaxRSS:{d}B", .{rss});
1051	}	1054	}
1052	try fwm.setColor(stderr, .reset);	1055	try stderr.setColor(.reset);
1053	}	1056	}
1054	try stderr.writeAll("\n");	1057	try writer.writeAll("\n");
1055	},	1058	},
1056	.skipped, .skipped_oom => \|skip\| {	1059	.skipped, .skipped_oom => \|skip\| {
1057	try fwm.setColor(stderr, .yellow);	1060	try stderr.setColor(.yellow);
1058	try stderr.writeAll(" skipped");	1061	try writer.writeAll(" skipped");
1059	if (skip == .skipped_oom) {	1062	if (skip == .skipped_oom) {
1060	try stderr.writeAll(" (not enough memory)");	1063	try writer.writeAll(" (not enough memory)");
1061	try fwm.setColor(stderr, .dim);	1064	try stderr.setColor(.dim);
1062	try stderr.print(" upper bound of {d} exceeded runner limit ({d})", .{ s.max_rss, run.max_rss });	1065	try writer.print(" upper bound of {d} exceeded runner limit ({d})", .{ s.max_rss, run.max_rss });
1063	try fwm.setColor(stderr, .yellow);	1066	try stderr.setColor(.yellow);
1064	}	1067	}
1065	try stderr.writeAll("\n");	1068	try writer.writeAll("\n");
1066	try fwm.setColor(stderr, .reset);	1069	try stderr.setColor(.reset);
1067	},	1070	},
1068	.failure => {	1071	.failure => {
1069	try printStepFailure(s, stderr, fwm, false);	1072	try printStepFailure(s, stderr, false);
1070	try fwm.setColor(stderr, .reset);	1073	try stderr.setColor(.reset);
1071	},	1074	},
1072	}	1075	}
1073	}	1076	}
1074		1077
1075	fn printStepFailure(	1078	fn printStepFailure(s: *Step, stderr: Io.Terminal, dim: bool) !void {
1076	s: *Step,	1079	const w = stderr.writer;
1077	stderr: *Writer,
1078	fwm: File.Writer.Mode,
1079	dim: bool,
1080	) !void {
1081	if (s.result_error_bundle.errorMessageCount() > 0) {	1080	if (s.result_error_bundle.errorMessageCount() > 0) {
1082	try fwm.setColor(stderr, .red);	1081	try stderr.setColor(.red);
1083	try stderr.print(" {d} errors\n", .{	1082	try w.print(" {d} errors\n", .{
1084	s.result_error_bundle.errorMessageCount(),	1083	s.result_error_bundle.errorMessageCount(),
1085	});	1084	});
1086	} else if (!s.test_results.isSuccess()) {	1085	} else if (!s.test_results.isSuccess()) {
1087	// These first values include all of the test "statuses". Every test is either passsed,	1086	// These first values include all of the test "statuses". Every test is either passsed,
1088	// skipped, failed, crashed, or timed out.	1087	// skipped, failed, crashed, or timed out.
1089	try fwm.setColor(stderr, .green);	1088	try stderr.setColor(.green);
1090	try stderr.print(" {d} pass", .{s.test_results.passCount()});	1089	try w.print(" {d} pass", .{s.test_results.passCount()});
1091	try fwm.setColor(stderr, .reset);	1090	try stderr.setColor(.reset);
1092	if (dim) try fwm.setColor(stderr, .dim);	1091	if (dim) try stderr.setColor(.dim);
1093	if (s.test_results.skip_count > 0) {	1092	if (s.test_results.skip_count > 0) {
1094	try stderr.writeAll(", ");	1093	try w.writeAll(", ");
1095	try fwm.setColor(stderr, .yellow);	1094	try stderr.setColor(.yellow);
1096	try stderr.print("{d} skip", .{s.test_results.skip_count});	1095	try w.print("{d} skip", .{s.test_results.skip_count});
1097	try fwm.setColor(stderr, .reset);	1096	try stderr.setColor(.reset);
1098	if (dim) try fwm.setColor(stderr, .dim);	1097	if (dim) try stderr.setColor(.dim);
1099	}	1098	}
1100	if (s.test_results.fail_count > 0) {	1099	if (s.test_results.fail_count > 0) {
1101	try stderr.writeAll(", ");	1100	try w.writeAll(", ");
1102	try fwm.setColor(stderr, .red);	1101	try stderr.setColor(.red);
1103	try stderr.print("{d} fail", .{s.test_results.fail_count});	1102	try w.print("{d} fail", .{s.test_results.fail_count});
1104	try fwm.setColor(stderr, .reset);	1103	try stderr.setColor(.reset);
1105	if (dim) try fwm.setColor(stderr, .dim);	1104	if (dim) try stderr.setColor(.dim);
1106	}	1105	}
1107	if (s.test_results.crash_count > 0) {	1106	if (s.test_results.crash_count > 0) {
1108	try stderr.writeAll(", ");	1107	try w.writeAll(", ");
1109	try fwm.setColor(stderr, .red);	1108	try stderr.setColor(.red);
1110	try stderr.print("{d} crash", .{s.test_results.crash_count});	1109	try w.print("{d} crash", .{s.test_results.crash_count});
1111	try fwm.setColor(stderr, .reset);	1110	try stderr.setColor(.reset);
1112	if (dim) try fwm.setColor(stderr, .dim);	1111	if (dim) try stderr.setColor(.dim);
1113	}	1112	}
1114	if (s.test_results.timeout_count > 0) {	1113	if (s.test_results.timeout_count > 0) {
1115	try stderr.writeAll(", ");	1114	try w.writeAll(", ");
1116	try fwm.setColor(stderr, .red);	1115	try stderr.setColor(.red);
1117	try stderr.print("{d} timeout", .{s.test_results.timeout_count});	1116	try w.print("{d} timeout", .{s.test_results.timeout_count});
1118	try fwm.setColor(stderr, .reset);	1117	try stderr.setColor(.reset);
1119	if (dim) try fwm.setColor(stderr, .dim);	1118	if (dim) try stderr.setColor(.dim);
1120	}	1119	}
1121	try stderr.print(" ({d} total)", .{s.test_results.test_count});	1120	try w.print(" ({d} total)", .{s.test_results.test_count});
1122		1121
1123	// Memory leaks are intentionally written after the total, because is isn't a test status,	1122	// Memory leaks are intentionally written after the total, because is isn't a test status,
1124	// but just a flag that any tests -- even passed ones -- can have. We also use a different	1123	// but just a flag that any tests -- even passed ones -- can have. We also use a different
1125	// separator, so it looks like:	1124	// separator, so it looks like:
1126	// 2 pass, 1 skip, 2 fail (5 total); 2 leaks	1125	// 2 pass, 1 skip, 2 fail (5 total); 2 leaks
1127	if (s.test_results.leak_count > 0) {	1126	if (s.test_results.leak_count > 0) {
1128	try stderr.writeAll("; ");	1127	try w.writeAll("; ");
1129	try fwm.setColor(stderr, .red);	1128	try stderr.setColor(.red);
1130	try stderr.print("{d} leaks", .{s.test_results.leak_count});	1129	try w.print("{d} leaks", .{s.test_results.leak_count});
1131	try fwm.setColor(stderr, .reset);	1130	try stderr.setColor(.reset);
1132	if (dim) try fwm.setColor(stderr, .dim);	1131	if (dim) try stderr.setColor(.dim);
1133	}	1132	}
1134		1133
1135	// It's usually not helpful to know how many error logs there were because they tend to	1134	// It's usually not helpful to know how many error logs there were because they tend to
...	@@ -1142,21 +1141,21 @@ fn printStepFailure(	...	@@ -1142,21 +1141,21 @@ fn printStepFailure(
1142	break :show alt_results.isSuccess();	1141	break :show alt_results.isSuccess();
1143	};	1142	};
1144	if (show_err_logs) {	1143	if (show_err_logs) {
1145	try stderr.writeAll("; ");	1144	try w.writeAll("; ");
1146	try fwm.setColor(stderr, .red);	1145	try stderr.setColor(.red);
1147	try stderr.print("{d} error logs", .{s.test_results.log_err_count});	1146	try w.print("{d} error logs", .{s.test_results.log_err_count});
1148	try fwm.setColor(stderr, .reset);	1147	try stderr.setColor(.reset);
1149	if (dim) try fwm.setColor(stderr, .dim);	1148	if (dim) try stderr.setColor(.dim);
1150	}	1149	}
1151		1150
1152	try stderr.writeAll("\n");	1151	try w.writeAll("\n");
1153	} else if (s.result_error_msgs.items.len > 0) {	1152	} else if (s.result_error_msgs.items.len > 0) {
1154	try fwm.setColor(stderr, .red);	1153	try stderr.setColor(.red);
1155	try stderr.writeAll(" failure\n");	1154	try w.writeAll(" failure\n");
1156	} else {	1155	} else {
1157	assert(s.result_stderr.len > 0);	1156	assert(s.result_stderr.len > 0);
1158	try fwm.setColor(stderr, .red);	1157	try stderr.setColor(.red);
1159	try stderr.writeAll(" stderr\n");	1158	try w.writeAll(" w\n");
1160	}	1159	}
1161	}	1160	}
1162		1161
...	@@ -1164,11 +1163,11 @@ fn printTreeStep(	...	@@ -1164,11 +1163,11 @@ fn printTreeStep(
1164	b: *std.Build,	1163	b: *std.Build,
1165	s: *Step,	1164	s: *Step,
1166	run: *const Run,	1165	run: *const Run,
1167	stderr: *Writer,	1166	stderr: Io.Terminal,
1168	fwm: File.Writer.Mode,
1169	parent_node: *PrintNode,	1167	parent_node: *PrintNode,
1170	step_stack: std.AutoArrayHashMapUnmanaged(Step, void),	1168	step_stack: std.AutoArrayHashMapUnmanaged(Step, void),
1171	) !void {	1169	) !void {
		1170	const writer = stderr.writer;
1172	const first = step_stack.swapRemove(s);	1171	const first = step_stack.swapRemove(s);
1173	const summary = run.summary;	1172	const summary = run.summary;
1174	const skip = switch (summary) {	1173	const skip = switch (summary) {
...	@@ -1178,26 +1177,26 @@ fn printTreeStep(	...	@@ -1178,26 +1177,26 @@ fn printTreeStep(
1178	.failures => s.state == .success,	1177	.failures => s.state == .success,
1179	};	1178	};
1180	if (skip) return;	1179	if (skip) return;
1181	try printPrefix(parent_node, stderr, fwm);	1180	try printPrefix(parent_node, stderr);
1182		1181
1183	if (parent_node.parent != null) {	1182	if (parent_node.parent != null) {
1184	if (parent_node.last) {	1183	if (parent_node.last) {
1185	try printChildNodePrefix(stderr, fwm);	1184	try printChildNodePrefix(stderr);
1186	} else {	1185	} else {
1187	try stderr.writeAll(switch (fwm) {	1186	try writer.writeAll(switch (stderr.mode) {
1188	.terminal_escaped => "\x1B\x28\x30\x74\x71\x1B\x28\x42 ", // ├─	1187	.escape_codes => "\x1B\x28\x30\x74\x71\x1B\x28\x42 ", // ├─
1189	else => "+- ",	1188	else => "+- ",
1190	});	1189	});
1191	}	1190	}
1192	}	1191	}
1193		1192
1194	if (!first) try fwm.setColor(stderr, .dim);	1193	if (!first) try stderr.setColor(.dim);
1195		1194
1196	// dep_prefix omitted here because it is redundant with the tree.	1195	// dep_prefix omitted here because it is redundant with the tree.
1197	try stderr.writeAll(s.name);	1196	try writer.writeAll(s.name);
1198		1197
1199	if (first) {	1198	if (first) {
1200	try printStepStatus(s, stderr, fwm, run);	1199	try printStepStatus(s, stderr, run);
1201		1200
1202	const last_index = if (summary == .all) s.dependencies.items.len -\| 1 else blk: {	1201	const last_index = if (summary == .all) s.dependencies.items.len -\| 1 else blk: {
1203	var i: usize = s.dependencies.items.len;	1202	var i: usize = s.dependencies.items.len;
...	@@ -1219,17 +1218,17 @@ fn printTreeStep(	...	@@ -1219,17 +1218,17 @@ fn printTreeStep(
1219	.parent = parent_node,	1218	.parent = parent_node,
1220	.last = i == last_index,	1219	.last = i == last_index,
1221	};	1220	};
1222	try printTreeStep(b, dep, run, stderr, fwm, &print_node, step_stack);	1221	try printTreeStep(b, dep, run, stderr, &print_node, step_stack);
1223	}	1222	}
1224	} else {	1223	} else {
1225	if (s.dependencies.items.len == 0) {	1224	if (s.dependencies.items.len == 0) {
1226	try stderr.writeAll(" (reused)\n");	1225	try writer.writeAll(" (reused)\n");
1227	} else {	1226	} else {
1228	try stderr.print(" (+{d} more reused dependencies)\n", .{	1227	try writer.print(" (+{d} more reused dependencies)\n", .{
1229	s.dependencies.items.len,	1228	s.dependencies.items.len,
1230	});	1229	});
1231	}	1230	}
1232	try fwm.setColor(stderr, .reset);	1231	try stderr.setColor(.reset);
1233	}	1232	}
1234	}	1233	}
1235		1234
...	@@ -1300,7 +1299,8 @@ fn workerMakeOneStep(	...	@@ -1300,7 +1299,8 @@ fn workerMakeOneStep(
1300	prog_node: std.Progress.Node,	1299	prog_node: std.Progress.Node,
1301	run: *Run,	1300	run: *Run,
1302	) void {	1301	) void {
1303	const io = b.graph.io;	1302	const graph = b.graph;
		1303	const io = graph.io;
1304	const gpa = run.gpa;	1304	const gpa = run.gpa;
1305		1305
1306	// First, check the conditions for running this step. If they are not met,	1306	// First, check the conditions for running this step. If they are not met,
...	@@ -1369,11 +1369,11 @@ fn workerMakeOneStep(	...	@@ -1369,11 +1369,11 @@ fn workerMakeOneStep(
1369	const show_error_msgs = s.result_error_msgs.items.len > 0;	1369	const show_error_msgs = s.result_error_msgs.items.len > 0;
1370	const show_stderr = s.result_stderr.len > 0;	1370	const show_stderr = s.result_stderr.len > 0;
1371	if (show_error_msgs or show_compile_errors or show_stderr) {	1371	if (show_error_msgs or show_compile_errors or show_stderr) {
1372	const stderr = io.lockStderrWriter(&stdio_buffer_allocation) catch \|err\| switch (err) {	1372	const stderr = io.lockStderr(&stdio_buffer_allocation, graph.stderr_mode) catch \|err\| switch (err) {
1373	error.Canceled => return,	1373	error.Canceled => return,
1374	};	1374	};
1375	defer io.unlockStderrWriter();	1375	defer io.unlockStderr();
1376	printErrorMessages(gpa, s, .{}, &stderr.interface, stderr.mode, run.error_style, run.multiline_errors) catch {};	1376	printErrorMessages(gpa, s, .{}, stderr.terminal(), run.error_style, run.multiline_errors) catch {};
1377	}	1377	}
1378		1378
1379	handle_result: {	1379	handle_result: {
...	@@ -1440,11 +1440,11 @@ pub fn printErrorMessages(	...	@@ -1440,11 +1440,11 @@ pub fn printErrorMessages(
1440	gpa: Allocator,	1440	gpa: Allocator,
1441	failing_step: *Step,	1441	failing_step: *Step,
1442	options: std.zig.ErrorBundle.RenderOptions,	1442	options: std.zig.ErrorBundle.RenderOptions,
1443	stderr: *Writer,	1443	stderr: Io.Terminal,
1444	fwm: File.Writer.Mode,
1445	error_style: ErrorStyle,	1444	error_style: ErrorStyle,
1446	multiline_errors: MultilineErrors,	1445	multiline_errors: MultilineErrors,
1447	) !void {	1446	) !void {
		1447	const writer = stderr.writer;
1448	if (error_style.verboseContext()) {	1448	if (error_style.verboseContext()) {
1449	// Provide context for where these error messages are coming from by	1449	// Provide context for where these error messages are coming from by
1450	// printing the corresponding Step subtree.	1450	// printing the corresponding Step subtree.
...	@@ -1456,70 +1456,70 @@ pub fn printErrorMessages(	...	@@ -1456,70 +1456,70 @@ pub fn printErrorMessages(
1456	}	1456	}
1457		1457
1458	// Now, `step_stack` has the subtree that we want to print, in reverse order.	1458	// Now, `step_stack` has the subtree that we want to print, in reverse order.
1459	try fwm.setColor(stderr, .dim);	1459	try stderr.setColor(.dim);
1460	var indent: usize = 0;	1460	var indent: usize = 0;
1461	while (step_stack.pop()) \|s\| : (indent += 1) {	1461	while (step_stack.pop()) \|s\| : (indent += 1) {
1462	if (indent > 0) {	1462	if (indent > 0) {
1463	try stderr.splatByteAll(' ', (indent - 1) * 3);	1463	try writer.splatByteAll(' ', (indent - 1) * 3);
1464	try printChildNodePrefix(stderr, fwm);	1464	try printChildNodePrefix(stderr);
1465	}	1465	}
1466		1466
1467	try stderr.writeAll(s.name);	1467	try writer.writeAll(s.name);
1468		1468
1469	if (s == failing_step) {	1469	if (s == failing_step) {
1470	try printStepFailure(s, stderr, fwm, true);	1470	try printStepFailure(s, stderr, true);
1471	} else {	1471	} else {
1472	try stderr.writeAll("\n");	1472	try writer.writeAll("\n");
1473	}	1473	}
1474	}	1474	}
1475	try fwm.setColor(stderr, .reset);	1475	try stderr.setColor(.reset);
1476	} else {	1476	} else {
1477	// Just print the failing step itself.	1477	// Just print the failing step itself.
1478	try fwm.setColor(stderr, .dim);	1478	try stderr.setColor(.dim);
1479	try stderr.writeAll(failing_step.name);	1479	try writer.writeAll(failing_step.name);
1480	try printStepFailure(failing_step, stderr, fwm, true);	1480	try printStepFailure(failing_step, stderr, true);
1481	try fwm.setColor(stderr, .reset);	1481	try stderr.setColor(.reset);
1482	}	1482	}
1483		1483
1484	if (failing_step.result_stderr.len > 0) {	1484	if (failing_step.result_stderr.len > 0) {
1485	try stderr.writeAll(failing_step.result_stderr);	1485	try writer.writeAll(failing_step.result_stderr);
1486	if (!mem.endsWith(u8, failing_step.result_stderr, "\n")) {	1486	if (!mem.endsWith(u8, failing_step.result_stderr, "\n")) {
1487	try stderr.writeAll("\n");	1487	try writer.writeAll("\n");
1488	}	1488	}
1489	}	1489	}
1490		1490
1491	try failing_step.result_error_bundle.renderToWriter(options, stderr, fwm);	1491	try failing_step.result_error_bundle.renderToTerminal(options, stderr);
1492		1492
1493	for (failing_step.result_error_msgs.items) \|msg\| {	1493	for (failing_step.result_error_msgs.items) \|msg\| {
1494	try fwm.setColor(stderr, .red);	1494	try stderr.setColor(.red);
1495	try stderr.writeAll("error:");	1495	try writer.writeAll("error:");
1496	try fwm.setColor(stderr, .reset);	1496	try stderr.setColor(.reset);
1497	if (std.mem.indexOfScalar(u8, msg, '\n') == null) {	1497	if (std.mem.indexOfScalar(u8, msg, '\n') == null) {
1498	try stderr.print(" {s}\n", .{msg});	1498	try writer.print(" {s}\n", .{msg});
1499	} else switch (multiline_errors) {	1499	} else switch (multiline_errors) {
1500	.indent => {	1500	.indent => {
1501	var it = std.mem.splitScalar(u8, msg, '\n');	1501	var it = std.mem.splitScalar(u8, msg, '\n');
1502	try stderr.print(" {s}\n", .{it.first()});	1502	try writer.print(" {s}\n", .{it.first()});
1503	while (it.next()) \|line\| {	1503	while (it.next()) \|line\| {
1504	try stderr.print(" {s}\n", .{line});	1504	try writer.print(" {s}\n", .{line});
1505	}	1505	}
1506	},	1506	},
1507	.newline => try stderr.print("\n{s}\n", .{msg}),	1507	.newline => try writer.print("\n{s}\n", .{msg}),
1508	.none => try stderr.print(" {s}\n", .{msg}),	1508	.none => try writer.print(" {s}\n", .{msg}),
1509	}	1509	}
1510	}	1510	}
1511		1511
1512	if (error_style.verboseContext()) {	1512	if (error_style.verboseContext()) {
1513	if (failing_step.result_failed_command) \|cmd_str\| {	1513	if (failing_step.result_failed_command) \|cmd_str\| {
1514	try fwm.setColor(stderr, .red);	1514	try stderr.setColor(.red);
1515	try stderr.writeAll("failed command: ");	1515	try writer.writeAll("failed command: ");
1516	try fwm.setColor(stderr, .reset);	1516	try stderr.setColor(.reset);
1517	try stderr.writeAll(cmd_str);	1517	try writer.writeAll(cmd_str);
1518	try stderr.writeByte('\n');	1518	try writer.writeByte('\n');
1519	}	1519	}
1520	}	1520	}
1521		1521
1522	try stderr.writeByte('\n');	1522	try writer.writeByte('\n');
1523	}	1523	}
1524		1524
1525	fn printSteps(builder: std.Build, w: Writer) !void {	1525	fn printSteps(builder: std.Build, w: Writer) !void {

lib/compiler/resinator/cli.zig+5-5

...	@@ -126,14 +126,14 @@ pub const Diagnostics = struct {	...	@@ -126,14 +126,14 @@ pub const Diagnostics = struct {
126	}	126	}
127		127
128	pub fn renderToStderr(self: *Diagnostics, io: Io, args: []const []const u8) void {	128	pub fn renderToStderr(self: *Diagnostics, io: Io, args: []const []const u8) void {
129	const stderr = io.lockStderrWriter(&.{});	129	const stderr = io.lockStderr(&.{}, null);
130	defer io.unlockStderrWriter();	130	defer io.unlockStderr();
131	self.renderToWriter(args, &stderr.interface, stderr.mode) catch return;	131	self.renderToWriter(args, stderr.terminal()) catch return;
132	}	132	}
133		133
134	pub fn renderToWriter(self: Diagnostics, args: []const []const u8, writer: std.Io.Writer, config: std.Io.tty.Config) !void {	134	pub fn renderToWriter(self: *Diagnostics, args: []const []const u8, t: Io.Terminal) !void {
135	for (self.errors.items) \|err_details\| {	135	for (self.errors.items) \|err_details\| {
136	try renderErrorMessage(writer, config, err_details, args);	136	try renderErrorMessage(t, err_details, args);
137	}	137	}
138	}	138	}
139		139

lib/compiler/resinator/errors.zig+3-3

...	@@ -69,10 +69,10 @@ pub const Diagnostics = struct {	...	@@ -69,10 +69,10 @@ pub const Diagnostics = struct {
69		69
70	pub fn renderToStderr(self: *Diagnostics, cwd: Io.Dir, source: []const u8, source_mappings: ?SourceMappings) void {	70	pub fn renderToStderr(self: *Diagnostics, cwd: Io.Dir, source: []const u8, source_mappings: ?SourceMappings) void {
71	const io = self.io;	71	const io = self.io;
72	const stderr = io.lockStderrWriter(&.{});	72	const stderr = io.lockStderr(&.{}, null);
73	defer io.unlockStderrWriter();	73	defer io.unlockStderr();
74	for (self.errors.items) \|err_details\| {	74	for (self.errors.items) \|err_details\| {
75	renderErrorMessage(io, &stderr.interface, stderr.mode, cwd, err_details, source, self.strings.items, source_mappings) catch return;	75	renderErrorMessage(io, stderr.terminal(), cwd, err_details, source, self.strings.items, source_mappings) catch return;
76	}	76	}
77	}	77	}
78		78

lib/compiler/resinator/main.zig+14-17

 @@ -35,8 +35,8 @@ pub fn main() !void {
     const args = try std.process.argsAlloc(arena);
     if (args.len < 2) {
-        const stderr = io.lockStderrWriter(&.{});
+        const stderr = try io.lockStderr(&.{}, null);
-        try renderErrorMessage(&stderr.interface, stderr.mode, .err, "expected zig lib dir as first argument", .{});
+        try renderErrorMessage(stderr.terminal(), .err, "expected zig lib dir as first argument", .{});
         std.process.exit(1);
     }
     const zig_lib_dir = args[1];
 @@ -80,9 +80,9 @@ pub fn main() !void {
             // so that there is a clear separation between the cli diagnostics and whatever
             // gets printed after
             if (cli_diagnostics.errors.items.len > 0) {
-                const stderr = io.lockStderrWriter(&.{});
+                const stderr = try io.lockStderr(&.{}, null);
-                defer io.unlockStderrWriter();
+                defer io.unlockStderr();
-                try stderr.interface.writeByte('\n');
+                try stderr.file_writer.interface.writeByte('\n');
             }
         }
         break :options options;
 @@ -130,15 +130,12 @@ pub fn main() !void {
             var stderr_buf: [512]u8 = undefined;
             var diagnostics: aro.Diagnostics = .{ .output = output: {
                 if (zig_integration) break :output .{ .to_list = .{ .arena = .init(gpa) } };
-                const stderr = io.lockStderrWriter(&stderr_buf);
+                const stderr = try io.lockStderr(&stderr_buf, null);
-                break :output .{ .to_writer = .{
+                break :output .{ .to_writer = stderr.terminal() };
-                    .writer = &stderr.interface,
-                    .color = stderr.mode,
-                } };
             } };
             defer {
                 diagnostics.deinit();
-                if (!zig_integration) std.debug.unlockStderrWriter();
+                if (!zig_integration) std.debug.unlockStderr();
             }
             var comp = aro.Compilation.init(aro_arena, aro_arena, io, &diagnostics, Io.Dir.cwd());
 @@ -699,9 +696,9 @@ const ErrorHandler = union(enum) {
             },
             .stderr => {
                 // aro errors have already been emitted
-                const stderr = io.lockStderrWriter(&.{});
+                const stderr = io.lockStderr(&.{}, null);
-                defer io.unlockStderrWriter();
+                defer io.unlockStderr();
-                try renderErrorMessage(&stderr.interface, stderr.mode, .err, "{s}", .{fail_msg});
+                try renderErrorMessage(stderr.terminal(), .err, "{s}", .{fail_msg});
             },
         }
     }
 @@ -745,9 +742,9 @@ const ErrorHandler = union(enum) {
                 try server.serveErrorBundle(error_bundle);
             },
             .stderr => {
-                const stderr = io.lockStderrWriter(&.{});
+                const stderr = try io.lockStderr(&.{}, null);
-                defer io.unlockStderrWriter();
+                defer io.unlockStderr();
-                try renderErrorMessage(&stderr.interface, stderr.mode, msg_type, format, args);
+                try renderErrorMessage(stderr.terminal(), msg_type, format, args);
             },
         }
     }

lib/compiler/test_runner.zig+4-4

...	@@ -405,18 +405,18 @@ pub fn fuzz(	...	@@ -405,18 +405,18 @@ pub fn fuzz(
405	testOne(ctx, input.toSlice()) catch \|err\| switch (err) {	405	testOne(ctx, input.toSlice()) catch \|err\| switch (err) {
406	error.SkipZigTest => return,	406	error.SkipZigTest => return,
407	else => {	407	else => {
408	const stderr = std.debug.lockStderrWriter(&.{});	408	const stderr = std.debug.lockStderr(&.{}, null).terminal();
409	p: {	409	p: {
410	if (@errorReturnTrace()) \|trace\| {	410	if (@errorReturnTrace()) \|trace\| {
411	std.debug.writeStackTrace(trace, &stderr.interface, stderr.mode) catch break :p;	411	std.debug.writeStackTrace(trace, stderr) catch break :p;
412	}	412	}
413	stderr.interface.print("failed with error.{t}\n", .{err}) catch break :p;	413	stderr.writer.print("failed with error.{t}\n", .{err}) catch break :p;
414	}	414	}
415	std.process.exit(1);	415	std.process.exit(1);
416	},	416	},
417	};	417	};
418	if (log_err_count != 0) {	418	if (log_err_count != 0) {
419	const stderr = std.debug.lockStderrWriter(&.{});	419	const stderr = std.debug.lockStderr(&.{}, .no_color);
420	stderr.interface.print("error logs detected\n", .{}) catch {};	420	stderr.interface.print("error logs detected\n", .{}) catch {};
421	std.process.exit(1);	421	std.process.exit(1);
422	}	422	}

lib/std/Build.zig+36-37

...	@@ -129,6 +129,9 @@ pub const Graph = struct {	...	@@ -129,6 +129,9 @@ pub const Graph = struct {
129	dependency_cache: InitializedDepMap = .empty,	129	dependency_cache: InitializedDepMap = .empty,
130	allow_so_scripts: ?bool = null,	130	allow_so_scripts: ?bool = null,
131	time_report: bool,	131	time_report: bool,
		132	/// Similar to the `Io.Terminal.Mode` returned by `Io.lockStderr`, but also
		133	/// respects the '--color' flag.
		134	stderr_mode: ?Io.Terminal.Mode = null,
132	};	135	};
133		136
134	const AvailableDeps = []const struct { []const u8, []const u8 };	137	const AvailableDeps = []const struct { []const u8, []const u8 };
...	@@ -2255,9 +2258,10 @@ pub const GeneratedFile = struct {	...	@@ -2255,9 +2258,10 @@ pub const GeneratedFile = struct {
2255		2258
2256	pub fn getPath3(gen: GeneratedFile, src_builder: Build, asking_step: ?Step) Io.Cancelable![]const u8 {	2259	pub fn getPath3(gen: GeneratedFile, src_builder: Build, asking_step: ?Step) Io.Cancelable![]const u8 {
2257	return gen.path orelse {	2260	return gen.path orelse {
2258	const io = gen.step.owner.graph.io;	2261	const graph = gen.step.owner.graph;
2259	const stderr = try io.lockStderrWriter(&.{});	2262	const io = graph.io;
2260	dumpBadGetPathHelp(gen.step, &stderr.interface, stderr.mode, src_builder, asking_step) catch {};	2263	const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
		2264	dumpBadGetPathHelp(gen.step, stderr.terminal(), src_builder, asking_step) catch {};
2261	@panic("misconfigured build script");	2265	@panic("misconfigured build script");
2262	};	2266	};
2263	}	2267	}
...	@@ -2468,13 +2472,15 @@ pub const LazyPath = union(enum) {	...	@@ -2468,13 +2472,15 @@ pub const LazyPath = union(enum) {
2468	// TODO make gen.file.path not be absolute and use that as the	2472	// TODO make gen.file.path not be absolute and use that as the
2469	// basis for not traversing up too many directories.	2473	// basis for not traversing up too many directories.
2470		2474
		2475	const graph = src_builder.graph;
		2476
2471	var file_path: Cache.Path = .{	2477	var file_path: Cache.Path = .{
2472	.root_dir = Cache.Directory.cwd(),	2478	.root_dir = Cache.Directory.cwd(),
2473	.sub_path = gen.file.path orelse {	2479	.sub_path = gen.file.path orelse {
2474	const io = src_builder.graph.io;	2480	const io = graph.io;
2475	const stderr = try io.lockStderrWriter(&.{});	2481	const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
2476	dumpBadGetPathHelp(gen.file.step, &stderr.interface, stderr.mode, src_builder, asking_step) catch {};	2482	dumpBadGetPathHelp(gen.file.step, stderr.terminal(), src_builder, asking_step) catch {};
2477	io.unlockStderrWriter();	2483	io.unlockStderr();
2478	@panic("misconfigured build script");	2484	@panic("misconfigured build script");
2479	},	2485	},
2480	};	2486	};
...	@@ -2564,43 +2570,36 @@ fn dumpBadDirnameHelp(	...	@@ -2564,43 +2570,36 @@ fn dumpBadDirnameHelp(
2564	comptime msg: []const u8,	2570	comptime msg: []const u8,
2565	args: anytype,	2571	args: anytype,
2566	) anyerror!void {	2572	) anyerror!void {
2567	const stderr = std.debug.lockStderrWriter(&.{});	2573	const stderr = std.debug.lockStderr(&.{}).terminal();
2568	defer std.debug.unlockStderrWriter();	2574	defer std.debug.unlockStderr();
2569		2575	const w = stderr.writer;
2570	const w = &stderr.interface;
2571	const fwm = stderr.mode;
2572		2576
2573	try w.print(msg, args);	2577	try w.print(msg, args);
2574		2578
2575	if (fail_step) \|s\| {	2579	if (fail_step) \|s\| {
2576	fwm.setColor(w, .red) catch {};	2580	stderr.setColor(.red) catch {};
2577	try w.writeAll(" The step was created by this stack trace:\n");	2581	try w.writeAll(" The step was created by this stack trace:\n");
2578	fwm.setColor(w, .reset) catch {};	2582	stderr.setColor(.reset) catch {};
2579		2583
2580	s.dump(w, fwm);	2584	s.dump(stderr);
2581	}	2585	}
2582		2586
2583	if (asking_step) \|as\| {	2587	if (asking_step) \|as\| {
2584	fwm.setColor(w, .red) catch {};	2588	stderr.setColor(.red) catch {};
2585	try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});	2589	try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});
2586	fwm.setColor(w, .reset) catch {};	2590	stderr.setColor(.reset) catch {};
2587		2591
2588	as.dump(w, fwm);	2592	as.dump(stderr);
2589	}	2593	}
2590		2594
2591	fwm.setColor(w, .red) catch {};	2595	stderr.setColor(.red) catch {};
2592	try w.writeAll(" Hope that helps. Proceeding to panic.\n");	2596	try w.writeAll(" Proceeding to panic.\n");
2593	fwm.setColor(w, .reset) catch {};	2597	stderr.setColor(.reset) catch {};
2594	}	2598	}
2595		2599
2596	/// In this function the stderr mutex has already been locked.	2600	/// In this function the stderr mutex has already been locked.
2597	pub fn dumpBadGetPathHelp(	2601	pub fn dumpBadGetPathHelp(s: Step, t: Io.Terminal, src_builder: Build, asking_step: ?*Step) anyerror!void {
2598	s: *Step,	2602	const w = t.writer;
2599	w: *Io.Writer,
2600	fwm: File.Writer.Mode,
2601	src_builder: *Build,
2602	asking_step: ?*Step,
2603	) anyerror!void {
2604	try w.print(	2603	try w.print(
2605	\\getPath() was called on a GeneratedFile that wasn't built yet.	2604	\\getPath() was called on a GeneratedFile that wasn't built yet.
2606	\\ source package path: {s}	2605	\\ source package path: {s}
...	@@ -2611,21 +2610,21 @@ pub fn dumpBadGetPathHelp(	...	@@ -2611,21 +2610,21 @@ pub fn dumpBadGetPathHelp(
2611	s.name,	2610	s.name,
2612	});	2611	});
2613		2612
2614	fwm.setColor(w, .red) catch {};	2613	t.setColor(.red) catch {};
2615	try w.writeAll(" The step was created by this stack trace:\n");	2614	try w.writeAll(" The step was created by this stack trace:\n");
2616	fwm.setColor(w, .reset) catch {};	2615	t.setColor(.reset) catch {};
2617		2616
2618	s.dump(w, fwm);	2617	s.dump(t);
2619	if (asking_step) \|as\| {	2618	if (asking_step) \|as\| {
2620	fwm.setColor(w, .red) catch {};	2619	t.setColor(.red) catch {};
2621	try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});	2620	try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});
2622	fwm.setColor(w, .reset) catch {};	2621	t.setColor(.reset) catch {};
2623		2622
2624	as.dump(w, fwm);	2623	as.dump(t);
2625	}	2624	}
2626	fwm.setColor(w, .red) catch {};	2625	t.setColor(.red) catch {};
2627	try w.writeAll(" Hope that helps. Proceeding to panic.\n");	2626	try w.writeAll(" Proceeding to panic.\n");
2628	fwm.setColor(w, .reset) catch {};	2627	t.setColor(.reset) catch {};
2629	}	2628	}
2630		2629
2631	pub const InstallDir = union(enum) {	2630	pub const InstallDir = union(enum) {

lib/std/Build/Fuzz.zig+10-8

 @@ -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);
+        const stderr = try io.lockStderr(&buf, graph.stderr_mode);
-        defer io.unlockStderrWriter();
+        defer io.unlockStderr();
-        build_runner.printErrorMessages(gpa, &compile.step, .{}, &stderr.interface, stderr.mode, .verbose, .indent) catch {};
+        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();
+            defer io.unlockStderr();
-            build_runner.printErrorMessages(gpa, &run.step, .{}, &stderr.interface, stderr.mode, .verbose, .indent) catch {};
+            build_runner.printErrorMessages(gpa, &run.step, .{}, stderr.terminal(), .verbose, .indent) catch {};
             return;
         },
         else => {

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

 @@ -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 {};
     }
 }

lib/std/Build/Step/Compile.zig+9-8

 @@ -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(&.{});
+        const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
-        std.Build.dumpBadGetPathHelp(&compile.step, &stderr.interface, stderr.mode, compile.step.owner, asking_step) catch {};
+        std.Build.dumpBadGetPathHelp(&compile.step, stderr.terminal(), compile.step.owner, asking_step) catch {};
-        io.unlockStderrWriter();
+        io.unlockStderr();
         @panic("missing emit option for " ++ tag_name);
     };
     const path = generated_file.path orelse {
-        const stderr = try io.lockStderrWriter(&.{});
+        const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
-        std.Build.dumpBadGetPathHelp(&compile.step, &stderr.interface, stderr.mode, compile.step.owner, asking_step) catch {};
+        std.Build.dumpBadGetPathHelp(&compile.step, stderr.terminal(), compile.step.owner, asking_step) catch {};
-        io.unlockStderrWriter();
+        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();
     };

lib/std/Build/Step/Run.zig+12-10

 @@ -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 terminal_mode: Io.Terminal.Mode = if (inherit) m: {
-            const stderr = try io.lockStderrWriter(&.{});
+            const stderr = try io.lockStderr(&.{}, graph.stderr_mode);
-            try setColorEnvironmentVariables(run, env_map, stderr.mode);
+            break :m stderr.terminal_mode;
-        }
+        } else .no_color;
-        defer if (inherit) io.unlockStderrWriter();
+        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) {
+        .inherit => switch (terminal_mode) {
-            .terminal_escaped => continue :color .enable,
+            .no_color, .windows_api => continue :color .disable,
-            else => continue :color .disable,
+            .escape_codes => continue :color .enable,
         },
         .auto => {
             const capture_stderr = run.captured_stderr != null or switch (run.stdio) {

lib/std/Io.zig+1-1

...	@@ -713,7 +713,7 @@ pub const VTable = struct {	...	@@ -713,7 +713,7 @@ pub const VTable = struct {
713	processExecutableOpen: const fn (?anyopaque, File.OpenFlags) std.process.OpenExecutableError!File,	713	processExecutableOpen: const fn (?anyopaque, File.OpenFlags) std.process.OpenExecutableError!File,
714	processExecutablePath: const fn (?anyopaque, buffer: []u8) std.process.ExecutablePathError!usize,	714	processExecutablePath: const fn (?anyopaque, buffer: []u8) std.process.ExecutablePathError!usize,
715	lockStderr: const fn (?anyopaque, buffer: []u8, ?Terminal.Mode) Cancelable!LockedStderr,	715	lockStderr: const fn (?anyopaque, buffer: []u8, ?Terminal.Mode) Cancelable!LockedStderr,
716	tryLockStderr: const fn (?anyopaque, buffer: []u8) Cancelable!?LockedStderr,	716	tryLockStderr: const fn (?anyopaque, buffer: []u8, ?Terminal.Mode) Cancelable!?LockedStderr,
717	unlockStderr: const fn (?anyopaque) void,	717	unlockStderr: const fn (?anyopaque) void,
718		718
719	now: const fn (?anyopaque, Clock) Clock.Error!Timestamp,	719	now: const fn (?anyopaque, Clock) Clock.Error!Timestamp,

lib/std/Io/File/Writer.zig+1-1

...	@@ -229,7 +229,7 @@ pub fn seekToUnbuffered(w: *Writer, offset: u64) SeekError!void {	...	@@ -229,7 +229,7 @@ pub fn seekToUnbuffered(w: *Writer, offset: u64) SeekError!void {
229	.positional, .positional_simple => {	229	.positional, .positional_simple => {
230	w.pos = offset;	230	w.pos = offset;
231	},	231	},
232	.streaming, .streaming_simple, .terminal_escaped, .terminal_winapi => {	232	.streaming, .streaming_simple => {
233	if (w.seek_err) \|err\| return err;	233	if (w.seek_err) \|err\| return err;
234	io.vtable.fileSeekTo(io.userdata, w.file, offset) catch \|err\| {	234	io.vtable.fileSeekTo(io.userdata, w.file, offset) catch \|err\| {
235	w.seek_err = err;	235	w.seek_err = err;

lib/std/Io/Terminal.zig-22

...	@@ -130,25 +130,3 @@ pub fn setColor(t: Terminal, color: Color) Io.Writer.Error!void {	...	@@ -130,25 +130,3 @@ pub fn setColor(t: Terminal, color: Color) Io.Writer.Error!void {
130	},	130	},
131	}	131	}
132	}	132	}
133
134	pub fn disableEscape(t: *Terminal) Mode {
135	const prev = t.mode;
136	t.mode = t.mode.toUnescaped();
137	return prev;
138	}
139
140	pub fn restoreEscape(t: *Terminal, mode: Mode) void {
141	t.mode = mode;
142	}
143
144	pub fn writeAllUnescaped(t: *Terminal, bytes: []const u8) Io.Writer.Error!void {
145	const prev_mode = t.disableEscape();
146	defer t.restoreEscape(prev_mode);
147	return t.interface.writeAll(bytes);
148	}
149
150	pub fn printUnescaped(t: *Terminal, comptime fmt: []const u8, args: anytype) Io.Writer.Error!void {
151	const prev_mode = t.disableEscape();
152	defer t.restoreEscape(prev_mode);
153	return t.interface.print(fmt, args);
154	}

lib/std/Io/Threaded.zig+3-3

...	@@ -7178,7 +7178,7 @@ fn fileWriteFileStreaming(	...	@@ -7178,7 +7178,7 @@ fn fileWriteFileStreaming(
7178	break :o .{ &off, @min(@intFromEnum(limit), size - file_reader.pos, max_count) };	7178	break :o .{ &off, @min(@intFromEnum(limit), size - file_reader.pos, max_count) };
7179	},	7179	},
7180	.streaming => .{ null, limit.minInt(max_count) },	7180	.streaming => .{ null, limit.minInt(max_count) },
7181	.streaming_reading, .positional_reading => break :sf,	7181	.streaming_simple, .positional_simple => break :sf,
7182	.failure => return error.ReadFailed,	7182	.failure => return error.ReadFailed,
7183	};	7183	};
7184	const current_thread = Thread.getCurrent(t);	7184	const current_thread = Thread.getCurrent(t);
...	@@ -7251,7 +7251,7 @@ fn fileWriteFileStreaming(	...	@@ -7251,7 +7251,7 @@ fn fileWriteFileStreaming(
7251	}	7251	}
7252	var off_in: i64 = undefined;	7252	var off_in: i64 = undefined;
7253	const off_in_ptr: ?*i64 = switch (file_reader.mode) {	7253	const off_in_ptr: ?*i64 = switch (file_reader.mode) {
7254	.positional_reading, .streaming_reading => return error.Unimplemented,	7254	.positional_simple, .streaming_simple => return error.Unimplemented,
7255	.positional => p: {	7255	.positional => p: {
7256	off_in = @intCast(file_reader.pos);	7256	off_in = @intCast(file_reader.pos);
7257	break :p &off_in;	7257	break :p &off_in;
...	@@ -7427,7 +7427,7 @@ fn fileWriteFilePositional(	...	@@ -7427,7 +7427,7 @@ fn fileWriteFilePositional(
7427	}	7427	}
7428	var off_in: i64 = undefined;	7428	var off_in: i64 = undefined;
7429	const off_in_ptr: ?*i64 = switch (file_reader.mode) {	7429	const off_in_ptr: ?*i64 = switch (file_reader.mode) {
7430	.positional_reading, .streaming_reading => return error.Unimplemented,	7430	.positional_simple, .streaming_simple => return error.Unimplemented,
7431	.positional => p: {	7431	.positional => p: {
7432	off_in = @intCast(file_reader.pos);	7432	off_in = @intCast(file_reader.pos);
7433	break :p &off_in;	7433	break :p &off_in;

lib/std/debug.zig+12-12

...	@@ -283,12 +283,12 @@ var static_single_threaded_io: Io.Threaded = .init_single_threaded;	...	@@ -283,12 +283,12 @@ var static_single_threaded_io: Io.Threaded = .init_single_threaded;
283	///	283	///
284	/// Alternatively, use the higher-level `Io.lockStderr` to integrate with the	284	/// Alternatively, use the higher-level `Io.lockStderr` to integrate with the
285	/// application's chosen `Io` implementation.	285	/// application's chosen `Io` implementation.
286	pub fn lockStderr(buffer: []u8) Io.Terminal {	286	pub fn lockStderr(buffer: []u8) Io.LockedStderr {
287	return (static_single_threaded_io.ioBasic().lockStderr(buffer, null) catch \|err\| switch (err) {	287	return static_single_threaded_io.ioBasic().lockStderr(buffer, null) catch \|err\| switch (err) {
288	// Impossible to cancel because no calls to cancel using	288	// Impossible to cancel because no calls to cancel using
289	// `static_single_threaded_io` exist.	289	// `static_single_threaded_io` exist.
290	error.Canceled => unreachable,	290	error.Canceled => unreachable,
291	}).terminal();	291	};
292	}	292	}
293		293
294	pub fn unlockStderr() void {	294	pub fn unlockStderr() void {
...	@@ -311,7 +311,7 @@ pub fn print(comptime fmt: []const u8, args: anytype) void {	...	@@ -311,7 +311,7 @@ pub fn print(comptime fmt: []const u8, args: anytype) void {
311	var buffer: [64]u8 = undefined;	311	var buffer: [64]u8 = undefined;
312	const stderr = lockStderr(&buffer);	312	const stderr = lockStderr(&buffer);
313	defer unlockStderr();	313	defer unlockStderr();
314	stderr.writer.print(fmt, args) catch return;	314	stderr.file_writer.interface.print(fmt, args) catch return;
315	}	315	}
316	}	316	}
317		317
...	@@ -327,7 +327,7 @@ pub inline fn getSelfDebugInfo() !*SelfInfo {	...	@@ -327,7 +327,7 @@ pub inline fn getSelfDebugInfo() !*SelfInfo {
327	/// Tries to print a hexadecimal view of the bytes, unbuffered, and ignores any error returned.	327	/// Tries to print a hexadecimal view of the bytes, unbuffered, and ignores any error returned.
328	/// Obtains the stderr mutex while dumping.	328	/// Obtains the stderr mutex while dumping.
329	pub fn dumpHex(bytes: []const u8) void {	329	pub fn dumpHex(bytes: []const u8) void {
330	const stderr = lockStderr(&.{});	330	const stderr = lockStderr(&.{}).terminal();
331	defer unlockStderr();	331	defer unlockStderr();
332	dumpHexFallible(stderr, bytes) catch {};	332	dumpHexFallible(stderr, bytes) catch {};
333	}	333	}
...	@@ -551,7 +551,7 @@ pub fn defaultPanic(	...	@@ -551,7 +551,7 @@ pub fn defaultPanic(
551	_ = panicking.fetchAdd(1, .seq_cst);	551	_ = panicking.fetchAdd(1, .seq_cst);
552		552
553	trace: {	553	trace: {
554	const stderr = lockStderr(&.{});	554	const stderr = lockStderr(&.{}).terminal();
555	defer unlockStderr();	555	defer unlockStderr();
556	const writer = stderr.writer;	556	const writer = stderr.writer;
557		557
...	@@ -581,7 +581,7 @@ pub fn defaultPanic(	...	@@ -581,7 +581,7 @@ pub fn defaultPanic(
581	// A panic happened while trying to print a previous panic message.	581	// A panic happened while trying to print a previous panic message.
582	// We're still holding the mutex but that's fine as we're going to	582	// We're still holding the mutex but that's fine as we're going to
583	// call abort().	583	// call abort().
584	const stderr = lockStderr(&.{});	584	const stderr = lockStderr(&.{}).terminal();
585	stderr.writer.writeAll("aborting due to recursive panic\n") catch {};	585	stderr.writer.writeAll("aborting due to recursive panic\n") catch {};
586	},	586	},
587	else => {}, // Panicked while printing the recursive panic message.	587	else => {}, // Panicked while printing the recursive panic message.
...	@@ -751,7 +751,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin	...	@@ -751,7 +751,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
751	}	751	}
752	/// A thin wrapper around `writeCurrentStackTrace` which writes to stderr and ignores write errors.	752	/// A thin wrapper around `writeCurrentStackTrace` which writes to stderr and ignores write errors.
753	pub fn dumpCurrentStackTrace(options: StackUnwindOptions) void {	753	pub fn dumpCurrentStackTrace(options: StackUnwindOptions) void {
754	const stderr = lockStderr(&.{});	754	const stderr = lockStderr(&.{}).terminal();
755	defer unlockStderr();	755	defer unlockStderr();
756	writeCurrentStackTrace(.{	756	writeCurrentStackTrace(.{
757	.first_address = a: {	757	.first_address = a: {
...	@@ -814,7 +814,7 @@ pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void	...	@@ -814,7 +814,7 @@ pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void
814	}	814	}
815	/// A thin wrapper around `writeStackTrace` which writes to stderr and ignores write errors.	815	/// A thin wrapper around `writeStackTrace` which writes to stderr and ignores write errors.
816	pub fn dumpStackTrace(st: *const StackTrace) void {	816	pub fn dumpStackTrace(st: *const StackTrace) void {
817	const stderr = lockStderr(&.{});	817	const stderr = lockStderr(&.{}).terminal();
818	defer unlockStderr();	818	defer unlockStderr();
819	writeStackTrace(st, stderr) catch \|err\| switch (err) {	819	writeStackTrace(st, stderr) catch \|err\| switch (err) {
820	error.WriteFailed => {},	820	error.WriteFailed => {},
...	@@ -1550,7 +1550,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex	...	@@ -1550,7 +1550,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex
1550	_ = panicking.fetchAdd(1, .seq_cst);	1550	_ = panicking.fetchAdd(1, .seq_cst);
1551		1551
1552	trace: {	1552	trace: {
1553	const stderr = lockStderr(&.{});	1553	const stderr = lockStderr(&.{}).terminal();
1554	defer unlockStderr();	1554	defer unlockStderr();
1555		1555
1556	if (addr) \|a\| {	1556	if (addr) \|a\| {
...	@@ -1571,7 +1571,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex	...	@@ -1571,7 +1571,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex
1571	// A segfault happened while trying to print a previous panic message.	1571	// A segfault happened while trying to print a previous panic message.
1572	// We're still holding the mutex but that's fine as we're going to	1572	// We're still holding the mutex but that's fine as we're going to
1573	// call abort().	1573	// call abort().
1574	const stderr = lockStderr(&.{});	1574	const stderr = lockStderr(&.{}).terminal();
1575	stderr.writer.writeAll("aborting due to recursive panic\n") catch {};	1575	stderr.writer.writeAll("aborting due to recursive panic\n") catch {};
1576	},	1576	},
1577	else => {}, // Panicked while printing the recursive panic message.	1577	else => {}, // Panicked while printing the recursive panic message.
...	@@ -1678,7 +1678,7 @@ pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize	...	@@ -1678,7 +1678,7 @@ pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize
1678	pub fn dump(t: @This()) void {	1678	pub fn dump(t: @This()) void {
1679	if (!enabled) return;	1679	if (!enabled) return;
1680		1680
1681	const stderr = lockStderr(&.{});	1681	const stderr = lockStderr(&.{}).terminal();
1682	defer unlockStderr();	1682	defer unlockStderr();
1683	const end = @min(t.index, size);	1683	const end = @min(t.index, size);
1684	for (t.addrs[0..end], 0..) \|frames_array, i\| {	1684	for (t.addrs[0..end], 0..) \|frames_array, i\| {

lib/std/debug/simple_panic.zig+3-3

...	@@ -14,9 +14,9 @@ const std = @import("../std.zig");	...	@@ -14,9 +14,9 @@ const std = @import("../std.zig");
14	pub fn call(msg: []const u8, ra: ?usize) noreturn {	14	pub fn call(msg: []const u8, ra: ?usize) noreturn {
15	@branchHint(.cold);	15	@branchHint(.cold);
16	_ = ra;	16	_ = ra;
17	const stderr = std.debug.lockStderrWriter(&.{});	17	const stderr_writer = std.debug.lockStderr(&.{}, null).terminal().writer;
18	stderr.interface.writeAll(msg) catch {};	18	stderr_writer.writeAll(msg) catch {};
19	stderr.interface.flush(msg) catch {};	19	stderr_writer.flush(msg) catch {};
20	@trap();	20	@trap();
21	}	21	}
22		22

lib/std/json/dynamic.zig+3-3

...	@@ -47,9 +47,9 @@ pub const Value = union(enum) {	...	@@ -47,9 +47,9 @@ pub const Value = union(enum) {
47	}	47	}
48		48
49	pub fn dump(v: Value) void {	49	pub fn dump(v: Value) void {
50	const stderr = std.debug.lockStderrWriter(&.{});	50	const stderr = std.debug.lockStderr(&.{}, null);
51	defer std.debug.unlockStderrWriter();	51	defer std.debug.unlockStderr();
52	json.Stringify.value(v, .{}, &stderr.interface) catch return;	52	json.Stringify.value(v, .{}, &stderr.file_writer.interface) catch return;
53	}	53	}
54		54
55	pub fn jsonStringify(value: @This(), jws: anytype) !void {	55	pub fn jsonStringify(value: @This(), jws: anytype) !void {

lib/std/log.zig+1-1

...	@@ -92,7 +92,7 @@ pub fn defaultLog(	...	@@ -92,7 +92,7 @@ pub fn defaultLog(
92	args: anytype,	92	args: anytype,
93	) void {	93	) void {
94	var buffer: [64]u8 = undefined;	94	var buffer: [64]u8 = undefined;
95	const stderr = std.debug.lockStderr(&buffer);	95	const stderr = std.debug.lockStderr(&buffer).terminal();
96	defer std.debug.unlockStderr();	96	defer std.debug.unlockStderr();
97	return defaultLogFileTerminal(level, scope, format, args, stderr) catch {};	97	return defaultLogFileTerminal(level, scope, format, args, stderr) catch {};
98	}	98	}

lib/std/process.zig+1-1

...	@@ -1856,7 +1856,7 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {	...	@@ -1856,7 +1856,7 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
1856	/// and does not return.	1856	/// and does not return.
1857	pub fn cleanExit(io: Io) void {	1857	pub fn cleanExit(io: Io) void {
1858	if (builtin.mode == .Debug) return;	1858	if (builtin.mode == .Debug) return;
1859	_ = io.lockStderrWriter(&.{}) catch {};	1859	_ = io.lockStderr(&.{}, .no_color) catch {};
1860	exit(0);	1860	exit(0);
1861	}	1861	}
1862		1862

lib/std/testing.zig+11-10

 @@ -368,8 +368,8 @@ 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;
-    if (io.lockStderrWriter(&.{})) |stderr| {
+    if (io.lockStderr(&.{}, null)) |stderr| {
-        defer io.unlockStderrWriter();
+        defer io.unlockStderr();
         failEqualSlices(T, expected, actual, diff_index, &stderr.interface, stderr.mode) catch {};
     } else |_| {}
     return error.TestExpectedEqual;
 @@ -381,7 +381,7 @@ fn failEqualSlices(
     actual: []const T,
     diff_index: usize,
     w: *Io.Writer,
-    fwm: Io.File.Writer.Mode,
+    terminal_mode: Io.Terminal.Mode,
 ) !void {
     try w.print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
 @@ -404,12 +404,12 @@ fn failEqualSlices(
     var differ = if (T == u8) BytesDiffer{
         .expected = expected_window,
         .actual = actual_window,
-        .file_writer_mode = fwm,
+        .terminal_mode = terminal_mode,
     } else SliceDiffer(T){
         .start_index = window_start,
         .expected = expected_window,
         .actual = actual_window,
-        .file_writer_mode = fwm,
+        .terminal_mode = terminal_mode,
     };
     // Print indexes as hex for slices of u8 since it's more likely to be binary data where
 @@ -466,21 +466,22 @@ fn SliceDiffer(comptime T: type) type {
         start_index: usize,
         expected: []const T,
         actual: []const T,
-        file_writer_mode: Io.File.Writer.Mode,
+        terminal_mode: Io.Terminal.Mode,
         const Self = @This();
         pub fn write(self: Self, writer: *Io.Writer) !void {
+            const t: Io.Terminal = .{ .writer = writer, .mode = self.terminal_mode };
             for (self.expected, 0..) |value, i| {
                 const full_index = self.start_index + i;
                 const diff = if (i < self.actual.len) !std.meta.eql(self.actual[i], value) else true;
-                if (diff) try self.file_writer_mode.setColor(writer, .red);
+                if (diff) try t.setColor(writer, .red);
                 if (@typeInfo(T) == .pointer) {
                     try writer.print("[{}]{*}: {any}\n", .{ full_index, value, value });
                 } else {
                     try writer.print("[{}]: {any}\n", .{ full_index, value });
                 }
-                if (diff) try self.file_writer_mode.setColor(writer, .reset);
+                if (diff) try t.setColor(writer, .reset);
             }
         }
     };
 @@ -489,7 +490,7 @@ fn SliceDiffer(comptime T: type) type {
 const BytesDiffer = struct {
     expected: []const u8,
     actual: []const u8,
-    file_writer_mode: Io.File.Writer.Mode,
+    terminal_mode: Io.Terminal.Mode,
     pub fn write(self: BytesDiffer, writer: *Io.Writer) !void {
         var expected_iterator = std.mem.window(u8, self.expected, 16, 16);
 @@ -516,7 +517,7 @@ const BytesDiffer = struct {
                     try self.writeDiff(writer, "{c}", .{byte}, diff);
                 } else {
                     // TODO: remove this `if` when https://github.com/ziglang/zig/issues/7600 is fixed
-                    if (self.file_writer_mode == .terminal_winapi) {
+                    if (self.terminal_mode == .windows_api) {
                         try self.writeDiff(writer, ".", .{}, diff);
                         continue;
                     }

lib/std/zig.zig+7-14

 @@ -46,25 +46,18 @@ pub const SrcHasher = std.crypto.hash.Blake3;
 pub const SrcHash = [16]u8;
 pub const Color = enum {
-    /// Determine whether stderr is a terminal or not automatically.
+    /// Auto-detect whether stream supports terminal colors.
     auto,
-    /// Assume stderr is not a terminal.
+    /// Force-enable colors.
     off,
-    /// Assume stderr is a terminal.
+    /// Suppress colors.
     on,
-    pub fn getTtyConf(color: Color, detected: Io.File.Writer.Mode) Io.File.Writer.Mode {
+    pub fn terminalMode(color: Color) ?Io.Terminal.Mode {
         return switch (color) {
-            .auto => detected,
+            .auto => null,
-            .on => .terminal_escaped,
+            .on => .escape_codes,
-            .off => .streaming,
+            .off => .no_color,
-        };
-    }
-    pub fn detectTtyConf(color: Color, io: Io) Io.File.Writer.Mode {
-        return switch (color) {
-            .auto => .detect(io, .stderr()),
-            .on => .terminal_escaped,
-            .off => .streaming,
         };
     }
 };

lib/std/zig/ErrorBundle.zig+37-35

 @@ -166,51 +166,53 @@ pub const RenderToStderrError = Io.Cancelable || Io.File.Writer.Error;
 pub fn renderToStderr(eb: ErrorBundle, io: Io, options: RenderOptions, color: std.zig.Color) RenderToStderrError!void {
     var buffer: [256]u8 = undefined;
-    const stderr = try io.lockStderrWriter(&buffer);
+    const stderr = try io.lockStderr(&buffer, color.terminalMode());
-    defer io.unlockStderrWriter();
+    defer io.unlockStderr();
-    renderToWriter(eb, options, &stderr.interface, color.getTtyConf(stderr.mode)) catch |err| switch (err) {
+    renderToTerminal(eb, options, stderr.terminal()) catch |err| switch (err) {
-        error.WriteFailed => return stderr.err.?,
+        error.WriteFailed => return stderr.file_writer.err.?,
         else => |e| return e,
     };
 }
-pub fn renderToWriter(
+pub fn renderToWriter(eb: ErrorBundle, options: RenderOptions, w: *Writer) Writer.Error!void {
-    eb: ErrorBundle,
+    return renderToTerminal(eb, options, .{ .writer = w, .mode = .no_color }) catch |err| switch (err) {
-    options: RenderOptions,
+        error.WriteFailed => |e| return e,
-    w: *Writer,
+        else => unreachable,
-    fwm: Io.File.Writer.Mode,
+    };
-) Io.File.Writer.Mode.SetColorError!void {
+}
+pub fn renderToTerminal(eb: ErrorBundle, options: RenderOptions, t: Io.Terminal) Io.Terminal.SetColorError!void {
     if (eb.extra.len == 0) return;
     for (eb.getMessages()) |err_msg| {
-        try renderErrorMessageToWriter(eb, options, err_msg, w, fwm, "error", .red, 0);
+        try renderErrorMessage(eb, options, err_msg, t, "error", .red, 0);
     }
     if (options.include_log_text) {
         const log_text = eb.getCompileLogOutput();
         if (log_text.len != 0) {
-            try w.writeAll("\nCompile Log Output:\n");
+            try t.writer.writeAll("\nCompile Log Output:\n");
-            try w.writeAll(log_text);
+            try t.writer.writeAll(log_text);
         }
     }
 }
-fn renderErrorMessageToWriter(
+fn renderErrorMessage(
     eb: ErrorBundle,
     options: RenderOptions,
     err_msg_index: MessageIndex,
-    w: *Writer,
+    t: Io.Terminal,
-    fwm: Io.File.Writer.Mode,
     kind: []const u8,
-    color: Io.File.Writer.Color,
+    color: Io.Terminal.Color,
     indent: usize,
-) Io.File.Writer.Mode.SetColorError!void {
+) Io.Terminal.SetColorError!void {
+    const w = t.writer;
     const err_msg = eb.getErrorMessage(err_msg_index);
     if (err_msg.src_loc != .none) {
         const src = eb.extraData(SourceLocation, @intFromEnum(err_msg.src_loc));
         var prefix: Writer.Discarding = .init(&.{});
         try w.splatByteAll(' ', indent);
         prefix.count += indent;
-        try fwm.setColor(w, .bold);
+        try t.setColor(.bold);
         try w.print("{s}:{d}:{d}: ", .{
             eb.nullTerminatedString(src.data.src_path),
             src.data.line + 1,
 @@ -221,7 +223,7 @@ fn renderErrorMessageToWriter(
             src.data.line + 1,
             src.data.column + 1,
         });
-        try fwm.setColor(w, color);
+        try t.setColor(color);
         try w.writeAll(kind);
         prefix.count += kind.len;
         try w.writeAll(": ");
 @@ -229,17 +231,17 @@ fn renderErrorMessageToWriter(
         // This is the length of the part before the error message:
         // e.g. "file.zig:4:5: error: "
         const prefix_len: usize = @intCast(prefix.count);
-        try fwm.setColor(w, .reset);
+        try t.setColor(.reset);
-        try fwm.setColor(w, .bold);
+        try t.setColor(.bold);
         if (err_msg.count == 1) {
             try writeMsg(eb, err_msg, w, prefix_len);
             try w.writeByte('\n');
         } else {
             try writeMsg(eb, err_msg, w, prefix_len);
-            try fwm.setColor(w, .dim);
+            try t.setColor(.dim);
             try w.print(" ({d} times)\n", .{err_msg.count});
         }
-        try fwm.setColor(w, .reset);
+        try t.setColor(.reset);
         if (src.data.source_line != 0 and options.include_source_line) {
             const line = eb.nullTerminatedString(src.data.source_line);
             for (line) |b| switch (b) {
 @@ -252,19 +254,19 @@ fn renderErrorMessageToWriter(
             // -1 since span.main includes the caret
             const after_caret = src.data.span_end -| src.data.span_main -| 1;
             try w.splatByteAll(' ', src.data.column - before_caret);
-            try fwm.setColor(w, .green);
+            try t.setColor(.green);
             try w.splatByteAll('~', before_caret);
             try w.writeByte('^');
             try w.splatByteAll('~', after_caret);
             try w.writeByte('\n');
-            try fwm.setColor(w, .reset);
+            try t.setColor(.reset);
         }
         for (eb.getNotes(err_msg_index)) |note| {
-            try renderErrorMessageToWriter(eb, options, note, w, fwm, "note", .cyan, indent);
+            try renderErrorMessage(eb, options, note, t, "note", .cyan, indent);
         }
         if (src.data.reference_trace_len > 0 and options.include_reference_trace) {
-            try fwm.setColor(w, .reset);
+            try t.setColor(.reset);
-            try fwm.setColor(w, .dim);
+            try t.setColor(.dim);
             try w.print("referenced by:\n", .{});
             var ref_index = src.end;
             for (0..src.data.reference_trace_len) |_| {
 @@ -291,25 +293,25 @@ fn renderErrorMessageToWriter(
                     );
                 }
             }
-            try fwm.setColor(w, .reset);
+            try t.setColor(.reset);
         }
     } else {
-        try fwm.setColor(w, color);
+        try t.setColor(color);
         try w.splatByteAll(' ', indent);
         try w.writeAll(kind);
         try w.writeAll(": ");
-        try fwm.setColor(w, .reset);
+        try t.setColor(.reset);
         const msg = eb.nullTerminatedString(err_msg.msg);
         if (err_msg.count == 1) {
             try w.print("{s}\n", .{msg});
         } else {
             try w.print("{s}", .{msg});
-            try fwm.setColor(w, .dim);
+            try t.setColor(.dim);
             try w.print(" ({d} times)\n", .{err_msg.count});
         }
-        try fwm.setColor(w, .reset);
+        try t.setColor(.reset);
         for (eb.getNotes(err_msg_index)) |note| {
-            try renderErrorMessageToWriter(eb, options, note, w, fwm, "note", .cyan, indent + 4);
+            try renderErrorMessage(eb, options, note, t, "note", .cyan, indent + 4);
         }
     }
 }

lib/std/zig/parser_test.zig+8-8

...	@@ -6333,25 +6333,25 @@ var fixed_buffer_mem: [100 * 1024]u8 = undefined;	...	@@ -6333,25 +6333,25 @@ var fixed_buffer_mem: [100 * 1024]u8 = undefined;
6333		6333
6334	fn testParse(io: Io, source: [:0]const u8, allocator: Allocator, anything_changed: *bool) ![]u8 {	6334	fn testParse(io: Io, source: [:0]const u8, allocator: Allocator, anything_changed: *bool) ![]u8 {
6335	var buffer: [64]u8 = undefined;	6335	var buffer: [64]u8 = undefined;
6336	const stderr = try io.lockStderrWriter(&buffer);	6336	const stderr = try io.lockStderr(&buffer, null);
6337	defer io.unlockStderrWriter();	6337	defer io.unlockStderr();
6338		6338
6339	var tree = try std.zig.Ast.parse(allocator, source, .zig);	6339	var tree = try std.zig.Ast.parse(allocator, source, .zig);
6340	defer tree.deinit(allocator);	6340	defer tree.deinit(allocator);
6341		6341
6342	for (tree.errors) \|parse_error\| {	6342	for (tree.errors) \|parse_error\| {
6343	const loc = tree.tokenLocation(0, parse_error.token);	6343	const loc = tree.tokenLocation(0, parse_error.token);
6344	try stderr.printUnescaped("(memory buffer):{d}:{d}: error: ", .{ loc.line + 1, loc.column + 1 });	6344	try stderr.writer.print("(memory buffer):{d}:{d}: error: ", .{ loc.line + 1, loc.column + 1 });
6345	try tree.renderError(parse_error, &stderr.interface);	6345	try tree.renderError(parse_error, stderr.writer);
6346	try stderr.interface.print("\n{s}\n", .{source[loc.line_start..loc.line_end]});	6346	try stderr.writer.print("\n{s}\n", .{source[loc.line_start..loc.line_end]});
6347	{	6347	{
6348	var i: usize = 0;	6348	var i: usize = 0;
6349	while (i < loc.column) : (i += 1) {	6349	while (i < loc.column) : (i += 1) {
6350	try stderr.writeAllUnescaped(" ");	6350	try stderr.writer.writeAll(" ");
6351	}	6351	}
6352	try stderr.writeAllUnescaped("^");	6352	try stderr.writer.writeAll("^");
6353	}	6353	}
6354	try stderr.writeAllUnescaped("\n");	6354	try stderr.writer.writeAll("\n");
6355	}	6355	}
6356	if (tree.errors.len != 0) {	6356	if (tree.errors.len != 0) {
6357	return error.ParseError;	6357	return error.ParseError;

src/Air/print.zig+6-6

...	@@ -76,9 +76,9 @@ pub fn dump(air: Air, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {	...	@@ -76,9 +76,9 @@ pub fn dump(air: Air, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
76	const comp = pt.zcu.comp;	76	const comp = pt.zcu.comp;
77	const io = comp.io;	77	const io = comp.io;
78	var buffer: [512]u8 = undefined;	78	var buffer: [512]u8 = undefined;
79	const stderr = try io.lockStderrWriter(&buffer);	79	const stderr = try io.lockStderr(&buffer, null);
80	defer io.unlockStderrWriter();	80	defer io.unlockStderr();
81	const w = &stderr.interface;	81	const w = &stderr.file_writer.interface;
82	air.write(w, pt, liveness);	82	air.write(w, pt, liveness);
83	}	83	}
84		84
...	@@ -86,9 +86,9 @@ pub fn dumpInst(air: Air, inst: Air.Inst.Index, pt: Zcu.PerThread, liveness: ?Ai	...	@@ -86,9 +86,9 @@ pub fn dumpInst(air: Air, inst: Air.Inst.Index, pt: Zcu.PerThread, liveness: ?Ai
86	const comp = pt.zcu.comp;	86	const comp = pt.zcu.comp;
87	const io = comp.io;	87	const io = comp.io;
88	var buffer: [512]u8 = undefined;	88	var buffer: [512]u8 = undefined;
89	const stderr = try io.lockStderrWriter(&buffer);	89	const stderr = try io.lockStderr(&buffer, null);
90	defer io.unlockStderrWriter();	90	defer io.unlockStderr();
91	const w = &stderr.interface;	91	const w = &stderr.file_writer.interface;
92	air.writeInst(w, inst, pt, liveness);	92	air.writeInst(w, inst, pt, liveness);
93	}	93	}
94		94

src/Compilation.zig+30-15

 @@ -2092,14 +2092,16 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
         }
         if (options.verbose_llvm_cpu_features) {
-            if (options.root_mod.resolved_target.llvm_cpu_features) |cf| print: {
+            if (options.root_mod.resolved_target.llvm_cpu_features) |cf| {
-                const stderr = try io.lockStderrWriter(&.{});
+                const stderr = try io.lockStderr(&.{}, null);
-                defer io.unlockStderrWriter();
+                defer io.unlockStderr();
-                const w = &stderr.interface;
+                const w = &stderr.file_writer.interface;
-                w.print("compilation: {s}\n", .{options.root_name}) catch break :print;
+                printVerboseLlvmCpuFeatures(w, arena, options.root_name, target, cf) catch |err| switch (err) {
-                w.print("  target: {s}\n", .{try target.zigTriple(arena)}) catch break :print;
+                    error.WriteFailed => switch (stderr.file_writer.err.?) {
-                w.print("  cpu: {s}\n", .{target.cpu.model.name}) catch break :print;
+                        error.Canceled => |e| return e,
-                w.print("  features: {s}\n", .{cf}) catch {};
+                        else => {},
+                    },
+                };
             }
         }
 @@ -2700,6 +2702,19 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
     return comp;
 }
+fn printVerboseLlvmCpuFeatures(
+    w: *Writer,
+    arena: Allocator,
+    root_name: []const u8,
+    target: *const std.Target,
+    cf: [*:0]const u8,
+) Writer.Error!void {
+    try w.print("compilation: {s}\n", .{root_name});
+    try w.print("  target: {s}\n", .{try target.zigTriple(arena)});
+    try w.print("  cpu: {s}\n", .{target.cpu.model.name});
+    try w.print("  features: {s}\n", .{cf});
+}
 pub fn destroy(comp: *Compilation) void {
     const gpa = comp.gpa;
     const io = comp.io;
 @@ -4259,9 +4274,9 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
             // However, we haven't reported any such error.
             // This is a compiler bug.
             print_ctx: {
-                const stderr = std.debug.lockStderrWriter(&.{});
+                const stderr = std.debug.lockStderr(&.{}).terminal();
-                defer std.debug.unlockStderrWriter();
+                defer std.debug.unlockStderr();
-                const w = &stderr.interface;
+                const w = stderr.writer;
                 w.writeAll("referenced transitive analysis errors, but none actually emitted\n") catch break :print_ctx;
                 w.print("{f} [transitive failure]\n", .{zcu.fmtAnalUnit(failed_unit)}) catch break :print_ctx;
                 while (ref) |r| {
 @@ -7772,11 +7787,11 @@ pub fn lockAndSetMiscFailure(
 pub fn dumpArgv(io: Io, argv: []const []const u8) Io.Cancelable!void {
     var buffer: [64]u8 = undefined;
-    const stderr = try io.lockStderrWriter(&buffer);
+    const stderr = try io.lockStderr(&buffer);
-    defer io.unlockStderrWriter();
+    defer io.unlockStderr();
-    const w = &stderr.interface;
+    const w = &stderr.file_writer.interface;
     return dumpArgvWriter(w, argv) catch |err| switch (err) {
-        error.WriteFailed => switch (stderr.err.?) {
+        error.WriteFailed => switch (stderr.file_writer.err.?) {
             error.Canceled => return error.Canceled,
             else => return,
         },

src/InternPool.zig+5-5

...	@@ -11169,9 +11169,9 @@ pub fn mutateVarInit(ip: *InternPool, io: Io, index: Index, init_index: Index) v	...	@@ -11169,9 +11169,9 @@ pub fn mutateVarInit(ip: *InternPool, io: Io, index: Index, init_index: Index) v
11169		11169
11170	pub fn dump(ip: *const InternPool, io: Io) Io.Cancelable!void {	11170	pub fn dump(ip: *const InternPool, io: Io) Io.Cancelable!void {
11171	var buffer: [4096]u8 = undefined;	11171	var buffer: [4096]u8 = undefined;
11172	const stderr_writer = try io.lockStderrWriter(&buffer);	11172	const stderr = try io.lockStderr(&buffer, null);
11173	defer io.unlockStderrWriter();	11173	defer io.unlockStderr();
11174	const w = &stderr_writer.interface;	11174	const w = &stderr.file_writer.interface;
11175	try dumpStatsFallible(ip, w, std.heap.page_allocator);	11175	try dumpStatsFallible(ip, w, std.heap.page_allocator);
11176	try dumpAllFallible(ip, w);	11176	try dumpAllFallible(ip, w);
11177	}	11177	}
...	@@ -11536,8 +11536,8 @@ fn dumpAllFallible(ip: const InternPool, w: Io.Writer) anyerror!void {	...	@@ -11536,8 +11536,8 @@ fn dumpAllFallible(ip: const InternPool, w: Io.Writer) anyerror!void {
11536		11536
11537	pub fn dumpGenericInstances(ip: *const InternPool, io: Io, allocator: Allocator) Io.Cancelable!void {	11537	pub fn dumpGenericInstances(ip: *const InternPool, io: Io, allocator: Allocator) Io.Cancelable!void {
11538	var buffer: [4096]u8 = undefined;	11538	var buffer: [4096]u8 = undefined;
11539	const stderr_writer = try io.lockStderrWriter(&buffer);	11539	const stderr_writer = try io.lockStderr(&buffer, null);
11540	defer io.unlockStderrWriter();	11540	defer io.unlockStderr();
11541	const w = &stderr_writer.interface;	11541	const w = &stderr_writer.interface;
11542	try ip.dumpGenericInstancesFallible(allocator, w);	11542	try ip.dumpGenericInstancesFallible(allocator, w);
11543	}	11543	}

src/Zcu/PerThread.zig+4-4

...	@@ -4560,10 +4560,10 @@ fn runCodegenInner(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air) e	...	@@ -4560,10 +4560,10 @@ fn runCodegenInner(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air) e
4560		4560
4561	if (build_options.enable_debug_extensions and comp.verbose_air) p: {	4561	if (build_options.enable_debug_extensions and comp.verbose_air) p: {
4562	const io = comp.io;	4562	const io = comp.io;
4563	const stderr = try io.lockStderrWriter(&.{});	4563	const stderr = try io.lockStderr(&.{}, null);
4564	defer io.unlockStderrWriter();	4564	defer io.unlockStderr();
4565	printVerboseAir(pt, liveness, fqn, air, &stderr.interface) catch \|err\| switch (err) {	4565	printVerboseAir(pt, liveness, fqn, air, &stderr.file_writer.interface) catch \|err\| switch (err) {
4566	error.WriteFailed => switch (stderr.err.?) {	4566	error.WriteFailed => switch (stderr.file_writer.err.?) {
4567	error.Canceled => \|e\| return e,	4567	error.Canceled => \|e\| return e,
4568	else => break :p,	4568	else => break :p,
4569	},	4569	},

src/codegen/aarch64/Select.zig+3-4

 @@ -11274,16 +11274,15 @@ fn initValueAdvanced(
 }
 pub fn dumpValues(isel: *Select, which: enum { only_referenced, all }) void {
     const zcu = isel.pt.zcu;
-    const io = zcu.comp.io;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(isel.nav_index);
     errdefer |err| @panic(@errorName(err));
-    const stderr_writer = io.lockStderrWriter(&.{}) catch return;
+    const locked_stderr = std.debug.lockStderr(&.{}, null);
-    defer io.unlockStderrWriter();
+    defer std.debug.unlockStderr();
-    const stderr = &stderr_writer.interface;
+    const stderr = &locked_stderr.file_writer.interface;
     var reverse_live_values: std.AutoArrayHashMapUnmanaged(Value.Index, std.ArrayList(Air.Inst.Index)) = .empty;
     defer {

src/crash_report.zig+3-3

...	@@ -95,9 +95,9 @@ fn dumpCrashContext() Io.Writer.Error!void {	...	@@ -95,9 +95,9 @@ fn dumpCrashContext() Io.Writer.Error!void {
95		95
96	// TODO: this does mean that a different thread could grab the stderr mutex between the context	96	// TODO: this does mean that a different thread could grab the stderr mutex between the context
97	// and the actual panic printing, which would be quite confusing.	97	// and the actual panic printing, which would be quite confusing.
98	const stderr = std.debug.lockStderrWriter(&.{});	98	const stderr = std.debug.lockStderr(&.{});
99	defer std.debug.unlockStderrWriter();	99	defer std.debug.unlockStderr();
100	const w = &stderr.interface;	100	const w = &stderr.file_writer.interface;
101		101
102	try w.writeAll("Compiler crash context:\n");	102	try w.writeAll("Compiler crash context:\n");
103		103

src/libs/mingw.zig+12-12

...	@@ -314,14 +314,14 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {	...	@@ -314,14 +314,14 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
314		314
315	if (comp.verbose_cc) {	315	if (comp.verbose_cc) {
316	var buffer: [256]u8 = undefined;	316	var buffer: [256]u8 = undefined;
317	const stderr = try io.lockStderrWriter(&buffer);	317	const stderr = try io.lockStderr(&buffer, null);
318	defer io.unlockStderrWriter();	318	defer io.unlockStderr();
319	const w = &stderr.interface;	319	const w = &stderr.file_writer.interface;
320	w.print("def file: {s}\n", .{def_file_path}) catch \|err\| switch (err) {	320	w.print("def file: {s}\n", .{def_file_path}) catch \|err\| switch (err) {
321	error.WriteFailed => return stderr.err.?,	321	error.WriteFailed => return stderr.file_writer.err.?,
322	};	322	};
323	w.print("include dir: {s}\n", .{include_dir}) catch \|err\| switch (err) {	323	w.print("include dir: {s}\n", .{include_dir}) catch \|err\| switch (err) {
324	error.WriteFailed => return stderr.err.?,	324	error.WriteFailed => return stderr.file_writer.err.?,
325	};	325	};
326	}	326	}
327		327
...	@@ -339,12 +339,12 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {	...	@@ -339,12 +339,12 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
339		339
340	if (aro_comp.diagnostics.output.to_list.messages.items.len != 0) {	340	if (aro_comp.diagnostics.output.to_list.messages.items.len != 0) {
341	var buffer: [64]u8 = undefined;	341	var buffer: [64]u8 = undefined;
342	const stderr = try io.lockStderrWriter(&buffer);	342	const stderr = try io.lockStderr(&buffer, null);
343	defer io.unlockStderrWriter();	343	defer io.unlockStderr();
344	for (aro_comp.diagnostics.output.to_list.messages.items) \|msg\| {	344	for (aro_comp.diagnostics.output.to_list.messages.items) \|msg\| {
345	if (msg.kind == .@"fatal error" or msg.kind == .@"error") {	345	if (msg.kind == .@"fatal error" or msg.kind == .@"error") {
346	msg.write(&stderr.interface, stderr.mode, true) catch \|err\| switch (err) {	346	msg.write(stderr.terminal(), true) catch \|err\| switch (err) {
347	error.WriteFailed => return stderr.err.?,	347	error.WriteFailed => return stderr.file_writer.err.?,
348	};	348	};
349	return error.AroPreprocessorFailed;	349	return error.AroPreprocessorFailed;
350	}	350	}
...	@@ -365,9 +365,9 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {	...	@@ -365,9 +365,9 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
365	error.OutOfMemory => \|e\| return e,	365	error.OutOfMemory => \|e\| return e,
366	error.ParseError => {	366	error.ParseError => {
367	var buffer: [64]u8 = undefined;	367	var buffer: [64]u8 = undefined;
368	const stderr = try io.lockStderrWriter(&buffer);	368	const stderr = try io.lockStderr(&buffer, null);
369	defer io.unlockStderrWriter();	369	defer io.unlockStderr();
370	const w = &stderr.interface;	370	const w = &stderr.file_writer.interface;
371	try w.writeAll("error: ");	371	try w.writeAll("error: ");
372	try def_diagnostics.writeMsg(w, input);	372	try def_diagnostics.writeMsg(w, input);
373	try w.writeByte('\n');	373	try w.writeByte('\n');

src/libs/mingw/def.zig+3-3

...	@@ -1039,9 +1039,9 @@ fn testParse(	...	@@ -1039,9 +1039,9 @@ fn testParse(
1039	const module = parse(std.testing.allocator, source, machine_type, .mingw, &diagnostics) catch \|err\| switch (err) {	1039	const module = parse(std.testing.allocator, source, machine_type, .mingw, &diagnostics) catch \|err\| switch (err) {
1040	error.OutOfMemory => \|e\| return e,	1040	error.OutOfMemory => \|e\| return e,
1041	error.ParseError => {	1041	error.ParseError => {
1042	const stderr = try io.lockStderrWriter(&.{});	1042	const stderr = try io.lockStderr(&.{}, null);
1043	defer io.unlockStderrWriter();	1043	defer io.unlockStderr();
1044	const w = &stderr.interface;	1044	const w = &stderr.file_writer.interface;
1045	try diagnostics.writeMsg(w, source);	1045	try diagnostics.writeMsg(w, source);
1046	try w.writeByte('\n');	1046	try w.writeByte('\n');
1047	return err;	1047	return err;

src/link/Coff.zig+3-3

...	@@ -2382,9 +2382,9 @@ pub fn dump(coff: *Coff, tid: Zcu.PerThread.Id) Io.Cancelable!void {	...	@@ -2382,9 +2382,9 @@ pub fn dump(coff: *Coff, tid: Zcu.PerThread.Id) Io.Cancelable!void {
2382	const comp = coff.base.comp;	2382	const comp = coff.base.comp;
2383	const io = comp.io;	2383	const io = comp.io;
2384	var buffer: [512]u8 = undefined;	2384	var buffer: [512]u8 = undefined;
2385	const stderr = try io.lockStderrWriter(&buffer);	2385	const stderr = try io.lockStderr(&buffer, null);
2386	defer io.unlockStderrWriter();	2386	defer io.unlockStderr();
2387	const w = &stderr.interface;	2387	const w = &stderr.file_writer.interface;
2388	coff.printNode(tid, w, .root, 0) catch \|err\| switch (err) {	2388	coff.printNode(tid, w, .root, 0) catch \|err\| switch (err) {
2389	error.WriteFailed => return stderr.err.?,	2389	error.WriteFailed => return stderr.err.?,
2390	};	2390	};

src/link/Elf2.zig+3-3

...	@@ -3733,9 +3733,9 @@ pub fn dump(elf: *Elf, tid: Zcu.PerThread.Id) Io.Cancelable!void {	...	@@ -3733,9 +3733,9 @@ pub fn dump(elf: *Elf, tid: Zcu.PerThread.Id) Io.Cancelable!void {
3733	const comp = elf.base.comp;	3733	const comp = elf.base.comp;
3734	const io = comp.io;	3734	const io = comp.io;
3735	var buffer: [512]u8 = undefined;	3735	var buffer: [512]u8 = undefined;
3736	const stderr = try io.lockStderrWriter(&buffer);	3736	const stderr = try io.lockStderr(&buffer, null);
3737	defer io.unlockStderrWriter();	3737	defer io.lockStderr();
3738	const w = &stderr.interface;	3738	const w = &stderr.file_writer.interface;
3739	elf.printNode(tid, w, .root, 0) catch \|err\| switch (err) {	3739	elf.printNode(tid, w, .root, 0) catch \|err\| switch (err) {
3740	error.WriteFailed => return stderr.err.?,	3740	error.WriteFailed => return stderr.err.?,
3741	};	3741	};

src/main.zig+6-6

author	Andrew Kelley <andrew@ziglang.org> 2025-12-17 17:00:41-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-12-23 22:15:10-08:00
log	608145c2f07d90c46cdaa8bc2013f31b965a5b8b
tree	a8704744b3808887c25ecf7b674eed030b2f6c7d
parent	aa57793b680b3da05f1d888b4df15807905e57c8

...	@@ -4429,9 +4429,9 @@ fn runOrTest(	...	@@ -4429,9 +4429,9 @@ fn runOrTest(
4429	// the error message and invocation below.	4429	// the error message and invocation below.
4430	if (process.can_execv and arg_mode == .run) {	4430	if (process.can_execv and arg_mode == .run) {
4431	// execv releases the locks; no need to destroy the Compilation here.	4431	// execv releases the locks; no need to destroy the Compilation here.
4432	_ = try io.lockStderrWriter(&.{});	4432	_ = try io.lockStderr(&.{}, .no_color);
4433	const err = process.execve(gpa, argv.items, &env_map);	4433	const err = process.execve(gpa, argv.items, &env_map);
4434	io.unlockStderrWriter();	4434	io.unlockStderr();
4435	try warnAboutForeignBinaries(io, arena, arg_mode, target, link_libc);	4435	try warnAboutForeignBinaries(io, arena, arg_mode, target, link_libc);
4436	const cmd = try std.mem.join(arena, " ", argv.items);	4436	const cmd = try std.mem.join(arena, " ", argv.items);
4437	fatal("the following command failed to execve with '{t}':\n{s}", .{ err, cmd });	4437	fatal("the following command failed to execve with '{t}':\n{s}", .{ err, cmd });
...	@@ -4448,8 +4448,8 @@ fn runOrTest(	...	@@ -4448,8 +4448,8 @@ fn runOrTest(
4448	comp_destroyed.* = true;	4448	comp_destroyed.* = true;
4449		4449
4450	const term_result = t: {	4450	const term_result = t: {
4451	_ = try io.lockStderrWriter(&.{});	4451	_ = try io.lockStderr(&.{}, .no_color);
4452	defer io.unlockStderrWriter();	4452	defer io.unlockStderr();
4453	break :t child.spawnAndWait(io);	4453	break :t child.spawnAndWait(io);
4454	};	4454	};
4455	const term = term_result catch \|err\| {	4455	const term = term_result catch \|err\| {
...	@@ -5418,8 +5418,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)	...	@@ -5418,8 +5418,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)
5418	child.stderr_behavior = .Inherit;	5418	child.stderr_behavior = .Inherit;
5419		5419
5420	const term = t: {	5420	const term = t: {
5421	_ = try io.lockStderrWriter(&.{});	5421	_ = try io.lockStderr(&.{}, .no_color);
5422	defer io.unlockStderrWriter();	5422	defer io.unlockStderr();
5423	break :t child.spawnAndWait(io) catch \|err\|	5423	break :t child.spawnAndWait(io) catch \|err\|
5424	fatal("failed to spawn build runner {s}: {t}", .{ child_argv.items[0], err });	5424	fatal("failed to spawn build runner {s}: {t}", .{ child_argv.items[0], err });
5425	};	5425	};

fix more fallout from locking stderr