From 94ff38af87e9784fc78ad3186553c953860659c4 Mon Sep 17 00:00:00 2001
From: Mason Remaley <mason@gamesbymason.com>
Date: Wed, 8 Apr 2026 13:49:44 -0700
Subject: [PATCH] Separates error return traces from stack traces

Doesn't commit the changes to stage1, we can generate those at the end
once we're not making any more changes to it to avoid wasting storage.
---
 doc/langref.html.in                           |  2 +-
 lib/build-web/main.zig                        |  2 +-
 lib/docs/wasm/main.zig                        |  2 +-
 lib/std/Build/Step.zig                        |  2 +-
 lib/std/builtin.zig                           |  5 +-
 lib/std/debug.zig                             | 51 +++++++++++++------
 lib/std/heap/debug_allocator.zig              |  6 +--
 lib/std/start.zig                             |  2 +-
 lib/std/testing/FailingAllocator.zig          |  2 +-
 src/Sema.zig                                  | 45 ++++++++--------
 src/Zcu.zig                                   |  4 +-
 src/codegen/llvm.zig                          |  2 +-
 .../panic_has_source_location.zig             |  2 +-
 test/cases/disable_stack_tracing.zig          |  2 +-
 test/cases/safety/@alignCast misaligned.zig   |  2 +-
 .../@enumFromInt - no matching tag value.zig  |  2 +-
 ...numFromInt truncated bits - exhaustive.zig |  2 +-
 ...FromInt truncated bits - nonexhaustive.zig |  2 +-
 ...rCast error not present in destination.zig |  2 +-
 ...ast error union casted to disjoint set.zig |  2 +-
 test/cases/safety/@intCast to u0.zig          |  2 +-
 ...at cannot fit - boundary case - i0 max.zig |  2 +-
 ...at cannot fit - boundary case - i0 min.zig |  2 +-
 ...annot fit - boundary case - signed max.zig |  2 +-
 ...annot fit - boundary case - signed min.zig |  2 +-
 ...at cannot fit - boundary case - u0 max.zig |  2 +-
 ...at cannot fit - boundary case - u0 min.zig |  2 +-
 ...not fit - boundary case - unsigned max.zig |  2 +-
 ...not fit - boundary case - unsigned min.zig |  2 +-
 ...annot fit - boundary case - vector max.zig |  2 +-
 ...annot fit - boundary case - vector min.zig |  2 +-
 ...oat cannot fit - negative out of range.zig |  2 +-
 ...loat cannot fit - negative to unsigned.zig |  2 +-
 ...oat cannot fit - positive out of range.zig |  2 +-
 ...o to non-optional byte-aligned pointer.zig |  2 +-
 ...t address zero to non-optional pointer.zig |  2 +-
 .../@ptrFromInt with misaligned address.zig   |  2 +-
 .../@tagName on corrupted enum value.zig      |  2 +-
 .../@tagName on corrupted union value.zig     |  2 +-
 .../array slice sentinel mismatch vector.zig  |  2 +-
 .../safety/array slice sentinel mismatch.zig  |  2 +-
 test/cases/safety/bad union field access.zig  |  2 +-
 test/cases/safety/calling panic.zig           |  2 +-
 ...ast []u8 to bigger slice of wrong size.zig |  2 +-
 ...er to global error and no code matches.zig |  2 +-
 ...mpty slice with sentinel out of bounds.zig |  2 +-
 .../exact division failure - vectors.zig      |  2 +-
 test/cases/safety/exact division failure.zig  |  2 +-
 test/cases/safety/for_len_mismatch.zig        |  2 +-
 test/cases/safety/for_len_mismatch_three.zig  |  2 +-
 .../ignored expression integer overflow.zig   |  2 +-
 .../safety/integer addition overflow.zig      |  2 +-
 .../integer division by zero - vectors.zig    |  2 +-
 .../cases/safety/integer division by zero.zig |  2 +-
 .../integer multiplication overflow.zig       |  2 +-
 .../safety/integer negation overflow.zig      |  2 +-
 .../safety/integer subtraction overflow.zig   |  2 +-
 test/cases/safety/memcpy_alias.zig            |  2 +-
 test/cases/safety/memcpy_len_mismatch.zig     |  2 +-
 test/cases/safety/memmove_len_mismatch.zig    |  2 +-
 .../safety/memset_array_undefined_bytes.zig   |  2 +-
 .../safety/memset_array_undefined_large.zig   |  2 +-
 .../safety/memset_slice_undefined_bytes.zig   |  2 +-
 .../safety/memset_slice_undefined_large.zig   |  2 +-
 test/cases/safety/modrem by zero.zig          |  2 +-
 test/cases/safety/modulus by zero.zig         |  2 +-
 test/cases/safety/noreturn returned.zig       |  2 +-
 .../optional unwrap operator on C pointer.zig |  2 +-
 ...tional unwrap operator on null pointer.zig |  2 +-
 .../cases/safety/optional_empty_error_set.zig |  2 +-
 .../out of bounds array slice by length.zig   |  2 +-
 .../safety/out of bounds slice access.zig     |  2 +-
 ...r casting null to non-optional pointer.zig |  2 +-
 ...inter casting to null function pointer.zig |  2 +-
 .../pointer slice sentinel mismatch.zig       |  2 +-
 .../safety/remainder division by zero.zig     |  2 +-
 .../safety/shift left by huge amount.zig      |  2 +-
 .../safety/shift right by huge amount.zig     |  2 +-
 ...ed integer division overflow - vectors.zig |  2 +-
 .../signed integer division overflow.zig      |  2 +-
 ...in cast to unsigned integer - widening.zig |  2 +-
 ...ot fitting in cast to unsigned integer.zig |  2 +-
 .../safety/signed shift left overflow.zig     |  2 +-
 .../safety/signed shift right overflow.zig    |  2 +-
 .../safety/signed-unsigned vector cast.zig    |  2 +-
 ...ice by length sentinel mismatch on lhs.zig |  2 +-
 ...ice by length sentinel mismatch on rhs.zig |  2 +-
 .../slice sentinel mismatch - floats.zig      |  2 +-
 ... sentinel mismatch - optional pointers.zig |  2 +-
 .../safety/slice slice sentinel mismatch.zig  |  2 +-
 ...ice start index greater than end index.zig |  2 +-
 ...h sentinel out of bounds - runtime len.zig |  2 +-
 .../slice with sentinel out of bounds.zig     |  2 +-
 test/cases/safety/slice_cast_change_len_0.zig |  2 +-
 test/cases/safety/slice_cast_change_len_1.zig |  2 +-
 test/cases/safety/slice_cast_change_len_2.zig |  2 +-
 .../slicing null C pointer - runtime len.zig  |  2 +-
 test/cases/safety/slicing null C pointer.zig  |  2 +-
 ...else on corrupt enum value - one prong.zig |  2 +-
 ...tch else on corrupt enum value - union.zig |  2 +-
 .../switch else on corrupt enum value.zig     |  2 +-
 .../safety/switch on corrupted enum value.zig |  2 +-
 .../switch on corrupted union value.zig       |  2 +-
 test/cases/safety/truncating vector cast.zig  |  2 +-
 test/cases/safety/unreachable.zig             |  2 +-
 ...ast to signed integer - same bit count.zig |  2 +-
 .../safety/unsigned shift left overflow.zig   |  2 +-
 .../safety/unsigned shift right overflow.zig  |  2 +-
 .../safety/unsigned-signed vector cast.zig    |  2 +-
 test/cases/safety/unwrap error switch.zig     |  2 +-
 test/cases/safety/unwrap error.zig            |  2 +-
 ...e does not fit in shortening cast - u0.zig |  2 +-
 .../value does not fit in shortening cast.zig |  2 +-
 .../vector integer addition overflow.zig      |  2 +-
 ...vector integer multiplication overflow.zig |  2 +-
 .../vector integer negation overflow.zig      |  2 +-
 .../vector integer subtraction overflow.zig   |  2 +-
 test/cases/safety/zero casted to error.zig    |  2 +-
 test/cases/tail_call_noreturn.zig             |  4 +-
 test/stack_traces.zig                         | 18 +++----
 test/standalone/compile_asm/main.zig          |  2 +-
 test/standalone/issue_339/test.zig            |  2 +-
 test/tests.zig                                |  2 +-
 123 files changed, 190 insertions(+), 175 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 9f32e05896e3eccf237f6388b79198f65c90a0b8..0d2564a23935821462732926d5fb647233f09b2e 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -4900,7 +4900,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_close#}
 
       {#header_open|@errorReturnTrace#}
-      <pre>{#syntax#}@errorReturnTrace() ?*builtin.StackTrace{#endsyntax#}</pre>
+      <pre>{#syntax#}@errorReturnTrace() ?*builtin.ErrorReturnTrace{#endsyntax#}</pre>
       <p>
       If the binary is built with error return tracing, and this function is invoked in a
       function that calls a function with an error or error union return type, returns a
diff --git a/lib/build-web/main.zig b/lib/build-web/main.zig
index e71c47707b2a5fa6f93df8398ccf7778c1a81b9d..5899e5626563f9d82721569479e38e81abfada4f 100644
--- a/lib/build-web/main.zig
+++ b/lib/build-web/main.zig
@@ -40,7 +40,7 @@ pub const std_options: std.Options = .{
     .logFn = logFn,
 };
 
-pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn {
+pub fn panic(msg: []const u8, st: ?*std.debug.StackTrace, addr: ?usize) noreturn {
     _ = st;
     _ = addr;
     log.err("panic: {s}", .{msg});
diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index bee3e4acbcc370261f3b137d40584ea2ad2f8065..dadc6a34926debd48caa1de9500c818ce329b38f 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -33,7 +33,7 @@ pub const std_options: std.Options = .{
     //.log_level = .debug,
 };
 
-pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn {
+pub fn panic(msg: []const u8, st: ?*std.debug.StackTrace, addr: ?usize) noreturn {
     _ = st;
     _ = addr;
     log.err("panic: {s}", .{msg});
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index 9df1b9d0383db5fa8cdc582d6c7bc6e466132781..5d86a0d018d636424ae252c2068ea82ac7cde723 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -67,7 +67,7 @@ test_results: TestResults,
 
 /// The return address associated with creation of this step that can be useful
 /// to print along with debugging messages.
-debug_stack_trace: std.builtin.StackTrace,
+debug_stack_trace: std.debug.StackTrace,
 
 pub const TestResults = struct {
     /// The total number of tests in the step. Every test has a "status" from the following:
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index addfa166b3bc8043e1ac45a55373d40fcf237b75..04959733c1b6adb7f8b71bccff2a1fad43e85b5c 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -8,12 +8,9 @@ pub const assembly = @import("builtin/assembly.zig");
 
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const StackTrace = struct {
+pub const ErrorReturnTrace = struct {
     index: usize,
     instruction_addresses: []usize,
-    /// Set to true if inlined frames are given their own entries in `instruction_addresses`,
-    /// otherwise set to false.
-    includes_inlined_frames: bool,
 };
 
 /// This data structure is used by the Zig language code generation and
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index ef9b2c2b6cc71e3e763a334d9d1679d653f3e333..c10cdf949ec5c1d893e63447c112055f7e55964b 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -13,7 +13,6 @@ const windows = std.os.windows;
 const builtin = @import("builtin");
 const native_arch = builtin.cpu.arch;
 const native_os = builtin.os.tag;
-const StackTrace = std.builtin.StackTrace;
 
 const root = @import("root");
 
@@ -568,7 +567,7 @@ pub fn defaultPanic(msg: []const u8, first_trace_addr: ?usize) noreturn {
 
                 if (@errorReturnTrace()) |t| if (t.index > 0) {
                     writer.writeAll("error return context:\n") catch break :trace;
-                    writeStackTrace(t, stderr) catch break :trace;
+                    writeErrorReturnTrace(t, stderr) catch break :trace;
                     writer.writeAll("\nstack trace:\n") catch break :trace;
                 };
                 writeCurrentStackTrace(.{
@@ -607,6 +606,13 @@ fn waitForOtherThreadToFinishPanicking() void {
     }
 }
 
+/// This data structure is used by the Zig language code generation and
+/// therefore must be kept in sync with the compiler implementation.
+pub const StackTrace = struct {
+    index: usize,
+    instruction_addresses: []usize,
+};
+
 pub const StackUnwindOptions = struct {
     /// If not `null`, we will ignore all frames up until this return address. This is typically
     /// used to omit intermediate handling code (for instance, a panic handler and its machinery)
@@ -629,7 +635,6 @@ pub noinline fn captureCurrentStackTrace(options: StackUnwindOptions, addr_buf:
     const empty_trace: StackTrace = .{
         .index = 0,
         .instruction_addresses = &.{},
-        .includes_inlined_frames = false,
     };
     if (!std.options.allow_stack_tracing) return empty_trace;
     var it: StackIterator = .init(options.context);
@@ -665,7 +670,6 @@ pub noinline fn captureCurrentStackTrace(options: StackUnwindOptions, addr_buf:
     return .{
         .index = index,
         .instruction_addresses = addr_buf[0..index],
-        .includes_inlined_frames = false,
     };
 }
 /// Write the current stack trace to `writer`, annotated with source locations.
@@ -752,7 +756,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
             // Subtract 1 to get an address *in* the function call for a better source location.
             try printSourceAtAddress(io, di, t, .{
                 .address = ret_addr -| StackIterator.ra_call_offset,
-                .print_inlines = true,
+                .resolve_inline_callers = true,
             });
             printed_any_frame = true;
         },
@@ -786,8 +790,17 @@ pub const FormatStackTrace = struct {
     }
 };
 
+/// Write a previously captured error return trace to `writer`, annotated with source locations.
+pub fn writeErrorReturnTrace(st: *const std.builtin.ErrorReturnTrace, t: Io.Terminal) Writer.Error!void {
+    try writeTrace(st, t, false);
+}
+
 /// Write a previously captured stack trace to `writer`, annotated with source locations.
-pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void {
+pub fn writeStackTrace(et: *const StackTrace, t: Io.Terminal) Writer.Error!void {
+    try writeTrace(et, t, true);
+}
+
+fn writeTrace(trace: anytype, t: Io.Terminal, resolve_inline_callers: bool) Writer.Error!void {
     const writer = t.writer;
     if (!std.options.allow_stack_tracing) {
         t.setColor(.dim) catch {};
@@ -796,9 +809,9 @@ pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void
         return;
     }
 
-    // Fetch `st.index` straight away. Aside from avoiding redundant loads, this prevents issues if
-    // `st` is `@errorReturnTrace()` and errors are encountered while writing the stack trace.
-    const n_frames = st.index;
+    // Fetch `trace.index` straight away. Aside from avoiding redundant loads, this prevents issues if
+    // `trace` is `@errorReturnTrace()` and errors are encountered while writing the stack trace.
+    const n_frames = trace.index;
     if (n_frames == 0) return writer.writeAll("(empty stack trace)\n");
     const di = getSelfDebugInfo() catch |err| switch (err) {
         error.UnsupportedTarget => {
@@ -809,13 +822,13 @@ pub fn writeStackTrace(st: *const StackTrace, t: Io.Terminal) Writer.Error!void
         },
     };
     const io = std.Options.debug_io;
-    const captured_frames = @min(n_frames, st.instruction_addresses.len);
-    for (st.instruction_addresses[0..captured_frames]) |ret_addr| {
+    const captured_frames = @min(n_frames, trace.instruction_addresses.len);
+    for (trace.instruction_addresses[0..captured_frames]) |ret_addr| {
         // `ret_addr` is the return address, which is *after* the function call.
         // Subtract 1 to get an address *in* the function call for a better source location.
         try printSourceAtAddress(io, di, t, .{
             .address = ret_addr -| StackIterator.ra_call_offset,
-            .print_inlines = !st.includes_inlined_frames,
+            .resolve_inline_callers = resolve_inline_callers,
         });
     }
     if (n_frames > captured_frames) {
@@ -833,6 +846,15 @@ pub fn dumpStackTrace(st: *const StackTrace) void {
     };
 }
 
+/// A thin wrapper around `writeErrorReturnTrace` which writes to stderr and ignores write errors.
+pub fn dumpErrorReturnTrace(et: *const std.builtin.ErrorReturnTrace) void {
+    const stderr = lockStderr(&.{}).terminal();
+    defer unlockStderr();
+    writeErrorReturnTrace(et, stderr) catch |err| switch (err) {
+        error.WriteFailed => {},
+    };
+}
+
 const StackIterator = union(enum) {
     /// We will first report the current PC of this `CpuContextPtr`, then we will switch to a
     /// different strategy to actually unwind.
@@ -1124,7 +1146,7 @@ pub inline fn stripInstructionPtrAuthCode(ptr: usize) usize {
 
 const PrintSourceAddressOptions = struct {
     address: usize,
-    print_inlines: bool,
+    resolve_inline_callers: bool,
 };
 
 fn printSourceAtAddress(
@@ -1163,7 +1185,7 @@ fn printSourceAtAddress(
             symbol.name orelse "???",
             symbol.compile_unit_name orelse debug_info.getModuleName(io, options.address) catch "???",
         );
-        if (!options.print_inlines) break;
+        if (!options.resolve_inline_callers) break;
     }
 }
 fn printLineInfo(
@@ -1708,7 +1730,6 @@ pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize
                 const stack_trace: StackTrace = .{
                     .index = frames.len,
                     .instruction_addresses = frames,
-                    .includes_inlined_frames = false,
                 };
                 writeStackTrace(&stack_trace, stderr) catch return;
             }
diff --git a/lib/std/heap/debug_allocator.zig b/lib/std/heap/debug_allocator.zig
index 987bb4e6eaaca055953b8f2a4149b08b052db1b1..f49fc9493d408c0ea52eaae556a3ec3cc1b04b52 100644
--- a/lib/std/heap/debug_allocator.zig
+++ b/lib/std/heap/debug_allocator.zig
@@ -81,7 +81,7 @@
 //! Resizing and remapping are forwarded directly to the backing allocator,
 //! except where such operations would change the category from large to small.
 const builtin = @import("builtin");
-const StackTrace = std.builtin.StackTrace;
+const StackTrace = std.debug.StackTrace;
 
 const std = @import("std");
 const log = std.log.scoped(.DebugAllocator);
@@ -229,7 +229,7 @@ pub fn DebugAllocator(comptime config: Config) type {
                 std.debug.dumpStackTrace(self.getStackTrace(trace_kind));
             }
 
-            fn getStackTrace(self: *LargeAlloc, trace_kind: TraceKind) std.builtin.StackTrace {
+            fn getStackTrace(self: *LargeAlloc, trace_kind: TraceKind) std.debug.StackTrace {
                 assert(@intFromEnum(trace_kind) < trace_n);
                 const stack_addresses = &self.stack_addresses[@intFromEnum(trace_kind)];
                 var len: usize = 0;
@@ -239,7 +239,6 @@ pub fn DebugAllocator(comptime config: Config) type {
                 return .{
                     .instruction_addresses = stack_addresses,
                     .index = len,
-                    .includes_inlined_frames = false,
                 };
             }
 
@@ -342,7 +341,6 @@ pub fn DebugAllocator(comptime config: Config) type {
             return .{
                 .instruction_addresses = stack_addresses,
                 .index = len,
-                .includes_inlined_frames = false,
             };
         }
 
diff --git a/lib/std/start.zig b/lib/std/start.zig
index 29c76fdfadc55af1493546bc4b5fba7ef8dc2b76..01b33ba5f146d79ae8ba5a5ba0b7052d64b084cd 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -761,7 +761,7 @@ inline fn wrapMain(result: anytype) u8 {
         std.log.err("{t}", .{err});
         switch (native_os) {
             .freestanding, .other => {},
-            else => if (@errorReturnTrace()) |trace| std.debug.dumpStackTrace(trace),
+            else => if (@errorReturnTrace()) |trace| std.debug.dumpErrorReturnTrace(trace),
         }
         return 1;
     };
diff --git a/lib/std/testing/FailingAllocator.zig b/lib/std/testing/FailingAllocator.zig
index 6476725a2f70106602afc735e2d7bd368f850bea..bcd88567106dca6804b32b85ec32ac58319106fb 100644
--- a/lib/std/testing/FailingAllocator.zig
+++ b/lib/std/testing/FailingAllocator.zig
@@ -131,7 +131,7 @@ fn free(
 }
 
 /// Only valid once `has_induced_failure == true`
-pub fn getStackTrace(self: *FailingAllocator) std.builtin.StackTrace {
+pub fn getStackTrace(self: *FailingAllocator) std.debug.StackTrace {
     std.debug.assert(self.has_induced_failure);
     var len: usize = 0;
     while (len < self.stack_addresses.len and self.stack_addresses[len] != 0) {
diff --git a/src/Sema.zig b/src/Sema.zig
index 4702241a71aba52188f51cd1605131785673f95d..1767e058e0d627e663a41236a69bdc6d7f3c3a22 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2252,9 +2252,8 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
     });
     const addrs_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(addr_arr_ty));
 
-    // var st: StackTrace = undefined;
-    const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
-    const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty));
+    const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace);
+    const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(error_return_trace_ty));
 
     // st.instruction_addresses = &addrs;
     const instruction_addresses_field_name = try ip.getOrPutString(gpa, io, pt.tid, "instruction_addresses", .no_embedded_nulls);
@@ -6166,10 +6165,10 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
 
     if (!block.ownerModule().error_tracing) return .none;
 
-    const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
+    const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace);
     const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-    const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) {
-        error.AnalysisFail => @panic("std.builtin.StackTrace is corrupt"),
+    const field_index = sema.structFieldIndex(block, error_return_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) {
+        error.AnalysisFail => @panic("std.builtin.ErrorReturnTrace is corrupt"),
         error.ComptimeReturn, error.ComptimeBreak => unreachable,
         error.OutOfMemory, error.Canceled => |e| return e,
     };
@@ -6177,7 +6176,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
     return try block.addInst(.{
         .tag = .save_err_return_trace_index,
         .data = .{ .ty_pl = .{
-            .ty = Air.internedToRef(stack_trace_ty.toIntern()),
+            .ty = Air.internedToRef(error_return_trace_ty.toIntern()),
             .payload = @intCast(field_index),
         } },
     });
@@ -6209,11 +6208,11 @@ fn popErrorReturnTrace(
         // AstGen determined this result does not go to an error-handling expr (try/catch/return etc.), or
         // the result is comptime-known to be a non-error. Either way, pop unconditionally.
 
-        const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace);
-        const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
-        const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
+        const error_return_trace_ty = try sema.getBuiltinType(src, .ErrorReturnTrace);
+        const ptr_error_return_trace_ty = try pt.singleMutPtrType(error_return_trace_ty);
+        const err_return_trace = try block.addTy(.err_return_trace, ptr_error_return_trace_ty);
         const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-        const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, stack_trace_ty);
+        const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, error_return_trace_ty);
         try sema.storePtr2(block, src, field_ptr, src, saved_error_trace_index, src, .store);
     } else if (is_non_error == null) {
         // The result might be an error. If it is, we leave the error trace alone. If it isn't, we need
@@ -6234,11 +6233,11 @@ fn popErrorReturnTrace(
         defer then_block.instructions.deinit(gpa);
 
         // If non-error, then pop the error return trace by restoring the index.
-        const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace);
-        const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
-        const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
+        const error_return_trace_ty = try sema.getBuiltinType(src, .ErrorReturnTrace);
+        const ptr_error_return_trace_ty = try pt.singleMutPtrType(error_return_trace_ty);
+        const err_return_trace = try then_block.addTy(.err_return_trace, ptr_error_return_trace_ty);
         const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-        const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, stack_trace_ty);
+        const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, error_return_trace_ty);
         try sema.storePtr2(&then_block, src, field_ptr, src, saved_error_trace_index, src, .store);
         _ = try then_block.addBr(cond_block_inst, .void_value);
 
@@ -6373,15 +6372,15 @@ fn zirCall(
         // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only
         // need to clean-up our own trace if we were passed to a non-error-handling expression.
         if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) {
-            const stack_trace_ty = try sema.getBuiltinType(call_src, .StackTrace);
+            const error_return_trace_ty = try sema.getBuiltinType(call_src, .ErrorReturnTrace);
             const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-            const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src);
+            const field_index = try sema.structFieldIndex(block, error_return_trace_ty, field_name, call_src);
 
             // Insert a save instruction before the arg resolution + call instructions we just generated
             const save_inst = try block.insertInst(block_index, .{
                 .tag = .save_err_return_trace_index,
                 .data = .{ .ty_pl = .{
-                    .ty = Air.internedToRef(stack_trace_ty.toIntern()),
+                    .ty = Air.internedToRef(error_return_trace_ty.toIntern()),
                     .payload = @intCast(field_index),
                 } },
             });
@@ -19529,13 +19528,13 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
-    const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
-    const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern());
+    const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace);
+    const ptr_error_return_trace_ty = try pt.singleMutPtrType(error_return_trace_ty);
+    const opt_ptr_error_return_trace_ty = try pt.optionalType(ptr_error_return_trace_ty.toIntern());
 
     switch (sema.owner.unwrap()) {
         .func => |func| if (ip.funcAnalysisUnordered(func).has_error_trace and block.ownerModule().error_tracing) {
-            return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
+            return block.addTy(.err_return_trace, opt_ptr_error_return_trace_ty);
         },
 
         .@"comptime",
@@ -19547,7 +19546,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
         => {},
     }
     return Air.internedToRef(try pt.intern(.{ .opt = .{
-        .ty = opt_ptr_stack_trace_ty.toIntern(),
+        .ty = opt_ptr_error_return_trace_ty.toIntern(),
         .val = .none,
     } }));
 }
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 88258b236acf77c69a5b3e97b2d9e20ebc346c04..9b56b68c69f06cbfc1b4af238c3fdd5a389c025e 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -434,7 +434,7 @@ pub const BuiltinDecl = enum {
     AddressSpace,
     CallingConvention,
     returnError,
-    StackTrace,
+    ErrorReturnTrace,
     SourceLocation,
     CallModifier,
     AtomicOrder,
@@ -512,7 +512,7 @@ pub const BuiltinDecl = enum {
         return switch (decl) {
             .returnError => .func,
 
-            .StackTrace,
+            .ErrorReturnTrace,
             .CallingConvention,
             .SourceLocation,
             .Signedness,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 1ba3b272da797e44061a16136a8269fb3c61b195..b138c852621e81bad93f3c462efb52d02db71a08 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3374,7 +3374,7 @@ pub const Object = struct {
         }
 
         if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) {
-            // First parameter is a pointer to `std.builtin.StackTrace`.
+            // First parameter is a pointer to `std.builtin.ErrorReturnTrace`.
             const llvm_ptr_ty = try o.builder.ptrType(toLlvmAddressSpace(.generic, target));
             try llvm_params.append(o.gpa, llvm_ptr_ty);
         }
diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig
index a04d89c3ee3a9dd134fbe037a9ead08f59cd1edf..2db115ebf66d39a7c27e44d3d9b404af2ca20174 100644
--- a/test/cases/compile_errors/panic_has_source_location.zig
+++ b/test/cases/compile_errors/panic_has_source_location.zig
@@ -6,7 +6,7 @@ export fn foo() void {
     @panic("oh no");
 }
 
-pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(_: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn {
     @compileError("panic");
 }
 
diff --git a/test/cases/disable_stack_tracing.zig b/test/cases/disable_stack_tracing.zig
index 36620130c9a6fb6089e222b0bf7d0a5d7f5f179a..a1659f2bd46fa0428d59c117e47c1f15dfebc62d 100644
--- a/test/cases/disable_stack_tracing.zig
+++ b/test/cases/disable_stack_tracing.zig
@@ -13,7 +13,7 @@ pub fn main() !void {
 
     try stdout.interface.flush();
 }
-fn foo(w: *std.Io.Writer, st_buf: []usize) !std.builtin.StackTrace {
+fn foo(w: *std.Io.Writer, st_buf: []usize) !std.debug.StackTrace {
     try std.debug.writeCurrentStackTrace(.{}, .{ .writer = w, .mode = .no_color });
     return std.debug.captureCurrentStackTrace(.{}, st_buf);
 }
diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig
index f5e0dc87a7923dde14215dc4383477ee24830775..92b2badb5a056e9ef05e77b4098cd05ff8f50efa 100644
--- a/test/cases/safety/@alignCast misaligned.zig	
+++ b/test/cases/safety/@alignCast misaligned.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "incorrect alignment")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@enumFromInt - no matching tag value.zig b/test/cases/safety/@enumFromInt - no matching tag value.zig
index 35d23b2be7543f1f4f92e84408e5ea7491e34a7f..e9bb3a2abc0ccdb69c1709580c3b5ea673d02354 100644
--- a/test/cases/safety/@enumFromInt - no matching tag value.zig	
+++ b/test/cases/safety/@enumFromInt - no matching tag value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@enumFromInt truncated bits - exhaustive.zig b/test/cases/safety/@enumFromInt truncated bits - exhaustive.zig
index 4edbfae996280f074e9600f65e5c5aae5b646882..f93677cf7e01a6888a6f7165498df060a0594210 100644
--- a/test/cases/safety/@enumFromInt truncated bits - exhaustive.zig	
+++ b/test/cases/safety/@enumFromInt truncated bits - exhaustive.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn {
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
     }
diff --git a/test/cases/safety/@enumFromInt truncated bits - nonexhaustive.zig b/test/cases/safety/@enumFromInt truncated bits - nonexhaustive.zig
index 16e4699478c5f0448211fbe855a1eecadab0fd6e..f7bcd690634919b703dfa5958f2833609f672c26 100644
--- a/test/cases/safety/@enumFromInt truncated bits - nonexhaustive.zig	
+++ b/test/cases/safety/@enumFromInt truncated bits - nonexhaustive.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn {
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
     }
diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig
index bb8379042b279d385b91d12db0328fdd595c2a5e..b7a7b2ae2ab531be8644d9de6702fb002c8a5655 100644
--- a/test/cases/safety/@errorCast error not present in destination.zig	
+++ b/test/cases/safety/@errorCast error not present in destination.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@errorCast error union casted to disjoint set.zig b/test/cases/safety/@errorCast error union casted to disjoint set.zig
index 267c136e9e8b139c9bdc78c9aa1daa17ded5871d..a8b0b8dcfaa846df7b6fb1b374597ac794c1e753 100644
--- a/test/cases/safety/@errorCast error union casted to disjoint set.zig	
+++ b/test/cases/safety/@errorCast error union casted to disjoint set.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig
index 180ee78512fccc28ba1b33ef2b78e0570f0044cb..0649df2fb1bb37b22684b2a5c8b8bb8b92c55ba4 100644
--- a/test/cases/safety/@intCast to u0.zig	
+++ b/test/cases/safety/@intCast to u0.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 max.zig
index dd5c62e07cc10c5f317c60eb96ff6603fd6297d2..2b3a9c35562e7553c2e1f809128957bed00c8863 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 max.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 max.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 min.zig
index 0b0fab15d9ca8ec6abbdb1b85c86bde0b4f2dd4b..65a3d904c27770d438061333a51687ff077553ac 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 min.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 min.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - signed max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - signed max.zig
index 8c42449a87a8b8c6a1d5dc28763864b34f6fca4d..fda0fbd8c184bb951ed3c8fae3c6653b3006c312 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - signed max.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - signed max.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - signed min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - signed min.zig
index 49cee6a78613742cb8ac22dc7110ec906d207f7d..847a65e3aee059bf156684526483a3fd8e42bfbc 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - signed min.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - signed min.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 max.zig
index 0a786bff7baaced248118379e0fc586b6ee8932b..748d89e12a1e8bbd4ed5283a6c205b8e2cea2bb5 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 max.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 max.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 min.zig
index 07f5ff3e42b1cf2ee315c84d1f889c8510a1bd4a..ab43e1d9e8e1895c7916941dfd380cf93f2077ea 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 min.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 min.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned max.zig
index e54bc221da96a0562862c01b81106bf97f8ab2bf..f28cc6de0c2110a22d6a846e5edcbdc9b8ba40bd 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned max.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned max.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned min.zig
index 90bbb696e274792bbc0be62939124096410e8dc1..af03ad840a26d288a3ec60cd12dc79adc9fd0df4 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned min.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned min.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - vector max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - vector max.zig
index 77b1ef5a14fe37276ba85d468acb196240932881..f2b25df616080eb1bcdda4152ae3a0810e3cf669 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - vector max.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - vector max.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - vector min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - vector min.zig
index 095298e6facfca3d405da16b71e7a6967f69af3e..8e5208a882d20bba75b445c637cfc44544eb303c 100644
--- a/test/cases/safety/@intFromFloat cannot fit - boundary case - vector min.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - boundary case - vector min.zig	
@@ -1,5 +1,5 @@
 const std = @import("std");
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig
index b67604541cec32e182f68c5d447f9b4cdf040e54..95e077c774fa83ffd13485319f8ed91e6ddf8678 100644
--- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig
index f6e6f4662cf7c37d1683a5deb60ff9a679ac3c3d..74cb95297a24aaead6bb48fb0bed5de39eed3de9 100644
--- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig
index 594cedf8ed0d31ebf0d4bf21271daffc009670cc..faba3ffa639b2c5bf9efb3e987cd78fcb229ecf0 100644
--- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig
index 16630b6f6a7dc374e998a4359b9e761c23659bf3..ce9aa416493935048a5bb8e46882f0d1d04b5e20 100644
--- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig	
+++ b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig
index 21cfda643470e04be687f796323fc30cf2101d59..3b162c85e4b50cc162e1ac99ba13be798b3e38f1 100644
--- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig	
+++ b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig
index 81e2ffb91ef238d758deb6ff7a7184579219f8e5..7f2e527c1f498864355a035f64b2e0c249f644fd 100644
--- a/test/cases/safety/@ptrFromInt with misaligned address.zig	
+++ b/test/cases/safety/@ptrFromInt with misaligned address.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "incorrect alignment")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig
index faf8103880cdc478d1dd2aef8e8311c554bd054f..e1e9f6bb261b6f835778b78c972a34fcf48cc0d2 100644
--- a/test/cases/safety/@tagName on corrupted enum value.zig	
+++ b/test/cases/safety/@tagName on corrupted enum value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig
index 73e62a60b8ffcc3e0e6250c45dbd5a8d1030cac3..01d1e7f882732be6c1b4bf900169c173719d8e24 100644
--- a/test/cases/safety/@tagName on corrupted union value.zig	
+++ b/test/cases/safety/@tagName on corrupted union value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig
index 723288c437ea4d4ed4fcf7d93267a2db578600e5..408d18f2842e91648e8610d17847076c7eddf156 100644
--- a/test/cases/safety/array slice sentinel mismatch vector.zig	
+++ b/test/cases/safety/array slice sentinel mismatch vector.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
         std.process.exit(0);
diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig
index 49e9d8caaad5a0c145a151a5286f894bf144e87c..f58e43ab03a94951c778867879aae0b0628a3224 100644
--- a/test/cases/safety/array slice sentinel mismatch.zig	
+++ b/test/cases/safety/array slice sentinel mismatch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig
index 7cf0c30417ca14b3439662cddc5f0ca8a296eeb6..68568729f21471186c4c288b019f1ba7926c8ea7 100644
--- a/test/cases/safety/bad union field access.zig	
+++ b/test/cases/safety/bad union field access.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {
         std.process.exit(0);
diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig
index d77104bbb39e6b6f0ab70138faee5c403a2953a7..23455e1d4553c9c2af277a66fcd5707dfebc0751 100644
--- a/test/cases/safety/calling panic.zig	
+++ b/test/cases/safety/calling panic.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "oh no")) {
         std.process.exit(0);
diff --git a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig
index de15051993518235a1f7ff42d3b0cedfb5a4b5b5..220a215a9cc1e9057aa6f958831c3b8d3a68ddad 100644
--- a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
+++ b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
diff --git a/test/cases/safety/cast integer to global error and no code matches.zig b/test/cases/safety/cast integer to global error and no code matches.zig
index 51adb1ac1e8dc7f2705e31d1b3ff6a09d25825d6..4570c44dcde5ddda49201093dade7655577c560e 100644
--- a/test/cases/safety/cast integer to global error and no code matches.zig	
+++ b/test/cases/safety/cast integer to global error and no code matches.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig
index 1dacc309587582870dbe94e9e5639cd047a3ffcf..fab386becd991618300fe2eb945bc915b82ac155 100644
--- a/test/cases/safety/empty slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/empty slice with sentinel out of bounds.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
         std.process.exit(0);
diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig
index 0693b7b1286d7310129c112716d3643fc3568bc5..22bd4a924b2fbff185fe656d0d3365464c071b03 100644
--- a/test/cases/safety/exact division failure - vectors.zig	
+++ b/test/cases/safety/exact division failure - vectors.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig
index 262f921e923805f599afcdc1f8db94b0098991d6..f9b4677f01d8bb93edfd9202de7b776c94a2a788 100644
--- a/test/cases/safety/exact division failure.zig	
+++ b/test/cases/safety/exact division failure.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig
index 4b9affab36f2648de12387826668dc462bff2071..1887eb97e384f0d1c27525c4c0f760134d8d7709 100644
--- a/test/cases/safety/for_len_mismatch.zig
+++ b/test/cases/safety/for_len_mismatch.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
         std.process.exit(0);
diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig
index aed7479bf26b8cbe23b8b22951c9a026d78e6bde..0a0454ab5caff129b453f5910cc8d8042f64be63 100644
--- a/test/cases/safety/for_len_mismatch_three.zig
+++ b/test/cases/safety/for_len_mismatch_three.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
         std.process.exit(0);
diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig
index b92bfd4c266b25870444db4da90f5f409f7df586..6d3d9e0af0da5b35c63a18700f52981970a28e44 100644
--- a/test/cases/safety/ignored expression integer overflow.zig	
+++ b/test/cases/safety/ignored expression integer overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig
index 336b4831ac0f37b4860eb51018a35c435c26ef3e..808938c12298fe3c1a3b9ac587ba61376be2803e 100644
--- a/test/cases/safety/integer addition overflow.zig	
+++ b/test/cases/safety/integer addition overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig
index fe3aefeb1abae6f4ee63cbe701a91c2283f6f42c..ed0fa971c930b3d836f187349cd897b6de6bd2b6 100644
--- a/test/cases/safety/integer division by zero - vectors.zig	
+++ b/test/cases/safety/integer division by zero - vectors.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig
index a667c7c20658a6444f89f90f5caf6c5935ec2e48..7fe895d70e125dac8927aa9e0b30bdb7b1d9abff 100644
--- a/test/cases/safety/integer division by zero.zig	
+++ b/test/cases/safety/integer division by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig
index 311869657b1f988c76280242ece4c59b510e5ccd..6a026c2221168fdc7d86449d06fdbcb648534418 100644
--- a/test/cases/safety/integer multiplication overflow.zig	
+++ b/test/cases/safety/integer multiplication overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig
index 5d2681dee049831b26c0ebdc56faf4abb1242310..d5777a6834951cfb77135028361cb832d41fe876 100644
--- a/test/cases/safety/integer negation overflow.zig	
+++ b/test/cases/safety/integer negation overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig
index 142f1f44cdd404c56ac2f291d66faa5d99f463a0..758dfa898e1473eaff63f75b13f50c763e730dd6 100644
--- a/test/cases/safety/integer subtraction overflow.zig	
+++ b/test/cases/safety/integer subtraction overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig
index cdd5aeb2e251142fd9410103b46615c9f010f47c..5fa007e198d992281abca5997962dfb62b66aa60 100644
--- a/test/cases/safety/memcpy_alias.zig
+++ b/test/cases/safety/memcpy_alias.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "@memcpy arguments alias")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig
index 3728ca2a0173dd97a48371ab31facd0ba32bd3f5..e95ae542dbde4b4898d18b2123a8b3e9fe9ec8bf 100644
--- a/test/cases/safety/memcpy_len_mismatch.zig
+++ b/test/cases/safety/memcpy_len_mismatch.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "source and destination arguments have non-equal lengths")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memmove_len_mismatch.zig b/test/cases/safety/memmove_len_mismatch.zig
index 97624a4710dd5e86c9e7d173103b21db1da38c95..4dc28246babe1630867200f6e082d44a3adb5adc 100644
--- a/test/cases/safety/memmove_len_mismatch.zig
+++ b/test/cases/safety/memmove_len_mismatch.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "source and destination arguments have non-equal lengths")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig
index 6e374647c38cc979f46e3ca3d5ba5ccd1c319131..3e6d85f1186f1cf1932c4949d8485ec489081f69 100644
--- a/test/cases/safety/memset_array_undefined_bytes.zig
+++ b/test/cases/safety/memset_array_undefined_bytes.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig
index 3ea5bcc2e790bbdf2d6553e0cbfe3d12c0f5d0e7..479441b7dcbcda0b2705f031235ec542624886e4 100644
--- a/test/cases/safety/memset_array_undefined_large.zig
+++ b/test/cases/safety/memset_array_undefined_large.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig
index e3d8f2a5121629d7d54c6a0a69109bba0f085379..4514e9a4a6fff19f7f3843529d3214a6dcc38648 100644
--- a/test/cases/safety/memset_slice_undefined_bytes.zig
+++ b/test/cases/safety/memset_slice_undefined_bytes.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig
index 5131e592f9a386ae7a0d2e74e42af761d255a886..181cdb50ca41bfb0d7f6d853febae8d2b4d94b9f 100644
--- a/test/cases/safety/memset_slice_undefined_large.zig
+++ b/test/cases/safety/memset_slice_undefined_large.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig
index 365eeaba4389920f8f0c8aaf90b2dfa8b6bb5fad..4293baa0e0a0991555c1928d4174ed95c5357450 100644
--- a/test/cases/safety/modrem by zero.zig	
+++ b/test/cases/safety/modrem by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig
index 844f6e3b75be682abe3f17b2e9148263fbcc4e82..d133ce883a32761e95a02081eeb8408d74c9f7fc 100644
--- a/test/cases/safety/modulus by zero.zig	
+++ b/test/cases/safety/modulus by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig
index 58e392d224c1fce72ecdc297a743caacb7c45ccd..3bc6ab68c0e486b7ac460599e2d6773d1e3e9bcc 100644
--- a/test/cases/safety/noreturn returned.zig	
+++ b/test/cases/safety/noreturn returned.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "'noreturn' function returned")) {
         std.process.exit(0);
diff --git a/test/cases/safety/optional unwrap operator on C pointer.zig b/test/cases/safety/optional unwrap operator on C pointer.zig
index 308d97983592db1fc0aeb2906712761a8faa78a2..6009c758f01450cd213f9cfa25672e6ea944f766 100644
--- a/test/cases/safety/optional unwrap operator on C pointer.zig	
+++ b/test/cases/safety/optional unwrap operator on C pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/optional unwrap operator on null pointer.zig b/test/cases/safety/optional unwrap operator on null pointer.zig
index 63ee03facb462b4fd9972370188ca9713a272387..1aae8fa1df3938eb345a0e68b794c0c6420fa29f 100644
--- a/test/cases/safety/optional unwrap operator on null pointer.zig	
+++ b/test/cases/safety/optional unwrap operator on null pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/optional_empty_error_set.zig b/test/cases/safety/optional_empty_error_set.zig
index 60e6c5c3eb490955d9d18f198d7b0759bb76ed06..44dea2233b47dee5bde0845dd0349955d1d51450 100644
--- a/test/cases/safety/optional_empty_error_set.zig
+++ b/test/cases/safety/optional_empty_error_set.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ra: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, ra: ?usize) noreturn {
     _ = stack_trace;
     _ = ra;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
diff --git a/test/cases/safety/out of bounds array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig
index cc9bb0205a643ad8df46d488b192ed7309d6918c..bb8012458143eaa5d7bad6180b24aad2e0e3f143 100644
--- a/test/cases/safety/out of bounds array slice by length.zig	
+++ b/test/cases/safety/out of bounds array slice by length.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {
         std.process.exit(0);
diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig
index 61ae983fbab8ebea65a191b02722f9af9f9defe5..c2ea85b864cc7a57489eb07b37908d24f4bfab48 100644
--- a/test/cases/safety/out of bounds slice access.zig	
+++ b/test/cases/safety/out of bounds slice access.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/pointer casting null to non-optional pointer.zig b/test/cases/safety/pointer casting null to non-optional pointer.zig
index e10297dc49cf00fb006fd5ad2459782bb43f235a..491dc69dca06f727bf7356882b81986a28b69711 100644
--- a/test/cases/safety/pointer casting null to non-optional pointer.zig	
+++ b/test/cases/safety/pointer casting null to non-optional pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig
index 892e6cbfd98010617fbcc1551cd90245ede3269f..bf8d2a502edc71e7f1fd5998a526dde3c10a9be1 100644
--- a/test/cases/safety/pointer casting to null function pointer.zig	
+++ b/test/cases/safety/pointer casting to null function pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig
index 9ad91109d90de3261c5d1fe5857fbc62e526e744..5b0f8618c06d548048892726ffc7d374084c0cbe 100644
--- a/test/cases/safety/pointer slice sentinel mismatch.zig	
+++ b/test/cases/safety/pointer slice sentinel mismatch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig
index 754f160c9cad768a2540dc3697944d1daa50ff2f..4a45e7eee96fbf90846fedd64c7ba4714aaa10a1 100644
--- a/test/cases/safety/remainder division by zero.zig	
+++ b/test/cases/safety/remainder division by zero.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig
index 2b67721299bd6a9de1d3d2a20d898cf509c90dac..591334c1607556eba245a9eaa8dd3a8718ea1f7d 100644
--- a/test/cases/safety/shift left by huge amount.zig	
+++ b/test/cases/safety/shift left by huge amount.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
         std.process.exit(0);
diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig
index cf836eafa3a3884a490f94bf5d61a3f96147668e..a537b969c383be23828e2af8461309fdd86fba80 100644
--- a/test/cases/safety/shift right by huge amount.zig	
+++ b/test/cases/safety/shift right by huge amount.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig
index 56996e1e32094ca847447d3c3ea3bd3e2c893c95..a13fc604406f280b0deafad79db20b8581d05c1c 100644
--- a/test/cases/safety/signed integer division overflow - vectors.zig	
+++ b/test/cases/safety/signed integer division overflow - vectors.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig
index fa4b124189678410414211fe9d77c35e0b9a4bf6..1742386258e789e5f4e26aecf9868c69d88133f6 100644
--- a/test/cases/safety/signed integer division overflow.zig	
+++ b/test/cases/safety/signed integer division overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig
index be3a0ad662e441d8f803f156b88e2a10b5acc2f3..06b792e067c97bf5d53ee898649efc15ad004b2c 100644
--- a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig	
+++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig
index fb636c0bce360a1b9f4290c1bd18df65a6682ed1..b1d31ac78a0eeef826aa7fa8d1e7f4f0db174227 100644
--- a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig	
+++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig
index bd6bc012bb7296236551deda8c1923376121c554..93e1c5c1e77b9a72158ea15063344d3f7767c065 100644
--- a/test/cases/safety/signed shift left overflow.zig	
+++ b/test/cases/safety/signed shift left overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "left shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig
index 6dc5806e4fd042a65c94c1f4e779af349a34bc50..d51e1e926145ea2d4a09517ccacbba1ed0e7b4e3 100644
--- a/test/cases/safety/signed shift right overflow.zig	
+++ b/test/cases/safety/signed shift right overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "right shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig
index 50be6b84f384e980ecd5d677e7d28a978f492254..d6b2377e34e90a1084b525d264fca46817517d14 100644
--- a/test/cases/safety/signed-unsigned vector cast.zig	
+++ b/test/cases/safety/signed-unsigned vector cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice by length sentinel mismatch on lhs.zig b/test/cases/safety/slice by length sentinel mismatch on lhs.zig
index af92f90198e71e261206b0372121a489cbe2a7de..4dbeb2b0f86c41af6acf981de3eebc6958765490 100644
--- a/test/cases/safety/slice by length sentinel mismatch on lhs.zig	
+++ b/test/cases/safety/slice by length sentinel mismatch on lhs.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 1, found 3")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice by length sentinel mismatch on rhs.zig b/test/cases/safety/slice by length sentinel mismatch on rhs.zig
index f9a8730a99ee7d08f039e326fa4f33db2a2ed042..7bfaca25acc3946ff658ef9bc9a8ad30ac6c7357 100644
--- a/test/cases/safety/slice by length sentinel mismatch on rhs.zig	
+++ b/test/cases/safety/slice by length sentinel mismatch on rhs.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 1, found 0")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig
index 30e6b8a85cd0143f200bf4c368553e251f3fa41f..51d9b17b7500236ce68d33a7c59abd6c50d95ab8 100644
--- a/test/cases/safety/slice sentinel mismatch - floats.zig	
+++ b/test/cases/safety/slice sentinel mismatch - floats.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig
index c931aa31f1f75f054211c8ebf28d7bf9f2622540..34bd73f56c20981342bc8b5a968ec929c5dec1aa 100644
--- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
+++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig
index 881edb5d8e1c7d9938e51770ecc260371348baba..a824ad6bb8f73c783a4f93afd4dac6e30adb03d0 100644
--- a/test/cases/safety/slice slice sentinel mismatch.zig	
+++ b/test/cases/safety/slice slice sentinel mismatch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice start index greater than end index.zig b/test/cases/safety/slice start index greater than end index.zig
index 9835a253266991c229cf3aacc27508edf251f1b5..a9d90f676d56cd472618575b38dd7b401d4854b5 100644
--- a/test/cases/safety/slice start index greater than end index.zig	
+++ b/test/cases/safety/slice start index greater than end index.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig
index b5851d7b1137859647cdb931d081285a7d90cb07..838b31ce083edae683649daaacc1c205f5ba9bc1 100644
--- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig
index a3bcb49fc17cdf63ca71f931a91cdef87d120e41..1ef2e062626776cd957660bae5ada2bdd212e1d2 100644
--- a/test/cases/safety/slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slice_cast_change_len_0.zig b/test/cases/safety/slice_cast_change_len_0.zig
index d85299e6936805bbefac2b326e254c755ebe8af9..9b9a40e93b5b15942fd6c88bdd5a5034b00f8555 100644
--- a/test/cases/safety/slice_cast_change_len_0.zig
+++ b/test/cases/safety/slice_cast_change_len_0.zig
@@ -13,7 +13,7 @@ pub fn main() void {
     std.process.exit(1);
 }
 
-pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn {
     if (std.mem.eql(u8, message, "slice length '3' does not divide exactly into destination elements")) {
         std.process.exit(0);
     }
diff --git a/test/cases/safety/slice_cast_change_len_1.zig b/test/cases/safety/slice_cast_change_len_1.zig
index 388a052085ac54b14cac21007559be05d9451156..57a7b6a7380e3cc31d1ac630285ca2beeb2acdb7 100644
--- a/test/cases/safety/slice_cast_change_len_1.zig
+++ b/test/cases/safety/slice_cast_change_len_1.zig
@@ -13,7 +13,7 @@ pub fn main() void {
     std.process.exit(1);
 }
 
-pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn {
     if (std.mem.eql(u8, message, "slice length '1' does not divide exactly into destination elements")) {
         std.process.exit(0);
     }
diff --git a/test/cases/safety/slice_cast_change_len_2.zig b/test/cases/safety/slice_cast_change_len_2.zig
index ff7a18b8f0963609be205939db699764e61eb10c..f6a29feec74092d824811f7b24b0ca80f445bf07 100644
--- a/test/cases/safety/slice_cast_change_len_2.zig
+++ b/test/cases/safety/slice_cast_change_len_2.zig
@@ -13,7 +13,7 @@ pub fn main() void {
     std.process.exit(1);
 }
 
-pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn {
     if (std.mem.eql(u8, message, "slice length '1' does not divide exactly into destination elements")) {
         std.process.exit(0);
     }
diff --git a/test/cases/safety/slicing null C pointer - runtime len.zig b/test/cases/safety/slicing null C pointer - runtime len.zig
index e2145fedb0a8db60774ca3b337db6419a549d3d1..8266a035b70fe3b9a618422da03407ad6219cef8 100644
--- a/test/cases/safety/slicing null C pointer - runtime len.zig	
+++ b/test/cases/safety/slicing null C pointer - runtime len.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig
index 6fc0281d471f19f1be6c64c5d00178ca5f83ceb5..2035361cb2a0af969d68407d325d62ec12ba3700 100644
--- a/test/cases/safety/slicing null C pointer.zig	
+++ b/test/cases/safety/slicing null C pointer.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch else on corrupt enum value - one prong.zig b/test/cases/safety/switch else on corrupt enum value - one prong.zig
index 6bc20ef1007752779753bfa296812271219e5045..4babfb9133c4d41236275b2ccf0f9ff538a5f1f8 100644
--- a/test/cases/safety/switch else on corrupt enum value - one prong.zig	
+++ b/test/cases/safety/switch else on corrupt enum value - one prong.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch else on corrupt enum value - union.zig b/test/cases/safety/switch else on corrupt enum value - union.zig
index afb7bfdcdcc20f7848d1e7fbb50e4f236de08f19..20a24a81ccbe9bcfe77c60ac72f7f2fa5f8d96f1 100644
--- a/test/cases/safety/switch else on corrupt enum value - union.zig	
+++ b/test/cases/safety/switch else on corrupt enum value - union.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig
index 297cde40ea92fc6504103e4aa5b5f5bffcf0f641..6cab276eab07888a21426c149faf8650f7f213b3 100644
--- a/test/cases/safety/switch else on corrupt enum value.zig	
+++ b/test/cases/safety/switch else on corrupt enum value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig
index 7e08b3c495b4fe32412d857006357e0a63060282..c7f6f86940089cf6ba2c866eaab8a1dbdbdd5ebd 100644
--- a/test/cases/safety/switch on corrupted enum value.zig	
+++ b/test/cases/safety/switch on corrupted enum value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig
index d1c8d6a3f528c56d82980f3c15d775eec151e497..e2b21fd84a4bd402cdf8b0c260e06fc932a4c85c 100644
--- a/test/cases/safety/switch on corrupted union value.zig	
+++ b/test/cases/safety/switch on corrupted union value.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig
index 7805a5f92d005d0410f2ac32dcd97f6920e968c5..3531ac34b0a0ddbca4c02797376d6d74bd8d202e 100644
--- a/test/cases/safety/truncating vector cast.zig	
+++ b/test/cases/safety/truncating vector cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig
index 8b394e6f4f40f9be400b4b734902ed6dfecfe09e..52c20506122d5d8a2db209a514f4a75458cc1344 100644
--- a/test/cases/safety/unreachable.zig
+++ b/test/cases/safety/unreachable.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "reached unreachable code")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig
index 5047550800272266659c6746d5fef0e3e9666bed..c326dfb691b47c7721699f1d049555c822abdb8f 100644
--- a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig	
+++ b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig
index 37bb1b61ea70aedbfb03e99c04929e48566cbede..178e309126399fa4d53c757ef704ea754abfced5 100644
--- a/test/cases/safety/unsigned shift left overflow.zig	
+++ b/test/cases/safety/unsigned shift left overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "left shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig
index 2de5d7c714f0d7067bff6490ce2debab4ad9b901..5ebe44bf49a8ec967de17bf7784117dc042bdbf0 100644
--- a/test/cases/safety/unsigned shift right overflow.zig	
+++ b/test/cases/safety/unsigned shift right overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "right shift overflowed bits")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig
index a482701b96e2d5af1b702bf2ae7e78f6aa24f560..f603999d8b267a6dfbf57f07acda968b5ab443ab 100644
--- a/test/cases/safety/unsigned-signed vector cast.zig	
+++ b/test/cases/safety/unsigned-signed vector cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig
index e31a34593d6f9c10cc488254cc7dd970211466ce..57f1f3d7b7bfdbc22489f644101b865f5917df68 100644
--- a/test/cases/safety/unwrap error switch.zig	
+++ b/test/cases/safety/unwrap error switch.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
         std.process.exit(0);
diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig
index aae990b6444e35a3ef063e88ba146172476c5c55..ef79c5cce4d1abf76b51a74ce619cfb7b46776fc 100644
--- a/test/cases/safety/unwrap error.zig	
+++ b/test/cases/safety/unwrap error.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
         std.process.exit(0);
diff --git a/test/cases/safety/value does not fit in shortening cast - u0.zig b/test/cases/safety/value does not fit in shortening cast - u0.zig
index 0b12aed075041047081c79b9d0e6263819e79241..f8aa6ebb119cca1afa146045ee95220deb25f42b 100644
--- a/test/cases/safety/value does not fit in shortening cast - u0.zig	
+++ b/test/cases/safety/value does not fit in shortening cast - u0.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/value does not fit in shortening cast.zig b/test/cases/safety/value does not fit in shortening cast.zig
index ff5144e3e7e5e7c6ffa8fe425bd4619c2bf4b1ea..ea74f8739b977842d5ba08f436af3fc99c256014 100644
--- a/test/cases/safety/value does not fit in shortening cast.zig	
+++ b/test/cases/safety/value does not fit in shortening cast.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig
index 5f60d9c2f2cf2c30c5aee92fdb58b573e436c9a5..4b34248af58f989af47a76f5c9f4be144fc395d9 100644
--- a/test/cases/safety/vector integer addition overflow.zig	
+++ b/test/cases/safety/vector integer addition overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig
index 0a7573e508b0a6683d9fa5ede52465a0d0f94761..2d4183d316761fc32096f1fc9146535d36fe4f28 100644
--- a/test/cases/safety/vector integer multiplication overflow.zig	
+++ b/test/cases/safety/vector integer multiplication overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig
index 11dcfda430ba0eb484f485bc8ab039b79084a491..b06dc437541b3d703b7c4bb715aabb5760589586 100644
--- a/test/cases/safety/vector integer negation overflow.zig	
+++ b/test/cases/safety/vector integer negation overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig
index 5de596085416c6e191f3a029d2ab855cbd967dc7..a6db1e5e85767d3aa2b56c2fe365b2be16fb1d9c 100644
--- a/test/cases/safety/vector integer subtraction overflow.zig	
+++ b/test/cases/safety/vector integer subtraction overflow.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig
index 63be84677164a494a339ad2e56bab8b07693e629..5e379643a8a758cedea138e75e11b107acb9ebc0 100644
--- a/test/cases/safety/zero casted to error.zig	
+++ b/test/cases/safety/zero casted to error.zig	
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
     if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
diff --git a/test/cases/tail_call_noreturn.zig b/test/cases/tail_call_noreturn.zig
index 5cd716dd303e57453e5463a7ff9063b87456304a..875251e3f74a2a01aaa10558df8ad596ac6e8725 100644
--- a/test/cases/tail_call_noreturn.zig
+++ b/test/cases/tail_call_noreturn.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
 const builtin = std.builtin;
-pub fn foo(message: []const u8, stack_trace: ?*builtin.StackTrace) noreturn {
+pub fn foo(message: []const u8, stack_trace: ?*std.debug.StackTrace) noreturn {
     @call(.always_tail, bar, .{ message, stack_trace });
 }
-pub fn bar(message: []const u8, stack_trace: ?*builtin.StackTrace) noreturn {
+pub fn bar(message: []const u8, stack_trace: ?*std.debug.StackTrace) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/stack_traces.zig b/test/stack_traces.zig
index d0f1acc08b281736b81cfb23bd692c75442c09fa..ec3102975edc3378c92658bd1ff90f9b8ff37f4f 100644
--- a/test/stack_traces.zig
+++ b/test/stack_traces.zig
@@ -118,13 +118,13 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         \\    var stack_trace_buf: [8]usize = undefined;
         \\    dumpIt(&captureIt(&stack_trace_buf));
         \\}
-        \\fn captureIt(buf: []usize) std.builtin.StackTrace {
+        \\fn captureIt(buf: []usize) std.debug.StackTrace {
         \\    return captureItInner(buf);
         \\}
-        \\fn dumpIt(st: *const std.builtin.StackTrace) void {
+        \\fn dumpIt(st: *const std.debug.StackTrace) void {
         \\    std.debug.dumpStackTrace(st);
         \\}
-        \\fn captureItInner(buf: []usize) std.builtin.StackTrace {
+        \\fn captureItInner(buf: []usize) std.debug.StackTrace {
         \\    return std.debug.captureCurrentStackTrace(.{}, buf);
         \\}
         \\const std = @import("std");
@@ -159,13 +159,13 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         \\    var stack_trace_buf: [8]usize = undefined;
         \\    dumpIt(&captureIt(&stack_trace_buf));
         \\}
-        \\fn captureIt(buf: []usize) std.builtin.StackTrace {
+        \\fn captureIt(buf: []usize) std.debug.StackTrace {
         \\    return captureItInner(buf);
         \\}
-        \\fn dumpIt(st: *const std.builtin.StackTrace) void {
+        \\fn dumpIt(st: *const std.debug.StackTrace) void {
         \\    std.debug.dumpStackTrace(st);
         \\}
-        \\fn captureItInner(buf: []usize) std.builtin.StackTrace {
+        \\fn captureItInner(buf: []usize) std.debug.StackTrace {
         \\    return std.debug.captureCurrentStackTrace(.{}, buf);
         \\}
         \\const std = @import("std");
@@ -188,13 +188,13 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         \\fn threadMain(stack_trace_buf: []usize) void {
         \\    dumpIt(&captureIt(stack_trace_buf));
         \\}
-        \\fn captureIt(buf: []usize) std.builtin.StackTrace {
+        \\fn captureIt(buf: []usize) std.debug.StackTrace {
         \\    return captureItInner(buf);
         \\}
-        \\fn dumpIt(st: *const std.builtin.StackTrace) void {
+        \\fn dumpIt(st: *const std.debug.StackTrace) void {
         \\    std.debug.dumpStackTrace(st);
         \\}
-        \\fn captureItInner(buf: []usize) std.builtin.StackTrace {
+        \\fn captureItInner(buf: []usize) std.debug.StackTrace {
         \\    return std.debug.captureCurrentStackTrace(.{}, buf);
         \\}
         \\const std = @import("std");
diff --git a/test/standalone/compile_asm/main.zig b/test/standalone/compile_asm/main.zig
index 1e6c93e562dee9f1d7eab41b4214241cfc4cc754..a3b11b9da974d71aa022fc57a375f2a8ef90004a 100644
--- a/test/standalone/compile_asm/main.zig
+++ b/test/standalone/compile_asm/main.zig
@@ -4,7 +4,7 @@ export fn main(r0: u32, r1: u32, atags: u32) callconv(.c) noreturn {
     _ = atags;
     unreachable; // never gets run so it doesn't matter
 }
-pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").debug.StackTrace, _: ?usize) noreturn {
     _ = msg;
     _ = error_return_trace;
     while (true) {}
diff --git a/test/standalone/issue_339/test.zig b/test/standalone/issue_339/test.zig
index e28839209c1988a68fb46c269a32d5d0b311cfd5..445385d16c78d0bc7ac9a075d004c85f17b56bc8 100644
--- a/test/standalone/issue_339/test.zig
+++ b/test/standalone/issue_339/test.zig
@@ -1,4 +1,4 @@
-const StackTrace = @import("std").builtin.StackTrace;
+const StackTrace = @import("std").debug.StackTrace;
 pub fn panic(msg: []const u8, stack_trace: ?*StackTrace, _: ?usize) noreturn {
     _ = msg;
     _ = stack_trace;
diff --git a/test/tests.zig b/test/tests.zig
index 9cb7a879b251fd4c224dc141f9df7327faf03789..97f99cffed5c95a48042e8426a3d7bac8a253b09 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -2200,7 +2200,7 @@ pub fn addCliTests(b: *std.Build) *Step {
             \\    return num * num;
             \\}
             \\extern fn zig_panic() noreturn;
-            \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace, _: ?usize) noreturn {
+            \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").debug.StackTrace, _: ?usize) noreturn {
             \\    _ = msg;
             \\    _ = error_return_trace;
             \\    zig_panic();
-- 
2.54.0