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();