From dd4eb86bc1614de29cdbdfee1c5dcbea78eee9c7 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 1 Jul 2025 16:35:19 -0700 Subject: [PATCH] sync --- src/InternPool.zig | 23 ++++++++----- src/crash_report.zig | 80 ++++++++++++++++++++++---------------------- src/link/SpirV.zig | 6 ++-- src/print_zir.zig | 26 +++++++------- src/print_zoir.zig | 6 ++-- 5 files changed, 73 insertions(+), 68 deletions(-) diff --git a/src/InternPool.zig b/src/InternPool.zig index 99696f5403..942a58684e 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -1887,18 +1887,23 @@ pub const NullTerminatedString = enum(u32) { const FormatData = struct { string: NullTerminatedString, ip: *const InternPool, + id: bool, }; - fn format(data: FormatData, bw: *std.io.Writer, comptime specifier: []const u8) std.io.Writer.Error!void { + fn format(data: FormatData, writer: *std.io.Writer) std.io.Writer.Error!void { const slice = data.string.toSlice(data.ip); - if (comptime std.mem.eql(u8, specifier, "")) { - try bw.writeAll(slice); - } else if (comptime std.mem.eql(u8, specifier, "i")) { - try bw.print("{fp}", .{std.zig.fmtId(slice)}); - } else @compileError("invalid format string '" ++ specifier ++ "' for '" ++ @typeName(NullTerminatedString) ++ "'"); + if (!data.id) { + try writer.writeAll(slice); + } else { + try writer.print("{f}", .{std.zig.fmtIdP(slice)}); + } } - pub fn fmt(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(format) { - return .{ .data = .{ .string = string, .ip = ip } }; + pub fn fmt(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(FormatData, format) { + return .{ .data = .{ .string = string, .ip = ip, .id = false } }; + } + + pub fn fmtId(string: NullTerminatedString, ip: *const InternPool) std.fmt.Formatter(FormatData, format) { + return .{ .data = .{ .string = string, .ip = ip, .id = true } }; } const debug_state = InternPool.debug_state; @@ -11409,7 +11414,7 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator) var it = instances.iterator(); while (it.next()) |entry| { const generic_fn_owner_nav = ip.getNav(ip.funcDeclInfo(entry.key_ptr.*).owner_nav); - try stderr_bw.print("{f} ({}): \n", .{ generic_fn_owner_nav.name.fmt(ip), entry.value_ptr.items.len }); + try stderr_bw.print("{f} ({d}): \n", .{ generic_fn_owner_nav.name.fmt(ip), entry.value_ptr.items.len }); for (entry.value_ptr.items) |index| { const unwrapped_index = index.unwrap(ip); const func = ip.extraFuncInstance(unwrapped_index.tid, unwrapped_index.getExtra(ip), unwrapped_index.getData(ip)); diff --git a/src/crash_report.zig b/src/crash_report.zig index 082da556fc..e5c31d42b5 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -80,19 +80,19 @@ fn dumpStatusReport() !void { var fba = std.heap.FixedBufferAllocator.init(&crash_heap); const allocator = fba.allocator(); - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; const block: *Sema.Block = anal.block; const zcu = anal.sema.pt.zcu; const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu) orelse { const file = zcu.fileByIndex(block.src_base_inst.resolveFile(&zcu.intern_pool)); - try stderr_bw.print("Analyzing lost instruction in file '{f}'. This should not happen!\n\n", .{file.path.fmt(zcu.comp)}); + try stderr.print("Analyzing lost instruction in file '{f}'. This should not happen!\n\n", .{file.path.fmt(zcu.comp)}); return; }; - try stderr_bw.writeAll("Analyzing "); - try stderr_bw.print("Analyzing '{f}'\n", .{file.path.fmt(zcu.comp)}); + try stderr.writeAll("Analyzing "); + try stderr.print("Analyzing '{f}'\n", .{file.path.fmt(zcu.comp)}); print_zir.renderInstructionContext( allocator, @@ -101,12 +101,12 @@ fn dumpStatusReport() !void { file, src_base_node, 6, // indent - &stderr_bw, + stderr, ) catch |err| switch (err) { - error.OutOfMemory => try stderr_bw.writeAll(" \n"), + error.OutOfMemory => try stderr.writeAll(" \n"), else => |e| return e, }; - try stderr_bw.print( + try stderr.print( \\ For full context, use the command \\ zig ast-check -t {f} \\ @@ -117,30 +117,30 @@ fn dumpStatusReport() !void { while (parent) |curr| { fba.reset(); const cur_block_file = zcu.fileByIndex(curr.block.src_base_inst.resolveFile(&zcu.intern_pool)); - try stderr_bw.print(" in {f}\n", .{cur_block_file.path.fmt(zcu.comp)}); + try stderr.print(" in {f}\n", .{cur_block_file.path.fmt(zcu.comp)}); _, const cur_block_src_base_node = Zcu.LazySrcLoc.resolveBaseNode(curr.block.src_base_inst, zcu) orelse { - try stderr_bw.writeAll(" > [lost instruction; this should not happen]\n"); + try stderr.writeAll(" > [lost instruction; this should not happen]\n"); parent = curr.parent; continue; }; - try stderr_bw.writeAll(" > "); + try stderr.writeAll(" > "); print_zir.renderSingleInstruction( allocator, curr.body[curr.body_index], cur_block_file, cur_block_src_base_node, 6, // indent - &stderr_bw, + stderr, ) catch |err| switch (err) { - error.OutOfMemory => try stderr_bw.writeAll(" \n"), + error.OutOfMemory => try stderr.writeAll(" \n"), else => |e| return e, }; - try stderr_bw.writeAll("\n"); + try stderr.writeAll("\n"); parent = curr.parent; } - try stderr_bw.writeByte('\n'); + try stderr.writeByte('\n'); } var crash_heap: [16 * 4096]u8 = undefined; @@ -269,9 +269,9 @@ const StackContext = union(enum) { debug.dumpCurrentStackTrace(ct.ret_addr); }, .exception => |context| { - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); - debug.dumpStackTraceFromBase(context, &stderr_bw); + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; + debug.dumpStackTraceFromBase(context, stderr); }, .not_supported => { std.fs.File.stderr().writeAll("Stack trace not supported on this platform.\n") catch {}; @@ -381,20 +381,20 @@ const PanicSwitch = struct { state.recover_stage = .release_mutex; - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; if (builtin.single_threaded) { - stderr_bw.print("panic: ", .{}) catch goTo(releaseMutex, .{state}); + stderr.print("panic: ", .{}) catch goTo(releaseMutex, .{state}); } else { const current_thread_id = std.Thread.getCurrentId(); - stderr_bw.print("thread {} panic: ", .{current_thread_id}) catch goTo(releaseMutex, .{state}); + stderr.print("thread {} panic: ", .{current_thread_id}) catch goTo(releaseMutex, .{state}); } - stderr_bw.print("{s}\n", .{msg}) catch goTo(releaseMutex, .{state}); + stderr.print("{s}\n", .{msg}) catch goTo(releaseMutex, .{state}); state.recover_stage = .report_stack; dumpStatusReport() catch |err| { - stderr_bw.print("\nIntercepted error.{} while dumping current state. Continuing...\n", .{err}) catch {}; + stderr.print("\nIntercepted error.{} while dumping current state. Continuing...\n", .{err}) catch {}; }; goTo(reportStack, .{state}); @@ -409,9 +409,9 @@ const PanicSwitch = struct { recover(state, trace, stack, msg); state.recover_stage = .release_mutex; - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); - stderr_bw.writeAll("\nOriginal Error:\n") catch {}; + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; + stderr.writeAll("\nOriginal Error:\n") catch {}; goTo(reportStack, .{state}); } @@ -481,9 +481,9 @@ const PanicSwitch = struct { recover(state, trace, stack, msg); state.recover_stage = .silent_abort; - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); - stderr_bw.writeAll("Aborting...\n") catch {}; + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; + stderr.writeAll("Aborting...\n") catch {}; goTo(abort, .{}); } @@ -510,11 +510,11 @@ const PanicSwitch = struct { // lower the verbosity, and restore it at the end if we don't panic. state.recover_verbosity = .message_only; - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); - stderr_bw.writeAll("\nPanicked during a panic: ") catch {}; - stderr_bw.writeAll(msg) catch {}; - stderr_bw.writeAll("\nInner panic stack:\n") catch {}; + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; + stderr.writeAll("\nPanicked during a panic: ") catch {}; + stderr.writeAll(msg) catch {}; + stderr.writeAll("\nInner panic stack:\n") catch {}; if (trace) |t| { debug.dumpStackTrace(t.*); } @@ -525,11 +525,11 @@ const PanicSwitch = struct { .message_only => { state.recover_verbosity = .silent; - var stderr_fw = std.fs.File.stderr().writer(); - var stderr_bw = stderr_fw.interface().unbuffered(); - stderr_bw.writeAll("\nPanicked while dumping inner panic stack: ") catch {}; - stderr_bw.writeAll(msg) catch {}; - stderr_bw.writeByte('\n') catch {}; + var stderr_fw = std.fs.File.stderr().writer(&.{}); + const stderr = &stderr_fw.interface; + stderr.writeAll("\nPanicked while dumping inner panic stack: ") catch {}; + stderr.writeAll(msg) catch {}; + stderr.writeByte('\n') catch {}; // If we succeed, restore all the way to dumping the stack. state.recover_verbosity = .message_and_stack; diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig index d2ad529972..c9a8a18843 100644 --- a/src/link/SpirV.zig +++ b/src/link/SpirV.zig @@ -206,7 +206,7 @@ pub fn flush( var error_info: std.io.Writer.Allocating = .init(self.object.gpa); defer error_info.deinit(); - try error_info.interface.writeAll("zig_errors:"); + try error_info.writer.writeAll("zig_errors:"); const ip = &self.base.comp.zcu.?.intern_pool; for (ip.global_error_set.getNamesFromMainThread()) |name| { // Errors can contain pretty much any character - to encode them in a string we must escape @@ -214,9 +214,9 @@ pub fn flush( // name if it contains no strange characters is nice for debugging. URI encoding fits the bill. // We're using : as separator, which is a reserved character. - try error_info.interface.writeByte(':'); + try error_info.writer.writeByte(':'); try std.Uri.Component.percentEncode( - &error_info.interface, + &error_info.writer, name.toSlice(ip), struct { fn isValidChar(c: u8) bool { diff --git a/src/print_zir.zig b/src/print_zir.zig index 61fa2f56cf..5a0c829a50 100644 --- a/src/print_zir.zig +++ b/src/print_zir.zig @@ -42,7 +42,7 @@ pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.io.Writer) !v const import_path = zir.nullTerminatedString(item.data.name); try bw.print(" @import(\"{f}\") ", .{ - std.zig.fmtEscapes(import_path), + std.zig.fmtString(import_path), }); try writer.writeSrcTokAbs(bw, item.data.token); try bw.writeAll("\n"); @@ -785,7 +785,7 @@ const Writer = struct { ) Error!void { const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str; const str = inst_data.get(self.code); - try stream.print("\"{f}\")", .{std.zig.fmtEscapes(str)}); + try stream.print("\"{f}\")", .{std.zig.fmtString(str)}); } fn writeSliceStart(self: *Writer, stream: *std.io.Writer, inst: Zir.Inst.Index) !void { @@ -942,7 +942,7 @@ const Writer = struct { const extra = self.code.extraData(Zir.Inst.Param, inst_data.payload_index); const body = self.code.bodySlice(extra.end, extra.data.type.body_len); try stream.print("\"{f}\", ", .{ - std.zig.fmtEscapes(self.code.nullTerminatedString(extra.data.name)), + std.zig.fmtString(self.code.nullTerminatedString(extra.data.name)), }); if (extra.data.type.is_generic) try stream.writeAll("[generic] "); @@ -1212,7 +1212,7 @@ const Writer = struct { try stream.writeAll(", "); } else { const asm_source = self.code.nullTerminatedString(extra.data.asm_source); - try stream.print("\"{f}\", ", .{std.zig.fmtEscapes(asm_source)}); + try stream.print("\"{f}\", ", .{std.zig.fmtString(asm_source)}); } try stream.writeAll(", "); @@ -1230,7 +1230,7 @@ const Writer = struct { const name = self.code.nullTerminatedString(output.data.name); const constraint = self.code.nullTerminatedString(output.data.constraint); try stream.print("output({fp}, \"{f}\", ", .{ - std.zig.fmtId(name), std.zig.fmtEscapes(constraint), + std.zig.fmtId(name), std.zig.fmtString(constraint), }); try self.writeFlag(stream, "->", is_type); try self.writeInstRef(stream, output.data.operand); @@ -1249,7 +1249,7 @@ const Writer = struct { const name = self.code.nullTerminatedString(input.data.name); const constraint = self.code.nullTerminatedString(input.data.constraint); try stream.print("input({fp}, \"{f}\", ", .{ - std.zig.fmtId(name), std.zig.fmtEscapes(constraint), + std.zig.fmtId(name), std.zig.fmtString(constraint), }); try self.writeInstRef(stream, input.data.operand); try stream.writeAll(")"); @@ -1308,7 +1308,7 @@ const Writer = struct { .field => { const field_name = self.code.nullTerminatedString(extra.data.field_name_start); try self.writeInstRef(stream, extra.data.obj_ptr); - try stream.print(", \"{f}\"", .{std.zig.fmtEscapes(field_name)}); + try stream.print(", \"{f}\"", .{std.zig.fmtString(field_name)}); }, } try stream.writeAll(", ["); @@ -2212,7 +2212,7 @@ const Writer = struct { const extra = self.code.extraData(Zir.Inst.Field, inst_data.payload_index).data; const name = self.code.nullTerminatedString(extra.field_name_start); try self.writeInstRef(stream, extra.lhs); - try stream.print(", \"{f}\") ", .{std.zig.fmtEscapes(name)}); + try stream.print(", \"{f}\") ", .{std.zig.fmtString(name)}); try self.writeSrcNode(stream, inst_data.src_node); } @@ -2253,7 +2253,7 @@ const Writer = struct { ) Error!void { const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; const str = inst_data.get(self.code); - try stream.print("\"{f}\") ", .{std.zig.fmtEscapes(str)}); + try stream.print("\"{f}\") ", .{std.zig.fmtString(str)}); try self.writeSrcTok(stream, inst_data.src_tok); } @@ -2261,7 +2261,7 @@ const Writer = struct { const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_op; const str = inst_data.getStr(self.code); try self.writeInstRef(stream, inst_data.operand); - try stream.print(", \"{f}\")", .{std.zig.fmtEscapes(str)}); + try stream.print(", \"{f}\")", .{std.zig.fmtString(str)}); } fn writeFunc( @@ -2703,10 +2703,10 @@ const Writer = struct { try self.writeInstIndex(stream, ptr_inst); }, .decl_val => |str| try stream.print("decl_val \"{f}\"", .{ - std.zig.fmtEscapes(self.code.nullTerminatedString(str)), + std.zig.fmtString(self.code.nullTerminatedString(str)), }), .decl_ref => |str| try stream.print("decl_ref \"{f}\"", .{ - std.zig.fmtEscapes(self.code.nullTerminatedString(str)), + std.zig.fmtString(self.code.nullTerminatedString(str)), }), } } @@ -2839,7 +2839,7 @@ const Writer = struct { const extra = self.code.extraData(Zir.Inst.Import, inst_data.payload_index).data; try self.writeInstRef(stream, extra.res_ty); const import_path = self.code.nullTerminatedString(extra.path); - try stream.print(", \"{f}\") ", .{std.zig.fmtEscapes(import_path)}); + try stream.print(", \"{f}\") ", .{std.zig.fmtString(import_path)}); try self.writeSrcTok(stream, inst_data.src_tok); } }; diff --git a/src/print_zoir.zig b/src/print_zoir.zig index 3828726437..df587fd365 100644 --- a/src/print_zoir.zig +++ b/src/print_zoir.zig @@ -72,8 +72,8 @@ const PrintZon = struct { }, .float_literal => |x| try pz.w.print("float({d})", .{x}), .char_literal => |x| try pz.w.print("char({d})", .{x}), - .enum_literal => |x| try pz.w.print("enum_literal({fp})", .{std.zig.fmtId(x.get(zoir))}), - .string_literal => |x| try pz.w.print("str(\"{f}\")", .{std.zig.fmtEscapes(x)}), + .enum_literal => |x| try pz.w.print("enum_literal({f})", .{std.zig.fmtIdP(x.get(zoir))}), + .string_literal => |x| try pz.w.print("str(\"{f}\")", .{std.zig.fmtString(x)}), .empty_literal => try pz.w.writeAll("empty_literal(.{})"), .array_literal => |vals| { try pz.w.writeAll("array_literal({"); @@ -92,7 +92,7 @@ const PrintZon = struct { pz.indent += 1; for (s.names, 0..s.vals.len) |name, idx| { try pz.newline(); - try pz.w.print("[{fp}] ", .{std.zig.fmtId(name.get(zoir))}); + try pz.w.print("[{f}] ", .{std.zig.fmtIdP(name.get(zoir))}); try pz.renderNode(s.vals.at(@intCast(idx))); try pz.w.writeByte(','); }