Commit 74931fe25cdd94e1cd08b5ece9dcce19959bc079 | zig

lib/compiler/build_runner.zig+16-25

...	...	@@ -442,8 +442,7 @@ pub fn main() !void {
442	442	if (builtin.single_threaded) fatal("'--webui' is not yet supported on single-threaded hosts", .{});
443	443	}
444	444
445		const stderr: std.fs.File = .stderr();
446		const ttyconf = get_tty_conf(color, stderr);
	445	const ttyconf = color.detectTtyConf();
447	446	switch (ttyconf) {
448	447	.no_color => try graph.env_map.put("NO_COLOR", "1"),
449	448	.escape_codes => try graph.env_map.put("CLICOLOR_FORCE", "1"),
...	...	@@ -522,9 +521,9 @@ pub fn main() !void {
522	521	.error_style = error_style,
523	522	.multiline_errors = multiline_errors,
524	523	.summary = summary orelse if (watch or webui_listen != null) .line else .failures,
525		.ttyconf = ttyconf,
526		.stderr = stderr,
527	524	.thread_pool = undefined,
	525
	526	.ttyconf = ttyconf,
528	527	};
529	528	defer {
530	529	run.memory_blocked_steps.deinit(gpa);
...	...	@@ -563,9 +562,9 @@ pub fn main() !void {
563	562	break :ws .init(.{
564	563	.gpa = gpa,
565	564	.thread_pool = &run.thread_pool,
	565	.ttyconf = ttyconf,
566	566	.graph = &graph,
567	567	.all_steps = run.step_stack.keys(),
568		.ttyconf = run.ttyconf,
569	568	.root_prog_node = main_progress_node,
570	569	.watch = watch,
571	570	.listen_address = listen_address,
...	...	@@ -578,7 +577,7 @@ pub fn main() !void {
578	577	}
579	578
580	579	rebuild: while (true) : (if (run.error_style.clearOnUpdate()) {
581		const bw = std.debug.lockStderrWriter(&stdio_buffer_allocation);
	580	const bw, _ = std.debug.lockStderrWriter(&stdio_buffer_allocation);
582	581	defer std.debug.unlockStderrWriter();
583	582	try bw.writeAll("\x1B[2J\x1B[3J\x1B[H");
584	583	}) {
...	...	@@ -682,13 +681,14 @@ const Run = struct {
682	681	/// Allocated into `gpa`.
683	682	step_stack: std.AutoArrayHashMapUnmanaged(*Step, void),
684	683	thread_pool: std.Thread.Pool,
	684	/// Similar to the `tty.Config` returned by `std.debug.lockStderrWriter`,
	685	/// but also respects the '--color' flag.
	686	ttyconf: tty.Config,
685	687
686	688	claimed_rss: usize,
687	689	error_style: ErrorStyle,
688	690	multiline_errors: MultilineErrors,
689	691	summary: Summary,
690		ttyconf: tty.Config,
691		stderr: File,
692	692	};
693	693
694	694	fn prepare(
...	...	@@ -834,8 +834,6 @@ fn runStepNames(
834	834	}
835	835	}
836	836
837		const ttyconf = run.ttyconf;
838
839	837	if (fuzz) \|mode\| blk: {
840	838	switch (builtin.os.tag) {
841	839	// Current implementation depends on two things that need to be ported to Windows:
...	...	@@ -863,9 +861,9 @@ fn runStepNames(
863	861	gpa,
864	862	io,
865	863	thread_pool,
	864	run.ttyconf,
866	865	step_stack.keys(),
867	866	parent_prog_node,
868		ttyconf,
869	867	mode,
870	868	) catch \|err\| fatal("failed to start fuzzer: {s}", .{@errorName(err)});
871	869	defer f.deinit();
...	...	@@ -890,8 +888,9 @@ fn runStepNames(
890	888	.none => break :summary,
891	889	}
892	890
893		const w = std.debug.lockStderrWriter(&stdio_buffer_allocation);
	891	const w, _ = std.debug.lockStderrWriter(&stdio_buffer_allocation);
894	892	defer std.debug.unlockStderrWriter();
	893	const ttyconf = run.ttyconf;
895	894
896	895	const total_count = success_count + failure_count + pending_count + skipped_count;
897	896	ttyconf.setColor(w, .cyan) catch {};
...	...	@@ -1399,9 +1398,10 @@ fn workerMakeOneStep(
1399	1398	const show_error_msgs = s.result_error_msgs.items.len > 0;
1400	1399	const show_stderr = s.result_stderr.len > 0;
1401	1400	if (show_error_msgs or show_compile_errors or show_stderr) {
1402		const bw = std.debug.lockStderrWriter(&stdio_buffer_allocation);
	1401	const bw, _ = std.debug.lockStderrWriter(&stdio_buffer_allocation);
1403	1402	defer std.debug.unlockStderrWriter();
1404		printErrorMessages(run.gpa, s, .{ .ttyconf = run.ttyconf }, bw, run.error_style, run.multiline_errors) catch {};
	1403	const ttyconf = run.ttyconf;
	1404	printErrorMessages(run.gpa, s, .{}, bw, ttyconf, run.error_style, run.multiline_errors) catch {};
1405	1405	}
1406	1406
1407	1407	handle_result: {
...	...	@@ -1465,11 +1465,10 @@ pub fn printErrorMessages(
1465	1465	failing_step: *Step,
1466	1466	options: std.zig.ErrorBundle.RenderOptions,
1467	1467	stderr: *Writer,
	1468	ttyconf: tty.Config,
1468	1469	error_style: ErrorStyle,
1469	1470	multiline_errors: MultilineErrors,
1470	1471	) !void {
1471		const ttyconf = options.ttyconf;
1472
1473	1472	if (error_style.verboseContext()) {
1474	1473	// Provide context for where these error messages are coming from by
1475	1474	// printing the corresponding Step subtree.
...	...	@@ -1513,7 +1512,7 @@ pub fn printErrorMessages(
1513	1512	}
1514	1513	}
1515	1514
1516		try failing_step.result_error_bundle.renderToWriter(options, stderr);
	1515	try failing_step.result_error_bundle.renderToWriter(options, stderr, ttyconf);
1517	1516
1518	1517	for (failing_step.result_error_msgs.items) \|msg\| {
1519	1518	try ttyconf.setColor(stderr, .red);
...	...	@@ -1759,14 +1758,6 @@ const ErrorStyle = enum {
1759	1758	const MultilineErrors = enum { indent, newline, none };
1760	1759	const Summary = enum { all, new, failures, line, none };
1761	1760
1762		fn get_tty_conf(color: Color, stderr: File) tty.Config {
1763		return switch (color) {
1764		.auto => tty.detectConfig(stderr),
1765		.on => .escape_codes,
1766		.off => .no_color,
1767		};
1768		}
1769
1770	1761	fn fatalWithHint(comptime f: []const u8, args: anytype) noreturn {
1771	1762	std.debug.print(f ++ "\n access the help menu with 'zig build -h'\n", args);
1772	1763	process.exit(1);

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

...	...	@@ -124,10 +124,10 @@ pub const Diagnostics = struct {
124	124	try self.errors.append(self.allocator, error_details);
125	125	}
126	126
127		pub fn renderToStdErr(self: *Diagnostics, args: []const []const u8, config: std.Io.tty.Config) void {
128		const stderr = std.debug.lockStderrWriter(&.{});
	127	pub fn renderToStdErr(self: *Diagnostics, args: []const []const u8) void {
	128	const stderr, const ttyconf = std.debug.lockStderrWriter(&.{});
129	129	defer std.debug.unlockStderrWriter();
130		self.renderToWriter(args, stderr, config) catch return;
	130	self.renderToWriter(args, stderr, ttyconf) catch return;
131	131	}
132	132
133	133	pub fn renderToWriter(self: Diagnostics, args: []const []const u8, writer: std.Io.Writer, config: std.Io.tty.Config) !void {

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

...	...	@@ -67,20 +67,15 @@ pub const Diagnostics = struct {
67	67	return @intCast(index);
68	68	}
69	69
70		pub fn renderToStdErr(self: *Diagnostics, cwd: std.fs.Dir, source: []const u8, tty_config: std.Io.tty.Config, source_mappings: ?SourceMappings) void {
	70	pub fn renderToStdErr(self: *Diagnostics, cwd: std.fs.Dir, source: []const u8, source_mappings: ?SourceMappings) void {
71	71	const io = self.io;
72		const stderr = std.debug.lockStderrWriter(&.{});
	72	const stderr, const ttyconf = std.debug.lockStderrWriter(&.{});
73	73	defer std.debug.unlockStderrWriter();
74	74	for (self.errors.items) \|err_details\| {
75		renderErrorMessage(io, stderr, tty_config, cwd, err_details, source, self.strings.items, source_mappings) catch return;
	75	renderErrorMessage(io, stderr, ttyconf, cwd, err_details, source, self.strings.items, source_mappings) catch return;
76	76	}
77	77	}
78	78
79		pub fn renderToStdErrDetectTTY(self: *Diagnostics, cwd: std.fs.Dir, source: []const u8, source_mappings: ?SourceMappings) void {
80		const tty_config = std.Io.tty.detectConfig(std.fs.File.stderr());
81		return self.renderToStdErr(cwd, source, tty_config, source_mappings);
82		}
83
84	79	pub fn contains(self: *const Diagnostics, err: ErrorDetails.Error) bool {
85	80	for (self.errors.items) \|details\| {
86	81	if (details.err == err) return true;

lib/compiler/resinator/main.zig+29-34

...	...	@@ -28,13 +28,11 @@ pub fn main() !void {
28	28	defer arena_state.deinit();
29	29	const arena = arena_state.allocator();
30	30
31		const stderr = std.fs.File.stderr();
32		const stderr_config = std.Io.tty.detectConfig(stderr);
33
34	31	const args = try std.process.argsAlloc(arena);
35	32
36	33	if (args.len < 2) {
37		try renderErrorMessage(std.debug.lockStderrWriter(&.{}), stderr_config, .err, "expected zig lib dir as first argument", .{});
	34	const w, const ttyconf = std.debug.lockStderrWriter(&.{});
	35	try renderErrorMessage(w, ttyconf, .err, "expected zig lib dir as first argument", .{});
38	36	std.process.exit(1);
39	37	}
40	38	const zig_lib_dir = args[1];
...	...	@@ -56,9 +54,7 @@ pub fn main() !void {
56	54	.in = undefined, // won't be receiving messages
57	55	},
58	56	},
59		false => .{
60		.tty = stderr_config,
61		},
	57	false => .stderr,
62	58	};
63	59
64	60	var options = options: {
...	...	@@ -75,12 +71,14 @@ pub fn main() !void {
75	71
76	72	if (!zig_integration) {
77	73	// print any warnings/notes
78		cli_diagnostics.renderToStdErr(cli_args, stderr_config);
	74	cli_diagnostics.renderToStdErr(cli_args);
79	75	// If there was something printed, then add an extra newline separator
80	76	// so that there is a clear separation between the cli diagnostics and whatever
81	77	// gets printed after
82	78	if (cli_diagnostics.errors.items.len > 0) {
83		try stderr.writeAll("\n");
	79	const stderr, _ = std.debug.lockStderrWriter(&.{});
	80	defer std.debug.unlockStderrWriter();
	81	try stderr.writeByte('\n');
84	82	}
85	83	}
86	84	break :options options;
...	...	@@ -130,17 +128,18 @@ pub fn main() !void {
130	128	const aro_arena = aro_arena_state.allocator();
131	129
132	130	var stderr_buf: [512]u8 = undefined;
133		var stderr_writer = stderr.writer(&stderr_buf);
134		var diagnostics: aro.Diagnostics = switch (zig_integration) {
135		false => .{ .output = .{ .to_writer = .{
136		.writer = &stderr_writer.interface,
137		.color = stderr_config,
138		} } },
139		true => .{ .output = .{ .to_list = .{
140		.arena = .init(gpa),
141		} } },
142		};
143		defer diagnostics.deinit();
	131	var diagnostics: aro.Diagnostics = .{ .output = output: {
	132	if (zig_integration) break :output .{ .to_list = .{ .arena = .init(gpa) } };
	133	const w, const ttyconf = std.debug.lockStderrWriter(&stderr_buf);
	134	break :output .{ .to_writer = .{
	135	.writer = w,
	136	.color = ttyconf,
	137	} };
	138	} };
	139	defer {
	140	diagnostics.deinit();
	141	if (!zig_integration) std.debug.unlockStderrWriter();
	142	}
144	143
145	144	var comp = aro.Compilation.init(aro_arena, aro_arena, io, &diagnostics, std.fs.cwd());
146	145	defer comp.deinit();
...	...	@@ -307,7 +306,7 @@ pub fn main() !void {
307	306
308	307	// print any warnings/notes
309	308	if (!zig_integration) {
310		diagnostics.renderToStdErr(std.fs.cwd(), final_input, stderr_config, mapping_results.mappings);
	309	diagnostics.renderToStdErr(std.fs.cwd(), final_input, mapping_results.mappings);
311	310	}
312	311
313	312	// write the depfile
...	...	@@ -660,7 +659,7 @@ const SourceMappings = @import("source_mapping.zig").SourceMappings;
660	659
661	660	const ErrorHandler = union(enum) {
662	661	server: std.zig.Server,
663		tty: std.Io.tty.Config,
	662	stderr,
664	663
665	664	pub fn emitCliDiagnostics(
666	665	self: *ErrorHandler,
...	...	@@ -675,9 +674,7 @@ const ErrorHandler = union(enum) {
675	674
676	675	try server.serveErrorBundle(error_bundle);
677	676	},
678		.tty => {
679		diagnostics.renderToStdErr(args, self.tty);
680		},
	677	.stderr => diagnostics.renderToStdErr(args),
681	678	}
682	679	}
683	680
...	...	@@ -698,11 +695,11 @@ const ErrorHandler = union(enum) {
698	695
699	696	try server.serveErrorBundle(error_bundle);
700	697	},
701		.tty => {
	698	.stderr => {
702	699	// aro errors have already been emitted
703		const stderr = std.debug.lockStderrWriter(&.{});
	700	const stderr, const ttyconf = std.debug.lockStderrWriter(&.{});
704	701	defer std.debug.unlockStderrWriter();
705		try renderErrorMessage(stderr, self.tty, .err, "{s}", .{fail_msg});
	702	try renderErrorMessage(stderr, ttyconf, .err, "{s}", .{fail_msg});
706	703	},
707	704	}
708	705	}
...	...	@@ -722,9 +719,7 @@ const ErrorHandler = union(enum) {
722	719
723	720	try server.serveErrorBundle(error_bundle);
724	721	},
725		.tty => {
726		diagnostics.renderToStdErr(cwd, source, self.tty, mappings);
727		},
	722	.stderr => diagnostics.renderToStdErr(cwd, source, mappings),
728	723	}
729	724	}
730	725
...	...	@@ -745,10 +740,10 @@ const ErrorHandler = union(enum) {
745	740
746	741	try server.serveErrorBundle(error_bundle);
747	742	},
748		.tty => {
749		const stderr = std.debug.lockStderrWriter(&.{});
	743	.stderr => {
	744	const stderr, const ttyconf = std.debug.lockStderrWriter(&.{});
750	745	defer std.debug.unlockStderrWriter();
751		try renderErrorMessage(stderr, self.tty, msg_type, format, args);
	746	try renderErrorMessage(stderr, ttyconf, msg_type, format, args);
752	747	},
753	748	}
754	749	}

lib/compiler/std-docs.zig+1-2

...	...	@@ -394,8 +394,7 @@ fn buildWasmBinary(
394	394	}
395	395
396	396	if (result_error_bundle.errorMessageCount() > 0) {
397		const color = std.zig.Color.auto;
398		result_error_bundle.renderToStdErr(color.renderOptions());
	397	result_error_bundle.renderToStdErr(.{}, true);
399	398	std.log.err("the following command failed with {d} compilation errors:\n{s}", .{
400	399	result_error_bundle.errorMessageCount(),
401	400	try std.Build.Step.allocPrintCmd(arena, null, argv.items),

lib/std/Build.zig+5-7

...	...	@@ -2257,8 +2257,8 @@ pub const GeneratedFile = struct {
2257	2257
2258	2258	pub fn getPath2(gen: GeneratedFile, src_builder: Build, asking_step: ?Step) []const u8 {
2259	2259	return gen.path orelse {
2260		const w = debug.lockStderrWriter(&.{});
2261		dumpBadGetPathHelp(gen.step, w, .detect(.stderr()), src_builder, asking_step) catch {};
	2260	const w, const ttyconf = debug.lockStderrWriter(&.{});
	2261	dumpBadGetPathHelp(gen.step, w, ttyconf, src_builder, asking_step) catch {};
2262	2262	debug.unlockStderrWriter();
2263	2263	@panic("misconfigured build script");
2264	2264	};
...	...	@@ -2466,8 +2466,8 @@ pub const LazyPath = union(enum) {
2466	2466	var file_path: Cache.Path = .{
2467	2467	.root_dir = Cache.Directory.cwd(),
2468	2468	.sub_path = gen.file.path orelse {
2469		const w = debug.lockStderrWriter(&.{});
2470		dumpBadGetPathHelp(gen.file.step, w, .detect(.stderr()), src_builder, asking_step) catch {};
	2469	const w, const ttyconf = debug.lockStderrWriter(&.{});
	2470	dumpBadGetPathHelp(gen.file.step, w, ttyconf, src_builder, asking_step) catch {};
2471	2471	debug.unlockStderrWriter();
2472	2472	@panic("misconfigured build script");
2473	2473	},
...	...	@@ -2558,13 +2558,11 @@ fn dumpBadDirnameHelp(
2558	2558	comptime msg: []const u8,
2559	2559	args: anytype,
2560	2560	) anyerror!void {
2561		const w = debug.lockStderrWriter(&.{});
	2561	const w, const tty_config = debug.lockStderrWriter(&.{});
2562	2562	defer debug.unlockStderrWriter();
2563	2563
2564	2564	try w.print(msg, args);
2565	2565
2566		const tty_config = std.Io.tty.detectConfig(.stderr());
2567
2568	2566	if (fail_step) \|s\| {
2569	2567	tty_config.setColor(w, .red) catch {};
2570	2568	try w.writeAll(" The step was created by this stack trace:\n");

lib/std/Build/Fuzz.zig+9-9

...	...	@@ -16,6 +16,7 @@ const build_runner = @import("root");
16	16
17	17	gpa: Allocator,
18	18	io: Io,
	19	ttyconf: tty.Config,
19	20	mode: Mode,
20	21
21	22	/// Allocated into `gpa`.
...	...	@@ -25,7 +26,6 @@ wait_group: std.Thread.WaitGroup,
25	26	root_prog_node: std.Progress.Node,
26	27	prog_node: std.Progress.Node,
27	28	thread_pool: *std.Thread.Pool,
28		ttyconf: tty.Config,
29	29
30	30	/// Protects `coverage_files`.
31	31	coverage_mutex: std.Thread.Mutex,
...	...	@@ -79,9 +79,9 @@ pub fn init(
79	79	gpa: Allocator,
80	80	io: Io,
81	81	thread_pool: *std.Thread.Pool,
	82	ttyconf: tty.Config,
82	83	all_steps: []const *Build.Step,
83	84	root_prog_node: std.Progress.Node,
84		ttyconf: tty.Config,
85	85	mode: Mode,
86	86	) Allocator.Error!Fuzz {
87	87	const run_steps: []const *Step.Run = steps: {
...	...	@@ -115,11 +115,11 @@ pub fn init(
115	115	return .{
116	116	.gpa = gpa,
117	117	.io = io,
	118	.ttyconf = ttyconf,
118	119	.mode = mode,
119	120	.run_steps = run_steps,
120	121	.wait_group = .{},
121	122	.thread_pool = thread_pool,
122		.ttyconf = ttyconf,
123	123	.root_prog_node = root_prog_node,
124	124	.prog_node = .none,
125	125	.coverage_files = .empty,
...	...	@@ -158,7 +158,7 @@ pub fn deinit(fuzz: *Fuzz) void {
158	158	fuzz.gpa.free(fuzz.run_steps);
159	159	}
160	160
161		fn rebuildTestsWorkerRun(run: *Step.Run, gpa: Allocator, ttyconf: std.Io.tty.Config, parent_prog_node: std.Progress.Node) void {
	161	fn rebuildTestsWorkerRun(run: *Step.Run, gpa: Allocator, ttyconf: tty.Config, parent_prog_node: std.Progress.Node) void {
162	162	rebuildTestsWorkerRunFallible(run, gpa, ttyconf, parent_prog_node) catch \|err\| {
163	163	const compile = run.producer.?;
164	164	log.err("step '{s}': failed to rebuild in fuzz mode: {s}", .{
...	...	@@ -167,7 +167,7 @@ fn rebuildTestsWorkerRun(run: *Step.Run, gpa: Allocator, ttyconf: std.Io.tty.Con
167	167	};
168	168	}
169	169
170		fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, ttyconf: std.Io.tty.Config, parent_prog_node: std.Progress.Node) !void {
	170	fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, ttyconf: tty.Config, parent_prog_node: std.Progress.Node) !void {
171	171	const compile = run.producer.?;
172	172	const prog_node = parent_prog_node.start(compile.step.name, 0);
173	173	defer prog_node.end();
...	...	@@ -180,9 +180,9 @@ fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, ttyconf: std.Io
180	180
181	181	if (show_error_msgs or show_compile_errors or show_stderr) {
182	182	var buf: [256]u8 = undefined;
183		const w = std.debug.lockStderrWriter(&buf);
	183	const w, _ = std.debug.lockStderrWriter(&buf);
184	184	defer std.debug.unlockStderrWriter();
185		build_runner.printErrorMessages(gpa, &compile.step, .{ .ttyconf = ttyconf }, w, .verbose, .indent) catch {};
	185	build_runner.printErrorMessages(gpa, &compile.step, .{}, w, ttyconf, .verbose, .indent) catch {};
186	186	}
187	187
188	188	const rebuilt_bin_path = result catch \|err\| switch (err) {
...	...	@@ -206,9 +206,9 @@ fn fuzzWorkerRun(
206	206	run.rerunInFuzzMode(fuzz, unit_test_index, prog_node) catch \|err\| switch (err) {
207	207	error.MakeFailed => {
208	208	var buf: [256]u8 = undefined;
209		const w = std.debug.lockStderrWriter(&buf);
	209	const w, _ = std.debug.lockStderrWriter(&buf);
210	210	defer std.debug.unlockStderrWriter();
211		build_runner.printErrorMessages(gpa, &run.step, .{ .ttyconf = fuzz.ttyconf }, w, .verbose, .indent) catch {};
	211	build_runner.printErrorMessages(gpa, &run.step, .{}, w, fuzz.ttyconf, .verbose, .indent) catch {};
212	212	return;
213	213	},
214	214	else => {

lib/std/Build/Step/Compile.zig+5-6

...	...	@@ -1056,15 +1056,15 @@ fn getGeneratedFilePath(compile: *Compile, comptime tag_name: []const u8, asking
1056	1056	const maybe_path: ?*GeneratedFile = @field(compile, tag_name);
1057	1057
1058	1058	const generated_file = maybe_path orelse {
1059		const w = std.debug.lockStderrWriter(&.{});
1060		std.Build.dumpBadGetPathHelp(&compile.step, w, .detect(.stderr()), compile.step.owner, asking_step) catch {};
	1059	const w, const ttyconf = std.debug.lockStderrWriter(&.{});
	1060	std.Build.dumpBadGetPathHelp(&compile.step, w, ttyconf, compile.step.owner, asking_step) catch {};
1061	1061	std.debug.unlockStderrWriter();
1062	1062	@panic("missing emit option for " ++ tag_name);
1063	1063	};
1064	1064
1065	1065	const path = generated_file.path orelse {
1066		const w = std.debug.lockStderrWriter(&.{});
1067		std.Build.dumpBadGetPathHelp(&compile.step, w, .detect(.stderr()), compile.step.owner, asking_step) catch {};
	1066	const w, const ttyconf = std.debug.lockStderrWriter(&.{});
	1067	std.Build.dumpBadGetPathHelp(&compile.step, w, ttyconf, compile.step.owner, asking_step) catch {};
1068	1068	std.debug.unlockStderrWriter();
1069	1069	@panic(tag_name ++ " is null. Is there a missing step dependency?");
1070	1070	};
...	...	@@ -2027,10 +2027,9 @@ fn checkCompileErrors(compile: *Compile) !void {
2027	2027	var aw: std.Io.Writer.Allocating = .init(arena);
2028	2028	defer aw.deinit();
2029	2029	try actual_eb.renderToWriter(.{
2030		.ttyconf = .no_color,
2031	2030	.include_reference_trace = false,
2032	2031	.include_source_line = false,
2033		}, &aw.writer);
	2032	}, &aw.writer, .no_color);
2034	2033	break :ae try aw.toOwnedSlice();
2035	2034	};
2036	2035

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

...	...	@@ -54,9 +54,9 @@ pub fn notifyUpdate(ws: *WebServer) void {
54	54	pub const Options = struct {
55	55	gpa: Allocator,
56	56	thread_pool: *std.Thread.Pool,
	57	ttyconf: Io.tty.Config,
57	58	graph: *const std.Build.Graph,
58	59	all_steps: []const *Build.Step,
59		ttyconf: Io.tty.Config,
60	60	root_prog_node: std.Progress.Node,
61	61	watch: bool,
62	62	listen_address: net.IpAddress,
...	...	@@ -101,10 +101,10 @@ pub fn init(opts: Options) WebServer {
101	101	return .{
102	102	.gpa = opts.gpa,
103	103	.thread_pool = opts.thread_pool,
	104	.ttyconf = opts.ttyconf,
104	105	.graph = opts.graph,
105	106	.all_steps = all_steps,
106	107	.listen_address = opts.listen_address,
107		.ttyconf = opts.ttyconf,
108	108	.root_prog_node = opts.root_prog_node,
109	109	.watch = opts.watch,
110	110
...	...	@@ -236,9 +236,9 @@ pub fn finishBuild(ws: *WebServer, opts: struct {
236	236	ws.gpa,
237	237	ws.graph.io,
238	238	ws.thread_pool,
	239	ws.ttyconf,
239	240	ws.all_steps,
240	241	ws.root_prog_node,
241		ws.ttyconf,
242	242	.{ .forever = .{ .ws = ws } },
243	243	) catch \|err\| std.process.fatal("failed to start fuzzer: {s}", .{@errorName(err)});
244	244	ws.fuzz.?.start();
...	...	@@ -655,8 +655,7 @@ fn buildClientWasm(ws: *WebServer, arena: Allocator, optimize: std.builtin.Optim
655	655	}
656	656
657	657	if (result_error_bundle.errorMessageCount() > 0) {
658		const color = std.zig.Color.auto;
659		result_error_bundle.renderToStdErr(color.renderOptions());
	658	result_error_bundle.renderToStdErr(.{}, .auto);
660	659	log.err("the following command failed with {d} compilation errors:\n{s}", .{
661	660	result_error_bundle.errorMessageCount(),
662	661	try Build.Step.allocPrintCmd(arena, null, argv.items),

lib/std/debug.zig+19-19

...	...	@@ -272,7 +272,7 @@ pub fn unlockStdErr() void {
272	272	std.Progress.unlockStdErr();
273	273	}
274	274
275		/// Allows the caller to freely write to stderr until `unlockStdErr` is called.
	275	/// Allows the caller to freely write to stderr until `unlockStderrWriter` is called.
276	276	///
277	277	/// During the lock, any `std.Progress` information is cleared from the terminal.
278	278	///
...	...	@@ -282,8 +282,16 @@ pub fn unlockStdErr() void {
282	282	///
283	283	/// The returned `Writer` does not need to be manually flushed: flushing is performed automatically
284	284	/// when the matching `unlockStderrWriter` call occurs.
285		pub fn lockStderrWriter(buffer: []u8) *Writer {
286		return std.Progress.lockStderrWriter(buffer);
	285	pub fn lockStderrWriter(buffer: []u8) struct { *Writer, tty.Config } {
	286	const global = struct {
	287	var conf: ?tty.Config = null;
	288	};
	289	const w = std.Progress.lockStderrWriter(buffer);
	290	// The stderr lock also locks access to `global.conf`.
	291	if (global.conf == null) {
	292	global.conf = .detect(.stderr());
	293	}
	294	return .{ w, global.conf.? };
287	295	}
288	296
289	297	pub fn unlockStderrWriter() void {
...	...	@@ -297,7 +305,7 @@ pub fn unlockStderrWriter() void {
297	305	/// function returns.
298	306	pub fn print(comptime fmt: []const u8, args: anytype) void {
299	307	var buffer: [64]u8 = undefined;
300		const bw = lockStderrWriter(&buffer);
	308	const bw, _ = lockStderrWriter(&buffer);
301	309	defer unlockStderrWriter();
302	310	nosuspend bw.print(fmt, args) catch return;
303	311	}
...	...	@@ -314,9 +322,8 @@ pub inline fn getSelfDebugInfo() !*SelfInfo {
314	322	/// Tries to print a hexadecimal view of the bytes, unbuffered, and ignores any error returned.
315	323	/// Obtains the stderr mutex while dumping.
316	324	pub fn dumpHex(bytes: []const u8) void {
317		const bw = lockStderrWriter(&.{});
	325	const bw, const ttyconf = lockStderrWriter(&.{});
318	326	defer unlockStderrWriter();
319		const ttyconf = tty.detectConfig(.stderr());
320	327	dumpHexFallible(bw, ttyconf, bytes) catch {};
321	328	}
322	329
...	...	@@ -538,9 +545,7 @@ pub fn defaultPanic(
538	545	_ = panicking.fetchAdd(1, .seq_cst);
539	546
540	547	trace: {
541		const tty_config = tty.detectConfig(.stderr());
542
543		const stderr = lockStderrWriter(&.{});
	548	const stderr, const tty_config = lockStderrWriter(&.{});
544	549	defer unlockStderrWriter();
545	550
546	551	if (builtin.single_threaded) {
...	...	@@ -743,8 +748,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, writer: *Wri
743	748	}
744	749	/// A thin wrapper around `writeCurrentStackTrace` which writes to stderr and ignores write errors.
745	750	pub fn dumpCurrentStackTrace(options: StackUnwindOptions) void {
746		const tty_config = tty.detectConfig(.stderr());
747		const stderr = lockStderrWriter(&.{});
	751	const stderr, const tty_config = lockStderrWriter(&.{});
748	752	defer unlockStderrWriter();
749	753	writeCurrentStackTrace(.{
750	754	.first_address = a: {
...	...	@@ -809,8 +813,7 @@ pub fn writeStackTrace(st: const StackTrace, writer: Writer, tty_config: tty.C
809	813	}
810	814	/// A thin wrapper around `writeStackTrace` which writes to stderr and ignores write errors.
811	815	pub fn dumpStackTrace(st: *const StackTrace) void {
812		const tty_config = tty.detectConfig(.stderr());
813		const stderr = lockStderrWriter(&.{});
	816	const stderr, const tty_config = lockStderrWriter(&.{});
814	817	defer unlockStderrWriter();
815	818	writeStackTrace(st, stderr, tty_config) catch \|err\| switch (err) {
816	819	error.WriteFailed => {},
...	...	@@ -1552,9 +1555,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex
1552	1555	_ = panicking.fetchAdd(1, .seq_cst);
1553	1556
1554	1557	trace: {
1555		const tty_config = tty.detectConfig(.stderr());
1556
1557		const stderr = lockStderrWriter(&.{});
	1558	const stderr, const tty_config = lockStderrWriter(&.{});
1558	1559	defer unlockStderrWriter();
1559	1560
1560	1561	if (addr) \|a\| {
...	...	@@ -1612,7 +1613,7 @@ test "manage resources correctly" {
1612	1613	&di,
1613	1614	&discarding.writer,
1614	1615	S.showMyTrace(),
1615		tty.detectConfig(.stderr()),
	1616	.no_color,
1616	1617	);
1617	1618	}
1618	1619
...	...	@@ -1674,8 +1675,7 @@ pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize
1674	1675	pub fn dump(t: @This()) void {
1675	1676	if (!enabled) return;
1676	1677
1677		const tty_config = tty.detectConfig(.stderr());
1678		const stderr = lockStderrWriter(&.{});
	1678	const stderr, const tty_config = lockStderrWriter(&.{});
1679	1679	defer unlockStderrWriter();
1680	1680	const end = @min(t.index, size);
1681	1681	for (t.addrs[0..end], 0..) \|frames_array, i\| {

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

...	...	@@ -47,7 +47,7 @@ pub const Value = union(enum) {
47	47	}
48	48
49	49	pub fn dump(v: Value) void {
50		const w = std.debug.lockStderrWriter(&.{});
	50	const w, _ = std.debug.lockStderrWriter(&.{});
51	51	defer std.debug.unlockStderrWriter();
52	52
53	53	json.Stringify.value(v, .{}, w) catch return;

lib/std/log.zig+1-1

...	...	@@ -151,7 +151,7 @@ pub fn defaultLog(
151	151	const level_txt = comptime message_level.asText();
152	152	const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
153	153	var buffer: [64]u8 = undefined;
154		const stderr = std.debug.lockStderrWriter(&buffer);
	154	const stderr, _ = std.debug.lockStderrWriter(&buffer);
155	155	defer std.debug.unlockStderrWriter();
156	156	nosuspend stderr.print(level_txt ++ prefix2 ++ format ++ "\n", args) catch return;
157	157	}

lib/std/testing.zig+4-4

...	...	@@ -355,7 +355,7 @@ test expectApproxEqRel {
355	355	/// This function is intended to be used only in tests. When the two slices are not
356	356	/// equal, prints diagnostics to stderr to show exactly how they are not equal (with
357	357	/// the differences highlighted in red), then returns a test failure error.
358		/// The colorized output is optional and controlled by the return of `std.Io.tty.detectConfig()`.
	358	/// The colorized output is optional and controlled by the return of `std.Io.tty.Config.detect`.
359	359	/// If your inputs are UTF-8 encoded strings, consider calling `expectEqualStrings` instead.
360	360	pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const T) !void {
361	361	const diff_index: usize = diff_index: {
...	...	@@ -367,9 +367,9 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
367	367	break :diff_index if (expected.len == actual.len) return else shortest;
368	368	};
369	369	if (!backend_can_print) return error.TestExpectedEqual;
370		const stderr_w = std.debug.lockStderrWriter(&.{});
	370	const stderr_w, const ttyconf = std.debug.lockStderrWriter(&.{});
371	371	defer std.debug.unlockStderrWriter();
372		failEqualSlices(T, expected, actual, diff_index, stderr_w) catch {};
	372	failEqualSlices(T, expected, actual, diff_index, stderr_w, ttyconf) catch {};
373	373	return error.TestExpectedEqual;
374	374	}
375	375
...	...	@@ -379,6 +379,7 @@ fn failEqualSlices(
379	379	actual: []const T,
380	380	diff_index: usize,
381	381	w: *std.Io.Writer,
	382	ttyconf: std.Io.tty.Config,
382	383	) !void {
383	384	try w.print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
384	385
...	...	@@ -398,7 +399,6 @@ fn failEqualSlices(
398	399	const actual_window = actual[window_start..@min(actual.len, window_start + max_window_size)];
399	400	const actual_truncated = window_start + actual_window.len < actual.len;
400	401
401		const ttyconf = std.Io.tty.detectConfig(.stderr());
402	402	var differ = if (T == u8) BytesDiffer{
403	403	.expected = expected_window,
404	404	.actual = actual_window,

lib/std/zig.zig+8-7

...	...	@@ -53,17 +53,18 @@ pub const Color = enum {
53	53	/// Assume stderr is a terminal.
54	54	on,
55	55
56		pub fn get_tty_conf(color: Color) Io.tty.Config {
	56	pub fn getTtyConf(color: Color, detected: Io.tty.Config) Io.tty.Config {
57	57	return switch (color) {
58		.auto => Io.tty.detectConfig(std.fs.File.stderr()),
	58	.auto => detected,
59	59	.on => .escape_codes,
60	60	.off => .no_color,
61	61	};
62	62	}
63
64		pub fn renderOptions(color: Color) std.zig.ErrorBundle.RenderOptions {
65		return .{
66		.ttyconf = get_tty_conf(color),
	63	pub fn detectTtyConf(color: Color) Io.tty.Config {
	64	return switch (color) {
	65	.auto => .detect(.stderr()),
	66	.on => .escape_codes,
	67	.off => .no_color,
67	68	};
68	69	}
69	70	};
...	...	@@ -606,7 +607,7 @@ pub fn printAstErrorsToStderr(gpa: Allocator, tree: Ast, path: []const u8, color
606	607
607	608	var error_bundle = try wip_errors.toOwnedBundle("");
608	609	defer error_bundle.deinit(gpa);
609		error_bundle.renderToStdErr(color.renderOptions());
	610	error_bundle.renderToStdErr(.{}, color);
610	611	}
611	612
612	613	pub fn putAstErrorsIntoBundle(

lib/std/zig/ErrorBundle.zig+8-9

...	...	@@ -157,23 +157,22 @@ pub fn nullTerminatedString(eb: ErrorBundle, index: String) [:0]const u8 {
157	157	}
158	158
159	159	pub const RenderOptions = struct {
160		ttyconf: Io.tty.Config,
161	160	include_reference_trace: bool = true,
162	161	include_source_line: bool = true,
163	162	include_log_text: bool = true,
164	163	};
165	164
166		pub fn renderToStdErr(eb: ErrorBundle, options: RenderOptions) void {
	165	pub fn renderToStdErr(eb: ErrorBundle, options: RenderOptions, color: std.zig.Color) void {
167	166	var buffer: [256]u8 = undefined;
168		const w = std.debug.lockStderrWriter(&buffer);
	167	const w, const ttyconf = std.debug.lockStderrWriter(&buffer);
169	168	defer std.debug.unlockStderrWriter();
170		renderToWriter(eb, options, w) catch return;
	169	renderToWriter(eb, options, w, color.getTtyConf(ttyconf)) catch return;
171	170	}
172	171
173		pub fn renderToWriter(eb: ErrorBundle, options: RenderOptions, w: *Writer) (Writer.Error \|\| std.posix.UnexpectedError)!void {
	172	pub fn renderToWriter(eb: ErrorBundle, options: RenderOptions, w: *Writer, ttyconf: Io.tty.Config) (Writer.Error \|\| std.posix.UnexpectedError)!void {
174	173	if (eb.extra.len == 0) return;
175	174	for (eb.getMessages()) \|err_msg\| {
176		try renderErrorMessageToWriter(eb, options, err_msg, w, "error", .red, 0);
	175	try renderErrorMessageToWriter(eb, options, err_msg, w, ttyconf, "error", .red, 0);
177	176	}
178	177
179	178	if (options.include_log_text) {
...	...	@@ -190,11 +189,11 @@ fn renderErrorMessageToWriter(
190	189	options: RenderOptions,
191	190	err_msg_index: MessageIndex,
192	191	w: *Writer,
	192	ttyconf: Io.tty.Config,
193	193	kind: []const u8,
194	194	color: Io.tty.Color,
195	195	indent: usize,
196	196	) (Writer.Error \|\| std.posix.UnexpectedError)!void {
197		const ttyconf = options.ttyconf;
198	197	const err_msg = eb.getErrorMessage(err_msg_index);
199	198	if (err_msg.src_loc != .none) {
200	199	const src = eb.extraData(SourceLocation, @intFromEnum(err_msg.src_loc));
...	...	@@ -251,7 +250,7 @@ fn renderErrorMessageToWriter(
251	250	try ttyconf.setColor(w, .reset);
252	251	}
253	252	for (eb.getNotes(err_msg_index)) \|note\| {
254		try renderErrorMessageToWriter(eb, options, note, w, "note", .cyan, indent);
	253	try renderErrorMessageToWriter(eb, options, note, w, ttyconf, "note", .cyan, indent);
255	254	}
256	255	if (src.data.reference_trace_len > 0 and options.include_reference_trace) {
257	256	try ttyconf.setColor(w, .reset);
...	...	@@ -300,7 +299,7 @@ fn renderErrorMessageToWriter(
300	299	}
301	300	try ttyconf.setColor(w, .reset);
302	301	for (eb.getNotes(err_msg_index)) \|note\| {
303		try renderErrorMessageToWriter(eb, options, note, w, "note", .cyan, indent + 4);
	302	try renderErrorMessageToWriter(eb, options, note, w, ttyconf, "note", .cyan, indent + 4);
304	303	}
305	304	}
306	305	}

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

...	...	@@ -6386,7 +6386,7 @@ var fixed_buffer_mem: [100 * 1024]u8 = undefined;
6386	6386
6387	6387	fn testParse(source: [:0]const u8, allocator: mem.Allocator, anything_changed: *bool) ![]u8 {
6388	6388	var buffer: [64]u8 = undefined;
6389		const stderr = std.debug.lockStderrWriter(&buffer);
	6389	const stderr, _ = std.debug.lockStderrWriter(&buffer);
6390	6390	defer std.debug.unlockStderrWriter();
6391	6391
6392	6392	var tree = try std.zig.Ast.parse(allocator, source, .zig);

src/Air/print.zig+2-2

...	...	@@ -73,13 +73,13 @@ pub fn writeInst(
73	73	}
74	74
75	75	pub fn dump(air: Air, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
76		const stderr_bw = std.debug.lockStderrWriter(&.{});
	76	const stderr_bw, _ = std.debug.lockStderrWriter(&.{});
77	77	defer std.debug.unlockStderrWriter();
78	78	air.write(stderr_bw, pt, liveness);
79	79	}
80	80
81	81	pub fn dumpInst(air: Air, inst: Air.Inst.Index, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
82		const stderr_bw = std.debug.lockStderrWriter(&.{});
	82	const stderr_bw, _ = std.debug.lockStderrWriter(&.{});
83	83	defer std.debug.unlockStderrWriter();
84	84	air.writeInst(stderr_bw, inst, pt, liveness);
85	85	}

src/Compilation.zig+3-3

...	...	@@ -2093,7 +2093,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
2093	2093
2094	2094	if (options.verbose_llvm_cpu_features) {
2095	2095	if (options.root_mod.resolved_target.llvm_cpu_features) \|cf\| print: {
2096		const stderr_w = std.debug.lockStderrWriter(&.{});
	2096	const stderr_w, _ = std.debug.lockStderrWriter(&.{});
2097	2097	defer std.debug.unlockStderrWriter();
2098	2098	stderr_w.print("compilation: {s}\n", .{options.root_name}) catch break :print;
2099	2099	stderr_w.print(" target: {s}\n", .{try target.zigTriple(arena)}) catch break :print;
...	...	@@ -4270,7 +4270,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
4270	4270	// However, we haven't reported any such error.
4271	4271	// This is a compiler bug.
4272	4272	print_ctx: {
4273		var stderr_w = std.debug.lockStderrWriter(&.{});
	4273	var stderr_w, _ = std.debug.lockStderrWriter(&.{});
4274	4274	defer std.debug.unlockStderrWriter();
4275	4275	stderr_w.writeAll("referenced transitive analysis errors, but none actually emitted\n") catch break :print_ctx;
4276	4276	stderr_w.print("{f} [transitive failure]\n", .{zcu.fmtAnalUnit(failed_unit)}) catch break :print_ctx;
...	...	@@ -7752,7 +7752,7 @@ pub fn lockAndSetMiscFailure(
7752	7752
7753	7753	pub fn dump_argv(argv: []const []const u8) void {
7754	7754	var buffer: [64]u8 = undefined;
7755		const stderr = std.debug.lockStderrWriter(&buffer);
	7755	const stderr, _ = std.debug.lockStderrWriter(&buffer);
7756	7756	defer std.debug.unlockStderrWriter();
7757	7757	nosuspend {
7758	7758	for (argv, 0..) \|arg, i\| {

src/InternPool.zig+2-2

...	...	@@ -11330,7 +11330,7 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
11330	11330
11331	11331	fn dumpAllFallible(ip: *const InternPool) anyerror!void {
11332	11332	var buffer: [4096]u8 = undefined;
11333		const stderr_bw = std.debug.lockStderrWriter(&buffer);
	11333	const stderr_bw, _ = std.debug.lockStderrWriter(&buffer);
11334	11334	defer std.debug.unlockStderrWriter();
11335	11335	for (ip.locals, 0..) \|*local, tid\| {
11336	11336	const items = local.shared.items.view();
...	...	@@ -11462,7 +11462,7 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator)
11462	11462	}
11463	11463
11464	11464	var buffer: [4096]u8 = undefined;
11465		const stderr_bw = std.debug.lockStderrWriter(&buffer);
	11465	const stderr_bw, _ = std.debug.lockStderrWriter(&buffer);
11466	11466	defer std.debug.unlockStderrWriter();
11467	11467
11468	11468	const SortContext = struct {

src/Package/Fetch.zig+2-2

...	...	@@ -2043,7 +2043,7 @@ const UnpackResult = struct {
2043	2043	defer errors.deinit(gpa);
2044	2044	var aw: Io.Writer.Allocating = .init(gpa);
2045	2045	defer aw.deinit();
2046		try errors.renderToWriter(.{ .ttyconf = .no_color }, &aw.writer);
	2046	try errors.renderToWriter(.{}, &aw.writer, .no_color);
2047	2047	try std.testing.expectEqualStrings(
2048	2048	\\error: unable to unpack
2049	2049	\\ note: unable to create symlink from 'dir2/file2' to 'filename': SymlinkError
...	...	@@ -2360,7 +2360,7 @@ const TestFetchBuilder = struct {
2360	2360	}
2361	2361	var aw: Io.Writer.Allocating = .init(std.testing.allocator);
2362	2362	defer aw.deinit();
2363		try errors.renderToWriter(.{ .ttyconf = .no_color }, &aw.writer);
	2363	try errors.renderToWriter(.{}, &aw.writer, .no_color);
2364	2364	try std.testing.expectEqualStrings(msg, aw.written());
2365	2365	}
2366	2366	};

src/Sema.zig+1-1

...	...	@@ -2631,7 +2631,7 @@ pub fn failWithOwnedErrorMsg(sema: Sema, block: ?Block, err_msg: *Zcu.ErrorMsg
2631	2631	Compilation.addModuleErrorMsg(zcu, &wip_errors, err_msg.*, false) catch @panic("out of memory");
2632	2632	std.debug.print("compile error during Sema:\n", .{});
2633	2633	var error_bundle = wip_errors.toOwnedBundle("") catch @panic("out of memory");
2634		error_bundle.renderToStdErr(.{ .ttyconf = .no_color });
	2634	error_bundle.renderToStdErr(.{}, .auto);
2635	2635	std.debug.panicExtra(@returnAddress(), "unexpected compile error occurred", .{});
2636	2636	}
2637	2637

src/Zcu/PerThread.zig+1-1

...	...	@@ -4473,7 +4473,7 @@ fn runCodegenInner(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air) e
4473	4473	defer if (liveness) \|*l\| l.deinit(gpa);
4474	4474
4475	4475	if (build_options.enable_debug_extensions and comp.verbose_air) {
4476		const stderr = std.debug.lockStderrWriter(&.{});
	4476	const stderr, _ = std.debug.lockStderrWriter(&.{});
4477	4477	defer std.debug.unlockStderrWriter();
4478	4478	stderr.print("# Begin Function AIR: {f}:\n", .{fqn.fmt(ip)}) catch {};
4479	4479	air.write(stderr, pt, liveness);

src/codegen/aarch64/Select.zig+1-1

...	...	@@ -11188,7 +11188,7 @@ fn initValueAdvanced(
11188	11188	}
11189	11189	pub fn dumpValues(isel: *Select, which: enum { only_referenced, all }) void {
11190	11190	errdefer \|err\| @panic(@errorName(err));
11191		const stderr = std.debug.lockStderrWriter(&.{});
	11191	const stderr, _ = std.debug.lockStderrWriter(&.{});
11192	11192	defer std.debug.unlockStderrWriter();
11193	11193
11194	11194	const zcu = isel.pt.zcu;

src/crash_report.zig+1-1

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

src/fmt.zig+4-4

...	...	@@ -124,7 +124,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
124	124	try wip_errors.addZirErrorMessages(zir, tree, source_code, "<stdin>");
125	125	var error_bundle = try wip_errors.toOwnedBundle("");
126	126	defer error_bundle.deinit(gpa);
127		error_bundle.renderToStdErr(color.renderOptions());
	127	error_bundle.renderToStdErr(.{}, color);
128	128	process.exit(2);
129	129	}
130	130	} else {
...	...	@@ -138,7 +138,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
138	138	try wip_errors.addZoirErrorMessages(zoir, tree, source_code, "<stdin>");
139	139	var error_bundle = try wip_errors.toOwnedBundle("");
140	140	defer error_bundle.deinit(gpa);
141		error_bundle.renderToStdErr(color.renderOptions());
	141	error_bundle.renderToStdErr(.{}, color);
142	142	process.exit(2);
143	143	}
144	144	}
...	...	@@ -317,7 +317,7 @@ fn fmtPathFile(
317	317	try wip_errors.addZirErrorMessages(zir, tree, source_code, file_path);
318	318	var error_bundle = try wip_errors.toOwnedBundle("");
319	319	defer error_bundle.deinit(gpa);
320		error_bundle.renderToStdErr(fmt.color.renderOptions());
	320	error_bundle.renderToStdErr(.{}, fmt.color);
321	321	fmt.any_error = true;
322	322	}
323	323	},
...	...	@@ -332,7 +332,7 @@ fn fmtPathFile(
332	332	try wip_errors.addZoirErrorMessages(zoir, tree, source_code, file_path);
333	333	var error_bundle = try wip_errors.toOwnedBundle("");
334	334	defer error_bundle.deinit(gpa);
335		error_bundle.renderToStdErr(fmt.color.renderOptions());
	335	error_bundle.renderToStdErr(.{}, fmt.color);
336	336	fmt.any_error = true;
337	337	}
338	338	},

src/libs/mingw.zig+4-4

...	...	@@ -312,7 +312,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
312	312	const include_dir = try comp.dirs.zig_lib.join(arena, &.{ "libc", "mingw", "def-include" });
313	313
314	314	if (comp.verbose_cc) print: {
315		var stderr = std.debug.lockStderrWriter(&.{});
	315	var stderr, _ = std.debug.lockStderrWriter(&.{});
316	316	defer std.debug.unlockStderrWriter();
317	317	nosuspend stderr.print("def file: {s}\n", .{def_file_path}) catch break :print;
318	318	nosuspend stderr.print("include dir: {s}\n", .{include_dir}) catch break :print;
...	...	@@ -332,11 +332,11 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
332	332
333	333	if (aro_comp.diagnostics.output.to_list.messages.items.len != 0) {
334	334	var buffer: [64]u8 = undefined;
335		const w = std.debug.lockStderrWriter(&buffer);
	335	const w, const ttyconf = std.debug.lockStderrWriter(&buffer);
336	336	defer std.debug.unlockStderrWriter();
337	337	for (aro_comp.diagnostics.output.to_list.messages.items) \|msg\| {
338	338	if (msg.kind == .@"fatal error" or msg.kind == .@"error") {
339		msg.write(w, .detect(std.fs.File.stderr()), true) catch {};
	339	msg.write(w, ttyconf, true) catch {};
340	340	return error.AroPreprocessorFailed;
341	341	}
342	342	}
...	...	@@ -356,7 +356,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
356	356	error.OutOfMemory => \|e\| return e,
357	357	error.ParseError => {
358	358	var buffer: [64]u8 = undefined;
359		const w = std.debug.lockStderrWriter(&buffer);
	359	const w, _ = std.debug.lockStderrWriter(&buffer);
360	360	defer std.debug.unlockStderrWriter();
361	361	try w.writeAll("error: ");
362	362	try def_diagnostics.writeMsg(w, input);

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

...	...	@@ -1028,7 +1028,7 @@ fn testParse(machine_type: std.coff.IMAGE.FILE.MACHINE, source: [:0]const u8, ex
1028	1028	const module = parse(std.testing.allocator, source, machine_type, .mingw, &diagnostics) catch \|err\| switch (err) {
1029	1029	error.OutOfMemory => \|e\| return e,
1030	1030	error.ParseError => {
1031		const stderr = std.debug.lockStderrWriter(&.{});
	1031	const stderr, _ = std.debug.lockStderrWriter(&.{});
1032	1032	defer std.debug.unlockStderrWriter();
1033	1033	try diagnostics.writeMsg(stderr, source);
1034	1034	try stderr.writeByte('\n');

src/link.zig+1-1

...	...	@@ -2215,7 +2215,7 @@ fn resolvePathInputLib(
2215	2215	var error_bundle = try wip_errors.toOwnedBundle("");
2216	2216	defer error_bundle.deinit(gpa);
2217	2217
2218		error_bundle.renderToStdErr(color.renderOptions());
	2218	error_bundle.renderToStdErr(.{}, color);
2219	2219
2220	2220	std.process.exit(1);
2221	2221	}

src/link/Coff.zig+1-1

...	...	@@ -2335,7 +2335,7 @@ pub fn deleteExport(coff: *Coff, exported: Zcu.Exported, name: InternPool.NullTe
2335	2335	}
2336	2336
2337	2337	pub fn dump(coff: *Coff, tid: Zcu.PerThread.Id) void {
2338		const w = std.debug.lockStderrWriter(&.{});
	2338	const w, _ = std.debug.lockStderrWriter(&.{});
2339	2339	defer std.debug.unlockStderrWriter();
2340	2340	coff.printNode(tid, w, .root, 0) catch {};
2341	2341	}

src/link/Elf2.zig+1-1

...	...	@@ -1965,7 +1965,7 @@ pub fn deleteExport(elf: *Elf, exported: Zcu.Exported, name: InternPool.NullTerm
1965	1965	}
1966	1966
1967	1967	pub fn dump(elf: *Elf, tid: Zcu.PerThread.Id) void {
1968		const w = std.debug.lockStderrWriter(&.{});
	1968	const w, _ = std.debug.lockStderrWriter(&.{});
1969	1969	defer std.debug.unlockStderrWriter();
1970	1970	elf.printNode(tid, w, .root, 0) catch {};
1971	1971	}

src/main.zig+9-9

...	...	@@ -4520,7 +4520,7 @@ fn updateModule(comp: *Compilation, color: Color, prog_node: std.Progress.Node)
4520	4520	defer errors.deinit(comp.gpa);
4521	4521
4522	4522	if (errors.errorMessageCount() > 0) {
4523		errors.renderToStdErr(color.renderOptions());
	4523	errors.renderToStdErr(.{}, color);
4524	4524	return error.CompileErrorsReported;
4525	4525	}
4526	4526	}
...	...	@@ -4573,7 +4573,7 @@ fn cmdTranslateC(
4573	4573	return;
4574	4574	} else {
4575	4575	const color: Color = .auto;
4576		result.errors.renderToStdErr(color.renderOptions());
	4576	result.errors.renderToStdErr(.{}, color);
4577	4577	process.exit(1);
4578	4578	}
4579	4579	}
...	...	@@ -5199,7 +5199,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)
5199	5199
5200	5200	if (fetch.error_bundle.root_list.items.len > 0) {
5201	5201	var errors = try fetch.error_bundle.toOwnedBundle("");
5202		errors.renderToStdErr(color.renderOptions());
	5202	errors.renderToStdErr(.{}, color);
5203	5203	process.exit(1);
5204	5204	}
5205	5205
...	...	@@ -6135,7 +6135,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
6135	6135	try wip_errors.init(arena);
6136	6136	try wip_errors.addZirErrorMessages(zir, tree, source, display_path);
6137	6137	var error_bundle = try wip_errors.toOwnedBundle("");
6138		error_bundle.renderToStdErr(color.renderOptions());
	6138	error_bundle.renderToStdErr(.{}, color);
6139	6139	if (zir.loweringFailed()) {
6140	6140	process.exit(1);
6141	6141	}
...	...	@@ -6206,7 +6206,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
6206	6206	try wip_errors.init(arena);
6207	6207	try wip_errors.addZoirErrorMessages(zoir, tree, source, display_path);
6208	6208	var error_bundle = try wip_errors.toOwnedBundle("");
6209		error_bundle.renderToStdErr(color.renderOptions());
	6209	error_bundle.renderToStdErr(.{}, color);
6210	6210	process.exit(1);
6211	6211	}
6212	6212
...	...	@@ -6479,7 +6479,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
6479	6479	try wip_errors.init(arena);
6480	6480	try wip_errors.addZirErrorMessages(old_zir, old_tree, old_source, old_source_path);
6481	6481	var error_bundle = try wip_errors.toOwnedBundle("");
6482		error_bundle.renderToStdErr(color.renderOptions());
	6482	error_bundle.renderToStdErr(.{}, color);
6483	6483	process.exit(1);
6484	6484	}
6485	6485
...	...	@@ -6491,7 +6491,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
6491	6491	try wip_errors.init(arena);
6492	6492	try wip_errors.addZirErrorMessages(new_zir, new_tree, new_source, new_source_path);
6493	6493	var error_bundle = try wip_errors.toOwnedBundle("");
6494		error_bundle.renderToStdErr(color.renderOptions());
	6494	error_bundle.renderToStdErr(.{}, color);
6495	6495	process.exit(1);
6496	6496	}
6497	6497
...	...	@@ -6948,7 +6948,7 @@ fn cmdFetch(
6948	6948
6949	6949	if (fetch.error_bundle.root_list.items.len > 0) {
6950	6950	var errors = try fetch.error_bundle.toOwnedBundle("");
6951		errors.renderToStdErr(color.renderOptions());
	6951	errors.renderToStdErr(.{}, color);
6952	6952	process.exit(1);
6953	6953	}
6954	6954
...	...	@@ -7304,7 +7304,7 @@ fn loadManifest(
7304	7304
7305	7305	var error_bundle = try wip_errors.toOwnedBundle("");
7306	7306	defer error_bundle.deinit(gpa);
7307		error_bundle.renderToStdErr(options.color.renderOptions());
	7307	error_bundle.renderToStdErr(.{}, options.color);
7308	7308
7309	7309	process.exit(2);
7310	7310	}

tools/gen_spirv_spec.zig+3-4

...	...	@@ -89,10 +89,9 @@ pub fn main() !void {
89	89	const output = allocating.written()[0 .. allocating.written().len - 1 :0];
90	90
91	91	var tree = try std.zig.Ast.parse(allocator, output, .zig);
92		var color: std.zig.Color = .on;
93	92
94	93	if (tree.errors.len != 0) {
95		try std.zig.printAstErrorsToStderr(allocator, tree, "", color);
	94	try std.zig.printAstErrorsToStderr(allocator, tree, "", .auto);
96	95	return;
97	96	}
98	97
...	...	@@ -104,7 +103,7 @@ pub fn main() !void {
104	103	try wip_errors.addZirErrorMessages(zir, tree, output, "");
105	104	var error_bundle = try wip_errors.toOwnedBundle("");
106	105	defer error_bundle.deinit(allocator);
107		error_bundle.renderToStdErr(color.renderOptions());
	106	error_bundle.renderToStdErr(.{}, .auto);
108	107	}
109	108
110	109	const formatted_output = try tree.renderAlloc(allocator);
...	...	@@ -931,7 +930,7 @@ fn parseHexInt(text: []const u8) !u31 {
931	930	}
932	931
933	932	fn usageAndExit(arg0: []const u8, code: u8) noreturn {
934		const stderr = std.debug.lockStderrWriter(&.{});
	933	const stderr, _ = std.debug.lockStderrWriter(&.{});
935	934	stderr.print(
936	935	\\Usage: {s} <SPIRV-Headers repository path> <path/to/zig/src/codegen/spirv/extinst.zig.grammar.json>
937	936	\\

tools/generate_linux_syscalls.zig+3-1

...	...	@@ -177,7 +177,9 @@ pub fn main() !void {
177	177
178	178	const args = try std.process.argsAlloc(gpa);
179	179	if (args.len < 2 or mem.eql(u8, args[1], "--help")) {
180		usage(std.debug.lockStderrWriter(&.{}), args[0]) catch std.process.exit(2);
	180	const w, _ = std.debug.lockStderrWriter(&.{});
	181	defer std.debug.unlockStderrWriter();
	182	usage(w, args[0]) catch std.process.exit(2);
181	183	std.process.exit(1);
182	184	}
183	185	const linux_path = args[1];

tools/incr-check.zig+5-10

...	...	@@ -340,8 +340,7 @@ const Eval = struct {
340	340	.unknown => return,
341	341	.compile_errors => \|ce\| ce,
342	342	.stdout, .exit_code => {
343		const color: std.zig.Color = .auto;
344		error_bundle.renderToStdErr(color.renderOptions());
	343	error_bundle.renderToStdErr(.{}, .auto);
345	344	eval.fatal("update '{s}': unexpected compile errors", .{update.name});
346	345	},
347	346	};
...	...	@@ -350,8 +349,7 @@ const Eval = struct {
350	349
351	350	for (error_bundle.getMessages()) \|err_idx\| {
352	351	if (expected_idx == expected.errors.len) {
353		const color: std.zig.Color = .auto;
354		error_bundle.renderToStdErr(color.renderOptions());
	352	error_bundle.renderToStdErr(.{}, .auto);
355	353	eval.fatal("update '{s}': more errors than expected", .{update.name});
356	354	}
357	355	try eval.checkOneError(update, error_bundle, expected.errors[expected_idx], false, err_idx);
...	...	@@ -359,8 +357,7 @@ const Eval = struct {
359	357
360	358	for (error_bundle.getNotes(err_idx)) \|note_idx\| {
361	359	if (expected_idx == expected.errors.len) {
362		const color: std.zig.Color = .auto;
363		error_bundle.renderToStdErr(color.renderOptions());
	360	error_bundle.renderToStdErr(.{}, .auto);
364	361	eval.fatal("update '{s}': more error notes than expected", .{update.name});
365	362	}
366	363	try eval.checkOneError(update, error_bundle, expected.errors[expected_idx], true, note_idx);
...	...	@@ -369,8 +366,7 @@ const Eval = struct {
369	366	}
370	367
371	368	if (!std.mem.eql(u8, error_bundle.getCompileLogOutput(), expected.compile_log_output)) {
372		const color: std.zig.Color = .auto;
373		error_bundle.renderToStdErr(color.renderOptions());
	369	error_bundle.renderToStdErr(.{}, .auto);
374	370	eval.fatal("update '{s}': unexpected compile log output", .{update.name});
375	371	}
376	372	}
...	...	@@ -404,8 +400,7 @@ const Eval = struct {
404	400	expected.column != src.column + 1 or
405	401	!std.mem.eql(u8, expected.msg, msg))
406	402	{
407		const color: std.zig.Color = .auto;
408		eb.renderToStdErr(color.renderOptions());
	403	eb.renderToStdErr(.{}, .auto);
409	404	eval.fatal("update '{s}': compile error did not match expected error", .{update.name});
410	405	}
411	406	}

tools/update_clang_options.zig+3-1

...	...	@@ -961,7 +961,9 @@ fn objectLessThan(context: void, a: json.ObjectMap, b: json.ObjectMap) bool {
961	961	}
962	962
963	963	fn printUsageAndExit(arg0: []const u8) noreturn {
964		printUsage(std.debug.lockStderrWriter(&.{}), arg0) catch std.process.exit(2);
	964	const w, _ = std.debug.lockStderrWriter(&.{});
	965	defer std.debug.unlockStderrWriter();
	966	printUsage(w, arg0) catch std.process.exit(2);
965	967	std.process.exit(1);
966	968	}
967	969

tools/update_cpu_features.zig+1-1

...	...	@@ -2167,7 +2167,7 @@ fn processOneTarget(job: Job) void {
2167	2167	}
2168	2168
2169	2169	fn usageAndExit(arg0: []const u8, code: u8) noreturn {
2170		const stderr = std.debug.lockStderrWriter(&.{});
	2170	const stderr, _ = std.debug.lockStderrWriter(&.{});
2171	2171	stderr.print(
2172	2172	\\Usage: {s} /path/to/llvm-tblgen /path/git/llvm-project /path/git/zig [zig_name filter]
2173	2173	\\

tools/update_crc_catalog.zig+3-1

...	...	@@ -190,7 +190,9 @@ pub fn main() anyerror!void {
190	190	}
191	191
192	192	fn printUsageAndExit(arg0: []const u8) noreturn {
193		printUsage(std.debug.lockStderrWriter(&.{}), arg0) catch std.process.exit(2);
	193	const w, _ = std.debug.lockStderrWriter(&.{});
	194	defer std.debug.unlockStderrWriter();
	195	printUsage(w, arg0) catch std.process.exit(2);
194	196	std.process.exit(1);
195	197	}
196	198

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-10-28 12:42:05+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-10-30 09:31:28+00:00
log	74931fe25cdd94e1cd08b5ece9dcce19959bc079
tree	75449b1d594d55a872aeb03f2dd3be16ac396274
parent	74c23a237ef5245b63eb06b832a511aabeb715c0
signature	Commit is signed but in an unrecognized format.

std.debug.lockStderrWriter: also return ttyconf