authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:19-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:30-07:00
logdd4eb86bc1614de29cdbdfee1c5dcbea78eee9c7
tree4159c0f6c08749da6feec42652f40d8c65856cf1
parentc9915e949ebd4aa0d4d24ef5808ba0b1cff2ecfe

sync

5 files changed, 73 insertions(+), 68 deletions(-)

src/InternPool.zig+14-9
......@@ -1887,18 +1887,23 @@ pub const NullTerminatedString = enum(u32) {
18871887 const FormatData = struct {
18881888 string: NullTerminatedString,
18891889 ip: *const InternPool,
1890 id: bool,
18901891 };
1891 fn format(data: FormatData, bw: *std.io.Writer, comptime specifier: []const u8) std.io.Writer.Error!void {
1892 fn format(data: FormatData, writer: *std.io.Writer) std.io.Writer.Error!void {
18921893 const slice = data.string.toSlice(data.ip);
1893 if (comptime std.mem.eql(u8, specifier, "")) {
1894 try bw.writeAll(slice);
1895 } else if (comptime std.mem.eql(u8, specifier, "i")) {
1896 try bw.print("{fp}", .{std.zig.fmtId(slice)});
1897 } else @compileError("invalid format string '" ++ specifier ++ "' for '" ++ @typeName(NullTerminatedString) ++ "'");
1894 if (!data.id) {
1895 try writer.writeAll(slice);
1896 } else {
1897 try writer.print("{f}", .{std.zig.fmtIdP(slice)});
1898 }
1899 }
1900
1901 pub fn fmt(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(FormatData, format) {
1902 return .{ .data = .{ .string = string, .ip = ip, .id = false } };
18981903 }
18991904
1900 pub fn fmt(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(format) {
1901 return .{ .data = .{ .string = string, .ip = ip } };
1905 pub fn fmtId(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(FormatData, format) {
1906 return .{ .data = .{ .string = string, .ip = ip, .id = true } };
19021907 }
19031908
19041909 const debug_state = InternPool.debug_state;
......@@ -11409,7 +11414,7 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator)
1140911414 var it = instances.iterator();
1141011415 while (it.next()) |entry| {
1141111416 const generic_fn_owner_nav = ip.getNav(ip.funcDeclInfo(entry.key_ptr.*).owner_nav);
11412 try stderr_bw.print("{f} ({}): \n", .{ generic_fn_owner_nav.name.fmt(ip), entry.value_ptr.items.len });
11417 try stderr_bw.print("{f} ({d}): \n", .{ generic_fn_owner_nav.name.fmt(ip), entry.value_ptr.items.len });
1141311418 for (entry.value_ptr.items) |index| {
1141411419 const unwrapped_index = index.unwrap(ip);
1141511420 const func = ip.extraFuncInstance(unwrapped_index.tid, unwrapped_index.getExtra(ip), unwrapped_index.getData(ip));
src/crash_report.zig+40-40
......@@ -80,19 +80,19 @@ fn dumpStatusReport() !void {
8080 var fba = std.heap.FixedBufferAllocator.init(&crash_heap);
8181 const allocator = fba.allocator();
8282
83 var stderr_fw = std.fs.File.stderr().writer();
84 var stderr_bw = stderr_fw.interface().unbuffered();
83 var stderr_fw = std.fs.File.stderr().writer(&.{});
84 const stderr = &stderr_fw.interface;
8585 const block: *Sema.Block = anal.block;
8686 const zcu = anal.sema.pt.zcu;
8787
8888 const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu) orelse {
8989 const file = zcu.fileByIndex(block.src_base_inst.resolveFile(&zcu.intern_pool));
90 try stderr_bw.print("Analyzing lost instruction in file '{f}'. This should not happen!\n\n", .{file.path.fmt(zcu.comp)});
90 try stderr.print("Analyzing lost instruction in file '{f}'. This should not happen!\n\n", .{file.path.fmt(zcu.comp)});
9191 return;
9292 };
9393
94 try stderr_bw.writeAll("Analyzing ");
95 try stderr_bw.print("Analyzing '{f}'\n", .{file.path.fmt(zcu.comp)});
94 try stderr.writeAll("Analyzing ");
95 try stderr.print("Analyzing '{f}'\n", .{file.path.fmt(zcu.comp)});
9696
9797 print_zir.renderInstructionContext(
9898 allocator,
......@@ -101,12 +101,12 @@ fn dumpStatusReport() !void {
101101 file,
102102 src_base_node,
103103 6, // indent
104 &stderr_bw,
104 stderr,
105105 ) catch |err| switch (err) {
106 error.OutOfMemory => try stderr_bw.writeAll(" <out of memory dumping zir>\n"),
106 error.OutOfMemory => try stderr.writeAll(" <out of memory dumping zir>\n"),
107107 else => |e| return e,
108108 };
109 try stderr_bw.print(
109 try stderr.print(
110110 \\ For full context, use the command
111111 \\ zig ast-check -t {f}
112112 \\
......@@ -117,30 +117,30 @@ fn dumpStatusReport() !void {
117117 while (parent) |curr| {
118118 fba.reset();
119119 const cur_block_file = zcu.fileByIndex(curr.block.src_base_inst.resolveFile(&zcu.intern_pool));
120 try stderr_bw.print(" in {f}\n", .{cur_block_file.path.fmt(zcu.comp)});
120 try stderr.print(" in {f}\n", .{cur_block_file.path.fmt(zcu.comp)});
121121 _, const cur_block_src_base_node = Zcu.LazySrcLoc.resolveBaseNode(curr.block.src_base_inst, zcu) orelse {
122 try stderr_bw.writeAll(" > [lost instruction; this should not happen]\n");
122 try stderr.writeAll(" > [lost instruction; this should not happen]\n");
123123 parent = curr.parent;
124124 continue;
125125 };
126 try stderr_bw.writeAll(" > ");
126 try stderr.writeAll(" > ");
127127 print_zir.renderSingleInstruction(
128128 allocator,
129129 curr.body[curr.body_index],
130130 cur_block_file,
131131 cur_block_src_base_node,
132132 6, // indent
133 &stderr_bw,
133 stderr,
134134 ) catch |err| switch (err) {
135 error.OutOfMemory => try stderr_bw.writeAll(" <out of memory dumping zir>\n"),
135 error.OutOfMemory => try stderr.writeAll(" <out of memory dumping zir>\n"),
136136 else => |e| return e,
137137 };
138 try stderr_bw.writeAll("\n");
138 try stderr.writeAll("\n");
139139
140140 parent = curr.parent;
141141 }
142142
143 try stderr_bw.writeByte('\n');
143 try stderr.writeByte('\n');
144144}
145145
146146var crash_heap: [16 * 4096]u8 = undefined;
......@@ -269,9 +269,9 @@ const StackContext = union(enum) {
269269 debug.dumpCurrentStackTrace(ct.ret_addr);
270270 },
271271 .exception => |context| {
272 var stderr_fw = std.fs.File.stderr().writer();
273 var stderr_bw = stderr_fw.interface().unbuffered();
274 debug.dumpStackTraceFromBase(context, &stderr_bw);
272 var stderr_fw = std.fs.File.stderr().writer(&.{});
273 const stderr = &stderr_fw.interface;
274 debug.dumpStackTraceFromBase(context, stderr);
275275 },
276276 .not_supported => {
277277 std.fs.File.stderr().writeAll("Stack trace not supported on this platform.\n") catch {};
......@@ -381,20 +381,20 @@ const PanicSwitch = struct {
381381
382382 state.recover_stage = .release_mutex;
383383
384 var stderr_fw = std.fs.File.stderr().writer();
385 var stderr_bw = stderr_fw.interface().unbuffered();
384 var stderr_fw = std.fs.File.stderr().writer(&.{});
385 const stderr = &stderr_fw.interface;
386386 if (builtin.single_threaded) {
387 stderr_bw.print("panic: ", .{}) catch goTo(releaseMutex, .{state});
387 stderr.print("panic: ", .{}) catch goTo(releaseMutex, .{state});
388388 } else {
389389 const current_thread_id = std.Thread.getCurrentId();
390 stderr_bw.print("thread {} panic: ", .{current_thread_id}) catch goTo(releaseMutex, .{state});
390 stderr.print("thread {} panic: ", .{current_thread_id}) catch goTo(releaseMutex, .{state});
391391 }
392 stderr_bw.print("{s}\n", .{msg}) catch goTo(releaseMutex, .{state});
392 stderr.print("{s}\n", .{msg}) catch goTo(releaseMutex, .{state});
393393
394394 state.recover_stage = .report_stack;
395395
396396 dumpStatusReport() catch |err| {
397 stderr_bw.print("\nIntercepted error.{} while dumping current state. Continuing...\n", .{err}) catch {};
397 stderr.print("\nIntercepted error.{} while dumping current state. Continuing...\n", .{err}) catch {};
398398 };
399399
400400 goTo(reportStack, .{state});
......@@ -409,9 +409,9 @@ const PanicSwitch = struct {
409409 recover(state, trace, stack, msg);
410410
411411 state.recover_stage = .release_mutex;
412 var stderr_fw = std.fs.File.stderr().writer();
413 var stderr_bw = stderr_fw.interface().unbuffered();
414 stderr_bw.writeAll("\nOriginal Error:\n") catch {};
412 var stderr_fw = std.fs.File.stderr().writer(&.{});
413 const stderr = &stderr_fw.interface;
414 stderr.writeAll("\nOriginal Error:\n") catch {};
415415 goTo(reportStack, .{state});
416416 }
417417
......@@ -481,9 +481,9 @@ const PanicSwitch = struct {
481481 recover(state, trace, stack, msg);
482482
483483 state.recover_stage = .silent_abort;
484 var stderr_fw = std.fs.File.stderr().writer();
485 var stderr_bw = stderr_fw.interface().unbuffered();
486 stderr_bw.writeAll("Aborting...\n") catch {};
484 var stderr_fw = std.fs.File.stderr().writer(&.{});
485 const stderr = &stderr_fw.interface;
486 stderr.writeAll("Aborting...\n") catch {};
487487 goTo(abort, .{});
488488 }
489489
......@@ -510,11 +510,11 @@ const PanicSwitch = struct {
510510 // lower the verbosity, and restore it at the end if we don't panic.
511511 state.recover_verbosity = .message_only;
512512
513 var stderr_fw = std.fs.File.stderr().writer();
514 var stderr_bw = stderr_fw.interface().unbuffered();
515 stderr_bw.writeAll("\nPanicked during a panic: ") catch {};
516 stderr_bw.writeAll(msg) catch {};
517 stderr_bw.writeAll("\nInner panic stack:\n") catch {};
513 var stderr_fw = std.fs.File.stderr().writer(&.{});
514 const stderr = &stderr_fw.interface;
515 stderr.writeAll("\nPanicked during a panic: ") catch {};
516 stderr.writeAll(msg) catch {};
517 stderr.writeAll("\nInner panic stack:\n") catch {};
518518 if (trace) |t| {
519519 debug.dumpStackTrace(t.*);
520520 }
......@@ -525,11 +525,11 @@ const PanicSwitch = struct {
525525 .message_only => {
526526 state.recover_verbosity = .silent;
527527
528 var stderr_fw = std.fs.File.stderr().writer();
529 var stderr_bw = stderr_fw.interface().unbuffered();
530 stderr_bw.writeAll("\nPanicked while dumping inner panic stack: ") catch {};
531 stderr_bw.writeAll(msg) catch {};
532 stderr_bw.writeByte('\n') catch {};
528 var stderr_fw = std.fs.File.stderr().writer(&.{});
529 const stderr = &stderr_fw.interface;
530 stderr.writeAll("\nPanicked while dumping inner panic stack: ") catch {};
531 stderr.writeAll(msg) catch {};
532 stderr.writeByte('\n') catch {};
533533
534534 // If we succeed, restore all the way to dumping the stack.
535535 state.recover_verbosity = .message_and_stack;
src/link/SpirV.zig+3-3
......@@ -206,7 +206,7 @@ pub fn flush(
206206 var error_info: std.io.Writer.Allocating = .init(self.object.gpa);
207207 defer error_info.deinit();
208208
209 try error_info.interface.writeAll("zig_errors:");
209 try error_info.writer.writeAll("zig_errors:");
210210 const ip = &self.base.comp.zcu.?.intern_pool;
211211 for (ip.global_error_set.getNamesFromMainThread()) |name| {
212212 // Errors can contain pretty much any character - to encode them in a string we must escape
......@@ -214,9 +214,9 @@ pub fn flush(
214214 // name if it contains no strange characters is nice for debugging. URI encoding fits the bill.
215215 // We're using : as separator, which is a reserved character.
216216
217 try error_info.interface.writeByte(':');
217 try error_info.writer.writeByte(':');
218218 try std.Uri.Component.percentEncode(
219 &error_info.interface,
219 &error_info.writer,
220220 name.toSlice(ip),
221221 struct {
222222 fn isValidChar(c: u8) bool {
src/print_zir.zig+13-13
......@@ -42,7 +42,7 @@ pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.io.Writer) !v
4242
4343 const import_path = zir.nullTerminatedString(item.data.name);
4444 try bw.print(" @import(\"{f}\") ", .{
45 std.zig.fmtEscapes(import_path),
45 std.zig.fmtString(import_path),
4646 });
4747 try writer.writeSrcTokAbs(bw, item.data.token);
4848 try bw.writeAll("\n");
......@@ -785,7 +785,7 @@ const Writer = struct {
785785 ) Error!void {
786786 const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str;
787787 const str = inst_data.get(self.code);
788 try stream.print("\"{f}\")", .{std.zig.fmtEscapes(str)});
788 try stream.print("\"{f}\")", .{std.zig.fmtString(str)});
789789 }
790790
791791 fn writeSliceStart(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void {
......@@ -942,7 +942,7 @@ const Writer = struct {
942942 const extra = self.code.extraData(Zir.Inst.Param, inst_data.payload_index);
943943 const body = self.code.bodySlice(extra.end, extra.data.type.body_len);
944944 try stream.print("\"{f}\", ", .{
945 std.zig.fmtEscapes(self.code.nullTerminatedString(extra.data.name)),
945 std.zig.fmtString(self.code.nullTerminatedString(extra.data.name)),
946946 });
947947
948948 if (extra.data.type.is_generic) try stream.writeAll("[generic] ");
......@@ -1212,7 +1212,7 @@ const Writer = struct {
12121212 try stream.writeAll(", ");
12131213 } else {
12141214 const asm_source = self.code.nullTerminatedString(extra.data.asm_source);
1215 try stream.print("\"{f}\", ", .{std.zig.fmtEscapes(asm_source)});
1215 try stream.print("\"{f}\", ", .{std.zig.fmtString(asm_source)});
12161216 }
12171217 try stream.writeAll(", ");
12181218
......@@ -1230,7 +1230,7 @@ const Writer = struct {
12301230 const name = self.code.nullTerminatedString(output.data.name);
12311231 const constraint = self.code.nullTerminatedString(output.data.constraint);
12321232 try stream.print("output({fp}, \"{f}\", ", .{
1233 std.zig.fmtId(name), std.zig.fmtEscapes(constraint),
1233 std.zig.fmtId(name), std.zig.fmtString(constraint),
12341234 });
12351235 try self.writeFlag(stream, "->", is_type);
12361236 try self.writeInstRef(stream, output.data.operand);
......@@ -1249,7 +1249,7 @@ const Writer = struct {
12491249 const name = self.code.nullTerminatedString(input.data.name);
12501250 const constraint = self.code.nullTerminatedString(input.data.constraint);
12511251 try stream.print("input({fp}, \"{f}\", ", .{
1252 std.zig.fmtId(name), std.zig.fmtEscapes(constraint),
1252 std.zig.fmtId(name), std.zig.fmtString(constraint),
12531253 });
12541254 try self.writeInstRef(stream, input.data.operand);
12551255 try stream.writeAll(")");
......@@ -1308,7 +1308,7 @@ const Writer = struct {
13081308 .field => {
13091309 const field_name = self.code.nullTerminatedString(extra.data.field_name_start);
13101310 try self.writeInstRef(stream, extra.data.obj_ptr);
1311 try stream.print(", \"{f}\"", .{std.zig.fmtEscapes(field_name)});
1311 try stream.print(", \"{f}\"", .{std.zig.fmtString(field_name)});
13121312 },
13131313 }
13141314 try stream.writeAll(", [");
......@@ -2212,7 +2212,7 @@ const Writer = struct {
22122212 const extra = self.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
22132213 const name = self.code.nullTerminatedString(extra.field_name_start);
22142214 try self.writeInstRef(stream, extra.lhs);
2215 try stream.print(", \"{f}\") ", .{std.zig.fmtEscapes(name)});
2215 try stream.print(", \"{f}\") ", .{std.zig.fmtString(name)});
22162216 try self.writeSrcNode(stream, inst_data.src_node);
22172217 }
22182218
......@@ -2253,7 +2253,7 @@ const Writer = struct {
22532253 ) Error!void {
22542254 const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
22552255 const str = inst_data.get(self.code);
2256 try stream.print("\"{f}\") ", .{std.zig.fmtEscapes(str)});
2256 try stream.print("\"{f}\") ", .{std.zig.fmtString(str)});
22572257 try self.writeSrcTok(stream, inst_data.src_tok);
22582258 }
22592259
......@@ -2261,7 +2261,7 @@ const Writer = struct {
22612261 const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_op;
22622262 const str = inst_data.getStr(self.code);
22632263 try self.writeInstRef(stream, inst_data.operand);
2264 try stream.print(", \"{f}\")", .{std.zig.fmtEscapes(str)});
2264 try stream.print(", \"{f}\")", .{std.zig.fmtString(str)});
22652265 }
22662266
22672267 fn writeFunc(
......@@ -2703,10 +2703,10 @@ const Writer = struct {
27032703 try self.writeInstIndex(stream, ptr_inst);
27042704 },
27052705 .decl_val => |str| try stream.print("decl_val \"{f}\"", .{
2706 std.zig.fmtEscapes(self.code.nullTerminatedString(str)),
2706 std.zig.fmtString(self.code.nullTerminatedString(str)),
27072707 }),
27082708 .decl_ref => |str| try stream.print("decl_ref \"{f}\"", .{
2709 std.zig.fmtEscapes(self.code.nullTerminatedString(str)),
2709 std.zig.fmtString(self.code.nullTerminatedString(str)),
27102710 }),
27112711 }
27122712 }
......@@ -2839,7 +2839,7 @@ const Writer = struct {
28392839 const extra = self.code.extraData(Zir.Inst.Import, inst_data.payload_index).data;
28402840 try self.writeInstRef(stream, extra.res_ty);
28412841 const import_path = self.code.nullTerminatedString(extra.path);
2842 try stream.print(", \"{f}\") ", .{std.zig.fmtEscapes(import_path)});
2842 try stream.print(", \"{f}\") ", .{std.zig.fmtString(import_path)});
28432843 try self.writeSrcTok(stream, inst_data.src_tok);
28442844 }
28452845};
src/print_zoir.zig+3-3
......@@ -72,8 +72,8 @@ const PrintZon = struct {
7272 },
7373 .float_literal => |x| try pz.w.print("float({d})", .{x}),
7474 .char_literal => |x| try pz.w.print("char({d})", .{x}),
75 .enum_literal => |x| try pz.w.print("enum_literal({fp})", .{std.zig.fmtId(x.get(zoir))}),
76 .string_literal => |x| try pz.w.print("str(\"{f}\")", .{std.zig.fmtEscapes(x)}),
75 .enum_literal => |x| try pz.w.print("enum_literal({f})", .{std.zig.fmtIdP(x.get(zoir))}),
76 .string_literal => |x| try pz.w.print("str(\"{f}\")", .{std.zig.fmtString(x)}),
7777 .empty_literal => try pz.w.writeAll("empty_literal(.{})"),
7878 .array_literal => |vals| {
7979 try pz.w.writeAll("array_literal({");
......@@ -92,7 +92,7 @@ const PrintZon = struct {
9292 pz.indent += 1;
9393 for (s.names, 0..s.vals.len) |name, idx| {
9494 try pz.newline();
95 try pz.w.print("[{fp}] ", .{std.zig.fmtId(name.get(zoir))});
95 try pz.w.print("[{f}] ", .{std.zig.fmtIdP(name.get(zoir))});
9696 try pz.renderNode(s.vals.at(@intCast(idx)));
9797 try pz.w.writeByte(',');
9898 }