From ac207073f3426e615e7d4735994f73f67af7ee8e Mon Sep 17 00:00:00 2001
From: Mason Remaley <mason@gamesbymason.com>
Date: Sat, 11 Apr 2026 16:04:57 -0700
Subject: [PATCH] Reverts renaming of builtin.StackTrace -> ErrorReturnTrace

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

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 0d2564a23935821462732926d5fb647233f09b2e..9f32e05896e3eccf237f6388b79198f65c90a0b8 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.ErrorReturnTrace{#endsyntax#}</pre>
+      <pre>{#syntax#}@errorReturnTrace() ?*builtin.StackTrace{#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 5899e5626563f9d82721569479e38e81abfada4f..e71c47707b2a5fa6f93df8398ccf7778c1a81b9d 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.debug.StackTrace, addr: ?usize) noreturn {
+pub fn panic(msg: []const u8, st: ?*std.builtin.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 dadc6a34926debd48caa1de9500c818ce329b38f..bee3e4acbcc370261f3b137d40584ea2ad2f8065 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.debug.StackTrace, addr: ?usize) noreturn {
+pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn {
     _ = st;
     _ = addr;
     log.err("panic: {s}", .{msg});
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 04959733c1b6adb7f8b71bccff2a1fad43e85b5c..00ae6199d1d9cdf96e8202a29b3f0b7385b5d387 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -8,7 +8,7 @@ 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 ErrorReturnTrace = struct {
+pub const StackTrace = struct {
     index: usize,
     instruction_addresses: []usize,
 };
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 1cda6b50180b496b2f00d50aa6a78e216da3226e..afd47d981d465b6795661196dd9ee0c738ad9a59 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -816,7 +816,7 @@ pub const FormatStackTrace = struct {
 };
 
 /// Write a previously captured error return trace to `writer`, annotated with source locations.
-pub fn writeErrorReturnTrace(et: *const std.builtin.ErrorReturnTrace, t: Io.Terminal) Writer.Error!void {
+pub fn writeErrorReturnTrace(et: *const std.builtin.StackTrace, t: Io.Terminal) Writer.Error!void {
     // We take the slice by value, preventing the length from being mutated if an error occurs while
     // writing the stack trace.
     const len = @min(et.instruction_addresses.len, et.index);
@@ -885,7 +885,7 @@ 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 {
+pub fn dumpErrorReturnTrace(et: *const std.builtin.StackTrace) void {
     const stderr = lockStderr(&.{}).terminal();
     defer unlockStderr();
     writeErrorReturnTrace(et, stderr) catch |err| switch (err) {
diff --git a/src/Sema.zig b/src/Sema.zig
index 1767e058e0d627e663a41236a69bdc6d7f3c3a22..4702241a71aba52188f51cd1605131785673f95d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2252,8 +2252,9 @@ 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));
 
-    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));
+    // 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));
 
     // st.instruction_addresses = &addrs;
     const instruction_addresses_field_name = try ip.getOrPutString(gpa, io, pt.tid, "instruction_addresses", .no_embedded_nulls);
@@ -6165,10 +6166,10 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
 
     if (!block.ownerModule().error_tracing) return .none;
 
-    const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace);
+    const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace);
     const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-    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"),
+    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"),
         error.ComptimeReturn, error.ComptimeBreak => unreachable,
         error.OutOfMemory, error.Canceled => |e| return e,
     };
@@ -6176,7 +6177,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(error_return_trace_ty.toIntern()),
+            .ty = Air.internedToRef(stack_trace_ty.toIntern()),
             .payload = @intCast(field_index),
         } },
     });
@@ -6208,11 +6209,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 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 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 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, error_return_trace_ty);
+        const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, stack_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
@@ -6233,11 +6234,11 @@ fn popErrorReturnTrace(
         defer then_block.instructions.deinit(gpa);
 
         // If non-error, then pop the error return trace by restoring the index.
-        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 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 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, error_return_trace_ty);
+        const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, stack_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);
 
@@ -6372,15 +6373,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 error_return_trace_ty = try sema.getBuiltinType(call_src, .ErrorReturnTrace);
+            const stack_trace_ty = try sema.getBuiltinType(call_src, .StackTrace);
             const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls);
-            const field_index = try sema.structFieldIndex(block, error_return_trace_ty, field_name, call_src);
+            const field_index = try sema.structFieldIndex(block, stack_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(error_return_trace_ty.toIntern()),
+                    .ty = Air.internedToRef(stack_trace_ty.toIntern()),
                     .payload = @intCast(field_index),
                 } },
             });
