Commit 7f4c0e010d

Andrew Kelley <andrew@ziglang.org>
2024-09-27 02:14:17
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)
master
1 parent db8c074
Changed files (95)
lib
std
debug
SimplePanic.zig
builtin.zig
test
cases
compile_errors
panic_has_source_location.zig
safety
@alignCast misaligned.zig
@asyncCall with too small a frame.zig
@enumFromInt - no matching tag value.zig
@errorCast error not present in destination.zig
@errorCast error union casted to disjoint set.zig
@intCast to u0.zig
@intFromFloat cannot fit - negative out of range.zig
@intFromFloat cannot fit - negative to unsigned.zig
@intFromFloat cannot fit - positive out of range.zig
@ptrFromInt address zero to non-optional byte-aligned pointer.zig
@ptrFromInt address zero to non-optional pointer.zig
@ptrFromInt with misaligned address.zig
@tagName on corrupted enum value.zig
@tagName on corrupted union value.zig
array slice sentinel mismatch vector.zig
array slice sentinel mismatch.zig
bad union field access.zig
calling panic.zig
cast []u8 to bigger slice of wrong size.zig
cast integer to global error and no code matches.zig
empty slice with sentinel out of bounds.zig
exact division failure - vectors.zig
exact division failure.zig
for_len_mismatch.zig
for_len_mismatch_three.zig
ignored expression integer overflow.zig
integer addition overflow.zig
integer division by zero - vectors.zig
integer division by zero.zig
integer multiplication overflow.zig
integer negation overflow.zig
integer subtraction overflow.zig
invalid resume of async function.zig
memcpy_alias.zig
memcpy_len_mismatch.zig
memset_array_undefined_bytes.zig
memset_array_undefined_large.zig
memset_slice_undefined_bytes.zig
memset_slice_undefined_large.zig
modrem by zero.zig
modulus by zero.zig
noreturn returned.zig
nosuspend function call, callee suspends.zig
optional unwrap operator on C pointer.zig
optional unwrap operator on null pointer.zig
out of bounds array slice by length.zig
out of bounds slice access.zig
pointer casting null to non-optional pointer.zig
pointer casting to null function pointer.zig
pointer slice sentinel mismatch.zig
remainder division by zero.zig
resuming a function which is awaiting a call.zig
resuming a function which is awaiting a frame.zig
resuming a non-suspended function which has been suspended and resumed.zig
resuming a non-suspended function which never been suspended.zig
shift left by huge amount.zig
shift right by huge amount.zig
signed integer division overflow - vectors.zig
signed integer division overflow.zig
signed integer not fitting in cast to unsigned integer - widening.zig
signed integer not fitting in cast to unsigned integer.zig
signed shift left overflow.zig
signed shift right overflow.zig
signed-unsigned vector cast.zig
slice sentinel mismatch - floats.zig
slice sentinel mismatch - optional pointers.zig
slice slice sentinel mismatch.zig
slice start index greater than end index.zig
slice with sentinel out of bounds - runtime len.zig
slice with sentinel out of bounds.zig
slicing null C pointer - runtime len.zig
slicing null C pointer.zig
switch else on corrupt enum value - one prong.zig
switch else on corrupt enum value - union.zig
switch else on corrupt enum value.zig
switch on corrupted enum value.zig
switch on corrupted union value.zig
truncating vector cast.zig
unreachable.zig
unsigned integer not fitting in cast to signed integer - same bit count.zig
unsigned shift left overflow.zig
unsigned shift right overflow.zig
unsigned-signed vector cast.zig
unwrap error switch.zig
unwrap error.zig
value does not fit in shortening cast - u0.zig
value does not fit in shortening cast.zig
vector integer addition overflow.zig
vector integer multiplication overflow.zig
vector integer negation overflow.zig
vector integer subtraction overflow.zig
zero casted to error.zig
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);
 }
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.
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
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
 }
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);
 }
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);
 }
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);
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);
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);
 }
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
 }
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);
 }
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);
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);
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);
 }
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
 }
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);
 }
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);
 }
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);
 }
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
 }
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);
 }
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);
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);
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);
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);
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);
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);
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);