update safety test cases to new panic API

although they would also pass simply reverted to master branch because I made the deprecated API still work for now (to be removed after 0.14.0 is tagged)
author: Andrew Kelley <andrew@ziglang.org> 2024-09-26 17:14:17 -0700
committer: Andrew Kelley <andrew@ziglang.org> 2024-09-26 17:14:17 -0700
commit: 7f4c0e010d1eaa47533a711c781783e808494083 (patch)
tree: 7aef83ef1185994606b4573630e1ed96a5ebee5d
parent: db8c0744767b3d472f9682827a312a8ffed74adf (diff)
95 files changed, 1129 insertions, 270 deletions
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 664a45f12b..f2cd78160f 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -762,26 +762,35 @@ pub const TestFn = struct {
 };
 
 /// Deprecated, use the `Panic` namespace instead.
+/// To be deleted after 0.14.0 is released.
 pub const PanicFn = fn ([]const u8, ?*StackTrace, ?usize) noreturn;
-
 /// Deprecated, use the `Panic` namespace instead.
-pub const panic: PanicFn = if (@hasDecl(root, "panic"))
-    root.panic
-else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic"))
-    root.os.panic
-else
-    Panic.call;
+/// To be deleted after 0.14.0 is released.
+pub const panic: PanicFn = Panic.call;
 
 /// This namespace is used by the Zig compiler to emit various kinds of safety
 /// panics. These can be overridden by making a public `Panic` namespace in the
 /// root source file.
 pub const Panic: type = if (@hasDecl(root, "Panic"))
     root.Panic
+else if (@hasDecl(root, "panic")) // Deprecated, use `Panic` instead.
+    DeprecatedPanic
 else if (builtin.zig_backend == .stage2_riscv64)
     std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519
 else
     std.debug.FormattedPanic;
 