@@ -19528,13 +19529,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 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());
+    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());
 
     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_error_return_trace_ty);
+            return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
         },
 
         .@"comptime",
@@ -19546,7 +19547,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
         => {},
     }
     return Air.internedToRef(try pt.intern(.{ .opt = .{
-        .ty = opt_ptr_error_return_trace_ty.toIntern(),
+        .ty = opt_ptr_stack_trace_ty.toIntern(),
         .val = .none,
     } }));
 }
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 9b56b68c69f06cbfc1b4af238c3fdd5a389c025e..88258b236acf77c69a5b3e97b2d9e20ebc346c04 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -434,7 +434,7 @@ pub const BuiltinDecl = enum {
     AddressSpace,
     CallingConvention,
     returnError,
-    ErrorReturnTrace,
+    StackTrace,
     SourceLocation,
     CallModifier,
     AtomicOrder,
@@ -512,7 +512,7 @@ pub const BuiltinDecl = enum {
         return switch (decl) {
             .returnError => .func,
 
-            .ErrorReturnTrace,
+            .StackTrace,
             .CallingConvention,
             .SourceLocation,
             .Signedness,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index b138c852621e81bad93f3c462efb52d02db71a08..1ba3b272da797e44061a16136a8269fb3c61b195 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.ErrorReturnTrace`.
+            // First parameter is a pointer to `std.builtin.StackTrace`.
             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 2db115ebf66d39a7c27e44d3d9b404af2ca20174..a04d89c3ee3a9dd134fbe037a9ead08f59cd1edf 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     @compileError("panic");
 }
 
diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig
index 92b2badb5a056e9ef05e77b4098cd05ff8f50efa..f5e0dc87a7923dde14215dc4383477ee24830775 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 e9bb3a2abc0ccdb69c1709580c3b5ea673d02354..35d23b2be7543f1f4f92e84408e5ea7491e34a7f 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f93677cf7e01a6888a6f7165498df060a0594210..4edbfae996280f074e9600f65e5c5aae5b646882 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.builtin.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 f7bcd690634919b703dfa5958f2833609f672c26..16e4699478c5f0448211fbe855a1eecadab0fd6e 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.builtin.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 b7a7b2ae2ab531be8644d9de6702fb002c8a5655..bb8379042b279d385b91d12db0328fdd595c2a5e 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 a8b0b8dcfaa846df7b6fb1b374597ac794c1e753..267c136e9e8b139c9bdc78c9aa1daa17ded5871d 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 0649df2fb1bb37b22684b2a5c8b8bb8b92c55ba4..180ee78512fccc28ba1b33ef2b78e0570f0044cb 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 2b3a9c35562e7553c2e1f809128957bed00c8863..dd5c62e07cc10c5f317c60eb96ff6603fd6297d2 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 65a3d904c27770d438061333a51687ff077553ac..0b0fab15d9ca8ec6abbdb1b85c86bde0b4f2dd4b 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 fda0fbd8c184bb951ed3c8fae3c6653b3006c312..8c42449a87a8b8c6a1d5dc28763864b34f6fca4d 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 847a65e3aee059bf156684526483a3fd8e42bfbc..49cee6a78613742cb8ac22dc7110ec906d207f7d 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 748d89e12a1e8bbd4ed5283a6c205b8e2cea2bb5..0a786bff7baaced248118379e0fc586b6ee8932b 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 ab43e1d9e8e1895c7916941dfd380cf93f2077ea..07f5ff3e42b1cf2ee315c84d1f889c8510a1bd4a 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f28cc6de0c2110a22d6a846e5edcbdc9b8ba40bd..e54bc221da96a0562862c01b81106bf97f8ab2bf 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 af03ad840a26d288a3ec60cd12dc79adc9fd0df4..90bbb696e274792bbc0be62939124096410e8dc1 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f2b25df616080eb1bcdda4152ae3a0810e3cf669..77b1ef5a14fe37276ba85d468acb196240932881 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 8e5208a882d20bba75b445c637cfc44544eb303c..095298e6facfca3d405da16b71e7a6967f69af3e 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 95e077c774fa83ffd13485319f8ed91e6ddf8678..b67604541cec32e182f68c5d447f9b4cdf040e54 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 74cb95297a24aaead6bb48fb0bed5de39eed3de9..f6e6f4662cf7c37d1683a5deb60ff9a679ac3c3d 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 faba3ffa639b2c5bf9efb3e987cd78fcb229ecf0..594cedf8ed0d31ebf0d4bf21271daffc009670cc 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 ce9aa416493935048a5bb8e46882f0d1d04b5e20..16630b6f6a7dc374e998a4359b9e761c23659bf3 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 3b162c85e4b50cc162e1ac99ba13be798b3e38f1..21cfda643470e04be687f796323fc30cf2101d59 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 7f2e527c1f498864355a035f64b2e0c249f644fd..81e2ffb91ef238d758deb6ff7a7184579219f8e5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 e1e9f6bb261b6f835778b78c972a34fcf48cc0d2..faf8103880cdc478d1dd2aef8e8311c554bd054f 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 01d1e7f882732be6c1b4bf900169c173719d8e24..73e62a60b8ffcc3e0e6250c45dbd5a8d1030cac3 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 408d18f2842e91648e8610d17847076c7eddf156..723288c437ea4d4ed4fcf7d93267a2db578600e5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f58e43ab03a94951c778867879aae0b0628a3224..49e9d8caaad5a0c145a151a5286f894bf144e87c 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 68568729f21471186c4c288b019f1ba7926c8ea7..7cf0c30417ca14b3439662cddc5f0ca8a296eeb6 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 23455e1d4553c9c2af277a66fcd5707dfebc0751..d77104bbb39e6b6f0ab70138faee5c403a2953a7 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 220a215a9cc1e9057aa6f958831c3b8d3a68ddad..de15051993518235a1f7ff42d3b0cedfb5a4b5b5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4570c44dcde5ddda49201093dade7655577c560e..51adb1ac1e8dc7f2705e31d1b3ff6a09d25825d6 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 fab386becd991618300fe2eb945bc915b82ac155..1dacc309587582870dbe94e9e5639cd047a3ffcf 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 22bd4a924b2fbff185fe656d0d3365464c071b03..0693b7b1286d7310129c112716d3643fc3568bc5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f9b4677f01d8bb93edfd9202de7b776c94a2a788..262f921e923805f599afcdc1f8db94b0098991d6 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 1887eb97e384f0d1c27525c4c0f760134d8d7709..4b9affab36f2648de12387826668dc462bff2071 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 0a0454ab5caff129b453f5910cc8d8042f64be63..aed7479bf26b8cbe23b8b22951c9a026d78e6bde 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 6d3d9e0af0da5b35c63a18700f52981970a28e44..b92bfd4c266b25870444db4da90f5f409f7df586 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 808938c12298fe3c1a3b9ac587ba61376be2803e..336b4831ac0f37b4860eb51018a35c435c26ef3e 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 ed0fa971c930b3d836f187349cd897b6de6bd2b6..fe3aefeb1abae6f4ee63cbe701a91c2283f6f42c 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 7fe895d70e125dac8927aa9e0b30bdb7b1d9abff..a667c7c20658a6444f89f90f5caf6c5935ec2e48 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 6a026c2221168fdc7d86449d06fdbcb648534418..311869657b1f988c76280242ece4c59b510e5ccd 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 d5777a6834951cfb77135028361cb832d41fe876..5d2681dee049831b26c0ebdc56faf4abb1242310 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 758dfa898e1473eaff63f75b13f50c763e730dd6..142f1f44cdd404c56ac2f291d66faa5d99f463a0 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 5fa007e198d992281abca5997962dfb62b66aa60..cdd5aeb2e251142fd9410103b46615c9f010f47c 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 e95ae542dbde4b4898d18b2123a8b3e9fe9ec8bf..3728ca2a0173dd97a48371ab31facd0ba32bd3f5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4dc28246babe1630867200f6e082d44a3adb5adc..97624a4710dd5e86c9e7d173103b21db1da38c95 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 3e6d85f1186f1cf1932c4949d8485ec489081f69..6e374647c38cc979f46e3ca3d5ba5ccd1c319131 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 479441b7dcbcda0b2705f031235ec542624886e4..3ea5bcc2e790bbdf2d6553e0cbfe3d12c0f5d0e7 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4514e9a4a6fff19f7f3843529d3214a6dcc38648..e3d8f2a5121629d7d54c6a0a69109bba0f085379 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 181cdb50ca41bfb0d7f6d853febae8d2b4d94b9f..5131e592f9a386ae7a0d2e74e42af761d255a886 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4293baa0e0a0991555c1928d4174ed95c5357450..365eeaba4389920f8f0c8aaf90b2dfa8b6bb5fad 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 d133ce883a32761e95a02081eeb8408d74c9f7fc..844f6e3b75be682abe3f17b2e9148263fbcc4e82 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 3bc6ab68c0e486b7ac460599e2d6773d1e3e9bcc..58e392d224c1fce72ecdc297a743caacb7c45ccd 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 6009c758f01450cd213f9cfa25672e6ea944f766..308d97983592db1fc0aeb2906712761a8faa78a2 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 1aae8fa1df3938eb345a0e68b794c0c6420fa29f..63ee03facb462b4fd9972370188ca9713a272387 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 44dea2233b47dee5bde0845dd0349955d1d51450..60e6c5c3eb490955d9d18f198d7b0759bb76ed06 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.debug.StackTrace, ra: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 bb8012458143eaa5d7bad6180b24aad2e0e3f143..cc9bb0205a643ad8df46d488b192ed7309d6918c 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 c2ea85b864cc7a57489eb07b37908d24f4bfab48..61ae983fbab8ebea65a191b02722f9af9f9defe5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 491dc69dca06f727bf7356882b81986a28b69711..e10297dc49cf00fb006fd5ad2459782bb43f235a 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 bf8d2a502edc71e7f1fd5998a526dde3c10a9be1..892e6cbfd98010617fbcc1551cd90245ede3269f 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 5b0f8618c06d548048892726ffc7d374084c0cbe..9ad91109d90de3261c5d1fe5857fbc62e526e744 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4a45e7eee96fbf90846fedd64c7ba4714aaa10a1..754f160c9cad768a2540dc3697944d1daa50ff2f 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 591334c1607556eba245a9eaa8dd3a8718ea1f7d..2b67721299bd6a9de1d3d2a20d898cf509c90dac 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 a537b969c383be23828e2af8461309fdd86fba80..cf836eafa3a3884a490f94bf5d61a3f96147668e 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 a13fc604406f280b0deafad79db20b8581d05c1c..56996e1e32094ca847447d3c3ea3bd3e2c893c95 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 1742386258e789e5f4e26aecf9868c69d88133f6..fa4b124189678410414211fe9d77c35e0b9a4bf6 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 06b792e067c97bf5d53ee898649efc15ad004b2c..be3a0ad662e441d8f803f156b88e2a10b5acc2f3 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 b1d31ac78a0eeef826aa7fa8d1e7f4f0db174227..fb636c0bce360a1b9f4290c1bd18df65a6682ed1 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 93e1c5c1e77b9a72158ea15063344d3f7767c065..bd6bc012bb7296236551deda8c1923376121c554 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 d51e1e926145ea2d4a09517ccacbba1ed0e7b4e3..6dc5806e4fd042a65c94c1f4e779af349a34bc50 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 d6b2377e34e90a1084b525d264fca46817517d14..50be6b84f384e980ecd5d677e7d28a978f492254 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4dbeb2b0f86c41af6acf981de3eebc6958765490..af92f90198e71e261206b0372121a489cbe2a7de 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 7bfaca25acc3946ff658ef9bc9a8ad30ac6c7357..f9a8730a99ee7d08f039e326fa4f33db2a2ed042 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 51d9b17b7500236ce68d33a7c59abd6c50d95ab8..30e6b8a85cd0143f200bf4c368553e251f3fa41f 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 34bd73f56c20981342bc8b5a968ec929c5dec1aa..c931aa31f1f75f054211c8ebf28d7bf9f2622540 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 a824ad6bb8f73c783a4f93afd4dac6e30adb03d0..881edb5d8e1c7d9938e51770ecc260371348baba 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 a9d90f676d56cd472618575b38dd7b401d4854b5..9835a253266991c229cf3aacc27508edf251f1b5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 838b31ce083edae683649daaacc1c205f5ba9bc1..b5851d7b1137859647cdb931d081285a7d90cb07 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 1ef2e062626776cd957660bae5ada2bdd212e1d2..a3bcb49fc17cdf63ca71f931a91cdef87d120e41 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 9b9a40e93b5b15942fd6c88bdd5a5034b00f8555..d85299e6936805bbefac2b326e254c755ebe8af9 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.builtin.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 57a7b6a7380e3cc31d1ac630285ca2beeb2acdb7..388a052085ac54b14cac21007559be05d9451156 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.builtin.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 f6a29feec74092d824811f7b24b0ca80f445bf07..ff7a18b8f0963609be205939db699764e61eb10c 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, _: ?*std.builtin.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 8266a035b70fe3b9a618422da03407ad6219cef8..e2145fedb0a8db60774ca3b337db6419a549d3d1 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 2035361cb2a0af969d68407d325d62ec12ba3700..6fc0281d471f19f1be6c64c5d00178ca5f83ceb5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4babfb9133c4d41236275b2ccf0f9ff538a5f1f8..6bc20ef1007752779753bfa296812271219e5045 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 20a24a81ccbe9bcfe77c60ac72f7f2fa5f8d96f1..afb7bfdcdcc20f7848d1e7fbb50e4f236de08f19 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 6cab276eab07888a21426c149faf8650f7f213b3..297cde40ea92fc6504103e4aa5b5f5bffcf0f641 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 c7f6f86940089cf6ba2c866eaab8a1dbdbdd5ebd..7e08b3c495b4fe32412d857006357e0a63060282 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 e2b21fd84a4bd402cdf8b0c260e06fc932a4c85c..d1c8d6a3f528c56d82980f3c15d775eec151e497 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 3531ac34b0a0ddbca4c02797376d6d74bd8d202e..7805a5f92d005d0410f2ac32dcd97f6920e968c5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 52c20506122d5d8a2db209a514f4a75458cc1344..8b394e6f4f40f9be400b4b734902ed6dfecfe09e 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 c326dfb691b47c7721699f1d049555c822abdb8f..5047550800272266659c6746d5fef0e3e9666bed 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 178e309126399fa4d53c757ef704ea754abfced5..37bb1b61ea70aedbfb03e99c04929e48566cbede 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 5ebe44bf49a8ec967de17bf7784117dc042bdbf0..2de5d7c714f0d7067bff6490ce2debab4ad9b901 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f603999d8b267a6dfbf57f07acda968b5ab443ab..a482701b96e2d5af1b702bf2ae7e78f6aa24f560 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 57f1f3d7b7bfdbc22489f644101b865f5917df68..e31a34593d6f9c10cc488254cc7dd970211466ce 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 ef79c5cce4d1abf76b51a74ce619cfb7b46776fc..aae990b6444e35a3ef063e88ba146172476c5c55 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 f8aa6ebb119cca1afa146045ee95220deb25f42b..0b12aed075041047081c79b9d0e6263819e79241 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 ea74f8739b977842d5ba08f436af3fc99c256014..ff5144e3e7e5e7c6ffa8fe425bd4619c2bf4b1ea 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 4b34248af58f989af47a76f5c9f4be144fc395d9..5f60d9c2f2cf2c30c5aee92fdb58b573e436c9a5 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 2d4183d316761fc32096f1fc9146535d36fe4f28..0a7573e508b0a6683d9fa5ede52465a0d0f94761 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 b06dc437541b3d703b7c4bb715aabb5760589586..11dcfda430ba0eb484f485bc8ab039b79084a491 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 a6db1e5e85767d3aa2b56c2fe365b2be16fb1d9c..5de596085416c6e191f3a029d2ab855cbd967dc7 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 5e379643a8a758cedea138e75e11b107acb9ebc0..63be84677164a494a339ad2e56bab8b07693e629 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.debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.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 875251e3f74a2a01aaa10558df8ad596ac6e8725..5cd716dd303e57453e5463a7ff9063b87456304a 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: ?*std.debug.StackTrace) noreturn {
+pub fn foo(message: []const u8, stack_trace: ?*builtin.StackTrace) noreturn {
     @call(.always_tail, bar, .{ message, stack_trace });
 }
-pub fn bar(message: []const u8, stack_trace: ?*std.debug.StackTrace) noreturn {
+pub fn bar(message: []const u8, stack_trace: ?*builtin.StackTrace) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/standalone/compile_asm/main.zig b/test/standalone/compile_asm/main.zig
index a3b11b9da974d71aa022fc57a375f2a8ef90004a..1e6c93e562dee9f1d7eab41b4214241cfc4cc754 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").debug.StackTrace, _: ?usize) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.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 445385d16c78d0bc7ac9a075d004c85f17b56bc8..e28839209c1988a68fb46c269a32d5d0b311cfd5 100644
--- a/test/standalone/issue_339/test.zig
+++ b/test/standalone/issue_339/test.zig
@@ -1,4 +1,4 @@
-const StackTrace = @import("std").debug.StackTrace;
+const StackTrace = @import("std").builtin.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 511846dd312e516e1f74acdb74b50fb39993cb0d..dcdbd762afc671a2dc3c81c66e16bf7e943fcb81 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -2291,7 +2291,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").debug.StackTrace, _: ?usize) noreturn {
+            \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("builtin").StackTrace, _: ?usize) noreturn {
             \\    _ = msg;
             \\    _ = error_return_trace;
             \\    zig_panic();
-- 
2.54.0