+/// To be deleted after 0.14.0 is released.
+const DeprecatedPanic = struct {
+    pub const call = root.panic;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
 /// To be deleted after zig1.wasm is updated.
 pub const panicSentinelMismatch = Panic.sentinelMismatch;
 /// To be deleted after zig1.wasm is updated.
diff --git a/lib/std/debug/SimplePanic.zig b/lib/std/debug/SimplePanic.zig
index b8e818c6fc..9685642a5c 100644
--- a/lib/std/debug/SimplePanic.zig
+++ b/lib/std/debug/SimplePanic.zig
@@ -28,7 +28,7 @@ pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn {
 
 pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn {
     _ = ert;
-    _ = err;
+    _ = &err;
     call("attempt to unwrap error", null, null);
 }
 
diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig
index c29f126c9f..6e9d16d76d 100644
--- a/test/cases/compile_errors/panic_has_source_location.zig
+++ b/test/cases/compile_errors/panic_has_source_location.zig
@@ -6,10 +6,7 @@ export fn foo() void {
     @panic("oh no");
 }
 
-pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn {
-    _ = cause;
-    _ = ert;
-    _ = ra;
+pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     @compileError("panic");
 }
 
@@ -17,4 +14,4 @@ pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?
 // backend=stage2
 // target=native
 //
-// :13:5: error: panic
+// :10:5: error: panic
diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig
index b514810730..393c3ae2f7 100644
--- a/test/cases/safety/@alignCast misaligned.zig
+++ b/test/cases/safety/@alignCast misaligned.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .incorrect_alignment) {
+    if (std.mem.eql(u8, message, "incorrect alignment")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@asyncCall with too small a frame.zig b/test/cases/safety/@asyncCall with too small a frame.zig
index 3d7cdb3b1d..47d29dc3e0 100644
--- a/test/cases/safety/@asyncCall with too small a frame.zig
+++ b/test/cases/safety/@asyncCall with too small a frame.zig
@@ -1,7 +1,17 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     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 10f5267702..067599c5da 100644
--- a/test/cases/safety/@enumFromInt - no matching tag value.zig
+++ b/test/cases/safety/@enumFromInt - no matching tag value.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_enum_value) {
+    if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 73b87ad20e..0d92f9e18c 100644
--- a/test/cases/safety/@errorCast error not present in destination.zig
+++ b/test/cases/safety/@errorCast error not present in destination.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_error_code) {
+    if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 bdb2d80760..6f9de8cf5f 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_error_code) {
+    if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig
index daf5069e61..d9bb489c70 100644
--- a/test/cases/safety/@intCast to u0.zig
+++ b/test/cases/safety/@intCast to u0.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_truncated_data) {
+    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 d029f90343..fd7a915366 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_part_out_of_bounds) {
+    if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 ea2365ea6d..0a7195bbc2 100644
--- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig
+++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_part_out_of_bounds) {
+    if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 1bdc23982a..395ee133c9 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_part_out_of_bounds) {
+    if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 2788a31fd9..963fdf70cb 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_to_null) {
+    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 81e4500115..6826343ff7 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_to_null) {
+    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig
index 2c291f9ad3..ebf92b238d 100644
--- a/test/cases/safety/@ptrFromInt with misaligned address.zig
+++ b/test/cases/safety/@ptrFromInt with misaligned address.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .incorrect_alignment) {
+    if (std.mem.eql(u8, message, "incorrect alignment")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig
index a89dc72a97..23ababf264 100644
--- a/test/cases/safety/@tagName on corrupted enum value.zig
+++ b/test/cases/safety/@tagName on corrupted enum value.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_enum_value) {
+    if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig
index 799a9c6a17..38b86ef482 100644
--- a/test/cases/safety/@tagName on corrupted union value.zig
+++ b/test/cases/safety/@tagName on corrupted union value.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_enum_value) {
+    if (std.mem.eql(u8, message, "invalid enum value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig
index aea05a6b41..0185899c46 100644
--- a/test/cases/safety/array slice sentinel mismatch vector.zig
+++ b/test/cases/safety/array slice sentinel mismatch vector.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .sentinel_mismatch_other) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig
index 2e9bcf9366..f645e45f18 100644
--- a/test/cases/safety/array slice sentinel mismatch.zig
+++ b/test/cases/safety/array slice sentinel mismatch.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .sentinel_mismatch_usize => |info| {
-            if (info.expected == 0 and info.found == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig
index d73897f0f3..7258c37a44 100644
--- a/test/cases/safety/bad union field access.zig
+++ b/test/cases/safety/bad union field access.zig
@@ -1,16 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .inactive_union_field => |info| {
-            if (std.mem.eql(u8, info.active, "int") and
-                std.mem.eql(u8, info.accessed, "float"))
-            {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig
index d77f0dd911..7a7c120b6b 100644
--- a/test/cases/safety/calling panic.zig
+++ b/test/cases/safety/calling panic.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .explicit_call => |message| {
-            if (std.mem.eql(u8, message, "oh no")) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "oh no")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 50dac0411c..9590482df1 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .exact_division_remainder) {
+    if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 f6c5410a7b..aec6262275 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_error_code) {
+    if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 2c0a4ebb40..aa72bb74dd 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,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .index_out_of_bounds => |info| {
-            if (info.index == 1 and info.len == 0) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig
index 8d65d833e1..2b0cf5f472 100644
--- a/test/cases/safety/exact division failure - vectors.zig
+++ b/test/cases/safety/exact division failure - vectors.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .exact_division_remainder) {
+    if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig
index 8fa31d6ee0..72179f3127 100644
--- a/test/cases/safety/exact division failure.zig
+++ b/test/cases/safety/exact division failure.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .exact_division_remainder) {
+    if (std.mem.eql(u8, message, "exact division produced remainder")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig
index 37a0761ee9..17d43ab7f2 100644
--- a/test/cases/safety/for_len_mismatch.zig
+++ b/test/cases/safety/for_len_mismatch.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .for_len_mismatch) {
+    if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig
index 3f1f1ac230..16faaab1f9 100644
--- a/test/cases/safety/for_len_mismatch_three.zig
+++ b/test/cases/safety/for_len_mismatch_three.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .for_len_mismatch) {
+    if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig
index 1ddb3588bc..0552e47bec 100644
--- a/test/cases/safety/ignored expression integer overflow.zig
+++ b/test/cases/safety/ignored expression integer overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig
index 8aea6c7616..0195a5436e 100644
--- a/test/cases/safety/integer addition overflow.zig
+++ b/test/cases/safety/integer addition overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig
index 3ac58efd31..95dc075d6f 100644
--- a/test/cases/safety/integer division by zero - vectors.zig
+++ b/test/cases/safety/integer division by zero - vectors.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .divide_by_zero) {
+    if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig
index 7f14acc9a4..c2b083c7bd 100644
--- a/test/cases/safety/integer division by zero.zig
+++ b/test/cases/safety/integer division by zero.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .divide_by_zero) {
+    if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig
index d90d65ed86..1d194793a0 100644
--- a/test/cases/safety/integer multiplication overflow.zig
+++ b/test/cases/safety/integer multiplication overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig
index 9a569b5338..b37819e33b 100644
--- a/test/cases/safety/integer negation overflow.zig
+++ b/test/cases/safety/integer negation overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig
index a6591dd9ec..e44eebade3 100644
--- a/test/cases/safety/integer subtraction overflow.zig
+++ b/test/cases/safety/integer subtraction overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/invalid resume of async function.zig b/test/cases/safety/invalid resume of async function.zig
index c58f13b99d..834ed75ef4 100644
--- a/test/cases/safety/invalid resume of async function.zig
+++ b/test/cases/safety/invalid resume of async function.zig
@@ -1,6 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig
index 191a37f8eb..a01a597d90 100644
--- a/test/cases/safety/memcpy_alias.zig
+++ b/test/cases/safety/memcpy_alias.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .memcpy_alias) {
+    if (std.mem.eql(u8, message, "@memcpy arguments alias")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig
index aa5bb92732..943ddb582c 100644
--- a/test/cases/safety/memcpy_len_mismatch.zig
+++ b/test/cases/safety/memcpy_len_mismatch.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .memcpy_len_mismatch) {
+    if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig
index c1c86df1aa..4347ba55e5 100644
--- a/test/cases/safety/memset_array_undefined_bytes.zig
+++ b/test/cases/safety/memset_array_undefined_bytes.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig
index 3cab2f4c5f..efbff0e9ce 100644
--- a/test/cases/safety/memset_array_undefined_large.zig
+++ b/test/cases/safety/memset_array_undefined_large.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig
index d6a7e3e5cd..08401efd59 100644
--- a/test/cases/safety/memset_slice_undefined_bytes.zig
+++ b/test/cases/safety/memset_slice_undefined_bytes.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig
index a5e572eefd..3f31310982 100644
--- a/test/cases/safety/memset_slice_undefined_large.zig
+++ b/test/cases/safety/memset_slice_undefined_large.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig
index 16616f4801..11949fb896 100644
--- a/test/cases/safety/modrem by zero.zig
+++ b/test/cases/safety/modrem by zero.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .divide_by_zero) {
+    if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig
index 454b1cd432..9ddd96c458 100644
--- a/test/cases/safety/modulus by zero.zig
+++ b/test/cases/safety/modulus by zero.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .divide_by_zero) {
+    if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig
index ac413089e7..a6cf3e91ee 100644
--- a/test/cases/safety/noreturn returned.zig
+++ b/test/cases/safety/noreturn returned.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .noreturn_returned) {
+    if (std.mem.eql(u8, message, "'noreturn' function returned")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/nosuspend function call, callee suspends.zig b/test/cases/safety/nosuspend function call, callee suspends.zig
index 50f457f314..f40dfc14b0 100644
--- a/test/cases/safety/nosuspend function call, callee suspends.zig
+++ b/test/cases/safety/nosuspend function call, callee suspends.zig
@@ -1,6 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     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 59ffe381a4..da67bca3b9 100644
--- a/test/cases/safety/optional unwrap operator on C pointer.zig
+++ b/test/cases/safety/optional unwrap operator on C pointer.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .unwrap_null) {
+    if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 9b09d63f7b..3992f75ff3 100644
--- a/test/cases/safety/optional unwrap operator on null pointer.zig
+++ b/test/cases/safety/optional unwrap operator on null pointer.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .unwrap_null) {
+    if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 9ad18972f8..3aef3eb425 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,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .index_out_of_bounds => |info| {
-            if (info.index == 16 and info.len == 5) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig
index 7b7ac0f8fa..474be34db7 100644
--- a/test/cases/safety/out of bounds slice access.zig
+++ b/test/cases/safety/out of bounds slice access.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .index_out_of_bounds => |info| {
-            if (info.index == 4 and info.len == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 ad8921ae92..8f57156471 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_to_null) {
+    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 364f66ab19..13404b1a48 100644
--- a/test/cases/safety/pointer casting to null function pointer.zig
+++ b/test/cases/safety/pointer casting to null function pointer.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_to_null) {
+    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig
index 7d79144fcf..a7a9eb94b6 100644
--- a/test/cases/safety/pointer slice sentinel mismatch.zig
+++ b/test/cases/safety/pointer slice sentinel mismatch.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .sentinel_mismatch_usize => |info| {
-            if (info.expected == 0 and info.found == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig
index 9fee0aa13a..8681970a4b 100644
--- a/test/cases/safety/remainder division by zero.zig
+++ b/test/cases/safety/remainder division by zero.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .divide_by_zero) {
+    if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/resuming a function which is awaiting a call.zig b/test/cases/safety/resuming a function which is awaiting a call.zig
index 47545584ea..0e101594be 100644
--- a/test/cases/safety/resuming a function which is awaiting a call.zig
+++ b/test/cases/safety/resuming a function which is awaiting a call.zig
@@ -1,6 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/resuming a function which is awaiting a frame.zig b/test/cases/safety/resuming a function which is awaiting a frame.zig
index 26df1ae900..d005e31cd8 100644
--- a/test/cases/safety/resuming a function which is awaiting a frame.zig
+++ b/test/cases/safety/resuming a function which is awaiting a frame.zig
@@ -1,6 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig
index f8bf6d44c0..931d4de3e0 100644
--- a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig
+++ b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig
@@ -1,6 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     std.process.exit(0);
diff --git a/test/cases/safety/resuming a non-suspended function which never been suspended.zig b/test/cases/safety/resuming a non-suspended function which never been suspended.zig
index af288ab8ba..fb7d97b8ff 100644
--- a/test/cases/safety/resuming a non-suspended function which never been suspended.zig
+++ b/test/cases/safety/resuming a non-suspended function which never been suspended.zig
@@ -1,6 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = message;
     _ = stack_trace;
     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 09425b2cc1..01b40e0bfc 100644
--- a/test/cases/safety/shift left by huge amount.zig
+++ b/test/cases/safety/shift left by huge amount.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .shift_rhs_too_big) {
+    if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig
index b02e2a01af..7ef33ddb36 100644
--- a/test/cases/safety/shift right by huge amount.zig
+++ b/test/cases/safety/shift right by huge amount.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .shift_rhs_too_big) {
+    if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig
index 0da140b8f2..623e1eac21 100644
--- a/test/cases/safety/signed integer division overflow - vectors.zig
+++ b/test/cases/safety/signed integer division overflow - vectors.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig
index 576e3ef7aa..df805db4d9 100644
--- a/test/cases/safety/signed integer division overflow.zig
+++ b/test/cases/safety/signed integer division overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 762719df81..a446cde23a 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .negative_to_unsigned) {
+    if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 765a50d5a5..b839b36a22 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .negative_to_unsigned) {
+    if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig
index 148d79ca4d..5f9cb3aace 100644
--- a/test/cases/safety/signed shift left overflow.zig
+++ b/test/cases/safety/signed shift left overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .shl_overflow) {
+    if (std.mem.eql(u8, message, "left shift overflowed bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig
index f89f57a132..c65a361da5 100644
--- a/test/cases/safety/signed shift right overflow.zig
+++ b/test/cases/safety/signed shift right overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .shr_overflow) {
+    if (std.mem.eql(u8, message, "right shift overflowed bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig
index 2dee04d1bf..34f540ddb0 100644
--- a/test/cases/safety/signed-unsigned vector cast.zig
+++ b/test/cases/safety/signed-unsigned vector cast.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .negative_to_unsigned) {
+    if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig
index 71b32e0c8a..11ce2ff321 100644
--- a/test/cases/safety/slice sentinel mismatch - floats.zig
+++ b/test/cases/safety/slice sentinel mismatch - floats.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .sentinel_mismatch_other) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig
index 5e69a1d350..6e0766dfbe 100644
--- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig
+++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .sentinel_mismatch_other) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig
index 7f90b9edbf..58f80bd11b 100644
--- a/test/cases/safety/slice slice sentinel mismatch.zig
+++ b/test/cases/safety/slice slice sentinel mismatch.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .sentinel_mismatch_usize => |info| {
-            if (info.expected == 0 and info.found == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 5cdf1e46e9..55589c8684 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,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .start_index_greater_than_end => |info| {
-            if (info.start == 10 and info.end == 1) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 09d8fa32a5..80afb81f60 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,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .index_out_of_bounds => |info| {
-            if (info.index == 5 and info.len == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 1ec0698657..d36cb7141a 100644
--- a/test/cases/safety/slice with sentinel out of bounds.zig
+++ b/test/cases/safety/slice with sentinel out of bounds.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .index_out_of_bounds => |info| {
-            if (info.index == 5 and info.len == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 d4ebbdff18..7886121378 100644
--- a/test/cases/safety/slicing null C pointer - runtime len.zig
+++ b/test/cases/safety/slicing null C pointer - runtime len.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .unwrap_null) {
+    if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig
index b3e50b0ebf..502c7a1bbb 100644
--- a/test/cases/safety/slicing null C pointer.zig
+++ b/test/cases/safety/slicing null C pointer.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .unwrap_null) {
+    if (std.mem.eql(u8, message, "attempt to use null value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 bc8321a346..7e1e8dfce2 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .corrupt_switch) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 4f6e00c85a..b6781682d7 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .corrupt_switch) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 1d38217399..b06dec9168 100644
--- a/test/cases/safety/switch else on corrupt enum value.zig
+++ b/test/cases/safety/switch else on corrupt enum value.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .corrupt_switch) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig
index 1591401808..23f2884329 100644
--- a/test/cases/safety/switch on corrupted enum value.zig
+++ b/test/cases/safety/switch on corrupted enum value.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .corrupt_switch) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig
index 1ae72fcbfb..1829d3104f 100644
--- a/test/cases/safety/switch on corrupted union value.zig
+++ b/test/cases/safety/switch on corrupted union value.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .corrupt_switch) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig
index 32fb407555..e68b029c33 100644
--- a/test/cases/safety/truncating vector cast.zig
+++ b/test/cases/safety/truncating vector cast.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_truncated_data) {
+    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig
index b12b1a722f..bb55a01cfe 100644
--- a/test/cases/safety/unreachable.zig
+++ b/test/cases/safety/unreachable.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .reached_unreachable) {
+    if (std.mem.eql(u8, message, "reached unreachable code")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 937d522569..399e66c216 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_truncated_data) {
+    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig
index 53fe91c9fb..b7d1ffe09b 100644
--- a/test/cases/safety/unsigned shift left overflow.zig
+++ b/test/cases/safety/unsigned shift left overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .shl_overflow) {
+    if (std.mem.eql(u8, message, "left shift overflowed bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig
index a5389797fc..aa5fbf493c 100644
--- a/test/cases/safety/unsigned shift right overflow.zig
+++ b/test/cases/safety/unsigned shift right overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .shr_overflow) {
+    if (std.mem.eql(u8, message, "right shift overflowed bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig
index aab2f5ae16..1599eb045f 100644
--- a/test/cases/safety/unsigned-signed vector cast.zig
+++ b/test/cases/safety/unsigned-signed vector cast.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_truncated_data) {
+    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig
index dd587c4865..9661efdddd 100644
--- a/test/cases/safety/unwrap error switch.zig
+++ b/test/cases/safety/unwrap error switch.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .unwrap_error => |err| {
-            if (err == error.Whatever) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig
index a2ac8f5046..f428472462 100644
--- a/test/cases/safety/unwrap error.zig
+++ b/test/cases/safety/unwrap error.zig
@@ -1,14 +1,19 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    switch (cause) {
-        .unwrap_error => |err| {
-            if (err == error.Whatever) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
+    if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
+        std.process.exit(0);
     }
     std.process.exit(1);
 }
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 d06d1cf440..e6a4d84135 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_truncated_data) {
+    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
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 3f55f40f96..f2eaf3fd6e 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,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .cast_truncated_data) {
+    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig
index 3e3145db86..8cb936b2c7 100644
--- a/test/cases/safety/vector integer addition overflow.zig
+++ b/test/cases/safety/vector integer addition overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig
index eceb507efa..d3ae414bf6 100644
--- a/test/cases/safety/vector integer multiplication overflow.zig
+++ b/test/cases/safety/vector integer multiplication overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig
index 5f408dab8b..3c84df786a 100644
--- a/test/cases/safety/vector integer negation overflow.zig
+++ b/test/cases/safety/vector integer negation overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig
index c858ac5e34..dd34dd11e7 100644
--- a/test/cases/safety/vector integer subtraction overflow.zig
+++ b/test/cases/safety/vector integer subtraction overflow.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .integer_overflow) {
+    if (std.mem.eql(u8, message, "integer overflow")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig
index 591e4b62ef..83f93622ce 100644
--- a/test/cases/safety/zero casted to error.zig
+++ b/test/cases/safety/zero casted to error.zig
@@ -1,8 +1,18 @@
 const std = @import("std");
 
-pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub const Panic = struct {
+    pub const call = panic;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (cause == .invalid_error_code) {
+    if (std.mem.eql(u8, message, "invalid error code")) {
         std.process.exit(0);
     }
     std.process.exit(1);
author	Andrew Kelley <andrew@ziglang.org>	2024-09-26 17:14:17 -0700
committer	Andrew Kelley <andrew@ziglang.org>	2024-09-26 17:14:17 -0700
commit	7f4c0e010d1eaa47533a711c781783e808494083 (patch)
tree	7aef83ef1185994606b4573630e1ed96a5ebee5d
parent	db8c0744767b3d472f9682827a312a8ffed74adf (diff)